@shell-shock/plugin-prompts 0.3.49 → 0.3.52

package/dist/components/prompts-builtin.mjs

@@ -1,4 +1,399 @@
-import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/core/jsx-runtime";import{Show as r,code as i,splitProps as a}from"@alloy-js/core";import{FunctionDeclaration as o,VarDeclaration as s}from"@alloy-js/typescript";import{ReflectionKind as c}from"@powerlines/deepkit/vendor/type";import{Spacing as l}from"@powerlines/plugin-alloy/core/components/spacing";import{BuiltinFile as u}from"@powerlines/plugin-alloy/typescript/components/builtin-file";import{ClassDeclaration as d,ClassField as f,ClassMethod as p,ClassPropertyGet as m}from"@powerlines/plugin-alloy/typescript/components/class-declaration";import{InterfaceDeclaration as h,InterfaceMember as g}from"@powerlines/plugin-alloy/typescript/components/interface-declaration";import{TSDoc as _,TSDocDefaultValue as v,TSDocExample as y,TSDocParam as b,TSDocRemarks as x,TSDocReturns as S}from"@powerlines/plugin-alloy/typescript/components/tsdoc";import{TypeDeclaration as C}from"@powerlines/plugin-alloy/typescript/components/type-declaration";import{useTheme as w}from"@shell-shock/plugin-theme/contexts/theme";import T from"defu";function E(){let n=w();return[e(C,{export:!0,name:`PromptParser`,typeParameters:[{name:`TValue`,default:`string`}],doc:`A type for a custom prompt input parser, which can be used to create custom input styles for prompts. The function should return the parsed value for the given input string.`,children:i`(this: Prompt<TValue>, input: string) => TValue; `}),e(l,{}),e(C,{export:!0,name:`PromptFormatter`,typeParameters:[{name:`TValue`,default:`string`}],doc:`A type for a custom prompt input formatter, which can be used to create custom display styles for prompts. The function should return the formatted string to display for the given input value.`,children:i`(this: Prompt<TValue>, input: TValue) => string; `}),e(l,{}),e(o,{export:!0,name:`noMask`,doc:`A built-in prompt mask function that just returns the input as is, making it invisible`,parameters:[{name:`input`,type:`string`}],returnType:`string`,children:i`return input; `}),e(l,{}),e(o,{export:!0,name:`invisibleMask`,doc:`A built-in prompt mask function that makes input invisible`,parameters:[{name:`input`,type:`string`}],returnType:`string`,children:i`return " ".repeat(input.length); `}),e(l,{}),e(h,{export:!0,name:`PromptState`,doc:`The current state of a prompt`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`value`,type:`TValue`,doc:`The current value of the prompt`}),e(l,{}),e(g,{name:`isError`,type:`boolean`,doc:`Indicates whether the prompt is in an error state`}),e(l,{}),e(g,{name:`errorMessage`,optional:!0,type:`string`,doc:`If the prompt is in an error state, this will contain the error message to display`}),e(l,{}),e(g,{name:`isSubmitted`,type:`boolean`,doc:`Indicates whether the prompt is submitted`}),e(l,{}),e(g,{name:`isCancelled`,type:`boolean`,doc:`Indicates whether the prompt is cancelled`}),e(l,{}),e(g,{name:`isCompleted`,type:`boolean`,doc:`Indicates whether the prompt is completed, which can be used to indicate that the prompt interaction is finished regardless of whether it was submitted or cancelled`}),e(l,{})]}}),e(l,{}),e(h,{name:`PromptConfig`,doc:`Configuration options for creating a prompt`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`input`,optional:!0,type:`NodeJS.ReadStream`,doc:`The readable stream to use for prompt input, defaults to process.stdin`}),e(l,{}),e(g,{name:`output`,optional:!0,type:`NodeJS.WriteStream`,doc:`The writable stream to use for prompt output, defaults to process.stdout`}),e(l,{}),e(g,{name:`message`,type:`string`,doc:`The prompt message to display`}),e(l,{}),e(g,{name:`description`,optional:!0,type:`string`,doc:`The prompt description message to display`}),e(l,{}),e(g,{name:`initialValue`,optional:!0,type:`TValue`,doc:`The initial value of the prompt`}),e(l,{}),e(g,{name:`validate`,optional:!0,type:`(value: TValue) => boolean | string | null | undefined | Promise<boolean | string | null | undefined>`,doc:`A validation function that returns true if the input is valid, false or a string error message if the input is invalid`}),e(l,{}),e(g,{name:`parse`,optional:!0,type:`PromptParser<TValue>`,doc:`A function that parses the input value and returns the parsed result or throws an error if the input is invalid`}),e(l,{}),e(g,{name:`format`,optional:!0,type:`PromptFormatter<TValue>`,doc:`A function that formats the input value and returns the formatted result or throws an error if the input is invalid`}),e(l,{}),e(g,{name:`mask`,optional:!0,type:`(input: string) => string`,doc:`A function that masks the input value and returns the masked result. This can be used to create password inputs or other sensitive input types where the actual input value should not be displayed. If not provided, the prompt will display the input as is without masking.`}),e(l,{}),e(g,{name:`maskCompleted`,optional:!0,type:`(input: string) => string`,doc:`A function that masks the value submitted by the user so that it can then be used in the console output or elsewhere without exposing sensitive information. If not provided, the prompt will use the same mask function for both input and submitted value masking.`}),e(l,{}),e(g,{name:`defaultErrorMessage`,optional:!0,type:`string`,doc:`The default error message to display when validation fails`}),e(l,{}),e(g,{name:`timeout`,optional:!0,type:`number`,doc:`The timeout duration in milliseconds for the prompt. If none is provided, the prompt will not time out.`})]}}),e(l,{}),e(d,{abstract:!0,name:`Prompt`,doc:`Base prompt class that other prompt types can extend from`,extends:`EventEmitter`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(f,{name:`readline`,isPrivateMember:!0,type:`Interface`}),t(`hbr`,{}),e(f,{name:`value`,isPrivateMember:!0,optional:!0,type:`TValue`}),t(`hbr`,{}),e(f,{name:`isKeyPressed`,isPrivateMember:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`isDirty`,isPrivateMember:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`isClosed`,isPrivateMember:!0,type:`boolean`,children:i`false; `}),e(l,{}),e(f,{name:`initialValue`,abstract:!0,protected:!0,type:`TValue`}),t(`hbr`,{}),e(f,{name:`input`,protected:!0,type:`NodeJS.ReadStream`,children:i`process.stdin; `}),t(`hbr`,{}),e(f,{name:`output`,protected:!0,type:`NodeJS.WriteStream`,children:i`process.stdout; `}),t(`hbr`,{}),e(f,{name:`message`,protected:!0,type:`string`,children:i`""; `}),t(`hbr`,{}),e(f,{name:`description`,protected:!0,type:`string`,children:i`""; `}),t(`hbr`,{}),e(f,{name:`errorMessage`,protected:!0,type:`string | null`,children:i`null; `}),t(`hbr`,{}),e(f,{name:`defaultErrorMessage`,protected:!0,type:`string`,children:i`"An invalid value was provided"; `}),t(`hbr`,{}),e(f,{name:`isSubmitted`,protected:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`isCancelled`,protected:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`isInitial`,protected:!0,type:`boolean`,children:i`true; `}),t(`hbr`,{}),e(f,{name:`consoleOutput`,protected:!0,type:`string`,children:i`""; `}),t(`hbr`,{}),e(f,{name:`consoleStatus`,protected:!0,type:`string`,children:i`""; `}),t(`hbr`,{}),e(f,{name:`displayValue`,protected:!0,type:`string`,children:i`""; `}),t(`hbr`,{}),e(f,{name:`validate`,protected:!0,type:`(value: TValue) => boolean | string | null | undefined | Promise<boolean | string | null | undefined>`,children:i`() => true; `}),t(`hbr`,{}),e(f,{name:`parse`,protected:!0,type:`PromptParser<TValue>`,children:i`(value: string) => value as TValue; `}),t(`hbr`,{}),e(f,{name:`format`,protected:!0,type:`PromptFormatter<TValue>`,children:i`(value: TValue) => String(value); `}),t(`hbr`,{}),e(f,{name:`mask`,protected:!0,type:`(input: string) => string`,children:i`noMask; `}),t(`hbr`,{}),e(f,{name:`maskCompleted`,protected:!0,type:`(input: string) => string`,children:i`this.mask; `}),t(`hbr`,{}),e(f,{name:`cursor`,protected:!0,type:`number`,children:i`0; `}),t(`hbr`,{}),e(f,{name:`cursorHidden`,protected:!0,type:`boolean`,children:i`false; `}),e(l,{}),i`constructor(protected config: PromptConfig<TValue>) {
+import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { Show, code, splitProps } from "@alloy-js/core";
+import { FunctionDeclaration, VarDeclaration } from "@alloy-js/typescript";
+import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
+import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import { ClassDeclaration, ClassField, ClassMethod, ClassPropertyGet } from "@powerlines/plugin-alloy/typescript/components/class-declaration";
+import { InterfaceDeclaration, InterfaceMember } from "@powerlines/plugin-alloy/typescript/components/interface-declaration";
+import { TSDoc, TSDocDefaultValue, TSDocExample, TSDocParam, TSDocRemarks, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
+import { TypeDeclaration } from "@powerlines/plugin-alloy/typescript/components/type-declaration";
+import { useTheme } from "@shell-shock/plugin-theme/contexts/theme";
+import defu from "defu";
+
+//#region src/components/prompts-builtin.tsx
+/**
+* A component that generates TypeScript declarations for built-in prompt types and related utilities, such as the base Prompt class, specific prompt types like TextPrompt and SelectPrompt, and utility functions for handling prompt cancellations. This component serves as a central place to define the types and interfaces for prompts used in the Shell Shock CLI, providing a consistent API for creating and managing prompts throughout the application.
+*/
+function BasePromptDeclarations() {
+	const theme = useTheme();
+	return [
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "PromptParser",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			doc: "A type for a custom prompt input parser, which can be used to create custom input styles for prompts. The function should return the parsed value for the given input string.",
+			children: code`(this: Prompt<TValue>, input: string) => TValue; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "PromptFormatter",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			doc: "A type for a custom prompt input formatter, which can be used to create custom display styles for prompts. The function should return the formatted string to display for the given input value.",
+			children: code`(this: Prompt<TValue>, input: TValue) => string; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "noMask",
+			doc: "A built-in prompt mask function that just returns the input as is, making it invisible",
+			parameters: [{
+				name: "input",
+				type: "string"
+			}],
+			returnType: "string",
+			children: code`return input; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "invisibleMask",
+			doc: "A built-in prompt mask function that makes input invisible",
+			parameters: [{
+				name: "input",
+				type: "string"
+			}],
+			returnType: "string",
+			children: code`return " ".repeat(input.length); `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "PromptState",
+			doc: "The current state of a prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "value",
+						type: "TValue",
+						doc: "The current value of the prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "isError",
+						type: "boolean",
+						doc: "Indicates whether the prompt is in an error state"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "errorMessage",
+						required: false,
+						type: "string",
+						doc: "If the prompt is in an error state, this will contain the error message to display"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "isSubmitted",
+						type: "boolean",
+						doc: "Indicates whether the prompt is submitted"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "isCancelled",
+						type: "boolean",
+						doc: "Indicates whether the prompt is cancelled"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "isCompleted",
+						type: "boolean",
+						doc: "Indicates whether the prompt is completed, which can be used to indicate that the prompt interaction is finished regardless of whether it was submitted or cancelled"
+					}),
+					createComponent(Spacing, {})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "PromptConfig",
+			doc: "Configuration options for creating a prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "input",
+						required: false,
+						type: "NodeJS.ReadStream",
+						doc: "The readable stream to use for prompt input, defaults to process.stdin"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "output",
+						required: false,
+						type: "NodeJS.WriteStream",
+						doc: "The writable stream to use for prompt output, defaults to process.stdout"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "message",
+						type: "string",
+						doc: "The prompt message to display"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "description",
+						required: false,
+						type: "string",
+						doc: "The prompt description message to display"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "initialValue",
+						required: false,
+						type: "TValue",
+						doc: "The initial value of the prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "validate",
+						required: false,
+						type: "(value: TValue) => boolean | string | null | undefined | Promise<boolean | string | null | undefined>",
+						doc: "A validation function that returns true if the input is valid, false or a string error message if the input is invalid"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "parse",
+						required: false,
+						type: "PromptParser<TValue>",
+						doc: "A function that parses the input value and returns the parsed result or throws an error if the input is invalid"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "format",
+						required: false,
+						type: "PromptFormatter<TValue>",
+						doc: "A function that formats the input value and returns the formatted result or throws an error if the input is invalid"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "mask",
+						required: false,
+						type: "(input: string) => string",
+						doc: "A function that masks the input value and returns the masked result. This can be used to create password inputs or other sensitive input types where the actual input value should not be displayed. If not provided, the prompt will display the input as is without masking."
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "maskCompleted",
+						required: false,
+						type: "(input: string) => string",
+						doc: "A function that masks the value submitted by the user so that it can then be used in the console output or elsewhere without exposing sensitive information. If not provided, the prompt will use the same mask function for both input and submitted value masking."
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "defaultErrorMessage",
+						required: false,
+						type: "string",
+						doc: "The default error message to display when validation fails"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "timeout",
+						required: false,
+						type: "number",
+						doc: "The timeout duration in milliseconds for the prompt. If none is provided, the prompt will not time out."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			abstract: true,
+			name: "Prompt",
+			doc: "Base prompt class that other prompt types can extend from",
+			"extends": "EventEmitter",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "readline",
+						isPrivateMember: true,
+						type: "Interface"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "value",
+						isPrivateMember: true,
+						type: "TValue | undefined"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isKeyPressed",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isDirty",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isClosed",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassField, {
+						name: "initialValue",
+						abstract: true,
+						"protected": true,
+						type: "TValue"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "input",
+						"protected": true,
+						type: "NodeJS.ReadStream",
+						children: code`process.stdin; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "output",
+						"protected": true,
+						type: "NodeJS.WriteStream",
+						children: code`process.stdout; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "message",
+						"protected": true,
+						type: "string",
+						children: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "description",
+						"protected": true,
+						type: "string",
+						children: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "errorMessage",
+						"protected": true,
+						type: "string | null",
+						children: code`null; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "defaultErrorMessage",
+						"protected": true,
+						type: "string",
+						children: code`"An invalid value was provided"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isSubmitted",
+						"protected": true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isCancelled",
+						"protected": true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isInitial",
+						"protected": true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "consoleOutput",
+						"protected": true,
+						type: "string",
+						children: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "consoleStatus",
+						"protected": true,
+						type: "string",
+						children: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "displayValue",
+						"protected": true,
+						type: "string",
+						children: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "validate",
+						"protected": true,
+						type: "(value: TValue) => boolean | string | null | undefined | Promise<boolean | string | null | undefined>",
+						children: code`() => true; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "parse",
+						"protected": true,
+						type: "PromptParser<TValue>",
+						children: code`(value: string) => value as TValue; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "format",
+						"protected": true,
+						type: "PromptFormatter<TValue>",
+						children: code`(value: TValue) => String(value); `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "mask",
+						"protected": true,
+						type: "(input: string) => string",
+						children: code`noMask; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "maskCompleted",
+						"protected": true,
+						type: "(input: string) => string",
+						children: code`this.mask; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursor",
+						"protected": true,
+						type: "number",
+						children: code`0; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(protected config: PromptConfig<TValue>) {
           super();
 
           if (config.input) {
@@ -55,7 +450,49 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
 
         [Symbol.dispose]() {
           this.close();
-        } `,e(l,{}),e(m,{public:!0,name:`value`,type:`TValue`,doc:`A getter for the prompt value that returns the current value or the initial value if the current value is not set`,children:i`return this.#value || this.initialValue; `}),e(l,{}),e(m,{public:!0,name:`isError`,type:`boolean`,children:i`return !!this.errorMessage; `}),e(l,{}),e(m,{protected:!0,name:`isSelect`,type:`boolean`,children:i`return false; `}),e(l,{}),e(m,{protected:!0,name:`isCompleted`,type:`boolean`,children:i`return this.isCancelled || this.isSubmitted; `}),e(l,{}),e(m,{protected:!0,name:`isPlaceholder`,type:`boolean`,children:i`return (this.displayValue === this.format(this.initialValue) && !this.#isDirty) || !this.#isKeyPressed; `}),e(l,{}),e(m,{protected:!0,name:`status`,type:`string`,children:i`return this.isSubmitted ? "" : \` \\n    \${
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"public": true,
+						name: "value",
+						type: "TValue",
+						doc: "A getter for the prompt value that returns the current value or the initial value if the current value is not set",
+						children: code`return this.#value || this.initialValue; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"public": true,
+						name: "isError",
+						type: "boolean",
+						children: code`return !!this.errorMessage; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"protected": true,
+						name: "isSelect",
+						type: "boolean",
+						children: code`return false; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"protected": true,
+						name: "isCompleted",
+						type: "boolean",
+						children: code`return this.isCancelled || this.isSubmitted; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"protected": true,
+						name: "isPlaceholder",
+						type: "boolean",
+						children: code`return (this.displayValue === this.format(this.initialValue) && !this.#isDirty) || !this.#isKeyPressed; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"protected": true,
+						name: "status",
+						type: "string",
+						children: code`return this.isSubmitted ? "" : \` \\n    \${
               italic(
                 this.isError
                   ? textColors.prompt.description.error(splitText(this.errorMessage, "3/4").join("\\n"))
@@ -65,7 +502,34 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
                       ? textColors.prompt.description.active(splitText(this.description, "3/4").join("\\n"))
                       : ""
               )
-            }\`; `}),e(l,{}),e(m,{doc:`A property to check if the cursor is at the start`,name:`isCursorAtStart`,protected:!0,type:`boolean`,children:i`return this.cursor <= 0 || (this.isPlaceholder && this.cursor <= 1); `}),e(l,{}),e(m,{doc:`A property to check if the cursor is at the end`,name:`isCursorAtEnd`,protected:!0,type:`boolean`,children:i`return this.cursor >= this.displayValue.length || (this.isPlaceholder && this.cursor >= this.displayValue.length - 1); `}),e(l,{}),e(p,{doc:`A method to change the prompt value, which also updates the display value and fires a state update event. This method can be called by subclasses whenever the prompt value needs to be updated based on user input or other interactions.`,name:`changeValue`,protected:!0,parameters:[{name:`value`,type:`TValue`}],children:i`const previousValue = this.value;
+            }\`; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						doc: "A property to check if the cursor is at the start",
+						name: "isCursorAtStart",
+						"protected": true,
+						type: "boolean",
+						children: code`return this.cursor <= 0 || (this.isPlaceholder && this.cursor <= 1); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						doc: "A property to check if the cursor is at the end",
+						name: "isCursorAtEnd",
+						"protected": true,
+						type: "boolean",
+						children: code`return this.cursor >= this.displayValue.length || (this.isPlaceholder && this.cursor >= this.displayValue.length - 1); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to change the prompt value, which also updates the display value and fires a state update event. This method can be called by subclasses whenever the prompt value needs to be updated based on user input or other interactions.",
+						name: "changeValue",
+						"protected": true,
+						parameters: [{
+							name: "value",
+							type: "TValue"
+						}],
+						children: code`const previousValue = this.value;
 
           let updatedValue = value;
           if (value === undefined || value === "") {
@@ -86,7 +550,14 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             Promise.resolve(this.checkValidations(updatedValue)).then(() => this.sync());
           }, 0);
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to emit the current state`,name:`sync`,protected:!0,children:i`this.emit("state", {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to emit the current state",
+						name: "sync",
+						"protected": true,
+						children: code`this.emit("state", {
             value: this.value,
             errorMessage: this.errorMessage,
             isError: this.isError,
@@ -94,7 +565,22 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             isCancelled: this.isCancelled,
             isCompleted: this.isCompleted
           });
-          this.render(); `}),e(l,{}),e(p,{doc:`A method to ring the bell`,name:`bell`,protected:!0,children:i`this.output.write(beep); `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,protected:!0,returnType:`string`,children:i`return this.isPlaceholder
+          this.render(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to ring the bell",
+						name: "bell",
+						"protected": true,
+						children: code`this.output.write(beep); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						"protected": true,
+						returnType: "string",
+						children: code`return this.isPlaceholder
             ? textColors.prompt.input.disabled(this.displayValue)
             : this.isError
               ? textColors.prompt.input.error(this.displayValue)
@@ -102,12 +588,45 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
                 ? textColors.prompt.input.submitted(this.maskCompleted(this.displayValue))
                 : this.isCancelled
                   ? textColors.prompt.input.cancelled(this.maskCompleted(this.displayValue))
-              : bold(textColors.prompt.input.active(this.displayValue)); `}),e(l,{}),e(p,{doc:`A method to handle changes in the prompt value`,name:`onChange`,protected:!0,parameters:[{name:`previousValue`,type:`TValue`}],children:i` // can be implemented by subclasses to handle value changes if needed, this method is called whenever the prompt value changes and receives the previous value as an argument for reference`}),e(l,{}),e(p,{doc:`A method to handle key press events and determine the corresponding action`,name:`onKeyPress`,protected:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`const action = this.getAction(key);
+              : bold(textColors.prompt.input.active(this.displayValue)); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle changes in the prompt value",
+						name: "onChange",
+						"protected": true,
+						parameters: [{
+							name: "previousValue",
+							type: "TValue"
+						}],
+						children: code` // can be implemented by subclasses to handle value changes if needed, this method is called whenever the prompt value changes and receives the previous value as an argument for reference`
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle key press events and determine the corresponding action",
+						name: "onKeyPress",
+						"protected": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`const action = this.getAction(key);
           if (!action) {
             this.bell();
           } else if (typeof (this as any)[action] === "function") {
             (this as any)[action](key);
-          } `}),e(l,{}),e(p,{doc:`A method to close the prompt and clean up resources, which also emits a submit or cancel event based on the prompt state. This method should be called when the prompt interaction is finished and the prompt needs to be closed.`,name:`close`,async:!0,protected:!0,children:i`if (this.#isClosed) {
+          } `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to close the prompt and clean up resources, which also emits a submit or cancel event based on the prompt state. This method should be called when the prompt interaction is finished and the prompt needs to be closed.",
+						name: "close",
+						async: true,
+						"protected": true,
+						children: code`if (this.#isClosed) {
             return;
           }
 
@@ -120,14 +639,38 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
 
           this.#readline.close();
           this.emit(this.isSubmitted ? "submit" : "cancel", this.value);
-          this.#isClosed = true; `}),e(l,{}),e(p,{doc:`A method to validate the prompt input using the provided validator function, which updates the error message and error state based on the validation result. This method is called whenever the prompt value changes and needs to be validated.`,name:`checkValidations`,async:!0,protected:!0,parameters:[{name:`value`,type:`TValue`}],children:i`let result = await this.validate(value);
+          this.#isClosed = true; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to validate the prompt input using the provided validator function, which updates the error message and error state based on the validation result. This method is called whenever the prompt value changes and needs to be validated.",
+						name: "checkValidations",
+						async: true,
+						"protected": true,
+						parameters: [{
+							name: "value",
+							type: "TValue"
+						}],
+						children: code`let result = await this.validate(value);
           if (typeof result === "string") {
             this.errorMessage = result;
           } else if (typeof result === "boolean") {
             this.errorMessage = result ? null : this.defaultErrorMessage;
           } else {
             this.errorMessage = null;
-          } `}),e(l,{}),e(p,{doc:`A method to route key press events to specific prompt actions based on the key pressed. This method maps various key combinations and keys to corresponding actions that can be handled by the prompt, such as submitting, cancelling, navigating, etc.`,name:`getAction`,protected:!0,parameters:[{name:`key`,type:`Key`}],returnType:`string | false`,children:i`if (key.meta && key.name !== "escape") {
+          } `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to route key press events to specific prompt actions based on the key pressed. This method maps various key combinations and keys to corresponding actions that can be handled by the prompt, such as submitting, cancelling, navigating, etc.",
+						name: "getAction",
+						"protected": true,
+						parameters: [{
+							name: "key",
+							type: "Key"
+						}],
+						returnType: "string | false",
+						children: code`if (key.meta && key.name !== "escape") {
             return false;
           }
 
@@ -157,7 +700,18 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
           if (key.name === "right") action = "right";
           if (key.name === "left") action = "left";
 
-          return action || false; `}),e(l,{}),e(p,{doc:"A method to move the cursor to the left or right by a \\`count\\` of positions",name:`moveCursor`,parameters:[{name:`count`,type:`number`}],protected:!0,children:i`if (this.cursor + count < 0) {
+          return action || false; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the left or right by a \\`count\\` of positions",
+						name: "moveCursor",
+						parameters: [{
+							name: "count",
+							type: "number"
+						}],
+						"protected": true,
+						children: code`if (this.cursor + count < 0) {
             this.cursor = 0;
           } else if (this.cursor + count > this.displayValue.length) {
             this.cursor = this.displayValue.length;
@@ -165,7 +719,14 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             this.cursor += count;
           }
 
-           `}),e(l,{}),e(p,{doc:`A method to remove the character backward of the cursor`,name:`backspace`,protected:!0,children:i`if (this.isCursorAtStart) {
+           `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to remove the character backward of the cursor",
+						name: "backspace",
+						"protected": true,
+						children: code`if (this.isCursorAtStart) {
             return this.bell();
           }
 
@@ -183,7 +744,14 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
 
           this.moveCursor(isCursorAtEnd ? -1 : -2);
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to remove the character forward of the cursor`,name:`delete`,protected:!0,children:i`if (this.isCursorAtEnd) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to remove the character forward of the cursor",
+						name: "delete",
+						"protected": true,
+						children: code`if (this.isCursorAtEnd) {
             return this.bell();
           }
 
@@ -197,20 +765,42 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             this.moveCursor(-1);
           }
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to reset the prompt input`,name:`reset`,protected:!0,children:i`this.changeValue(this.initialValue);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to reset the prompt input",
+						name: "reset",
+						"protected": true,
+						children: code`this.changeValue(this.initialValue);
           this.cursor = 0;
 
           this.errorMessage = null;
           this.isCancelled = false;
           this.isSubmitted = false;
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to cancel the prompt input`,name:`cancel`,protected:!0,children:i`this.errorMessage = null;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to cancel the prompt input",
+						name: "cancel",
+						"protected": true,
+						children: code`this.errorMessage = null;
           this.isCancelled = true;
           this.isSubmitted = false;
 
           this.sync();
           this.output.write("\\n");
-          this.close(); `}),e(l,{}),e(p,{doc:`A method to submit the prompt input`,name:`submit`,async:!0,protected:!0,children:i`this.cursor = this.displayValue.length;
+          this.close(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to submit the prompt input",
+						name: "submit",
+						async: true,
+						"protected": true,
+						children: code`this.cursor = this.displayValue.length;
 
           await this.checkValidations(this.value);
           if (this.isError) {
@@ -223,7 +813,15 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             this.sync();
             this.output.write("\\n");
             this.close();
-          } `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`render`,private:!0,get children(){return i`if (this.#isClosed) {
+          } `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "render",
+						"private": true,
+						get children() {
+							return code`if (this.#isClosed) {
               return;
             }
 
@@ -244,12 +842,12 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
 
               this.consoleOutput = \` \${
               this.isSubmitted
-                ? textColors.prompt.icon.submitted("${n.icons.prompt.submitted}")
+                ? textColors.prompt.icon.submitted("${theme.icons.prompt.submitted}")
                 : this.isCancelled
-                  ? textColors.prompt.icon.cancelled("${n.icons.prompt.cancelled}")
+                  ? textColors.prompt.icon.cancelled("${theme.icons.prompt.cancelled}")
                   : this.isError
-                    ? textColors.prompt.icon.error("${n.icons.prompt.error}")
-                    : textColors.prompt.icon.active("${n.icons.prompt.active}")
+                    ? textColors.prompt.icon.error("${theme.icons.prompt.error}")
+                    : textColors.prompt.icon.active("${theme.icons.prompt.active}")
               }  \${
                 this.isCompleted
                 ? textColors.prompt.message.submitted(this.message)
@@ -272,7 +870,22 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
               this.consoleStatus = this.status;
             } finally {
               clearTimeout(timeout);
-            } `}}),e(l,{}),e(p,{doc:`A method to handle key press events and determine the corresponding action`,name:`keypress`,private:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`if (this.#isClosed) {
+            } `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle key press events and determine the corresponding action",
+						name: "keypress",
+						"private": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`if (this.#isClosed) {
             return;
           }
 
@@ -280,7 +893,124 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
             this.#isKeyPressed = true;
           }
 
-          return this.onKeyPress(char, key); `})]}}),e(l,{}),e(h,{name:`PromptFactoryConfig`,extends:`PromptConfig<TValue>`,doc:`Configuration options for creating a prompt with a prompt factory function`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`onState`,optional:!0,type:`(state: PromptState<TValue>) => any`,doc:`A function that is called when the prompt state changes, useful for updating the prompt message or other properties dynamically`}),e(l,{}),e(g,{name:`onSubmit`,optional:!0,type:`(value: TValue) => any`,doc:`A function that is called when the prompt is submitted, useful for handling the submitted value or performing actions based on the prompt state`}),e(l,{}),e(g,{name:`onCancel`,optional:!0,type:`(event: any) => any`,doc:`A function that is called when the prompt is canceled, useful for handling the canceled value or performing actions based on the prompt state`})]}}),e(l,{}),e(_,{heading:`A unique symbol used to indicate that a prompt was cancelled, which can be returned from a prompt function to signal that the prompt interaction should be cancelled and any pending promises should be rejected with this symbol. This allows for a consistent way to handle prompt cancellations across different prompt types and interactions.`}),e(s,{export:!0,name:`CANCEL_SYMBOL`,children:i`Symbol("shell-shock:prompts:cancel"); `}),e(l,{}),e(_,{heading:`A utility function to check if a given value is the {@link CANCEL_SYMBOL | cancel symbol}, which can be used to determine if a prompt interaction was cancelled based on the value returned from a prompt factory function. This function checks if the provided value is strictly equal to the {@link CANCEL_SYMBOL | CANCEL_SYMBOL}, allowing for a consistent way to handle prompt cancellations across different prompt types and interactions.`,get children(){return[e(b,{name:`value`,children:`The value to check.`}),e(S,{children:`A boolean indicating whether the provided value is the {@link CANCEL_SYMBOL | cancel symbol}, which can be used to determine if a prompt interaction was cancelled.`})]}}),e(o,{name:`isCancel`,export:!0,parameters:[{name:`value`,type:`any`}],returnType:`value is typeof CANCEL_SYMBOL`,children:i`return value === CANCEL_SYMBOL; `})]}function D(){return[e(h,{name:`StringPromptConfig`,extends:`PromptConfig<string>`,doc:`Configuration options for creating a text-based prompt`,get children(){return[e(g,{name:`initialValue`,optional:!0,type:`string`,doc:`The initial value of the prompt`}),e(l,{}),e(g,{name:`mask`,optional:!0,type:`(input: string) => string`,doc:`A function that masks the input value and returns the masked result`})]}}),e(l,{}),e(d,{name:`StringPrompt`,doc:`A prompt for text input`,extends:`Prompt<string>`,get children(){return[e(f,{name:`isInvalid`,isPrivateMember:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`initialValue`,protected:!0,override:!0,type:`string`,children:i`""; `}),e(l,{}),i`constructor(config: StringPromptConfig) {
+          return this.onKeyPress(char, key); `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "PromptFactoryConfig",
+			"extends": "PromptConfig<TValue>",
+			doc: "Configuration options for creating a prompt with a prompt factory function",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "onState",
+						required: false,
+						type: "(state: PromptState<TValue>) => any",
+						doc: "A function that is called when the prompt state changes, useful for updating the prompt message or other properties dynamically"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "onSubmit",
+						required: false,
+						type: "(value: TValue) => any",
+						doc: "A function that is called when the prompt is submitted, useful for handling the submitted value or performing actions based on the prompt state"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "onCancel",
+						required: false,
+						type: "(event: any) => any",
+						doc: "A function that is called when the prompt is canceled, useful for handling the canceled value or performing actions based on the prompt state"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "A unique symbol used to indicate that a prompt was cancelled, which can be returned from a prompt function to signal that the prompt interaction should be cancelled and any pending promises should be rejected with this symbol. This allows for a consistent way to handle prompt cancellations across different prompt types and interactions." }),
+		createComponent(VarDeclaration, {
+			"export": true,
+			name: "CANCEL_SYMBOL",
+			children: code`Symbol("shell-shock:prompts:cancel"); `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A utility function to check if a given value is the {@link CANCEL_SYMBOL | cancel symbol}, which can be used to determine if a prompt interaction was cancelled based on the value returned from a prompt factory function. This function checks if the provided value is strictly equal to the {@link CANCEL_SYMBOL | CANCEL_SYMBOL}, allowing for a consistent way to handle prompt cancellations across different prompt types and interactions.",
+			get children() {
+				return [createComponent(TSDocParam, {
+					name: "value",
+					children: `The value to check.`
+				}), createComponent(TSDocReturns, { children: `A boolean indicating whether the provided value is the {@link CANCEL_SYMBOL | cancel symbol}, which can be used to determine if a prompt interaction was cancelled.` })];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "isCancel",
+			"export": true,
+			parameters: [{
+				name: "value",
+				type: "any"
+			}],
+			returnType: "value is typeof CANCEL_SYMBOL",
+			children: code`return value === CANCEL_SYMBOL; `
+		})
+	];
+}
+/**
+* Declarations for a text-based prompt that allows users to input and edit text, with support for cursor movement, deletion, and custom masking. This prompt type can be used for various text input scenarios, such as entering a username, password, or any other string input. The TextPrompt class extends the base Prompt class and implements specific logic for handling text input and editing interactions.
+*/
+function TextPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			name: "StringPromptConfig",
+			"extends": "PromptConfig<string>",
+			doc: "Configuration options for creating a text-based prompt",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "initialValue",
+						required: false,
+						type: "string",
+						doc: "The initial value of the prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "mask",
+						required: false,
+						type: "(input: string) => string",
+						doc: "A function that masks the input value and returns the masked result"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "StringPrompt",
+			doc: "A prompt for text input",
+			"extends": "Prompt<string>",
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "isInvalid",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "string",
+						children: code`""; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: StringPromptConfig) {
           super(config);
 
           if (config.initialValue) {
@@ -294,7 +1024,21 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
           this.cursor = 0;
           this.sync();
           this.last();
-        } `,e(l,{}),e(p,{doc:`A method to handle onKeyPress events and determine the corresponding action`,name:`onKeyPress`,override:!0,protected:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`const action = this.getAction(key);
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle onKeyPress events and determine the corresponding action",
+						name: "onKeyPress",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`const action = this.getAction(key);
           if (action && typeof (this as any)[action] === "function") {
             return (this as any)[action]();
           }
@@ -308,24 +1052,97 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
           }\${char}\${
             this.displayValue.slice(this.cursor)
           }\`);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to handle changes in the prompt value`,name:`onChange`,override:!0,protected:!0,parameters:[{name:`previousValue`,type:`string`}],children:i`this.#isInvalid = false;
-          this.cursor = this.displayValue.slice(0, this.cursor).length + 1; `}),e(l,{}),e(p,{doc:`A method to reset the prompt input`,name:`reset`,override:!0,protected:!0,children:i`this.cursor = Number(!!this.initialValue);
-          super.reset(); `}),e(l,{}),e(p,{doc:`A method to validate the prompt input`,name:`checkValidations`,override:!0,async:!0,protected:!0,children:i`await super.checkValidations(this.value);
-          this.#isInvalid = this.isError; `}),e(l,{}),e(p,{doc:`A method to move the cursor to the end of the input`,name:`next`,protected:!0,children:i`this.changeValue(this.initialValue);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle changes in the prompt value",
+						name: "onChange",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "previousValue",
+							type: "string"
+						}],
+						children: code`this.#isInvalid = false;
+          this.cursor = this.displayValue.slice(0, this.cursor).length + 1; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to reset the prompt input",
+						name: "reset",
+						override: true,
+						"protected": true,
+						children: code`this.cursor = Number(!!this.initialValue);
+          super.reset(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to validate the prompt input",
+						name: "checkValidations",
+						override: true,
+						async: true,
+						"protected": true,
+						children: code`await super.checkValidations(this.value);
+          this.#isInvalid = this.isError; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the end of the input",
+						name: "next",
+						"protected": true,
+						children: code`this.changeValue(this.initialValue);
           this.cursor = this.displayValue.length;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the start`,name:`first`,protected:!0,children:i`this.cursor = 0;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the end`,name:`last`,protected:!0,children:i`this.cursor = this.displayValue.length;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the left`,name:`left`,protected:!0,children:i`if (this.cursor <= 0) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the start",
+						name: "first",
+						"protected": true,
+						children: code`this.cursor = 0;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the end",
+						name: "last",
+						"protected": true,
+						children: code`this.cursor = this.displayValue.length;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the left",
+						name: "left",
+						"protected": true,
+						children: code`if (this.cursor <= 0) {
             return this.bell();
           }
 
           this.moveCursor(-1);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the right`,name:`right`,protected:!0,children:i`if (this.cursor >= this.displayValue.length) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the right",
+						name: "right",
+						"protected": true,
+						children: code`if (this.cursor >= this.displayValue.length) {
             return this.bell();
           }
 
           this.moveCursor(1);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,override:!0,protected:!0,returnType:`string`,children:i`return this.isPlaceholder
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						override: true,
+						"protected": true,
+						returnType: "string",
+						children: code`return this.isPlaceholder
             ? textColors.prompt.input.disabled(this.displayValue)
             : this.#isInvalid
               ? textColors.prompt.input.error(this.displayValue)
@@ -333,7 +1150,25 @@ import{createComponent as e,createIntrinsic as t,mergeProps as n}from"@alloy-js/
                 ? textColors.prompt.input.submitted(this.displayValue)
                 : this.isCancelled
                   ? textColors.prompt.input.cancelled(this.displayValue)
-              : bold(textColors.prompt.input.active(this.displayValue)); `})]}}),e(l,{}),e(_,{heading:`A type definition for the configuration options to pass to the text prompt, which extends the base PromptConfig with additional options specific to text prompts. This type can be used when creating a text prompt using the {@link text | text prompt factory function} or when manually creating an instance of the TextPrompt class. The TextConfig type includes all the properties of the base PromptConfig, such as message, description, initialValue, validate, parse, format, mask, etc., as well as any additional properties that are specific to text prompts.`}),e(C,{name:`TextConfig`,export:!0,children:i`PromptFactoryConfig<string> & StringPromptConfig; `}),e(l,{}),e(_,{heading:`A function to create and run a text prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(x,{children:i`This function can be used to easily create and run a text prompt without needing to manually create an instance of the TextPrompt class and handle its events. The function accepts a configuration object that extends the base PromptFactoryConfig with additional options specific to text prompts, such as the initial value and mask function. The returned promise allows for easy handling of the prompt result using async/await syntax or traditional promise chaining.`}),e(y,{children:`import { text, isCancel } from "shell-shock:prompts";
+              : bold(textColors.prompt.input.active(this.displayValue)); `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "A type definition for the configuration options to pass to the text prompt, which extends the base PromptConfig with additional options specific to text prompts. This type can be used when creating a text prompt using the {@link text | text prompt factory function} or when manually creating an instance of the TextPrompt class. The TextConfig type includes all the properties of the base PromptConfig, such as message, description, initialValue, validate, parse, format, mask, etc., as well as any additional properties that are specific to text prompts." }),
+		createComponent(TypeDeclaration, {
+			name: "TextConfig",
+			"export": true,
+			children: code`PromptFactoryConfig<string> & StringPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a text prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: code`This function can be used to easily create and run a text prompt without needing to manually create an instance of the TextPrompt class and handle its events. The function accepts a configuration object that extends the base PromptFactoryConfig with additional options specific to text prompts, such as the initial value and mask function. The returned promise allows for easy handling of the prompt result using async/await syntax or traditional promise chaining.` }),
+					createComponent(TSDocExample, { children: `import { text, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const name = await text({
@@ -349,13 +1184,202 @@ async function run() {
   console.log("Hello, " + name + "!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the text prompt, which extends the base PromptConfig with additional options specific to text prompts`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`text`,export:!0,parameters:[{name:`config`,type:`TextConfig`}],returnType:`Promise<string | symbol>`,children:i`return new Promise<string | symbol>((response, reject) => {
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the text prompt, which extends the base PromptConfig with additional options specific to text prompts`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "text",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "TextConfig"
+			}],
+			returnType: "Promise<string | symbol>",
+			children: code`return new Promise<string | symbol>((response, reject) => {
             const prompt = new StringPrompt(config);
 
             prompt.on("state", state => config.onState?.(state));
             prompt.on("submit", value => response(value));
             prompt.on("cancel", event => response(CANCEL_SYMBOL));
-          });`})]}function O(){return[e(h,{name:`PromptOptionConfig`,doc:`Configuration for an option the user can select from the select prompt`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`label`,optional:!0,type:`string`,doc:`The message label for the option`}),e(l,{}),e(g,{name:`icon`,optional:!0,type:`string`,doc:`An icon for the option`}),e(l,{}),e(g,{name:`value`,type:`TValue`,doc:`The value of the option`}),e(l,{}),e(g,{name:`description`,optional:!0,type:`string`,doc:`The description of the option`}),e(l,{}),e(g,{name:`selected`,optional:!0,type:`boolean`,doc:`Whether the option is selected`}),e(l,{}),e(g,{name:`disabled`,optional:!0,type:`boolean`,doc:`Whether the option is disabled`})]}}),e(l,{}),e(h,{export:!0,name:`PromptOption`,extends:`PromptOptionConfig<TValue>`,doc:`An option the user can select from the select prompt`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`label`,type:`string`,doc:`The message label for the option`}),e(g,{name:`index`,type:`number`,doc:`The index of the option`}),e(l,{}),e(g,{name:`selected`,type:`boolean`,doc:`Whether the option is selected`}),e(l,{}),e(g,{name:`disabled`,type:`boolean`,doc:`Whether the option is disabled`})]}}),e(l,{}),e(h,{name:`SelectPromptConfig`,extends:`PromptConfig<TValue>`,doc:`An options object for configuring a select prompt`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(g,{name:`hint`,optional:!0,type:`string`,doc:`A hint to display to the user`}),e(l,{}),e(g,{name:`options`,type:`Array<string | PromptOptionConfig<TValue>>`,doc:`The options available for the select prompt`}),e(l,{}),e(g,{name:`optionsPerPage`,optional:!0,type:`number`,doc:`The number of options to display per page, defaults to 8`})]}}),e(l,{}),e(d,{name:`SelectPrompt`,doc:`A prompt for selecting an option from a list`,extends:`Prompt<TValue>`,typeParameters:[{name:`TValue`,default:`string`}],get children(){return[e(f,{name:`initialValue`,protected:!0,override:!0,type:`TValue`}),t(`hbr`,{}),e(f,{name:`optionsPerPage`,protected:!0,type:`number`,children:i`8; `}),t(`hbr`,{}),e(f,{name:`options`,protected:!0,type:`PromptOption<TValue>[]`,children:i`[]; `}),t(`hbr`,{}),e(f,{name:`cursorHidden`,protected:!0,override:!0,type:`boolean`,children:i`true; `}),e(l,{}),i`constructor(config: SelectPromptConfig<TValue>) {
+          });`
+		})
+	];
+}
+/**
+* Declarations for a select prompt that allows users to choose from a list of options, with support for pagination, option descriptions, and disabled options. This prompt type can be used for scenarios where the user needs to select one option from a predefined list, such as choosing a color, selecting a file, or picking an item from a menu. The SelectPrompt class extends the base Prompt class and implements specific logic for handling option selection and navigation interactions.
+*/
+function SelectPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			name: "PromptOptionConfig",
+			doc: "Configuration for an option the user can select from the select prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "label",
+						schema: { type: "string" },
+						required: false,
+						doc: "The message label for the option"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "icon",
+						schema: { type: "string" },
+						required: false,
+						doc: "An icon for the option"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "value",
+						type: "TValue",
+						doc: "The value of the option"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "description",
+						schema: { type: "string" },
+						required: false,
+						doc: "The description of the option"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "selected",
+						schema: { type: "boolean" },
+						required: false,
+						doc: "Whether the option is selected"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "disabled",
+						schema: { type: "boolean" },
+						required: false,
+						doc: "Whether the option is disabled"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "PromptOption",
+			"extends": "PromptOptionConfig<TValue>",
+			doc: "An option the user can select from the select prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "label",
+						type: "string",
+						doc: "The message label for the option"
+					}),
+					createComponent(InterfaceMember, {
+						name: "index",
+						type: "number",
+						doc: "The index of the option"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "selected",
+						type: "boolean",
+						doc: "Whether the option is selected"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "disabled",
+						type: "boolean",
+						doc: "Whether the option is disabled"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "SelectPromptConfig",
+			"extends": "PromptConfig<TValue>",
+			doc: "An options object for configuring a select prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "hint",
+						required: false,
+						type: "string",
+						doc: "A hint to display to the user"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "options",
+						type: "Array<string | PromptOptionConfig<TValue>>",
+						doc: "The options available for the select prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "optionsPerPage",
+						required: false,
+						type: "number",
+						doc: "The number of options to display per page, defaults to 8"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "SelectPrompt",
+			doc: "A prompt for selecting an option from a list",
+			"extends": "Prompt<TValue>",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "TValue"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "optionsPerPage",
+						"protected": true,
+						type: "number",
+						children: code`8; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "options",
+						"protected": true,
+						type: "PromptOption<TValue>[]",
+						children: code`[]; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: SelectPromptConfig<TValue>) {
           super(config);
 
           if (config.initialValue) {
@@ -400,37 +1424,136 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           }
 
           this.sync();
-        } `,e(l,{}),e(m,{doc:`Returns the currently selected option`,name:`selectedOption`,type:`PromptOption<TValue> | null`,protected:!0,children:i`return this.options.find(option => option.value === this.value) ?? null; `}),e(l,{}),e(p,{doc:`A method to route key press events to specific prompt actions based on the key pressed. This method maps various key combinations and keys to corresponding actions that can be handled by the prompt, such as submitting, cancelling, navigating, etc.`,name:`getAction`,override:!0,protected:!0,parameters:[{name:`key`,type:`Key`}],returnType:`string | false`,children:i`let action = super.getAction(key);
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						doc: "Returns the currently selected option",
+						name: "selectedOption",
+						type: "PromptOption<TValue> | null",
+						"protected": true,
+						children: code`return this.options.find(option => option.value === this.value) ?? null; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to route key press events to specific prompt actions based on the key pressed. This method maps various key combinations and keys to corresponding actions that can be handled by the prompt, such as submitting, cancelling, navigating, etc.",
+						name: "getAction",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "key",
+							type: "Key"
+						}],
+						returnType: "string | false",
+						children: code`let action = super.getAction(key);
           if (!action) {
             if (key.name === "j") action = "down";
             if (key.name === "k") action = "up";
           }
 
-          return action || false; `}),e(l,{}),e(p,{doc:`A method to reset the prompt input`,name:`reset`,override:!0,protected:!0,children:i`this.moveCursor(0);
-          super.reset(); `}),e(l,{}),e(p,{doc:`A method to submit the prompt input`,name:`submit`,async:!0,override:!0,protected:!0,children:i`if (!this.selectedOption?.disabled) {
+          return action || false; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to reset the prompt input",
+						name: "reset",
+						override: true,
+						"protected": true,
+						children: code`this.moveCursor(0);
+          super.reset(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to submit the prompt input",
+						name: "submit",
+						async: true,
+						override: true,
+						"protected": true,
+						children: code`if (!this.selectedOption?.disabled) {
             await super.submit();
           } else {
             this.bell();
-          } `}),e(l,{}),e(p,{doc:`A method to move the cursor to the end of the input`,name:`next`,protected:!0,children:i`this.moveCursor((this.cursor + 1) % this.options.length);
-          this.sync(); `}),e(l,{}),e(p,{doc:"A method to move the cursor to the left or right by a \\`count\\` of positions",name:`moveCursor`,parameters:[{name:`count`,type:`number`}],override:!0,protected:!0,children:i`this.cursor = count;
+          } `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the end of the input",
+						name: "next",
+						"protected": true,
+						children: code`this.moveCursor((this.cursor + 1) % this.options.length);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the left or right by a \\`count\\` of positions",
+						name: "moveCursor",
+						parameters: [{
+							name: "count",
+							type: "number"
+						}],
+						override: true,
+						"protected": true,
+						children: code`this.cursor = count;
 
           this.changeValue(this.options[count]!.value);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the first option`,name:`first`,protected:!0,children:i`this.moveCursor(0);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the last option`,name:`last`,protected:!0,children:i`this.moveCursor(this.options.length - 1);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the start`,name:`first`,protected:!0,children:i`this.cursor = 0;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the up`,name:`up`,protected:!0,children:i`if (this.cursor === 0) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the first option",
+						name: "first",
+						"protected": true,
+						children: code`this.moveCursor(0);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the last option",
+						name: "last",
+						"protected": true,
+						children: code`this.moveCursor(this.options.length - 1);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the start",
+						name: "first",
+						"protected": true,
+						children: code`this.cursor = 0;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the up",
+						name: "up",
+						"protected": true,
+						children: code`if (this.cursor === 0) {
             this.moveCursor(this.options.length - 1);
           } else {
             this.moveCursor(this.cursor - 1);
           }
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the down`,name:`down`,protected:!0,children:i`if (this.cursor === this.options.length - 1) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the down",
+						name: "down",
+						"protected": true,
+						children: code`if (this.cursor === this.options.length - 1) {
             this.moveCursor(0);
           } else {
             this.moveCursor(this.cursor + 1);
           }
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,override:!0,protected:!0,children:i`const spacing = Math.max(...this.options.map(option => option.label?.length || 0)) + 2;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						override: true,
+						"protected": true,
+						children: code`const spacing = Math.max(...this.options.map(option => option.label?.length || 0)) + 2;
 
           const startIndex = Math.max(Math.min(this.options.length - this.optionsPerPage, this.cursor - Math.floor(this.optionsPerPage / 2)), 0);
           const endIndex = Math.min(startIndex + this.optionsPerPage, this.options.length);
@@ -482,7 +1605,29 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
             output += super.onRender();
           }
 
-          return output; `})]}}),e(l,{}),e(_,{heading:`A type definition for the configuration options to pass to the select prompt, which extends the base PromptConfig with additional options specific to select prompts. This type can be used when creating a select prompt using the {@link select | select prompt factory function}.`,get children(){return e(x,{children:`The Select Config type includes all the properties of the base PromptConfig, such as message, description, initialValue, validate, parse, format, etc., as well as any additional properties that are specific to select prompts, such as the list of options and pagination settings.`})}}),e(C,{export:!0,name:`SelectConfig`,children:i`PromptFactoryConfig<string> & SelectPromptConfig; `}),e(l,{}),e(_,{heading:`A function to create and run a select prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(y,{children:`import { select, isCancel } from "shell-shock:prompts";
+          return output; `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A type definition for the configuration options to pass to the select prompt, which extends the base PromptConfig with additional options specific to select prompts. This type can be used when creating a select prompt using the {@link select | select prompt factory function}.",
+			get children() {
+				return createComponent(TSDocRemarks, { children: `The Select Config type includes all the properties of the base PromptConfig, such as message, description, initialValue, validate, parse, format, etc., as well as any additional properties that are specific to select prompts, such as the list of options and pagination settings.` });
+			}
+		}),
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "SelectConfig",
+			children: code`PromptFactoryConfig<string> & SelectPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a select prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { select, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const color = await select({
@@ -504,13 +1649,558 @@ async function run() {
   console.log("Your favorite color is " + color + "!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the select prompt, which extends the base PromptConfig with additional options specific to select prompts`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`select`,export:!0,parameters:[{name:`config`,type:`SelectConfig`}],returnType:`Promise<string | symbol>`,children:i`return new Promise<string | symbol>((response, reject) => {
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the select prompt, which extends the base PromptConfig with additional options specific to select prompts`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "select",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "SelectConfig"
+			}],
+			returnType: "Promise<string | symbol>",
+			children: code`return new Promise<string | symbol>((response, reject) => {
             const prompt = new SelectPrompt(config);
 
             prompt.on("state", state => config.onState?.(state));
             prompt.on("submit", value => response(value));
             prompt.on("cancel", event => response(CANCEL_SYMBOL));
-          });`})]}function k(){return[e(h,{name:`NumberPromptConfig`,extends:`PromptConfig<number>`,doc:`Configuration options for creating a numeric prompt`,get children(){return[e(g,{name:`isFloat`,optional:!0,type:`boolean`,doc:`Whether the prompt should accept floating point numbers`}),e(l,{}),e(g,{name:`precision`,optional:!0,type:`number`,doc:`The number of decimal places to round the input to, defaults to 2`}),e(l,{}),e(g,{name:`increment`,optional:!0,type:`number`,doc:`The increment value for the number prompt, defaults to 1`}),e(l,{}),e(g,{name:`min`,optional:!0,type:`number`,doc:`The minimum value for the number prompt, defaults to -Infinity`}),e(l,{}),e(g,{name:`max`,optional:!0,type:`number`,doc:`The maximum value for the number prompt, defaults to Infinity`})]}}),e(l,{}),e(d,{name:`NumberPrompt`,doc:`A prompt for selecting a number input`,extends:`Prompt<number>`,get children(){return[e(f,{name:`isInvalid`,isPrivateMember:!0,type:`boolean`,children:i`false; `}),e(l,{}),e(f,{name:`initialValue`,protected:!0,override:!0,type:`number`,children:i`0; `}),t(`hbr`,{}),e(f,{name:`defaultErrorMessage`,protected:!0,override:!0,type:`string`,children:i`"A valid numeric value must be provided"; `}),t(`hbr`,{}),e(f,{name:`isFloat`,protected:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`precision`,protected:!0,type:`number`,children:i`2; `}),t(`hbr`,{}),e(f,{name:`increment`,protected:!0,type:`number`,children:i`1; `}),t(`hbr`,{}),e(f,{name:`min`,protected:!0,type:`number`,children:i`Number.NEGATIVE_INFINITY; `}),t(`hbr`,{}),e(f,{name:`max`,protected:!0,type:`number`,children:i`Number.POSITIVE_INFINITY; `}),e(l,{}),i`constructor(config: NumberPromptConfig) {
+          });`
+		})
+	];
+}
+/**
+* Declarations for a multi-select prompt that allows users to choose multiple options from a list, with support for disabled options, bulk selection shortcuts, and required validation. This prompt type is useful for scenarios where users need to select one or more values from a predefined set.
+*/
+function MultiSelectPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			name: "MultiSelectPromptConfig",
+			"extends": "PromptConfig<TValue[]>",
+			doc: "An options object for configuring a multi-select prompt",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "options",
+						type: "Array<string | PromptOptionConfig<TValue>>",
+						doc: "The options available for the multi-select prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "required",
+						required: false,
+						type: "boolean",
+						doc: "Whether at least one option must be selected, defaults to true"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "initialValue",
+						required: false,
+						type: "TValue[]",
+						doc: "The initial selected values"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "cursorAt",
+						required: false,
+						type: "TValue",
+						doc: "A value indicating which option should be focused initially"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "optionsPerPage",
+						required: false,
+						type: "number",
+						doc: "The number of options to display per page, defaults to 8"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "MultiSelectPrompt",
+			doc: "A prompt for selecting multiple options from a list",
+			"extends": "Prompt<TValue[]>",
+			typeParameters: [{
+				name: "TValue",
+				default: "string"
+			}],
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "TValue[]",
+						children: code`[]; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "required",
+						"protected": true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "optionsPerPage",
+						"protected": true,
+						type: "number",
+						children: code`8; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "options",
+						"protected": true,
+						type: "PromptOption<TValue>[]",
+						children: code`[]; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: MultiSelectPromptConfig<TValue>) {
+          super(config);
+
+          this.required = config.required ?? true;
+          this.initialValue = Array.isArray(config.initialValue) ? [...config.initialValue] : [];
+
+          if (config.optionsPerPage) {
+            this.optionsPerPage = config.optionsPerPage;
+          }
+
+          this.options = config.options.map((opt, index) => {
+            let option = {} as Partial<PromptOption<TValue>>;
+            if (typeof opt === "string") {
+              option = {
+                label: opt,
+                value: opt as TValue,
+                selected: this.initialValue.includes(opt as TValue),
+                disabled: false
+              };
+            } else if (typeof opt === "object" && opt !== null) {
+              option = {
+                ...opt,
+                selected: this.initialValue.includes(opt.value as TValue) || !!opt.selected
+              };
+            } else {
+              throw new Error("Invalid option provided to MultiSelectPrompt at index #" + index);
+            }
+
+            return {
+              label: option.label || String(option.value),
+              ...option,
+              description: option.description,
+              selected: !!option.selected,
+              disabled: !!option.disabled,
+              index
+            } as PromptOption<TValue>;
+          });
+
+          if (config.cursorAt !== undefined) {
+            const index = this.options.findIndex(option => option.value === config.cursorAt);
+            if (index > -1) {
+              this.cursor = index;
+            }
+          }
+
+          if (this.options[this.cursor]?.disabled) {
+            this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          } else {
+            this.changeValue(this.getSelectedValues());
+          }
+
+          this.sync();
+        }
+
+        protected getAction(key: Key): string | false {
+          let action = super.getAction(key);
+          if (!action) {
+            if (key.name === "j") action = "down";
+            if (key.name === "k") action = "up";
+            if (key.name === "a") action = "toggleAll";
+            if (key.name === "i") action = "toggleInvert";
+            if (key.name === "space") action = "toggleCurrent";
+          }
+
+          return action || false;
+        }
+
+        protected override async submit() {
+          const selectedValues = this.getSelectedValues();
+          if (this.required && selectedValues.length === 0) {
+            this.error(
+              "Please select at least one option. Press <space> to toggle and <enter> to submit."
+            );
+            this.bell();
+            return;
+          }
+
+          this.changeValue(selectedValues);
+          await super.submit();
+        }
+
+        protected toggleCurrent() {
+          const option = this.options[this.cursor];
+          if (!option || option.disabled) {
+            this.bell();
+            return;
+          }
+
+          option.selected = !option.selected;
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected toggleAll() {
+          const enabled = this.options.filter(option => !option.disabled);
+          const areAllSelected = enabled.every(option => option.selected);
+          for (const option of enabled) {
+            option.selected = !areAllSelected;
+          }
+
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected toggleInvert() {
+          for (const option of this.options) {
+            if (!option.disabled) {
+              option.selected = !option.selected;
+            }
+          }
+
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected findNextEnabled(from: number, direction: 1 | -1): number {
+          if (this.options.length === 0) {
+            return 0;
+          }
+
+          let index = from;
+          for (let i = 0; i < this.options.length; i++) {
+            index = (index + direction + this.options.length) % this.options.length;
+            if (!this.options[index]?.disabled) {
+              return index;
+            }
+          }
+
+          return from;
+        }
+
+        protected getSelectedValues(): TValue[] {
+          return this.options
+            .filter(option => option.selected)
+            .map(option => option.value as TValue);
+        }
+
+        protected next() {
+          this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          this.sync();
+        }
+
+        protected up() {
+          this.moveCursor(this.findNextEnabled(this.cursor, -1));
+          this.sync();
+        }
+
+        protected down() {
+          this.moveCursor(this.findNextEnabled(this.cursor, 1));
+          this.sync();
+        }
+
+        protected first() {
+          this.moveCursor(this.findNextEnabled(0, 1));
+          this.sync();
+        }
+
+        protected last() {
+          this.moveCursor(this.findNextEnabled(this.options.length - 1, -1));
+          this.sync();
+        }
+
+        protected override moveCursor(count: number) {
+          this.cursor = count;
+          this.changeValue(this.getSelectedValues());
+          this.sync();
+        }
+
+        protected override onRender() {
+          const spacing = Math.max(...this.options.map(option => option.label?.length || 0), 0) + 2;
+          const startIndex = Math.max(
+            Math.min(
+              this.options.length - this.optionsPerPage,
+              this.cursor - Math.floor(this.optionsPerPage / 2)
+            ),
+            0
+          );
+          const endIndex = Math.min(startIndex + this.optionsPerPage, this.options.length);
+
+          let output = "";
+          if (!this.isCompleted) {
+            output += " \\\n";
+
+            for (let index = startIndex; index < endIndex; index++) {
+              const option = this.options[index]!;
+              const active = this.cursor === index;
+              const selected = !!option.selected;
+              const disabled = !!option.disabled;
+
+              const pointer = disabled
+                ? active
+                  ? bold(textColors.prompt.input.disabled(">"))
+                  : index === startIndex
+                    ? borderColors.app.divider.tertiary("↑")
+                    : index === endIndex - 1
+                      ? borderColors.app.divider.tertiary("↓")
+                      : " "
+                : active
+                  ? bold(textColors.prompt.input.active(">"))
+                  : index === startIndex
+                    ? borderColors.app.divider.tertiary("↑")
+                    : index === endIndex - 1
+                      ? borderColors.app.divider.tertiary("↓")
+                      : " ";
+
+              const marker = isUnicodeSupported ? (selected ? "🗹" : "☐") : (selected ? "[x]" : "[ ]");
+              const markerText = disabled
+                ? active
+                  ? bold(textColors.prompt.input.disabled(marker))
+                  : textColors.prompt.input.disabled(marker)
+                : active
+                  ? bold(textColors.prompt.input.active(marker))
+                  : textColors.prompt.input.inactive(marker);
+
+              const labelText = disabled
+                ? active
+                  ? bold(underline(textColors.prompt.input.disabled(option.label)))
+                  : strikethrough(textColors.prompt.input.disabled(option.label))
+                : active
+                  ? bold(underline(textColors.prompt.input.active(option.label)))
+                  : selected
+                    ? textColors.prompt.input.active(option.label)
+                    : textColors.prompt.input.inactive(option.label);
+
+              output +=
+                pointer +
+                " " +
+                markerText +
+                " " +
+                labelText +
+                " " +
+                " ".repeat(Math.max(0, spacing - option.label.length)) +
+                (option.description && active
+                  ? italic(textColors.prompt.description.active(option.description))
+                  : "") +
+                " \\\n";
+            }
+          } else {
+            const selected = this.options.filter(option => option.selected);
+            this.displayValue =
+              selected.length > 0
+                ? selected.map(option => option.label).join(", ")
+                : "(none)";
+            output += super.onRender();
+          }
+
+          return output;
+        }`
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "A type definition for the configuration options to pass to the multi-select prompt, which extends the base PromptConfig with additional options specific to multi-select prompts." }),
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "MultiSelectConfig",
+			children: code`PromptFactoryConfig<string[]> & MultiSelectPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a multi-select prompt, which returns a promise that resolves with the submitted values or a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { multiselect, isCancel } from "shell-shock:prompts";
+
+async function run() {
+  const tools = await multiselect({
+    message: "Select tools",
+    options: [
+      { value: "eslint", label: "ESLint" },
+      { value: "prettier", label: "Prettier" },
+      { value: "vitest", label: "Vitest", disabled: true }
+    ]
+  });
+
+  if (isCancel(tools)) {
+    console.log("Prompt was cancelled");
+    return;
+  }
+
+  console.log("Selected tools:", tools.join(", "));
+}
+
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the multi-select prompt`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the selected values or a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "multiselect",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "MultiSelectConfig"
+			}],
+			returnType: "Promise<string[] | symbol>",
+			children: code`return new Promise<string[] | symbol>((response, reject) => {
+            const prompt = new MultiSelectPrompt(config);
+
+            prompt.on("state", state => config.onState?.(state));
+            prompt.on("submit", value => response(value));
+            prompt.on("cancel", event => response(CANCEL_SYMBOL));
+          });`
+		})
+	];
+}
+/**
+* A component that renders the declarations for the built-in numeric prompt, which allows users to input and select numeric values with various configuration options such as floating point support, precision, increment, and min/max values.
+*/
+function NumericPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			name: "NumberPromptConfig",
+			"extends": "PromptConfig<number>",
+			doc: "Configuration options for creating a numeric prompt",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "isFloat",
+						required: false,
+						type: "boolean",
+						doc: "Whether the prompt should accept floating point numbers"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "precision",
+						required: false,
+						type: "number",
+						doc: "The number of decimal places to round the input to, defaults to 2"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "increment",
+						required: false,
+						type: "number",
+						doc: "The increment value for the number prompt, defaults to 1"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "min",
+						required: false,
+						type: "number",
+						doc: "The minimum value for the number prompt, defaults to -Infinity"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "max",
+						required: false,
+						type: "number",
+						doc: "The maximum value for the number prompt, defaults to Infinity"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "NumberPrompt",
+			doc: "A prompt for selecting a number input",
+			"extends": "Prompt<number>",
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "isInvalid",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "number",
+						children: code`0; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "defaultErrorMessage",
+						"protected": true,
+						override: true,
+						type: "string",
+						children: code`"A valid numeric value must be provided"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isFloat",
+						"protected": true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "precision",
+						"protected": true,
+						type: "number",
+						children: code`2; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "increment",
+						"protected": true,
+						type: "number",
+						children: code`1; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "min",
+						"protected": true,
+						type: "number",
+						children: code`Number.NEGATIVE_INFINITY; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "max",
+						"protected": true,
+						type: "number",
+						children: code`Number.POSITIVE_INFINITY; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: NumberPromptConfig) {
           super(config);
 
           if (config.initialValue) {
@@ -550,7 +2240,21 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           this.cursor = 0;
           this.sync();
           this.last();
-        } `,e(l,{}),e(p,{doc:`A method to handle key press events and determine the corresponding action`,name:`onKeyPress`,override:!0,protected:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`const action = this.getAction(key);
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle key press events and determine the corresponding action",
+						name: "onKeyPress",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`const action = this.getAction(key);
           if (action && typeof (this as any)[action] === "function") {
             return (this as any)[action]();
           }
@@ -578,10 +2282,45 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           }
 
           this.changeValue(value);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to handle changes in the prompt value`,name:`onChange`,override:!0,protected:!0,parameters:[{name:`previousValue`,type:`number`}],children:i`this.#isInvalid = false;
-          this.cursor = this.displayValue.slice(0, this.cursor).length + 1; `}),e(l,{}),e(p,{doc:`A method to validate the prompt input`,name:`checkValidations`,override:!0,async:!0,protected:!0,children:i`await super.checkValidations(this.value);
-          this.#isInvalid = this.isError; `}),e(l,{}),e(p,{doc:`A method to move the cursor to the end of the input`,name:`next`,protected:!0,children:i`this.changeValue(this.initialValue);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the up`,name:`up`,protected:!0,children:i`let value = this.value;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle changes in the prompt value",
+						name: "onChange",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "previousValue",
+							type: "number"
+						}],
+						children: code`this.#isInvalid = false;
+          this.cursor = this.displayValue.slice(0, this.cursor).length + 1; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to validate the prompt input",
+						name: "checkValidations",
+						override: true,
+						async: true,
+						"protected": true,
+						children: code`await super.checkValidations(this.value);
+          this.#isInvalid = this.isError; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the end of the input",
+						name: "next",
+						"protected": true,
+						children: code`this.changeValue(this.initialValue);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the up",
+						name: "up",
+						"protected": true,
+						children: code`let value = this.value;
           if (this.isPlaceholder) {
             value = this.min < 0 ? 0 : this.min;
           } else if (value >= this.max) {
@@ -591,7 +2330,14 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           this.changeValue(value + this.increment);
 
           this.sync();
-          this.last(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the down`,name:`down`,protected:!0,children:i`let value = this.value;
+          this.last(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the down",
+						name: "down",
+						"protected": true,
+						children: code`let value = this.value;
           if (this.isPlaceholder) {
             value = this.min < 0 ? 0 : this.min;
           } else if (value <= this.min) {
@@ -600,19 +2346,56 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
 
           this.changeValue(value === this.min ? this.min : value - this.increment);
           this.sync();
-          this.last(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the left`,name:`left`,protected:!0,children:i`if (this.cursor <= 0) {
+          this.last(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the left",
+						name: "left",
+						"protected": true,
+						children: code`if (this.cursor <= 0) {
             return this.bell();
           }
 
           this.moveCursor(-1);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the right`,name:`right`,protected:!0,children:i`if (this.cursor >= this.displayValue.length) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the right",
+						name: "right",
+						"protected": true,
+						children: code`if (this.cursor >= this.displayValue.length) {
             return this.bell();
           }
 
           this.moveCursor(1);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the start`,name:`first`,protected:!0,children:i`this.cursor = 0;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the end`,name:`last`,protected:!0,children:i`this.cursor = this.displayValue.length;
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,override:!0,protected:!0,returnType:`string`,children:i`return this.isPlaceholder
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the start",
+						name: "first",
+						"protected": true,
+						children: code`this.cursor = 0;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the end",
+						name: "last",
+						"protected": true,
+						children: code`this.cursor = this.displayValue.length;
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						override: true,
+						"protected": true,
+						returnType: "string",
+						children: code`return this.isPlaceholder
             ? textColors.prompt.input.disabled(this.displayValue)
             : this.#isInvalid
               ? textColors.prompt.input.error(this.displayValue)
@@ -620,7 +2403,24 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
                 ? textColors.prompt.input.submitted(this.displayValue)
                 : this.isCancelled
                   ? textColors.prompt.input.cancelled(this.displayValue)
-              : bold(textColors.prompt.input.active(this.displayValue)); `})]}}),e(l,{}),e(_,{heading:`An object representing the configuration options for a numeric prompt.`}),e(C,{name:`NumericConfig`,export:!0,children:i`PromptFactoryConfig<number> & NumberPromptConfig; `}),e(l,{}),e(_,{heading:`A function to create and run a numeric prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(y,{children:`import { numeric, isCancel } from "shell-shock:prompts";
+              : bold(textColors.prompt.input.active(this.displayValue)); `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "An object representing the configuration options for a numeric prompt." }),
+		createComponent(TypeDeclaration, {
+			name: "NumericConfig",
+			"export": true,
+			children: code`PromptFactoryConfig<number> & NumberPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a numeric prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { numeric, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const age = await numeric({
@@ -636,13 +2436,102 @@ async function run() {
   console.log("Your age is " + age + "!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the numeric prompt, which extends the base PromptFactoryConfig with additional options specific to numeric prompts`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`numeric`,export:!0,parameters:[{name:`config`,type:`NumericConfig`}],returnType:`Promise<number | symbol>`,children:i`return new Promise<number | symbol>((response, reject) => {
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the numeric prompt, which extends the base PromptFactoryConfig with additional options specific to numeric prompts`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "numeric",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "NumericConfig"
+			}],
+			returnType: "Promise<number | symbol>",
+			children: code`return new Promise<number | symbol>((response, reject) => {
             const prompt = new NumberPrompt(config);
 
             prompt.on("state", state => config.onState?.(state));
             prompt.on("submit", value => response(value));
             prompt.on("cancel", event => response(CANCEL_SYMBOL));
-          });`})]}function A(){return[e(h,{export:!0,name:`TogglePromptConfig`,extends:`PromptConfig<boolean>`,doc:`Configuration options for creating a boolean toggle prompt`,get children(){return[e(g,{name:`trueMessage`,optional:!0,type:`string`,doc:`The message for the true state of the prompt`}),e(l,{}),e(g,{name:`falseMessage`,optional:!0,type:`string`,doc:`The message for the false state of the prompt`}),e(l,{})]}}),e(l,{}),e(d,{export:!0,name:`TogglePrompt`,doc:`A prompt for toggling a boolean input`,extends:`Prompt<boolean>`,get children(){return[e(f,{name:`initialValue`,protected:!0,override:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`trueMessage`,protected:!0,type:`string`,children:i`"Yes"; `}),t(`hbr`,{}),e(f,{name:`falseMessage`,protected:!0,type:`string`,children:i`"No"; `}),t(`hbr`,{}),e(f,{name:`cursorHidden`,protected:!0,override:!0,type:`boolean`,children:i`true; `}),e(l,{}),i`constructor(config: TogglePromptConfig) {
+          });`
+		})
+	];
+}
+/**
+* A component that renders the declarations for the built-in toggle prompt, which allows users to select a boolean value (true/false) with support for custom messages for the true and false states. This prompt type can be used for scenarios where the user needs to toggle a setting on or off, such as enabling or disabling a feature. The TogglePrompt class extends the base Prompt class and implements specific logic for handling boolean input and rendering interactions.
+*/
+function TogglePromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "TogglePromptConfig",
+			"extends": "PromptConfig<boolean>",
+			doc: "Configuration options for creating a boolean toggle prompt",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "trueMessage",
+						required: false,
+						type: "string",
+						doc: "The message for the true state of the prompt"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(InterfaceMember, {
+						name: "falseMessage",
+						required: false,
+						type: "string",
+						doc: "The message for the false state of the prompt"
+					}),
+					createComponent(Spacing, {})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			"export": true,
+			name: "TogglePrompt",
+			doc: "A prompt for toggling a boolean input",
+			"extends": "Prompt<boolean>",
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "trueMessage",
+						"protected": true,
+						type: "string",
+						children: code`"Yes"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "falseMessage",
+						"protected": true,
+						type: "string",
+						children: code`"No"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: TogglePromptConfig) {
           super(config);
 
           if (config.initialValue) {
@@ -657,17 +2546,45 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           }
 
           this.sync();
-        } `,e(l,{}),e(p,{doc:`Update the toggle value to a checked state based on user input`,name:`check`,protected:!0,children:i`if (this.value === true) {
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "Update the toggle value to a checked state based on user input",
+						name: "check",
+						"protected": true,
+						children: code`if (this.value === true) {
             return this.bell();
           }
 
           this.changeValue(true);
-          this.sync(); `}),e(l,{}),e(p,{doc:`Update the toggle value to an unchecked state based on user input`,name:`uncheck`,protected:!0,children:i`if (this.value === false) {
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "Update the toggle value to an unchecked state based on user input",
+						name: "uncheck",
+						"protected": true,
+						children: code`if (this.value === false) {
             return this.bell();
           }
 
           this.changeValue(false);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to handle key press events and determine the corresponding action`,name:`onKeyPress`,override:!0,protected:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`const action = this.getAction(key);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle key press events and determine the corresponding action",
+						name: "onKeyPress",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`const action = this.getAction(key);
           if (action && typeof (this as any)[action] === "function") {
             return (this as any)[action]();
           }
@@ -682,8 +2599,59 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
             return this.bell();
           }
 
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to remove the character backward of the cursor`,name:`backspace`,protected:!0,children:i`this.uncheck(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the left`,name:`left`,protected:!0,children:i`this.uncheck(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to the right`,name:`right`,protected:!0,children:i`this.check(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to down`,name:`down`,protected:!0,children:i`this.uncheck(); `}),e(l,{}),e(p,{doc:`A method to move the cursor to up`,name:`up`,protected:!0,children:i`this.check(); `}),e(l,{}),e(p,{doc:`A method to move to the next value`,name:`next`,protected:!0,children:i`this.changeValue(!this.value);
-          this.sync(); `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,override:!0,protected:!0,returnType:`string`,children:i`return this.isSubmitted
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to remove the character backward of the cursor",
+						name: "backspace",
+						"protected": true,
+						children: code`this.uncheck(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the left",
+						name: "left",
+						"protected": true,
+						children: code`this.uncheck(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to the right",
+						name: "right",
+						"protected": true,
+						children: code`this.check(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to down",
+						name: "down",
+						"protected": true,
+						children: code`this.uncheck(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move the cursor to up",
+						name: "up",
+						"protected": true,
+						children: code`this.check(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to move to the next value",
+						name: "next",
+						"protected": true,
+						children: code`this.changeValue(!this.value);
+          this.sync(); `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						override: true,
+						"protected": true,
+						returnType: "string",
+						children: code`return this.isSubmitted
               ? textColors.prompt.input.submitted(this.value ? this.trueMessage : this.falseMessage)
               : this.isCancelled
                 ? textColors.prompt.input.cancelled(this.value ? this.trueMessage : this.falseMessage)
@@ -691,7 +2659,24 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
                 this.value ? textColors.prompt.input.inactive(this.falseMessage) : underline(bold(textColors.prompt.input.active(this.falseMessage)))
             } \${borderColors.app.divider.tertiary("/")} \${
                 this.value ? underline(bold(textColors.prompt.input.active(this.trueMessage))) : textColors.prompt.input.inactive(this.trueMessage)
-            }\`; `})]}}),e(l,{}),e(_,{heading:`An object representing the configuration options for a toggle prompt, which extends the base PromptFactoryConfig with additional options specific to the toggle prompt.`}),e(C,{name:`ToggleConfig`,export:!0,children:i`PromptFactoryConfig<boolean> & TogglePromptConfig; `}),e(l,{}),e(_,{heading:`A function to create and run a toggle prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(y,{children:`import { toggle, isCancel } from "shell-shock:prompts";
+            }\`; `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "An object representing the configuration options for a toggle prompt, which extends the base PromptFactoryConfig with additional options specific to the toggle prompt." }),
+		createComponent(TypeDeclaration, {
+			name: "ToggleConfig",
+			"export": true,
+			children: code`PromptFactoryConfig<boolean> & TogglePromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a toggle prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { toggle, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const likesIceCream = await toggle({
@@ -705,13 +2690,161 @@ async function run() {
   console.log("You" + (likesIceCream ? " like ice cream" : " don't like ice cream") + "!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the toggle prompt, which extends the base PromptFactoryConfig with additional options specific to the toggle prompt`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`toggle`,export:!0,parameters:[{name:`config`,type:`ToggleConfig`}],returnType:`Promise<boolean | symbol>`,children:i`return new Promise<boolean | symbol>((response, reject) => {
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the toggle prompt, which extends the base PromptFactoryConfig with additional options specific to the toggle prompt`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "toggle",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "ToggleConfig"
+			}],
+			returnType: "Promise<boolean | symbol>",
+			children: code`return new Promise<boolean | symbol>((response, reject) => {
             const prompt = new TogglePrompt(config);
 
             prompt.on("state", state => config.onState?.(state));
             prompt.on("submit", value => response(value));
             prompt.on("cancel", event => response(CANCEL_SYMBOL));
-          });`})]}function j(){return[e(h,{export:!0,name:`ConfirmPromptConfig`,extends:`PromptConfig<boolean>`,doc:`Configuration options for creating a boolean confirm prompt`,get children(){return[e(_,{heading:"The message for the \\`Yes\\` state of the prompt",get children(){return e(v,{get type(){return c.string},defaultValue:`Yes`})}}),e(g,{name:`yesMessage`,optional:!0,type:`string`}),e(l,{}),e(_,{heading:"The \\`Yes\\` option when choosing between yes/no",get children(){return e(v,{get type(){return c.string},defaultValue:`1`})}}),e(g,{name:`yesOption`,optional:!0,type:`string`}),e(l,{}),e(_,{heading:"The message for the \\`No\\` state of the prompt",get children(){return e(v,{get type(){return c.string},defaultValue:`(Y/n)`})}}),e(g,{name:`noMessage`,optional:!0,type:`string`}),e(l,{}),e(_,{heading:"The \\`No\\` option when choosing between yes/no",get children(){return e(v,{get type(){return c.string},defaultValue:`(y/N)`})}}),e(g,{name:`noOption`,optional:!0,type:`string`})]}}),e(l,{}),e(d,{export:!0,name:`ConfirmPrompt`,doc:`A prompt for confirming a boolean input`,extends:`Prompt<boolean>`,get children(){return[e(f,{name:`initialValue`,protected:!0,override:!0,type:`boolean`,children:i`false; `}),t(`hbr`,{}),e(f,{name:`yesMessage`,protected:!0,type:`string`,children:i`"Yes"; `}),t(`hbr`,{}),e(f,{name:`yesOption`,protected:!0,type:`string`,children:i`"(Y/n)"; `}),t(`hbr`,{}),e(f,{name:`noMessage`,protected:!0,type:`string`,children:i`"No"; `}),t(`hbr`,{}),e(f,{name:`noOption`,protected:!0,type:`string`,children:i`"(y/N)"; `}),t(`hbr`,{}),e(f,{name:`cursorHidden`,protected:!0,override:!0,type:`boolean`,children:i`true; `}),e(l,{}),i`constructor(config: ConfirmPromptConfig) {
+          });`
+		})
+	];
+}
+/**
+* A component that renders the declarations for the built-in confirm prompt, which allows users to select a boolean value (true/false) with support for custom messages for the true and false states. This prompt type can be used for scenarios where the user needs to toggle a setting on or off, such as enabling or disabling a feature. The ConfirmPrompt class extends the base Prompt class and implements specific logic for handling boolean input and rendering interactions.
+*/
+function ConfirmPromptDeclarations() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "ConfirmPromptConfig",
+			"extends": "PromptConfig<boolean>",
+			doc: "Configuration options for creating a boolean confirm prompt",
+			get children() {
+				return [
+					createComponent(TSDoc, {
+						heading: "The message for the \\`Yes\\` state of the prompt",
+						get children() {
+							return createComponent(TSDocDefaultValue, {
+								type: "string",
+								defaultValue: "Yes"
+							});
+						}
+					}),
+					createComponent(InterfaceMember, {
+						name: "yesMessage",
+						required: false,
+						type: "string"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(TSDoc, {
+						heading: "The \\`Yes\\` option when choosing between yes/no",
+						get children() {
+							return createComponent(TSDocDefaultValue, {
+								type: "string",
+								defaultValue: "1"
+							});
+						}
+					}),
+					createComponent(InterfaceMember, {
+						name: "yesOption",
+						required: false,
+						type: "string"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(TSDoc, {
+						heading: "The message for the \\`No\\` state of the prompt",
+						get children() {
+							return createComponent(TSDocDefaultValue, {
+								type: "string",
+								defaultValue: "(Y/n)"
+							});
+						}
+					}),
+					createComponent(InterfaceMember, {
+						name: "noMessage",
+						required: false,
+						type: "string"
+					}),
+					createComponent(Spacing, {}),
+					createComponent(TSDoc, {
+						heading: "The \\`No\\` option when choosing between yes/no",
+						get children() {
+							return createComponent(TSDocDefaultValue, {
+								type: "string",
+								defaultValue: "(y/N)"
+							});
+						}
+					}),
+					createComponent(InterfaceMember, {
+						name: "noOption",
+						required: false,
+						type: "string"
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			"export": true,
+			name: "ConfirmPrompt",
+			doc: "A prompt for confirming a boolean input",
+			"extends": "Prompt<boolean>",
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "initialValue",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`false; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "yesMessage",
+						"protected": true,
+						type: "string",
+						children: code`"Yes"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "yesOption",
+						"protected": true,
+						type: "string",
+						children: code`"(Y/n)"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "noMessage",
+						"protected": true,
+						type: "string",
+						children: code`"No"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "noOption",
+						"protected": true,
+						type: "string",
+						children: code`"(y/N)"; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "cursorHidden",
+						"protected": true,
+						override: true,
+						type: "boolean",
+						children: code`true; `
+					}),
+					createComponent(Spacing, {}),
+					code`constructor(config: ConfirmPromptConfig) {
           super(config);
 
           if (config.initialValue) {
@@ -732,7 +2865,21 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
           }
 
           this.sync();
-        } `,e(l,{}),e(p,{doc:`A method to handle key press events and determine the corresponding action`,name:`onKeyPress`,override:!0,protected:!0,parameters:[{name:`char`,type:`string`},{name:`key`,type:`Key`}],children:i`const action = this.getAction(key);
+        } `,
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to handle key press events and determine the corresponding action",
+						name: "onKeyPress",
+						override: true,
+						"protected": true,
+						parameters: [{
+							name: "char",
+							type: "string"
+						}, {
+							name: "key",
+							type: "Key"
+						}],
+						children: code`const action = this.getAction(key);
           if (action && typeof (this as any)[action] === "function") {
             return (this as any)[action]();
           }
@@ -745,11 +2892,37 @@ run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pas
             return this.submit();
           } else {
             return this.bell();
-          } `}),e(l,{}),e(p,{doc:`A method to render the prompt`,name:`onRender`,override:!0,protected:!0,returnType:`string`,children:i`return this.isSubmitted
+          } `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						doc: "A method to render the prompt",
+						name: "onRender",
+						override: true,
+						"protected": true,
+						returnType: "string",
+						children: code`return this.isSubmitted
               ? textColors.prompt.input.submitted(this.value ? this.yesMessage : this.noMessage)
               : this.isCancelled
                 ? textColors.prompt.input.cancelled(this.value ? this.yesMessage : this.noMessage)
-            : textColors.prompt.input.inactive(this.initialValue ? this.yesOption : this.noOption); `})]}}),e(l,{}),e(_,{heading:`An object representing the configuration options for a confirm prompt, which extends the base PromptFactoryConfig with additional options specific to the confirm prompt.`}),e(C,{name:`ConfirmConfig`,export:!0,children:i`PromptFactoryConfig<boolean> & ConfirmPromptConfig; `}),e(l,{}),e(_,{heading:`A function to create and run a confirm prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(y,{children:`import { confirm, isCancel } from "shell-shock:prompts";
+            : textColors.prompt.input.inactive(this.initialValue ? this.yesOption : this.noOption); `
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "An object representing the configuration options for a confirm prompt, which extends the base PromptFactoryConfig with additional options specific to the confirm prompt." }),
+		createComponent(TypeDeclaration, {
+			name: "ConfirmConfig",
+			"export": true,
+			children: code`PromptFactoryConfig<boolean> & ConfirmPromptConfig; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a confirm prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocExample, { children: `import { confirm, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const likesIceCream = await confirm({
@@ -763,13 +2936,65 @@ async function run() {
   console.log("You" + (likesIceCream ? " like ice cream" : " don't like ice cream") + "!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the confirm prompt, which extends the base PromptFactoryConfig with additional options specific to the confirm prompt`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`confirm`,export:!0,parameters:[{name:`config`,type:`ConfirmConfig`}],returnType:`Promise<boolean | symbol>`,children:i`return new Promise<boolean | symbol>((response, reject) => {
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the confirm prompt, which extends the base PromptFactoryConfig with additional options specific to the confirm prompt`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "confirm",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "ConfirmConfig"
+			}],
+			returnType: "Promise<boolean | symbol>",
+			children: code`return new Promise<boolean | symbol>((response, reject) => {
             const prompt = new ConfirmPrompt(config);
 
             prompt.on("state", state => config.onState?.(state));
             prompt.on("submit", value => response(value));
             prompt.on("cancel", event => response(CANCEL_SYMBOL));
-          }); `})]}function M(){return[e(o,{export:!0,name:`passwordMask`,doc:`A built-in prompt mask function that masks input with asterisks`,parameters:[{name:`input`,type:`string`}],returnType:`string`,children:i`return "*".repeat(input.length); `}),e(l,{}),e(_,{heading:`An object representing the configuration options for a password prompt, which extends the base PromptFactoryConfig with additional options specific to password prompts.`}),e(C,{name:`PasswordConfig`,export:!0,children:i`Omit<TextConfig, "mask" | "maskCompleted">; `}),e(l,{}),e(_,{heading:`A function to create and run a password prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(x,{children:i`This function creates an instance of the TextPrompt class with the provided configuration options and a custom mask function to handle password input. It sets up event listeners for state updates, submission, and cancellation to handle the prompt interactions and return the appropriate results. The password prompt allows users to input text that is masked for privacy, making it suitable for scenarios like entering passwords or sensitive information.`}),e(l,{}),e(y,{children:`import { password, isCancel } from "shell-shock:prompts";
+          }); `
+		})
+	];
+}
+/**
+* Declarations for a password prompt that allows users to input and edit text, with support for cursor movement, deletion, and custom masking. This prompt type can be used for various text input scenarios, such as entering a password or any other string input. The PasswordPrompt class extends the base Prompt class and implements specific logic for handling password input and editing interactions.
+*/
+function PasswordPromptDeclaration() {
+	return [
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "passwordMask",
+			doc: "A built-in prompt mask function that masks input with asterisks",
+			parameters: [{
+				name: "input",
+				type: "string"
+			}],
+			returnType: "string",
+			children: code`return "*".repeat(input.length); `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, { heading: "An object representing the configuration options for a password prompt, which extends the base PromptFactoryConfig with additional options specific to password prompts." }),
+		createComponent(TypeDeclaration, {
+			name: "PasswordConfig",
+			"export": true,
+			children: code`Omit<TextConfig, "mask" | "maskCompleted">; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "A function to create and run a password prompt, which returns a promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: code`This function creates an instance of the TextPrompt class with the provided configuration options and a custom mask function to handle password input. It sets up event listeners for state updates, submission, and cancellation to handle the prompt interactions and return the appropriate results. The password prompt allows users to input text that is masked for privacy, making it suitable for scenarios like entering passwords or sensitive information.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocExample, { children: `import { password, isCancel } from "shell-shock:prompts";
 
 async function run() {
   const userPassword = await password({
@@ -783,18 +3008,63 @@ async function run() {
   console.log("You entered a password!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`config`,children:`The configuration options to pass to the password prompt, which extends the base PromptConfig with additional options specific to password prompts`}),e(S,{children:`A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled`})]}}),e(o,{name:`password`,export:!0,parameters:[{name:`config`,type:`PasswordConfig`}],returnType:`Promise<string | symbol>`,children:i`return text({
+run(); ` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "config",
+						children: `The configuration options to pass to the password prompt, which extends the base PromptConfig with additional options specific to password prompts`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves with the submitted value or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			name: "password",
+			"export": true,
+			parameters: [{
+				name: "config",
+				type: "PasswordConfig"
+			}],
+			returnType: "Promise<string | symbol>",
+			children: code`return text({
             ...config,
             mask: passwordMask,
             maskCompleted: () => "*******"
-          });`})]}function N(){return[e(_,{heading:`A function to create and run a wait-for-key-press prompt, which returns a promise that resolves when any key is pressed or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.`,get children(){return[e(x,{children:i`This function creates an instance of the Prompt class with a custom onKeyPress handler that resolves the promise when any key is pressed. It sets up event listeners for state updates and cancellation to handle the prompt interactions and return the appropriate results. The wait-for-key-press prompt is useful for scenarios where you want to pause execution until the user presses any key, such as waiting for user input before proceeding with a task.`}),e(l,{}),e(y,{children:`import { waitForKeyPress } from "shell-shock:prompts";
+          });`
+		})
+	];
+}
+function WaitForKeyPressDeclaration() {
+	return [createComponent(TSDoc, {
+		heading: "A function to create and run a wait-for-key-press prompt, which returns a promise that resolves when any key is pressed or rejects with a {@link CANCEL_SYMBOL | cancel symbol} if the prompt is cancelled.",
+		get children() {
+			return [
+				createComponent(TSDocRemarks, { children: code`This function creates an instance of the Prompt class with a custom onKeyPress handler that resolves the promise when any key is pressed. It sets up event listeners for state updates and cancellation to handle the prompt interactions and return the appropriate results. The wait-for-key-press prompt is useful for scenarios where you want to pause execution until the user presses any key, such as waiting for user input before proceeding with a task.` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocExample, { children: `import { waitForKeyPress } from "shell-shock:prompts";
 
 async function run() {
   const result = await waitForKeyPress();
   console.log("A key was pressed!");
 }
 
-run(); `}),e(l,{}),e(b,{name:`timeout`,children:`The amount of time in milliseconds to wait before automatically resolving the prompt, defaults to 2 hours (7200000 ms)`}),e(S,{children:`A promise that resolves when any key is pressed`})]}}),e(o,{name:`waitForKeyPress`,export:!0,parameters:[{name:`timeout`,default:`7200000`}],children:i`process.stdin.setRawMode(true);
+run(); ` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocParam, {
+					name: "timeout",
+					children: `The amount of time in milliseconds to wait before automatically resolving the prompt, defaults to 2 hours (7200000 ms)`
+				}),
+				createComponent(TSDocReturns, { children: `A promise that resolves when any key is pressed` })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		name: "waitForKeyPress",
+		"export": true,
+		parameters: [{
+			name: "timeout",
+			default: "7200000"
+		}],
+		children: code`process.stdin.setRawMode(true);
         return new Promise(resolve => process.stdin.once("data", () => {
           if (timeout >= 0) {
             setTimeout(() => {
@@ -805,5 +3075,89 @@ run(); `}),e(l,{}),e(b,{name:`timeout`,children:`The amount of time in milliseco
 
           process.stdin.setRawMode(false);
           resolve(void 0);
-        })); `})]}function P(t){let[{children:i},o]=a(t,[`children`]);return e(u,n({id:`prompts`,description:`A collection of prompts that allow for interactive input in command-line applications.`},o,{get imports(){return T(o.imports??{},{"node:events":`EventEmitter`,"node:readline":[`Interface`,`Key`,`createInterface`,`emitKeypressEvents`]})},get builtinImports(){return T(o.builtinImports??{},{console:[`erase`,`beep`,`cursor`,`textColors`,`borderColors`,`bold`,`italic`,`underline`,`strikethrough`,`clear`,`stripAnsi`,`splitText`,`error`],env:[`env`,`isCI`,`isTest`,`isWindows`,`isDevelopment`,`isDebug`]})},get children(){return[e(l,{}),e(E,{}),e(l,{}),e(D,{}),e(l,{}),e(O,{}),e(l,{}),e(k,{}),e(l,{}),e(A,{}),e(l,{}),e(M,{}),e(l,{}),e(j,{}),e(l,{}),e(N,{}),e(l,{}),e(r,{get when(){return!!i},children:i})]}}))}export{E as BasePromptDeclarations,j as ConfirmPromptDeclarations,k as NumericPromptDeclarations,M as PasswordPromptDeclaration,P as PromptsBuiltin,O as SelectPromptDeclarations,D as TextPromptDeclarations,A as TogglePromptDeclarations,N as WaitForKeyPressDeclaration};
+        })); `
+	})];
+}
+/**
+* A built-in prompts module for Shell Shock.
+*/
+function PromptsBuiltin(props) {
+	const [{ children }, rest] = splitProps(props, ["children"]);
+	return createComponent(BuiltinFile, mergeProps({
+		id: "prompts",
+		description: "A collection of prompts that allow for interactive input in command-line applications."
+	}, rest, {
+		get imports() {
+			return defu(rest.imports ?? {}, {
+				"node:events": "EventEmitter",
+				"node:readline": [
+					"Interface",
+					"Key",
+					"createInterface",
+					"emitKeypressEvents"
+				]
+			});
+		},
+		get builtinImports() {
+			return defu(rest.builtinImports ?? {}, {
+				console: [
+					"erase",
+					"beep",
+					"cursor",
+					"textColors",
+					"borderColors",
+					"bold",
+					"italic",
+					"underline",
+					"strikethrough",
+					"clear",
+					"stripAnsi",
+					"splitText",
+					"error"
+				],
+				utils: ["isUnicodeSupported"],
+				env: [
+					"env",
+					"isCI",
+					"isTest",
+					"isWindows",
+					"isDevelopment",
+					"isDebug"
+				]
+			});
+		},
+		get children() {
+			return [
+				createComponent(Spacing, {}),
+				createComponent(BasePromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(TextPromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(SelectPromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(MultiSelectPromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(NumericPromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(TogglePromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(PasswordPromptDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(ConfirmPromptDeclarations, {}),
+				createComponent(Spacing, {}),
+				createComponent(WaitForKeyPressDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(Show, {
+					get when() {
+						return Boolean(children);
+					},
+					children
+				})
+			];
+		}
+	}));
+}
+
+//#endregion
+export { BasePromptDeclarations, ConfirmPromptDeclarations, MultiSelectPromptDeclarations, NumericPromptDeclarations, PasswordPromptDeclaration, PromptsBuiltin, SelectPromptDeclarations, TextPromptDeclarations, TogglePromptDeclarations, WaitForKeyPressDeclaration };
 //# sourceMappingURL=prompts-builtin.mjs.map