@reliverse/rempts 1.7.44 → 1.7.45

package/dist-npm/bin/mod.d.mts

@@ -0,0 +1,2333 @@
+import { AnimationName as AnimationName$1, Animation } from '@figliolia/chalk-animation';
+import { Readable, Writable } from 'node:stream';
+import { Fonts } from 'figlet';
+import { ReliArgParserOptions } from '@reliverse/reliarg';
+import { JSONSchema7 } from 'json-schema';
+import { JsonSchema7Type, JsonSchema7ObjectType } from 'zod-to-json-schema';
+import { Command as Command$1, Argument, Option } from 'commander';
+import * as _reliverse_relinka from '@reliverse/relinka';
+import { SpinnerName } from 'cli-spinners';
+import * as _reliverse_runtime from '@reliverse/runtime';
+import * as server from '@trpc/server';
+export { server as trpcServer };
+export { z } from 'zod/v4';
+import * as zod from 'zod';
+export { zod };
+
+type MsgType = "M_NULL" | "M_INFO_NULL" | "M_START" | "M_MIDDLE" | "M_GENERAL" | "M_GENERAL_NULL" | "M_INFO" | "M_ERROR" | "M_ERROR_NULL" | "M_END" | "M_NEWLINE" | "M_BAR";
+type TypographyName = "bold" | "strikethrough" | "underline" | "italic" | "none";
+type BorderColorName = "reset" | "inverse" | "dim" | "black" | "red" | "redBright" | "green" | "greenBright" | "yellow" | "yellowBright" | "blue" | "blueBright" | "magenta" | "magentaBright" | "cyan" | "cyanBright" | "bgCyan" | "bgCyanBright" | "white" | "gray";
+type ColorName = BorderColorName | "gradientGradient" | "rainbowGradient" | "cristalGradient" | "mindGradient" | "passionGradient" | "viceGradient" | "retroGradient" | "none";
+type AnimationName = "rainbow" | "pulse" | "glitch" | "radar" | "neon" | "karaoke";
+type VariantName$1 = "doubleBox" | "none";
+interface MsgConfig {
+    symbol: string;
+    prefix?: string;
+    color?: (text: string) => string;
+    newLineBefore?: boolean;
+    newLineAfter?: boolean;
+    suffix?: string;
+}
+interface PromptOptions {
+    schema?: any;
+    title?: string;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    titleAnimation?: AnimationName;
+    titleAnimationDelay?: number;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName$1;
+    hint?: string;
+    placeholder?: string;
+    validate?: (value: any) => boolean | string | undefined | Promise<boolean | string | undefined>;
+    defaultColor?: ColorName;
+    defaultTypography?: TypographyName;
+    choices?: ChoiceOptions[];
+    variantOptions?: {
+        box?: {
+            limit?: number;
+        };
+    };
+    action?: () => Promise<void>;
+    border?: boolean;
+    borderColor?: BorderColorName;
+    additionalLinesToDelete?: number;
+    hintPlaceholderColor?: ColorName;
+    hints?: string[];
+    required?: boolean;
+    initial?: any[];
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    symbol?: string;
+    customSymbol?: string;
+}
+interface ChoiceRequiredOptions {
+    id: string;
+    title: string;
+}
+interface ChoiceOptionalOptions {
+    description?: string;
+    titleTypography?: TypographyName;
+    action?: () => Promise<void>;
+}
+type ChoiceOptions = ChoiceRequiredOptions & ChoiceOptionalOptions;
+interface SelectOption<T> {
+    value: T;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+/**
+ * Standard terminal colors supported by most terminals
+ */
+type StandardColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray";
+/**
+ * All possible output colors including special colors
+ */
+type OutputColor = StandardColor | "dim";
+interface EditorExitResult {
+    saved: boolean;
+    content: string | null;
+    filename: string | null;
+}
+type MessageKind = "log" | "info" | "warn" | "error" | "success";
+type VerboseKind = `${MessageKind}-verbose`;
+type AllKinds = MessageKind | VerboseKind;
+interface MessageConfig {
+    type: "M_INFO" | "M_ERROR";
+    titleColor?: "retroGradient" | "viceGradient" | "yellowBright";
+    titleTypography?: "bold";
+    contentColor?: "dim";
+    contentTypography?: "italic";
+}
+interface StreamOptions {
+    delay?: number;
+    useSpinner?: boolean;
+    spinnerFrames?: string[];
+    spinnerDelay?: number;
+}
+interface ProgressBarOptions {
+    total: number;
+    width?: number;
+    completeChar?: string;
+    incompleteChar?: string;
+    format?: string;
+    colorize?: boolean;
+    increment?: number;
+    desiredTotalTime?: number;
+}
+interface ProgressBar {
+    update: (value: number) => Promise<void>;
+    increment: (amount?: number) => Promise<void>;
+    render: () => Promise<void>;
+}
+/**
+ * Union type for available prompt types.
+ */
+type PromptType = "input" | "inputmasked" | "select" | "multiselect" | "nummultiselect" | "numselect" | "toggle" | "confirm" | "spinner" | "progressbar" | "results" | "nextsteps" | "animatedtext" | "date" | "end";
+interface ConfirmPromptOptions {
+    title?: string;
+    message?: string;
+    defaultValue?: boolean;
+    initialValue?: boolean;
+    content?: string;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName$1;
+    borderColor?: BorderColorName;
+    hintPlaceholderColor?: ColorName;
+    variantOptions?: any;
+    action?: () => Promise<void>;
+    displayInstructions?: boolean;
+    debug?: boolean;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    border?: boolean;
+    terminalWidth?: number;
+}
+interface StreamTextOptions {
+    /**
+     * Text to stream
+     */
+    text: string;
+    /**
+     * Delay between each character in milliseconds
+     * @default 50
+     */
+    delay?: number;
+    /**
+     * Whether to show cursor while streaming
+     * @default false
+     */
+    showCursor?: boolean;
+    /**
+     * Color to use for the text
+     * @default undefined (no color)
+     */
+    color?: ColorName;
+    /**
+     * Whether to inject a newline at the end
+     * @default true
+     */
+    newline?: boolean;
+    /**
+     * Whether to clear the line before streaming
+     * @default false
+     */
+    clearLine?: boolean;
+    /**
+     * Callback function to update the spinner text
+     */
+    onProgress?: (currentText: string) => void;
+}
+interface PreventWrongTerminalSizeOptions {
+    isDev?: boolean;
+    shouldExit?: boolean;
+    minWidth?: number;
+    minHeight?: number;
+    sizeErrorDescription?: string;
+}
+/**
+ * InputPromptOptions
+ *
+ * Extended options for handling user input prompts, including validation
+ * and UI styling. Inherits from PromptOptions.
+ */
+type InputPromptOptions = {
+    border?: boolean;
+    borderColor?: BorderColorName;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName$1;
+    customSymbol?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    hardcoded?: {
+        userInput?: string;
+        errorMessage?: string;
+        showPlaceholder?: boolean;
+    };
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    message?: string;
+    mode?: "plain" | "password";
+    mask?: string;
+    placeholder?: string;
+    schema?: any;
+    shouldStream?: boolean;
+    streamDelay?: number;
+    symbol?: SymbolName;
+    symbolColor?: ColorName;
+    title?: string;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    validate?: (value: string) => string | boolean | undefined | Promise<string | boolean | undefined>;
+    variantOptions?: unknown;
+} & PromptOptions;
+interface RenderParams {
+    border: boolean;
+    borderColor?: BorderColorName;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName$1;
+    customSymbol?: string;
+    errorMessage: string;
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    mask?: string;
+    placeholder?: string;
+    symbol?: SymbolName;
+    symbolColor?: ColorName;
+    title?: string;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    userInput: string;
+    isRerender?: boolean;
+}
+/**
+ * Known symbol names that will have IntelliSense support
+ */
+type SymbolName = "pointer" | "start" | "middle" | "end" | "line" | "corner_top_right" | "step_active" | "step_error" | "log" | "success" | "info" | "warn" | "error";
+type Symbols = Record<SymbolName, string>;
+interface FmtMsgOptions {
+    type: MsgType;
+    title?: string;
+    titleAfterAnim?: string;
+    content?: string | undefined;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName$1;
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    hintTypography?: TypographyName;
+    border?: boolean;
+    borderColor?: ColorName;
+    dontRemoveBar?: boolean;
+    variantOptions?: {
+        box?: {
+            limit?: number;
+        };
+    };
+    errorMessage?: string;
+    addNewLineBefore?: boolean;
+    addNewLineAfter?: boolean;
+    placeholder?: string;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    terminalWidth?: number;
+    instructions?: string;
+    wrapTitle?: boolean;
+    wrapContent?: boolean;
+    symbol?: SymbolName;
+    customSymbol?: string;
+    symbolColor?: ColorName;
+    noNewLine?: boolean;
+}
+interface TogglePromptParams<T extends string> {
+    title?: string;
+    message?: string;
+    content?: string;
+    options?: [T, T];
+    defaultValue?: T;
+    initialValue?: T;
+    borderColor?: BorderColorName;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    border?: boolean;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    displayInstructions?: boolean;
+    debug?: boolean;
+}
+interface SeparatorOption {
+    separator: true;
+    width?: number;
+    symbol?: SymbolName;
+}
+interface SelectPromptParams<T extends string> {
+    title?: string;
+    message?: string;
+    content?: string;
+    options?: (SelectOption<T> | SeparatorOption)[];
+    optionsArray?: {
+        value: T;
+        label?: string;
+        hint?: string;
+    }[];
+    defaultValue?: T;
+    initialValue?: T;
+    required?: boolean;
+    borderColor?: BorderColorName;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    border?: boolean;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    debug?: boolean;
+    terminalWidth?: number;
+    displayInstructions?: boolean;
+    shouldStream?: boolean;
+    streamDelay?: number;
+}
+interface MultiselectPromptParams<T extends string> {
+    title?: string;
+    message?: string;
+    content?: string;
+    options: (SelectOption<T> | SeparatorOption)[];
+    defaultValue?: T[];
+    initialValues?: T[];
+    borderColor?: BorderColorName;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName$1;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    border?: boolean;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    debug?: boolean;
+    terminalWidth?: number;
+    displayInstructions?: boolean;
+    required?: boolean;
+    minSelect?: number;
+    maxSelect?: number;
+    selectAll?: boolean;
+}
+type DatePromptOptions = PromptOptions & {
+    dateFormat: string;
+    dateKind: "birthday" | "other";
+    defaultValue?: string;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    border?: boolean;
+};
+
+declare const animationMap: Record<AnimationName$1, (text: string) => Animation>;
+declare function animateText({ title, anim, delay, type, titleColor, titleTypography, border, borderColor, horizontalLineLength, }: {
+    title: string;
+    anim: AnimationName$1;
+    delay?: number;
+    type?: MsgType;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    borderColor?: BorderColorName;
+    border?: boolean;
+    horizontalLineLength?: number;
+}): Promise<void>;
+
+interface Options {
+    ctrlC?: number | false | "reject";
+    preserveLog?: boolean;
+    hideMessage?: boolean;
+    shouldStream?: boolean;
+    streamDelay?: number;
+    color?: ColorName;
+    placeholderColor?: ColorName;
+}
+declare function anykeyPrompt(message?: string, options?: Options): Promise<void>;
+
+/**
+ * Special value that indicates a cancelled operation
+ */
+declare const CANCEL: unique symbol;
+/**
+ * Type for the cancel value
+ */
+type CancelValue = typeof CANCEL;
+declare const isWindows: boolean;
+/**
+ * Sets raw mode on input stream
+ */
+declare function setRawMode(input: Readable, value: boolean): void;
+/**
+ * Gets the number of columns in the terminal
+ */
+declare function getColumns(output: Writable): number;
+interface BlockOptions {
+    input?: Readable;
+    output?: Writable;
+    overwrite?: boolean;
+    hideCursor?: boolean;
+}
+/**
+ * Creates a block for handling input with proper cursor and cleanup
+ */
+declare function block({ input, output, overwrite, hideCursor, }?: BlockOptions): () => void;
+/**
+ * Checks if a value represents a cancelled operation
+ * @param value - The value to check
+ * @returns true if the value represents a cancelled operation
+ */
+declare function isCancel(value: unknown): value is CancelValue;
+/**
+ * Handles cancellation of an operation
+ * @param message - Optional message to display before exiting
+ */
+declare function cancel(message?: string): never;
+/**
+ * Creates a cancel value that can be returned from operations
+ * @returns The cancel value
+ */
+declare function createCancel(): CancelValue;
+
+declare const confirm: (options: ConfirmPromptOptions) => Promise<boolean>;
+
+/**
+ * Prompts the user with a yes/no question, returning a boolean based on their input.
+ */
+declare function confirmPrompt(options: ConfirmPromptOptions): Promise<boolean>;
+
+declare function datePrompt(opts: DatePromptOptions): Promise<string>;
+
+interface EditorConfig {
+    syntaxHighlighting?: boolean;
+    theme?: "auto" | "light" | "dark";
+    defaultAllowSaveAs?: boolean;
+    defaultAllowOpen?: boolean;
+    defaultAutoCloseOnSave?: boolean;
+    defaultReturnContentOnSave?: boolean;
+    [key: string]: any;
+}
+interface EditorOptions {
+    filename?: string | null;
+    initialContent?: string | null;
+    onSave?: (content: string, filename: string | null) => Promise<string | boolean | undefined> | string | boolean | undefined;
+    onExit?: (content: string | null, saved: boolean, filename: string | null) => Promise<void> | void;
+    configOverrides?: Partial<EditorConfig>;
+    allowSaveAs?: boolean;
+    allowOpen?: boolean;
+    autoCloseOnSave?: boolean;
+    returnContentOnSave?: boolean;
+    mode?: string;
+    cwd?: string;
+}
+declare function startEditor(options?: EditorOptions): Promise<EditorExitResult>;
+
+declare const mainSymbols: {
+    tick: string;
+    info: string;
+    warning: string;
+    cross: string;
+    squareSmall: string;
+    squareSmallFilled: string;
+    circle: string;
+    circleFilled: string;
+    circleDotted: string;
+    circleDouble: string;
+    circleCircle: string;
+    circleCross: string;
+    circlePipe: string;
+    radioOn: string;
+    radioOff: string;
+    checkboxOn: string;
+    checkboxOff: string;
+    checkboxCircleOn: string;
+    checkboxCircleOff: string;
+    pointer: string;
+    triangleUpOutline: string;
+    triangleLeft: string;
+    triangleRight: string;
+    lozenge: string;
+    lozengeOutline: string;
+    hamburger: string;
+    smiley: string;
+    mustache: string;
+    star: string;
+    play: string;
+    nodejs: string;
+    oneSeventh: string;
+    oneNinth: string;
+    oneTenth: string;
+    circleQuestionMark: string;
+    questionMarkPrefix: string;
+    square: string;
+    squareDarkShade: string;
+    squareMediumShade: string;
+    squareLightShade: string;
+    squareTop: string;
+    squareBottom: string;
+    squareLeft: string;
+    squareRight: string;
+    squareCenter: string;
+    bullet: string;
+    dot: string;
+    ellipsis: string;
+    pointerSmall: string;
+    triangleUp: string;
+    triangleUpSmall: string;
+    triangleDown: string;
+    triangleDownSmall: string;
+    triangleLeftSmall: string;
+    triangleRightSmall: string;
+    home: string;
+    heart: string;
+    musicNote: string;
+    musicNoteBeamed: string;
+    arrowUp: string;
+    arrowDown: string;
+    arrowLeft: string;
+    arrowRight: string;
+    arrowLeftRight: string;
+    arrowUpDown: string;
+    almostEqual: string;
+    notEqual: string;
+    lessOrEqual: string;
+    greaterOrEqual: string;
+    identical: string;
+    infinity: string;
+    subscriptZero: string;
+    subscriptOne: string;
+    subscriptTwo: string;
+    subscriptThree: string;
+    subscriptFour: string;
+    subscriptFive: string;
+    subscriptSix: string;
+    subscriptSeven: string;
+    subscriptEight: string;
+    subscriptNine: string;
+    oneHalf: string;
+    oneThird: string;
+    oneQuarter: string;
+    oneFifth: string;
+    oneSixth: string;
+    oneEighth: string;
+    twoThirds: string;
+    twoFifths: string;
+    threeQuarters: string;
+    threeFifths: string;
+    threeEighths: string;
+    fourFifths: string;
+    fiveSixths: string;
+    fiveEighths: string;
+    sevenEighths: string;
+    line: string;
+    lineBold: string;
+    lineDouble: string;
+    lineDashed0: string;
+    lineDashed1: string;
+    lineDashed2: string;
+    lineDashed3: string;
+    lineDashed4: string;
+    lineDashed5: string;
+    lineDashed6: string;
+    lineDashed7: string;
+    lineDashed8: string;
+    lineDashed9: string;
+    lineDashed10: string;
+    lineDashed11: string;
+    lineDashed12: string;
+    lineDashed13: string;
+    lineDashed14: string;
+    lineDashed15: string;
+    lineVertical: string;
+    lineVerticalBold: string;
+    lineVerticalDouble: string;
+    lineVerticalDashed0: string;
+    lineVerticalDashed1: string;
+    lineVerticalDashed2: string;
+    lineVerticalDashed3: string;
+    lineVerticalDashed4: string;
+    lineVerticalDashed5: string;
+    lineVerticalDashed6: string;
+    lineVerticalDashed7: string;
+    lineVerticalDashed8: string;
+    lineVerticalDashed9: string;
+    lineVerticalDashed10: string;
+    lineVerticalDashed11: string;
+    lineDownLeft: string;
+    lineDownLeftArc: string;
+    lineDownBoldLeftBold: string;
+    lineDownBoldLeft: string;
+    lineDownLeftBold: string;
+    lineDownDoubleLeftDouble: string;
+    lineDownDoubleLeft: string;
+    lineDownLeftDouble: string;
+    lineDownRight: string;
+    lineDownRightArc: string;
+    lineDownBoldRightBold: string;
+    lineDownBoldRight: string;
+    lineDownRightBold: string;
+    lineDownDoubleRightDouble: string;
+    lineDownDoubleRight: string;
+    lineDownRightDouble: string;
+    lineUpLeft: string;
+    lineUpLeftArc: string;
+    lineUpBoldLeftBold: string;
+    lineUpBoldLeft: string;
+    lineUpLeftBold: string;
+    lineUpDoubleLeftDouble: string;
+    lineUpDoubleLeft: string;
+    lineUpLeftDouble: string;
+    lineUpRight: string;
+    lineUpRightArc: string;
+    lineUpBoldRightBold: string;
+    lineUpBoldRight: string;
+    lineUpRightBold: string;
+    lineUpDoubleRightDouble: string;
+    lineUpDoubleRight: string;
+    lineUpRightDouble: string;
+    lineUpDownLeft: string;
+    lineUpBoldDownBoldLeftBold: string;
+    lineUpBoldDownBoldLeft: string;
+    lineUpDownLeftBold: string;
+    lineUpBoldDownLeftBold: string;
+    lineUpDownBoldLeftBold: string;
+    lineUpDownBoldLeft: string;
+    lineUpBoldDownLeft: string;
+    lineUpDoubleDownDoubleLeftDouble: string;
+    lineUpDoubleDownDoubleLeft: string;
+    lineUpDownLeftDouble: string;
+    lineUpDownRight: string;
+    lineUpBoldDownBoldRightBold: string;
+    lineUpBoldDownBoldRight: string;
+    lineUpDownRightBold: string;
+    lineUpBoldDownRightBold: string;
+    lineUpDownBoldRightBold: string;
+    lineUpDownBoldRight: string;
+    lineUpBoldDownRight: string;
+    lineUpDoubleDownDoubleRightDouble: string;
+    lineUpDoubleDownDoubleRight: string;
+    lineUpDownRightDouble: string;
+    lineDownLeftRight: string;
+    lineDownBoldLeftBoldRightBold: string;
+    lineDownLeftBoldRightBold: string;
+    lineDownBoldLeftRight: string;
+    lineDownBoldLeftBoldRight: string;
+    lineDownBoldLeftRightBold: string;
+    lineDownLeftRightBold: string;
+    lineDownLeftBoldRight: string;
+    lineDownDoubleLeftDoubleRightDouble: string;
+    lineDownDoubleLeftRight: string;
+    lineDownLeftDoubleRightDouble: string;
+    lineUpLeftRight: string;
+    lineUpBoldLeftBoldRightBold: string;
+    lineUpLeftBoldRightBold: string;
+    lineUpBoldLeftRight: string;
+    lineUpBoldLeftBoldRight: string;
+    lineUpBoldLeftRightBold: string;
+    lineUpLeftRightBold: string;
+    lineUpLeftBoldRight: string;
+    lineUpDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleLeftRight: string;
+    lineUpLeftDoubleRightDouble: string;
+    lineUpDownLeftRight: string;
+    lineUpBoldDownBoldLeftBoldRightBold: string;
+    lineUpDownBoldLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRightBold: string;
+    lineUpBoldDownBoldLeftRightBold: string;
+    lineUpBoldDownBoldLeftBoldRight: string;
+    lineUpBoldDownLeftRight: string;
+    lineUpDownBoldLeftRight: string;
+    lineUpDownLeftBoldRight: string;
+    lineUpDownLeftRightBold: string;
+    lineUpBoldDownBoldLeftRight: string;
+    lineUpDownLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRight: string;
+    lineUpBoldDownLeftRightBold: string;
+    lineUpDownBoldLeftBoldRight: string;
+    lineUpDownBoldLeftRightBold: string;
+    lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleDownDoubleLeftRight: string;
+    lineUpDownLeftDoubleRightDouble: string;
+    lineCross: string;
+    lineBackslash: string;
+    lineSlash: string;
+};
+declare const fallbackSymbols: Record<string, string>;
+declare const figures: {
+    tick: string;
+    info: string;
+    warning: string;
+    cross: string;
+    squareSmall: string;
+    squareSmallFilled: string;
+    circle: string;
+    circleFilled: string;
+    circleDotted: string;
+    circleDouble: string;
+    circleCircle: string;
+    circleCross: string;
+    circlePipe: string;
+    radioOn: string;
+    radioOff: string;
+    checkboxOn: string;
+    checkboxOff: string;
+    checkboxCircleOn: string;
+    checkboxCircleOff: string;
+    pointer: string;
+    triangleUpOutline: string;
+    triangleLeft: string;
+    triangleRight: string;
+    lozenge: string;
+    lozengeOutline: string;
+    hamburger: string;
+    smiley: string;
+    mustache: string;
+    star: string;
+    play: string;
+    nodejs: string;
+    oneSeventh: string;
+    oneNinth: string;
+    oneTenth: string;
+    circleQuestionMark: string;
+    questionMarkPrefix: string;
+    square: string;
+    squareDarkShade: string;
+    squareMediumShade: string;
+    squareLightShade: string;
+    squareTop: string;
+    squareBottom: string;
+    squareLeft: string;
+    squareRight: string;
+    squareCenter: string;
+    bullet: string;
+    dot: string;
+    ellipsis: string;
+    pointerSmall: string;
+    triangleUp: string;
+    triangleUpSmall: string;
+    triangleDown: string;
+    triangleDownSmall: string;
+    triangleLeftSmall: string;
+    triangleRightSmall: string;
+    home: string;
+    heart: string;
+    musicNote: string;
+    musicNoteBeamed: string;
+    arrowUp: string;
+    arrowDown: string;
+    arrowLeft: string;
+    arrowRight: string;
+    arrowLeftRight: string;
+    arrowUpDown: string;
+    almostEqual: string;
+    notEqual: string;
+    lessOrEqual: string;
+    greaterOrEqual: string;
+    identical: string;
+    infinity: string;
+    subscriptZero: string;
+    subscriptOne: string;
+    subscriptTwo: string;
+    subscriptThree: string;
+    subscriptFour: string;
+    subscriptFive: string;
+    subscriptSix: string;
+    subscriptSeven: string;
+    subscriptEight: string;
+    subscriptNine: string;
+    oneHalf: string;
+    oneThird: string;
+    oneQuarter: string;
+    oneFifth: string;
+    oneSixth: string;
+    oneEighth: string;
+    twoThirds: string;
+    twoFifths: string;
+    threeQuarters: string;
+    threeFifths: string;
+    threeEighths: string;
+    fourFifths: string;
+    fiveSixths: string;
+    fiveEighths: string;
+    sevenEighths: string;
+    line: string;
+    lineBold: string;
+    lineDouble: string;
+    lineDashed0: string;
+    lineDashed1: string;
+    lineDashed2: string;
+    lineDashed3: string;
+    lineDashed4: string;
+    lineDashed5: string;
+    lineDashed6: string;
+    lineDashed7: string;
+    lineDashed8: string;
+    lineDashed9: string;
+    lineDashed10: string;
+    lineDashed11: string;
+    lineDashed12: string;
+    lineDashed13: string;
+    lineDashed14: string;
+    lineDashed15: string;
+    lineVertical: string;
+    lineVerticalBold: string;
+    lineVerticalDouble: string;
+    lineVerticalDashed0: string;
+    lineVerticalDashed1: string;
+    lineVerticalDashed2: string;
+    lineVerticalDashed3: string;
+    lineVerticalDashed4: string;
+    lineVerticalDashed5: string;
+    lineVerticalDashed6: string;
+    lineVerticalDashed7: string;
+    lineVerticalDashed8: string;
+    lineVerticalDashed9: string;
+    lineVerticalDashed10: string;
+    lineVerticalDashed11: string;
+    lineDownLeft: string;
+    lineDownLeftArc: string;
+    lineDownBoldLeftBold: string;
+    lineDownBoldLeft: string;
+    lineDownLeftBold: string;
+    lineDownDoubleLeftDouble: string;
+    lineDownDoubleLeft: string;
+    lineDownLeftDouble: string;
+    lineDownRight: string;
+    lineDownRightArc: string;
+    lineDownBoldRightBold: string;
+    lineDownBoldRight: string;
+    lineDownRightBold: string;
+    lineDownDoubleRightDouble: string;
+    lineDownDoubleRight: string;
+    lineDownRightDouble: string;
+    lineUpLeft: string;
+    lineUpLeftArc: string;
+    lineUpBoldLeftBold: string;
+    lineUpBoldLeft: string;
+    lineUpLeftBold: string;
+    lineUpDoubleLeftDouble: string;
+    lineUpDoubleLeft: string;
+    lineUpLeftDouble: string;
+    lineUpRight: string;
+    lineUpRightArc: string;
+    lineUpBoldRightBold: string;
+    lineUpBoldRight: string;
+    lineUpRightBold: string;
+    lineUpDoubleRightDouble: string;
+    lineUpDoubleRight: string;
+    lineUpRightDouble: string;
+    lineUpDownLeft: string;
+    lineUpBoldDownBoldLeftBold: string;
+    lineUpBoldDownBoldLeft: string;
+    lineUpDownLeftBold: string;
+    lineUpBoldDownLeftBold: string;
+    lineUpDownBoldLeftBold: string;
+    lineUpDownBoldLeft: string;
+    lineUpBoldDownLeft: string;
+    lineUpDoubleDownDoubleLeftDouble: string;
+    lineUpDoubleDownDoubleLeft: string;
+    lineUpDownLeftDouble: string;
+    lineUpDownRight: string;
+    lineUpBoldDownBoldRightBold: string;
+    lineUpBoldDownBoldRight: string;
+    lineUpDownRightBold: string;
+    lineUpBoldDownRightBold: string;
+    lineUpDownBoldRightBold: string;
+    lineUpDownBoldRight: string;
+    lineUpBoldDownRight: string;
+    lineUpDoubleDownDoubleRightDouble: string;
+    lineUpDoubleDownDoubleRight: string;
+    lineUpDownRightDouble: string;
+    lineDownLeftRight: string;
+    lineDownBoldLeftBoldRightBold: string;
+    lineDownLeftBoldRightBold: string;
+    lineDownBoldLeftRight: string;
+    lineDownBoldLeftBoldRight: string;
+    lineDownBoldLeftRightBold: string;
+    lineDownLeftRightBold: string;
+    lineDownLeftBoldRight: string;
+    lineDownDoubleLeftDoubleRightDouble: string;
+    lineDownDoubleLeftRight: string;
+    lineDownLeftDoubleRightDouble: string;
+    lineUpLeftRight: string;
+    lineUpBoldLeftBoldRightBold: string;
+    lineUpLeftBoldRightBold: string;
+    lineUpBoldLeftRight: string;
+    lineUpBoldLeftBoldRight: string;
+    lineUpBoldLeftRightBold: string;
+    lineUpLeftRightBold: string;
+    lineUpLeftBoldRight: string;
+    lineUpDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleLeftRight: string;
+    lineUpLeftDoubleRightDouble: string;
+    lineUpDownLeftRight: string;
+    lineUpBoldDownBoldLeftBoldRightBold: string;
+    lineUpDownBoldLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRightBold: string;
+    lineUpBoldDownBoldLeftRightBold: string;
+    lineUpBoldDownBoldLeftBoldRight: string;
+    lineUpBoldDownLeftRight: string;
+    lineUpDownBoldLeftRight: string;
+    lineUpDownLeftBoldRight: string;
+    lineUpDownLeftRightBold: string;
+    lineUpBoldDownBoldLeftRight: string;
+    lineUpDownLeftBoldRightBold: string;
+    lineUpBoldDownLeftBoldRight: string;
+    lineUpBoldDownLeftRightBold: string;
+    lineUpDownBoldLeftBoldRight: string;
+    lineUpDownBoldLeftRightBold: string;
+    lineUpDoubleDownDoubleLeftDoubleRightDouble: string;
+    lineUpDoubleDownDoubleLeftRight: string;
+    lineUpDownLeftDoubleRightDouble: string;
+    lineCross: string;
+    lineBackslash: string;
+    lineSlash: string;
+} | Record<string, string>;
+
+interface GroupOptions {
+    onCancel?: () => void;
+    showProgress?: boolean;
+    title?: string;
+}
+interface GroupContext<T> {
+    results: Partial<T>;
+    step: keyof T;
+    stepIndex: number;
+    totalSteps: number;
+}
+type GroupStep<T, K extends keyof T> = (context: GroupContext<T>) => Promise<T[K]> | T[K];
+type GroupSteps<T> = {
+    [K in keyof T]: GroupStep<T, K>;
+};
+/**
+ * Runs a series of prompts in sequence, where each prompt can depend on the results of previous prompts.
+ *
+ * @param steps Object where each key is a step name and each value is a function that returns a promise
+ * @param options Optional configuration including onCancel callback and progress display
+ * @returns Promise resolving to the complete results object
+ */
+declare function group<T extends Record<string, any>>(steps: GroupSteps<T>, options?: GroupOptions): Promise<T>;
+/**
+ * Utility function to create a step that depends on specific previous results
+ */
+declare function createStep<T, K extends keyof T, D extends keyof T>(stepFunction: (context: GroupContext<T>, dependency: T[D]) => Promise<T[K]> | T[K], dependencyKey: D): GroupStep<T, K>;
+/**
+ * Utility function to create a step that depends on multiple previous results
+ */
+declare function createMultiStep<T, K extends keyof T, D extends (keyof T)[]>(stepFunction: (context: GroupContext<T>, dependencies: {
+    [P in D[number]]: T[P];
+}) => Promise<T[K]> | T[K], dependencyKeys: D): GroupStep<T, K>;
+
+/**
+ * inputPrompt()
+ *
+ * Main entry point to prompt the user for input.
+ * - Renders a text prompt with optional hint, placeholder, and content.
+ * - Waits for user input (supporting "plain" or "password" modes).
+ * - Validates input with an optional TypeBox schema or custom validate() fn.
+ * - Shows errors if invalid, re-prompts if necessary.
+ * - Handles Ctrl+C gracefully, optionally printing an endTitle.
+ * - Returns the user's validated input, or a default value if empty.
+ *
+ * @param options InputPromptOptions to customize the prompt.
+ * @returns A Promise resolving to the validated user input (string).
+ */
+declare function inputPrompt(options: InputPromptOptions): Promise<string>;
+
+declare const input: typeof inputPrompt;
+declare const text: typeof inputPrompt;
+declare const password: (options: Omit<InputPromptOptions, "mode">) => Promise<string>;
+
+type StartPromptOptions = PromptOptions & {
+    clearConsole?: boolean;
+    horizontalLine?: boolean;
+    horizontalLineLength?: number;
+    packageName?: string;
+    packageVersion?: string;
+    terminalSizeOptions?: PreventWrongTerminalSizeOptions;
+    isDev?: boolean;
+    prevent?: {
+        unsupportedTTY?: boolean;
+        wrongTerminalSize?: boolean;
+        windowsHomeDirRoot?: boolean;
+    };
+    variant?: "header" | "ascii-art";
+    asciiArtFont?: Fonts;
+};
+declare function introPrompt(optionsOrTitle: StartPromptOptions | string): Promise<void>;
+
+declare const startPrompt: typeof introPrompt;
+declare const intro: typeof introPrompt;
+
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1Props<Input, Output>;
+}
+/** The Standard Schema properties interface. */
+interface StandardSchemaV1Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
+}
+/** The result interface of the validate function. */
+type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+/** The result interface if validation succeeds. */
+interface StandardSchemaV1SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+}
+/** The result interface if validation fails. */
+interface StandardSchemaV1FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: readonly StandardSchemaV1Issue[];
+}
+/** The issue interface of the failure output. */
+interface StandardSchemaV1Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
+}
+/** The path segment interface of the issue. */
+interface StandardSchemaV1PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+}
+/** The Standard Schema types interface. */
+interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+}
+/** Infers the input type of a Standard Schema. */
+type StandardSchemaV1InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+/** Infers the output type of a Standard Schema. */
+type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+
+/**
+ * Type which looks *enough* like a trpc v11(+?) router to infer its types correctly
+ * This is written from scratch to avoid any kind of dependency on @trpc/server v11+
+ */
+interface Trpc11RouterLike {
+    _def: {
+        _config: {
+            $types: {
+                meta: any;
+                ctx: any;
+            };
+        };
+        procedures: Record<string, Trpc11ProcedureLike | Trpc11ProcedureRecordLike | Record<string, Trpc11ProcedureLike>>;
+    };
+}
+/** Even though you use `t.router({})` to create a sub-router, the actual type is a record of procedures and sub-routers rather than a root-level router */
+interface Trpc11ProcedureRecordLike {
+    [key: string]: Trpc11ProcedureLike | Trpc11ProcedureRecordLike;
+}
+interface Trpc11ProcedureLike {
+    _def: {
+        type: "mutation" | "query" | "subscription";
+        _type?: undefined;
+        meta?: any;
+        inputs?: unknown[];
+        $types: {
+            input: any;
+            output: any;
+        };
+    };
+}
+interface Trpc10RouterLike {
+    _def: {
+        _config: {
+            $types: {
+                meta: any;
+                ctx: any;
+            };
+        };
+        procedures: Record<string, Trpc10ProcedureLike | Trpc10RouterLike>;
+    };
+}
+interface Trpc10ProcedureLike {
+    _def: {
+        type?: undefined;
+        mutation?: boolean;
+        query?: boolean;
+        subscription?: boolean;
+        meta?: any;
+        inputs: unknown[];
+        _input_in: any;
+        _output_out: any;
+    };
+}
+interface OrpcProcedureLike<Ctx> {
+    "~orpc": {
+        __initialContext?: (context: Ctx) => unknown;
+        inputSchema?: StandardSchemaV1;
+    };
+}
+interface OrpcRouterLike<Ctx> {
+    [key: string]: OrpcProcedureLike<Ctx> | OrpcRouterLike<Ctx>;
+}
+type CreateCallerFactoryLike<Procedures = Record<string, (input: unknown) => unknown>> = (router: any) => (context: any) => Procedures;
+type AnyRouter = Trpc10RouterLike | Trpc11RouterLike | OrpcRouterLike<any>;
+type AnyProcedure = Trpc10ProcedureLike | Trpc11ProcedureLike;
+type inferRouterContext<R extends AnyRouter> = R extends Trpc10RouterLike | Trpc11RouterLike ? R["_def"]["_config"]["$types"]["ctx"] : R extends OrpcRouterLike<infer Ctx> ? Ctx : never;
+declare const isTrpc11Procedure: (procedure: AnyProcedure) => procedure is Trpc11ProcedureLike;
+declare const isTrpc11Router: (router: AnyRouter) => router is Trpc11RouterLike;
+declare const isOrpcRouter: (router: AnyRouter) => router is OrpcRouterLike<any>;
+
+type EmptyArgs = Record<string, never>;
+interface BaseArgProps {
+    description?: string;
+    required?: boolean;
+    allowed?: string[];
+}
+interface BaseArgDefinition {
+    type: string;
+    description?: string;
+    required?: boolean;
+    default?: any;
+    allowed?: any[];
+    dependencies?: string[];
+}
+type PositionalArgDefinition = BaseArgDefinition & {
+    type: "positional";
+    default?: string;
+};
+type BooleanArgDefinition = BaseArgDefinition & {
+    type: "boolean";
+    default?: boolean;
+    allowed?: boolean[];
+    alias?: string;
+};
+type StringArgDefinition = BaseArgDefinition & {
+    type: "string";
+    default?: string;
+    alias?: string;
+};
+type NumberArgDefinition = BaseArgDefinition & {
+    type: "number";
+    default?: number;
+    allowed?: number[];
+    alias?: string;
+};
+type ArrayArgDefinition = BaseArgDefinition & {
+    type: "array";
+    default?: string | readonly string[];
+    alias?: string;
+};
+type ArgDefinition = PositionalArgDefinition | BooleanArgDefinition | StringArgDefinition | NumberArgDefinition | ArrayArgDefinition;
+type ArgDefinitions = Record<string, ArgDefinition>;
+interface CommandMeta {
+    name: string;
+    version?: string;
+    description?: string;
+    hidden?: boolean;
+    aliases?: string[];
+}
+/**
+ * A subcommand can be either:
+ * 1) A string path to a module with a default export of type Command.
+ * 2) A lazy import function returning a Promise that resolves to
+ *    { default: Command<any> } or directly to a Command instance.
+ */
+type CommandSpec = string | (() => Promise<{
+    default: Command<any>;
+} | Command<any>>);
+type CommandsMap = Record<string, CommandSpec>;
+interface CommandContext<ARGS> {
+    args: ARGS;
+    raw: string[];
+}
+type CommandRun<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+type CommandHook<ARGS> = (ctx: CommandContext<ARGS>) => void | Promise<void>;
+interface DefineCommandOptions<A extends ArgDefinitions = EmptyArgs> {
+    meta?: CommandMeta;
+    args?: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+    /**
+     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
+     * switch to RPC mode and use the router's procedures as CLI commands.
+     */
+    router?: AnyRouter;
+}
+interface Command<A extends ArgDefinitions = EmptyArgs> {
+    meta?: CommandMeta;
+    args: A;
+    run?: CommandRun<InferArgTypes<A>>;
+    /**
+     * Object subcommands for this command.
+     */
+    commands?: CommandsMap;
+    /**
+     * @deprecated Use `commands` instead. Will be removed in a future major version.
+     */
+    subCommands?: CommandsMap;
+    /**
+     * Called before the command runs. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdInit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called after the command finishes. Receives `{ args, raw }` (parsed args and raw argv).
+     */
+    onCmdExit?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdInit instead
+     */
+    setup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * @deprecated Use onCmdExit instead
+     */
+    cleanup?: CommandHook<InferArgTypes<A>>;
+    /**
+     * Called once per CLI process, before any command/run() is executed
+     */
+    onLauncherInit?: () => void | Promise<void>;
+    /**
+     * Called once per CLI process, after all command/run() logic is finished
+     */
+    onLauncherExit?: () => void | Promise<void>;
+    /**
+     * tRPC/oRPC router for RPC mode. When provided, the command will automatically
+     * switch to RPC mode and use the router's procedures as CLI commands.
+     */
+    router?: AnyRouter;
+}
+type InferArgTypes<A extends ArgDefinitions> = {
+    [K in keyof A]: A[K] extends PositionalArgDefinition ? string : A[K] extends BooleanArgDefinition ? boolean : A[K] extends StringArgDefinition ? string : A[K] extends NumberArgDefinition ? number : A[K] extends {
+        type: "array";
+    } ? string[] : never;
+};
+interface FileBasedOptions {
+    enable: boolean;
+    cmdsRootPath: string;
+}
+
+/**
+ * Load a command from the filesystem.
+ *
+ * @param cmdPath - Path to the command file or directory containing cmd.ts/cmd.js
+ * @returns Promise<Command> - The loaded command
+ *
+ * @example
+ * ```ts
+ * // Load a command
+ * const cmd = await loadCommand("./web/cmd");
+ *
+ * // Use with runCmd - pass args as separate array elements
+ * await runCmd(cmd, ["--dev", "true"]); // ✅ Correct
+ * await runCmd(cmd, [`--dev ${isDev}`]); // ❌ Wrong - creates single string
+ * ```
+ */
+declare function loadCommand(cmdPath: string): Promise<Command>;
+
+/**
+ * Static implementation functions for the typed command system.
+ * These functions are imported by the generated cmds.ts file.
+ */
+declare function argsToStringArray(args: Record<string, unknown>): string[];
+declare function createCallCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T, args?: TCommandArgsMap[T]) => Promise<void>)>;
+declare function createGetTypedCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T) => Promise<{
+    command: Command;
+    run: (args?: TCommandArgsMap[T]) => Promise<void>;
+}>)>;
+declare function callCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap, args?: TCommandArgsMap[keyof TCommandArgsMap]): Promise<void>;
+declare function getTypedCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap): Promise<{
+    command: Command;
+    run: (args?: TCommandArgsMap[keyof TCommandArgsMap]) => Promise<void>;
+}>;
+
+/**
+ * JSON representation of a commander `Command` instance
+ * Note: this is not necessarily a _complete_ representation of the command - it aims to be a big enough subset to be useful for generating documentation etc.
+ */
+interface CommandJSON {
+    name?: string;
+    version?: string;
+    description?: string;
+    usage?: string;
+    commands?: CommandJSON[];
+    arguments?: {
+        name: string;
+        description?: string;
+        required: boolean;
+        defaultValue?: {};
+        defaultValueDescription?: string;
+        variadic: boolean;
+        choices?: string[];
+    }[];
+    options?: {
+        name: string;
+        description?: string;
+        required: boolean;
+        defaultValue?: {};
+        defaultValueDescription?: string;
+        variadic: boolean;
+        attributeName?: string;
+        flags?: string;
+        short?: string;
+        negate: boolean;
+        optional: boolean;
+        choices?: string[];
+    }[];
+}
+/**
+ * Convert a commander `Command` instance to a JSON object.
+ *
+ * Note: in theory you could use this with any `Command` instance, it doesn't have
+ * to be one built by `@reliverse/rempts`. Implementing here because it's pretty simple to do and `commander` doesn't seem to provide a way to do it.
+ *
+ * Note: falsy values for strings are replaced with `undefined` in the output - e.g. if there's an empty description, it will be `undefined` in the output.
+ */
+declare const commandToJSON: (command: Command$1) => CommandJSON;
+
+interface TrpcCliParams<R extends AnyRouter> extends Dependencies {
+    /** A tRPC router. Procedures will become CLI commands. */
+    router: R;
+    name?: string;
+    version?: string;
+    description?: string;
+    usage?: string | string[];
+    /** Context to be supplied when invoking the router. */
+    context?: inferRouterContext<R>;
+    /** @deprecated this is actually **removed** not deprecated; use `aliases` on each procedure `meta` instead */
+    alias?: never;
+    /** @deprecated this is actually **removed** not deprecated; set `default: true` on the procedure `meta` instead */
+    _default?: never;
+    /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
+    trpcServer?: TrpcServerModuleLike | Promise<TrpcServerModuleLike>;
+}
+/** Rough shape of the `@trpc/server` (v10) module. Needed to pass in to `createRpcCli` when using trpc v10. */
+interface TrpcServerModuleLike {
+    initTRPC: {
+        create: () => {
+            createCallerFactory: CreateCallerFactoryLike<{}>;
+        };
+    };
+}
+/**
+ * Optional interface for describing procedures via meta - if your router conforms to this meta shape, it will contribute to the CLI help text.
+ */
+interface TrpcCliMeta {
+    /** Version of the script displayed in `--help` output. Use to avoid enabling `--version` option. */
+    version?: string;
+    /** Description of the script or command to display in `--help` output. */
+    description?: string;
+    /** Usage code examples to display in `--help` output. */
+    usage?: false | string | string[];
+    /** Example code snippets to display in `--help` output. */
+    examples?: string | string[];
+    /** If true, this command will be run if no command is specified. */
+    default?: boolean;
+    aliases?: {
+        /** Aliases for the command. Note: take care to avoid conflicts with other commands. */
+        command?: string[];
+        /** Aliases for the options. Note: take care to avoid conflicts with other options. An error will be thrown if an alias is defined for a non-existent option. */
+        options?: Record<string, string>;
+    };
+    /** If true, will use a single CLI option expect the entire input to be parsed in as JSON, e.g. `--input '{"foo": "bar"}`. Can be useful to opt out of the default mapping of input schemas to CLI options. */
+    jsonInput?: boolean;
+    /** Sub-property for the CLI meta. If present, will take precedence over the top-level meta, to avoid conflicts with other tools. */
+    cliMeta?: TrpcCliMeta;
+}
+interface ParsedProcedure {
+    positionalParameters: {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | (string & {});
+        required: boolean;
+        array: boolean;
+    }[];
+    /** JSON Schema type describing the flags for the procedure */
+    optionsJsonSchema: JsonSchema7Type;
+    /**
+     * Function for taking parsed argv output and transforming it so it can be passed into the procedure.
+     * Needed because this function is where inspect the input schema(s) and determine how to map the argv to the input
+     */
+    getPojoInput: (argv: {
+        positionalValues: (string | string[])[];
+        options: Record<string, unknown>;
+    }) => unknown;
+}
+type Result<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: string;
+};
+/** A function that logs any inputs. e.g. `console.info` */
+type Log = (...args: unknown[]) => void;
+/**
+ * A struct which has `info` and `error` functions for logging. Easiest example: `console`
+ * But most loggers like pino, winston etc. have a similar interface.
+ */
+interface Logger {
+    info?: Log;
+    error?: Log;
+}
+/**
+ * Slim reconstruction of an `omelette` instance. Hand-written here to avoid a hard dependency on `omelette` or its types.
+ * Usually you will just pass in an `omelette` instance by doing something like
+ *
+ * ```ts
+ * import omelette from 'omelette'
+ * import {createRpcCli} from '@reliverse/rempts'
+ *
+ * const cli = createRpcCli({
+ *   router: myRouter,
+ *   completion: omelette('myprogram'),
+ * })
+ * ```
+ *
+ * Or it also accepts an async function that resolves to an `omelette` instance, so you can use dynamic import:
+ *
+ * ```ts
+ * import {createRpcCli} from '@reliverse/rempts'
+ *
+ * const cli = await createRpcCli({
+ *   router: myRouter,
+ *   completion: () => import('omelette').then(omelette => omelette.default('myprogram')),
+ * })
+ * ```
+ */
+interface OmeletteInstanceLike {
+    on: (event: "complete", callback: (fragment: string, params: {
+        line: string;
+        fragment: number;
+        reply: (suggestions: string[]) => void;
+    }) => void) => void;
+    init: () => void;
+    setupShellInitFile: () => void;
+    cleanupShellInitFile: () => void;
+    tree: (value: any) => this;
+}
+interface InquirerPromptOptions {
+    message: string;
+    required?: boolean;
+    validate?: (input: string) => boolean | string;
+    default?: any;
+}
+/** looks like the `@inquirer/prompts` package */
+interface InquirerPromptsLike {
+    input: (params: InquirerPromptOptions) => Promise<string>;
+    confirm: (params: InquirerPromptOptions) => Promise<boolean>;
+}
+/** looks like the `prompts` package */
+interface PromptsLike {
+    prompt: Function;
+    inject: Function;
+}
+/** looks like the `enquirer` package */
+interface EnquirerLike {
+    prompt: <T>(params: {
+        type: "input";
+        name: string;
+        message: string;
+        validate?: (input: string) => boolean | string;
+        initial?: unknown;
+    }) => Promise<T>;
+}
+interface ClackPromptsLike {
+    intro: (title: string) => void;
+    outro: (title: string) => void;
+}
+type Promptable = InquirerPromptsLike | EnquirerLike | PromptsLike | Prompter | ClackPromptsLike | ((command: CommanderProgramLike) => Prompter);
+interface TrpcCliRunParams {
+    argv?: string[];
+    logger?: Logger;
+    completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
+    prompts?: Promptable;
+    /** Format an error thrown by the root procedure before logging to `logger.error` */
+    formatError?: (error: unknown) => string;
+    process?: {
+        exit: (code: number) => never;
+    };
+}
+/**
+ * Type that looks like a `commander` Command instance, but doesn't require a dependency on `commander` to avoid awkward typescript errors.
+ * If you need to use it as a `Command` instance, just cast it with `as` to `import('commander').Command`.
+ */
+interface CommanderProgramLike {
+    name: () => string;
+    parseAsync: (args: string[], options?: {
+        from: "user" | "node" | "electron";
+    }) => Promise<unknown>;
+    helpInformation: () => string;
+}
+interface TrpcCli {
+    /** run the CLI - gets args from `process.argv` by default */
+    run: (params?: TrpcCliRunParams, program?: CommanderProgramLike) => Promise<void>;
+    /**
+     * Build a `Commander` program from the CLI - you can use this to manually customise the program before passing it to `.run(...)`.
+     * Note that you will need to cast the return value to `import('commander').Command` to use it as a `Command` instance.
+     */
+    buildProgram: (params?: TrpcCliRunParams) => CommanderProgramLike;
+    /**
+     * @experimental
+     * Get a JSON representation of the CLI - useful for generating documentation etc. This function returns basic information about the CLI
+     * and each command - to get any extra details you will need to use the `buildProgram` function and walk the tree of commands yourself.
+     */
+    toJSON: (program?: CommanderProgramLike) => CommandJSON;
+}
+interface Dependencies {
+    "@valibot/to-json-schema"?: {
+        toJsonSchema: (input: unknown, options?: {
+            errorMode?: "throw" | "ignore" | "warn";
+        }) => JSONSchema7;
+    };
+    effect?: {
+        Schema: {
+            isSchema: (input: unknown) => input is "JSONSchemaMakeable";
+        };
+        JSONSchema: {
+            make: (input: "JSONSchemaMakeable") => JSONSchema7;
+        };
+    };
+}
+interface PromptContext {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    clearPromptOnDone?: boolean;
+    signal?: AbortSignal;
+    /** The command that is being prompted for. Cast this to a `commander.Command` to access the command's name, description, options etc. */
+    command: {
+        name: () => string;
+    };
+    /** The original inputs the user provided - if they passed some but not all arguments/options, this will contain the values they did pass. */
+    inputs: {
+        argv: string[];
+        arguments: {
+            name: string;
+            specified: boolean;
+            value: unknown;
+        }[];
+        options: {
+            name: string;
+            specified: boolean;
+            value: unknown;
+        }[];
+    };
+    /** If set, this is the argument that is being prompted for. Cast to a `commander.Argument`. */
+    argument?: {
+        name: () => string;
+    };
+    /** If set, this is the option that is being prompted for. Cast to a `commander.Option`. */
+    option?: {
+        name: () => string;
+    };
+}
+interface Prompter {
+    setup?: (context: PromptContext) => Promise<void>;
+    teardown?: (context: PromptContext) => Promise<void>;
+    input: (params: {
+        message: string;
+        validate?: (input: string) => boolean | string;
+        required?: boolean;
+        default?: string;
+    }, context: PromptContext) => Promise<string>;
+    select: (params: {
+        message: string;
+        choices: string[] | {
+            name: string;
+            value: string;
+            description?: string;
+        }[];
+        required?: boolean;
+        default?: string;
+        validate?: (input: string) => boolean | string;
+    }, context: PromptContext) => Promise<string>;
+    confirm: (params: {
+        message: string;
+        default?: boolean;
+        validate?: (input: string) => boolean | string;
+    }, context: PromptContext) => Promise<boolean>;
+    checkbox: (params: {
+        message: string;
+        choices: {
+            name: string;
+            value: string;
+            checked?: boolean;
+        }[];
+        required?: boolean;
+        default?: string[];
+    }, context: PromptContext) => Promise<string[]>;
+}
+
+/**
+ * Defines a command with metadata, argument definitions,
+ * an execution function, and (optional) subCommands.
+ */
+declare function defineCommand<A extends ArgDefinitions = EmptyArgs>(options: DefineCommandOptions<A>): Command<A>;
+/**
+ * Show usage for a given command.
+ */
+declare function showUsage<A extends ArgDefinitions>(command: Command<A>, parserOptions?: ReliArgParserOptions & {
+    fileBased?: FileBasedOptions;
+    autoExit?: boolean;
+    metaSettings?: {
+        showDescriptionOnMain?: boolean;
+    };
+    _fileBasedCurrentDir?: string;
+    _fileBasedPathSegments?: string[];
+    _isSubcommand?: boolean;
+}, globalCliMeta?: {
+    name?: string;
+    version?: string;
+    description?: string;
+}): Promise<void>;
+/**
+ * Primary entry point to run a command. This function supports:
+ *
+ * - File-based Commands: scanning for commands within a given commands root.
+ * - Commands defined within the command object.
+ * - Standard flags like --help, --version, and --debug.
+ * - RPC functionality: tRPC/oRPC router integration with automatic CLI generation.
+ *
+ * This function passes along remaining arguments to command runners to ensure
+ * consistent parsing.
+ */
+declare function createCli<A extends ArgDefinitions = EmptyArgs>(options: Command<A> | {
+    name?: string;
+    version?: string;
+    description?: string;
+    mainCommand?: Command<A>;
+    fileBased?: FileBasedOptions;
+    autoExit?: boolean;
+    metaSettings?: {
+        showDescriptionOnMain?: boolean;
+    };
+    meta?: Command<A>["meta"];
+    args?: Command<A>["args"];
+    run?: Command<A>["run"];
+    commands?: Command<A>["commands"];
+    onCmdInit?: Command<A>["onCmdInit"];
+    onCmdExit?: Command<A>["onCmdExit"];
+    onLauncherInit?: Command<A>["onLauncherInit"];
+    onLauncherExit?: Command<A>["onLauncherExit"];
+    rpc?: {
+        /** A tRPC router. Procedures will become CLI commands. */
+        router: AnyRouter;
+        /** Context to be supplied when invoking the router. */
+        context?: any;
+        /** The `@trpc/server` module to use for calling procedures. Required when using trpc v10. */
+        trpcServer?: any | Promise<any>;
+        /** Usage code examples to display in `--help` output. */
+        usage?: string | string[];
+        /** Dependencies for schema validation libraries */
+        "@valibot/to-json-schema"?: {
+            toJsonSchema: (input: unknown, options?: {
+                errorMode?: "throw" | "ignore" | "warn";
+            }) => any;
+        };
+        effect?: {
+            Schema: {
+                isSchema: (input: unknown) => input is "JSONSchemaMakeable";
+            };
+            JSONSchema: {
+                make: (input: "JSONSchemaMakeable") => any;
+            };
+        };
+    };
+    rpcRunParams?: {
+        argv?: string[];
+        logger?: Logger;
+        completion?: OmeletteInstanceLike | (() => Promise<OmeletteInstanceLike>);
+        prompts?: Promptable;
+        /** Format an error thrown by the root procedure before logging to `logger.error` */
+        formatError?: (error: unknown) => string;
+        process?: {
+            exit: (code: number) => never;
+        };
+    };
+}, legacyParserOptions?: ReliArgParserOptions & {
+    fileBased?: FileBasedOptions;
+    autoExit?: boolean;
+    metaSettings?: {
+        showDescriptionOnMain?: boolean;
+    };
+}): Promise<void> & {
+    run(_ctx?: any): Promise<void>;
+};
+/**
+ * Helper to define argument definitions with improved type inference
+ * for IntelliSense and validation for array defaults against options.
+ */
+declare function defineArgs<A extends ArgDefinitions>(args: A): A;
+/**
+ * Programmatically run a command with subcommand support and flexible argument handling.
+ * This function can handle subcommands (including nested), positional arguments, and automatically normalizes
+ * template literals and space-separated strings.
+ *
+ * @param command The command definition (from defineCommand)
+ * @param argv The argv array to parse (default: []). Supports template literals and subcommands.
+ * @param parserOptions Optional reliArgParser options
+ *
+ * @example
+ * ```ts
+ * // ✅ Single command with template literals
+ * await runCmdWithSubcommands(cmd, [`--dev ${isDev}`]);
+ *
+ * // ✅ Subcommand with arguments
+ * await runCmdWithSubcommands(cmd, [`build --input src/mod.ts --someBoolean`]);
+ *
+ * // ✅ Subcommand with positional arguments
+ * await runCmdWithSubcommands(cmd, [`build src/mod.ts --someBoolean`]);
+ *
+ * // ✅ Nested subcommands
+ * await runCmdWithSubcommands(cmd, [`build someSubCmd src/mod.ts --no-cjs`]);
+ * await runCmdWithSubcommands(cmd, [`build sub1 sub2 sub3 file.ts --flag`]);
+ *
+ * // ✅ Mixed array with subcommands
+ * await runCmdWithSubcommands(cmd, [
+ *   `build someSubCmd src/mod.ts`,
+ *   "--no-cjs",
+ *   "--verbose"
+ * ]);
+ * ```
+ */
+declare function runCmdWithSubcommands<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions & {
+    fileBased?: FileBasedOptions;
+    autoExit?: boolean;
+}): Promise<any>;
+/**
+ * Programmatically run a command's run() handler with parsed arguments.
+ * Does not handle subcommands, file-based commands, or global hooks.
+ * Suitable for use in demos, tests, or programmatic invocation.
+ *
+ * @param command The command definition (from defineCommand)
+ * @param argv The argv array to parse (default: []). Each argument should be a separate array element.
+ * @param parserOptions Optional reliArgParser options
+ *
+ * @example
+ * **each argument as separate array element**:
+ * ```ts
+ * await runCmd(cmd, ["--dev", "true"]);
+ * await runCmd(cmd, ["--name", "John", "--verbose"]);
+ * ```
+ * **automatic normalization of template literals**:
+ * ```ts
+ * await runCmd(cmd, [`--dev ${isDev}`]); // Automatically converted to ["--dev", "true"]
+ * await runCmd(cmd, [`--dev ${isDev} --build mod.ts`]); // ["--dev", "true", "--build", "mod.ts"]
+ * ```
+ */
+declare function runCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions): Promise<void>;
+
+declare const runMain: typeof createCli;
+
+/** uses omelette to add completions to a commander program */
+declare function addCompletions(program: Command$1, completion: OmeletteInstanceLike): void;
+
+/** An error thrown when the trpc procedure results in a bad request */
+declare class CliValidationError extends Error {
+}
+/** An error which is only thrown when a custom \`process\` parameter is used. Under normal circumstances, this should not be used, even internally. */
+declare class FailedToExitError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, { exitCode, cause }: {
+        exitCode: number;
+        cause: unknown;
+    });
+}
+
+declare class TrpcCommand extends Command$1 {
+    /** @internal track the commands that have been run, so that we can find the `__result` of the last command */
+    __ran: TrpcCommand[];
+    __input?: unknown;
+    /** @internal stash the return value of the underlying procedure on the command so to pass to `FailedToExitError` for use in a pinch */
+    __result?: unknown;
+}
+/**
+ * @internal takes a trpc router and returns an object that you **could** use to build a CLI, or UI, or a bunch of other things with.
+ * Officially, just internal for building a CLI. GLHF.
+ */
+declare const parseRouter: <R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>) => [string, ProcedureInfo][];
+interface ProcedureInfo {
+    meta: TrpcCliMeta;
+    parsedProcedure: ParsedProcedure;
+    incompatiblePairs: [string, string][];
+    procedure: {};
+}
+/**
+ * Run a trpc router as a CLI.
+ *
+ * @param router A trpc router
+ * @param context The context to use when calling the procedures - needed if your router requires a context
+ * @param trpcServer The trpc server module to use. Only needed if using trpc v10.
+ * @returns A CLI object with a `run` method that can be called to run the CLI. The `run` method will parse the command line arguments, call the appropriate trpc procedure, log the result and exit the process. On error, it will log the error and exit with a non-zero exit code.
+ */
+declare function createRpcCli<R extends AnyRouter>({ router, ...params }: TrpcCliParams<R>): TrpcCli;
+
+declare const flattenedProperties: (sch: JsonSchema7Type) => JsonSchema7ObjectType["properties"];
+/** For a union type, returns a list of pairs of properties which *shouldn't* be used together (because they don't appear in the same type variant) */
+declare const incompatiblePropertyPairs: (sch: JsonSchema7Type) => [string, string][];
+/**
+ * Tries fairly hard to build a roughly human-readable description of a json-schema type.
+ * A few common properties are given special treatment, most others are just stringified and output in `key: value` format.
+ */
+declare const getDescription: (v: JsonSchema7Type, depth?: number) => string;
+declare const getSchemaTypes: (propertyValue: JsonSchema7Type) => ("string" | "boolean" | "number" | (string & {}))[];
+declare const getEnumChoices: (propertyValue: JsonSchema7Type) => {
+    readonly type: "string_enum";
+    readonly choices: string[];
+} | {
+    readonly type: "number_enum";
+    readonly choices: number[];
+} | null;
+
+declare const lineByLineLogger: (logger: Logger) => Logger;
+/**
+ * A logger which uses `console.log` and `console.error` to log in the following way:
+ * - Primitives are logged directly
+ * - Arrays are logged item-by-item
+ * - Objects are logged as JSON
+ *
+ * This is useful for logging structured data in a human-readable way, and for piping logs to other tools.
+ */
+declare const lineByLineConsoleLogger: Logger;
+
+declare function parseProcedureInputs(inputs: unknown[], dependencies: Dependencies): Result<ParsedProcedure>;
+
+interface Shadowed<T> {
+    original: T;
+    shadow: T;
+}
+type WithValue<T> = Shadowed<T> & {
+    value: string | undefined;
+    specified: boolean;
+};
+interface Analysis {
+    command: Shadowed<Command$1>;
+    arguments: WithValue<Argument>[];
+    options: WithValue<Option>[];
+}
+declare const createShadowCommand: (command: Command$1, onAnalyze: (params: Analysis) => void | Promise<void>) => Command$1;
+declare const promptify: (program: CommanderProgramLike, prompts: Promptable) => CommanderProgramLike;
+
+declare const prettifyStandardSchemaError: (error: unknown) => string | null;
+declare function toDotPath(path: (string | number | symbol)[]): string;
+declare class StandardSchemaV1Error extends Error implements StandardSchemaV1FailureResult {
+    issues: StandardSchemaV1FailureResult["issues"];
+    constructor(failure: StandardSchemaV1FailureResult, options?: {
+        cause?: Error;
+    });
+}
+
+declare const looksLikeStandardSchemaFailure: (error: unknown) => error is StandardSchemaV1FailureResult;
+declare const looksLikeStandardSchema: (thing: unknown) => thing is StandardSchemaV1;
+
+/**
+ * Pretty much like the `instanceof` operator, but should work across different realms. Necessary for zod because some installations
+ * might result in this library using the commonjs zod export, while the user's code uses the esm export.
+ * https://github.com/mmkal/trpc-cli/issues/7
+ *
+ * Tradeoff: It's possible that this function will return false positives if the target class has the same name as an unrelated class in the current realm.
+ * So, only use it for classes that are unlikely to have name conflicts like `ZodAbc` or `TRPCDef`.
+ */
+declare const looksLikeInstanceof: <T>(value: unknown, target: string | (new (...args: any[]) => T)) => value is T;
+
+declare const log: _reliverse_relinka.RelinkaFunction;
+
+/**
+ * Maps complex colors (gradients, bright, background) to standard terminal colors.
+ * Used by ora spinners and other terminal utilities that only support basic colors.
+ *
+ * Handles:
+ * - Gradient colors -> solid colors (e.g., retroGradient -> cyan)
+ * - Bright colors -> base colors (e.g., redBright -> red)
+ * - Background colors -> foreground colors (e.g., bgRed -> red)
+ * - Special colors -> undefined (reset, inverse, dim, none)
+ *
+ * @param color The complex color to convert
+ * @returns A standard terminal color or undefined for special colors
+ */
+declare function toBaseColor(color?: ColorName): StandardColor | undefined;
+/**
+ * Maps any color type to a standard solid color for consistent display.
+ * Similar to toBaseColor but always returns a color (never undefined).
+ *
+ * Handles:
+ * - Gradient colors -> solid colors (e.g., retroGradient -> cyan)
+ * - Bright colors -> base colors (e.g., redBright -> red)
+ * - Background colors -> foreground colors (e.g., bgRed -> red)
+ * - Special colors (reset, inverse, none) -> dim
+ * - Undefined -> dim
+ *
+ * @param color The color to convert
+ * @returns A standard terminal color, defaulting to "dim" for special cases
+ */
+declare function toSolidColor(color?: ColorName): OutputColor;
+
+/**
+ * Logs messages with configurable styling and formatting.
+ * Doesn't support streaming functionality.
+ */
+declare function relinkaByRemptsDeprecated(kind: AllKinds, title: string, content?: string, hint?: string): void;
+/**
+ * Asynchronous version of relinka that supports streaming functionality.
+ * Use this when you want animated text output with optional spinner.
+ *
+ * Streaming is controlled by the streamOpts parameter:
+ * - Use { useSpinner: true } for spinner animation
+ * - Use { delay: number } for character-by-character streaming
+ * - Content and hint are optional regardless of streaming
+ */
+declare const relinkaAsyncByRemptsDeprecated: (kind: AllKinds, title: string, content?: string, hint?: string, streamOpts?: StreamOptions) => Promise<void>;
+declare const throwError: (error: unknown) => never;
+
+declare const colorMap: Record<ColorName, (text: string) => string>;
+declare const typographyMap: Record<TypographyName, (text: string) => string>;
+
+declare const symbols: Symbols;
+/**
+ * Returns a colored vertical bar symbol. Prevents gradient colors for bars.
+ */
+declare const bar: ({ borderColor }?: {
+    borderColor?: ColorName;
+}) => string;
+/**
+ * Main formatter function: builds the final text output based on FmtMsgOptions.
+ */
+declare function fmt(opts: FmtMsgOptions): {
+    text: string;
+    lineCount: number;
+};
+/**
+ * Logs a formatted message to the console and records how many lines it occupies.
+ */
+declare function msg(opts: FmtMsgOptions): void;
+/**
+ * Undo the last printed message by deleting its lines from the terminal.
+ * @param count How many messages to undo. Defaults to 1.
+ */
+declare function msgUndo(count?: number): void;
+/**
+ * Undo all printed messages so far.
+ */
+declare function msgUndoAll(): void;
+/**
+ * Prints:  "│  <text>"  (two spaces after the bar).
+ * If text is empty, it just prints "│".
+ * If indent is 1, it prints "│ <text>" (one space).
+ * If indent is 2, it prints "│  <text>" (two spaces), etc.
+ */
+declare function printLineBar(text: string, indent?: number): void;
+
+declare function getTerminalHeight(): number;
+declare function getExactTerminalWidth(): number;
+declare function getTerminalWidth(terminalWidth?: number): number;
+/**
+ * Force line returns at specific width. This function is ANSI code friendly and it'll
+ * ignore invisible codes during width calculation.
+ * @param {string} content
+ * @return {string}
+ */
+declare function breakLines(content: string, terminalWidth?: number): string;
+declare function removeCursor(): void;
+declare function restoreCursor(): void;
+declare function deleteLastLine(): void;
+declare function deleteLastLines(count: number): void;
+declare function countLines(text: string): number;
+
+declare const variantMap: {
+    doubleBox: typeof createDoubleBox;
+};
+type ValidVariant = keyof typeof variantMap;
+declare function isValidVariant(variant: string | undefined): variant is ValidVariant;
+declare function applyVariant(lines: string[] | string, variant?: VariantName$1, options?: {
+    limit?: number;
+}, borderColor?: ColorName): Promise<string>;
+declare function createDoubleBox(lines: string[], limit?: number, borderColor?: ColorName): string;
+
+declare const multiselect: <T extends string>(params: MultiselectPromptParams<T>) => Promise<T[]>;
+
+declare function multiselectPrompt<T extends string>(params: MultiselectPromptParams<T>): Promise<T[]>;
+
+interface NextStepsPromptOptions {
+    title?: string;
+    titleColor?: ColorName;
+    titleVariant?: VariantName$1;
+    titleTypography?: TypographyName;
+    content: string[];
+    contentColor?: ColorName;
+    contentVariant?: VariantName$1;
+    contentTypography?: TypographyName;
+}
+declare function nextStepsPrompt(options: NextStepsPromptOptions): Promise<void>;
+
+type VariantName = FmtMsgOptions["titleVariant"];
+interface NumberPromptOptions {
+    title: string;
+    hint?: string;
+    hintPlaceholderColor?: ColorName;
+    validate?: (value: number) => string | undefined | boolean | Promise<string | undefined | boolean>;
+    defaultValue?: string | number;
+    schema?: any;
+    titleColor?: ColorName;
+    titleTypography?: TypographyName;
+    titleVariant?: VariantName;
+    content?: string;
+    contentColor?: ColorName;
+    contentTypography?: TypographyName;
+    contentVariant?: VariantName;
+    borderColor?: BorderColorName;
+    variantOptions?: any;
+    endTitle?: string;
+    endTitleColor?: ColorName;
+    border?: boolean;
+    hardcoded?: {
+        userInput?: string;
+        errorMessage?: string;
+    };
+}
+declare function numberPrompt(opts: NumberPromptOptions): Promise<number>;
+
+type EndPromptOptions = PromptOptions & {
+    variant?: "footer" | "ascii-art";
+    asciiArtFont?: Fonts;
+};
+declare function outroPrompt(optionsOrTitle: EndPromptOptions | string): Promise<void>;
+
+declare const endPrompt: typeof outroPrompt;
+declare const outro: typeof outroPrompt;
+
+interface ResultsType {
+    username: string;
+}
+declare function resultPrompt({ results, inline, }: {
+    results: ResultsType;
+    inline?: boolean;
+}): Promise<void>;
+
+type NumMultiSelectPromptOptions = PromptOptions & {
+    defaultValue?: string[];
+};
+declare function numMultiSelectPrompt(opts: NumMultiSelectPromptOptions): Promise<(string | undefined)[]>;
+
+type NumSelectPromptOptions = PromptOptions & {
+    inline?: boolean;
+    defaultValue?: string;
+};
+declare function numSelectPrompt(opts: NumSelectPromptOptions): Promise<string | number>;
+
+declare const select: <T extends string>(params: SelectPromptParams<T>) => Promise<T>;
+declare const selectSimple: <T extends string>(params: Omit<SelectPromptParams<T>, "options"> & {
+    options: {
+        value: T;
+        label?: string;
+        hint?: string;
+    }[];
+}) => Promise<T>;
+
+/**
+ * Displays a selectable prompt in the terminal and returns the chosen value.
+ */
+declare function selectPrompt<T extends string>(params: SelectPromptParams<T>): Promise<T>;
+
+/**
+ * A toggle prompt that lets the user choose between two options (Yes/No style).
+ */
+declare function togglePrompt<T extends string>(params: TogglePromptParams<T>): Promise<boolean>;
+
+interface SpinnerOptions {
+    cancelMessage?: string;
+    color?: string;
+    delay?: number;
+    errorMessage?: string;
+    failText?: string;
+    frames?: string[];
+    hideCursor?: boolean;
+    indicator?: "dots" | "timer";
+    onCancel?: () => void;
+    prefixText?: string;
+    signal?: AbortSignal;
+    silent?: boolean;
+    spinner?: string;
+    successText?: string;
+    text: string;
+}
+interface ProgressOptions {
+    current: number;
+    total: number;
+    format?: "percentage" | "count" | "both";
+}
+interface SpinnerControls {
+    start: (text?: string) => SpinnerControls;
+    stop: (text?: string, code?: number) => void;
+    setText: (text: string) => void;
+    setProgress: (progress: ProgressOptions) => void;
+    succeed: (text?: string) => void;
+    fail: (text?: string) => void;
+    warn: (text?: string) => void;
+    info: (text?: string) => void;
+    isSpinning: () => boolean;
+    clear: () => void;
+    getElapsedTime: () => number;
+    pause: () => void;
+    resume: () => void;
+    dispose: () => void;
+    isCancelled: boolean;
+}
+/**
+ * Creates a terminal spinner with enhanced controls and styling options.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const spinner = useSpinner({ text: "Loading..." }).start();
+ * spinner.stop();
+ *
+ * // With progress tracking
+ * const spinner = useSpinner({ text: "Processing files..." }).start();
+ * for (let i = 0; i < files.length; i++) {
+ *   spinner.setProgress({ current: i + 1, total: files.length });
+ *   await processFile(files[i]);
+ * }
+ * spinner.succeed();
+ *
+ * // With custom color and spinner
+ * const spinner = useSpinner({
+ *   text: "Processing...",
+ *   color: "cyan",
+ *   spinner: "dots"
+ * }).start();
+ *
+ * // With success/failure states
+ * const spinner = useSpinner({
+ *   text: "Uploading...",
+ *   successText: "Upload complete!",
+ *   failText: "Upload failed!"
+ * }).start();
+ * try {
+ *   await uploadFile();
+ *   spinner.succeed();
+ * } catch (error) {
+ *   spinner.fail();
+ * }
+ *
+ * // Using the wrapper for async operations
+ * await useSpinner.promise(
+ *   async (spinner) => {
+ *     await longOperation();
+ *     spinner.setProgress({ current: 50, total: 100 });
+ *   },
+ *   {
+ *     text: "Working...",
+ *     successText: "Done!",
+ *     failText: "Failed!"
+ *   }
+ * );
+ * ```
+ */
+declare function useSpinner(options: SpinnerOptions): SpinnerControls;
+declare namespace useSpinner {
+    var promise: <T>(operation: (spinner: SpinnerControls) => Promise<T>, options: SpinnerOptions) => Promise<T>;
+    var nested: (parentOptions: SpinnerOptions) => {
+        start: () => {
+            child: (childOptions: SpinnerOptions) => SpinnerControls;
+            finish: (success: boolean, text?: string) => void;
+            dispose: () => void;
+        };
+    };
+    var withTiming: <T>(operation: (spinner: SpinnerControls) => Promise<T>, options: SpinnerOptions) => Promise<{
+        result: T;
+        duration: number;
+    }>;
+}
+
+declare const spinner: typeof useSpinner;
+
+declare function taskProgressPrompt(options: ProgressBarOptions): Promise<ProgressBar>;
+
+type SimpleSpinnerType = "default" | "dottedCircle" | "boxSpinner";
+type OraSpinnerType = Extract<SpinnerName, OraAllowedSpinners>;
+type OraAllowedSpinners = "dots" | "bouncingBar" | "arc";
+interface TaskOptions<T extends "simple" | "ora"> {
+    initialMessage: string;
+    successMessage?: string;
+    errorMessage?: string;
+    delay?: number;
+    spinnerSolution: T;
+    spinnerType?: T extends "simple" ? SimpleSpinnerType : OraSpinnerType;
+    action: (updateMessage: (message: string) => void) => Promise<void>;
+}
+declare function taskSpinPrompt<T extends "simple" | "ora">(options: TaskOptions<T>): Promise<void>;
+
+declare function colorize(text: string, colorName?: ColorName, typography?: TypographyName): string;
+
+declare const errorHandler: (error: Error, customMessage?: string) => never;
+
+declare function preventUnsupportedTTY(): void;
+/**
+ * Prevents EISDIR errors when trying to read Windows home directory as a file
+ * @param filePath The file path to check
+ */
+declare function preventWindowsHomeDirRoot(filePath: string): never | undefined;
+declare function preventWrongTerminalSize({ isDev, shouldExit, minWidth, minHeight, sizeErrorDescription, }: PreventWrongTerminalSizeOptions): Promise<void>;
+
+/**
+ * Ends the prompt by optionally displaying an end message and running the action if confirmed.
+ * Preserves the last prompt state unless there's an endTitle.
+ */
+declare function completePrompt(prompt: "input" | "confirm" | "select" | "multiselect" | "toggle", isCtrlC: boolean, _endTitle: string | undefined, _endTitleColor: ColorName | undefined, _titleTypography: TypographyName | undefined, _titleVariant: VariantName$1 | undefined, _border?: boolean, borderColor?: BorderColorName, action?: () => Promise<void>, value?: boolean): Promise<boolean>;
+declare function renderEndLine(): void;
+declare function renderEndLineInput(): void;
+
+/**
+ * Simulates streaming text output in the console, character by character
+ */
+declare function streamText({ text, delay, showCursor, color, newline, clearLine, onProgress, }: StreamTextOptions): Promise<void>;
+/**
+ * Simulates streaming text output in a message box
+ */
+declare function streamTextBox({ text, delay, color, borderColor, }: Omit<StreamTextOptions, "showCursor" | "newline" | "clearLine"> & {
+    borderColor?: BorderColorName;
+}): Promise<void>;
+/**
+ * Simulates streaming text output with a loading spinner using ora
+ */
+declare function streamTextWithSpinner({ text, delay, color, spinnerFrames, spinnerDelay, }: StreamTextOptions & {
+    spinnerFrames?: string[];
+    spinnerDelay?: number;
+}): Promise<void>;
+
+declare const pm: _reliverse_runtime.PkgManagerInfo;
+declare const reliversePrompts: {
+    name: string;
+    version: string;
+    description: string;
+};
+
+/**
+ * Checks if the terminal is interactive
+ */
+declare function isTerminalInteractive(input?: NodeJS.ReadStream & {
+    fd: 0;
+}): boolean;
+/**
+ * Validates a name against allowed characters
+ */
+interface ValidationResult {
+    isValid: boolean;
+    message?: string;
+}
+declare function isValidName(name: string): ValidationResult;
+/**
+ * Cleans up project name from config by removing scope and invalid characters.
+ * For paths with multiple segments (e.g. "@org/subpath/cli"), takes the last segment.
+ * This also ensures complex cases (e.g. "@some@weird/path/the-name!" returns "the-name").
+ */
+declare function normalizeName(name: string): string;
+
+declare function createAsciiArt({ message, font, clearConsole, }: {
+    message: string;
+    font?: Fonts;
+    clearConsole?: boolean;
+}): Promise<void>;
+
+export { CANCEL, CliValidationError, FailedToExitError, StandardSchemaV1Error, TrpcCommand, addCompletions, animateText, animationMap, anykeyPrompt, applyVariant, argsToStringArray, bar, block, breakLines, callCmdImpl, cancel, colorMap, colorize, commandToJSON, completePrompt, confirm, confirmPrompt, countLines, createAsciiArt, createCallCmd, createCancel, createCli, createGetTypedCmd, createMultiStep, createRpcCli, createShadowCommand, createStep, datePrompt, defineArgs, defineCommand, deleteLastLine, deleteLastLines, endPrompt, errorHandler, fallbackSymbols, figures, flattenedProperties, fmt, getColumns, getDescription, getEnumChoices, getExactTerminalWidth, getSchemaTypes, getTerminalHeight, getTerminalWidth, getTypedCmdImpl, group, incompatiblePropertyPairs, input, inputPrompt, intro, introPrompt, isCancel, isOrpcRouter, isTerminalInteractive, isTrpc11Procedure, isTrpc11Router, isValidName, isValidVariant, isWindows, lineByLineConsoleLogger, lineByLineLogger, loadCommand, log, looksLikeInstanceof, looksLikeStandardSchema, looksLikeStandardSchemaFailure, mainSymbols, msg, msgUndo, msgUndoAll, multiselect, multiselectPrompt, nextStepsPrompt, normalizeName, numMultiSelectPrompt, numSelectPrompt, numberPrompt, outro, outroPrompt, parseProcedureInputs, parseRouter, password, pm, prettifyStandardSchemaError, preventUnsupportedTTY, preventWindowsHomeDirRoot, preventWrongTerminalSize, printLineBar, promptify, relinkaAsyncByRemptsDeprecated, relinkaByRemptsDeprecated, reliversePrompts, removeCursor, renderEndLine, renderEndLineInput, restoreCursor, resultPrompt, runCmd, runCmdWithSubcommands, runMain, select, selectPrompt, selectSimple, setRawMode, showUsage, spinner, startEditor, startPrompt, streamText, streamTextBox, streamTextWithSpinner, symbols, taskProgressPrompt, taskSpinPrompt, text, throwError, toBaseColor, toDotPath, toSolidColor, togglePrompt, typographyMap, useSpinner, variantMap };
+export type { AllKinds, AnyProcedure, AnyRouter, ArgDefinition, ArgDefinitions, ArrayArgDefinition, BaseArgDefinition, BaseArgProps, BooleanArgDefinition, BorderColorName, CancelValue, ChoiceOptions, ClackPromptsLike, ColorName, Command, CommandContext, CommandHook, CommandJSON, CommandMeta, CommandRun, CommandSpec, CommanderProgramLike, CommandsMap, ConfirmPromptOptions, CreateCallerFactoryLike, DatePromptOptions, DefineCommandOptions, Dependencies, EditorExitResult, EmptyArgs, EnquirerLike, FileBasedOptions, FmtMsgOptions, GroupContext, GroupOptions, GroupStep, GroupSteps, InferArgTypes, InputPromptOptions, InquirerPromptOptions, InquirerPromptsLike, Log, Logger, MessageConfig, MessageKind, MsgConfig, MsgType, MultiselectPromptParams, NumberArgDefinition, OmeletteInstanceLike, OrpcProcedureLike, OrpcRouterLike, OutputColor, ParsedProcedure, PositionalArgDefinition, PreventWrongTerminalSizeOptions, ProgressBar, ProgressBarOptions, PromptContext, PromptOptions, PromptType, Promptable, Prompter, PromptsLike, RenderParams, Result, ResultsType, SelectOption, SelectPromptParams, SeparatorOption, StandardColor, StandardSchemaV1, StandardSchemaV1FailureResult, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1PathSegment, StandardSchemaV1Props, StandardSchemaV1Result, StandardSchemaV1SuccessResult, StandardSchemaV1Types, StreamOptions, StreamTextOptions, StringArgDefinition, SymbolName, Symbols, TogglePromptParams, Trpc10ProcedureLike, Trpc10RouterLike, Trpc11ProcedureLike, Trpc11ProcedureRecordLike, Trpc11RouterLike, TrpcCli, TrpcCliMeta, TrpcCliParams, TrpcCliRunParams, TrpcServerModuleLike, TypographyName, VariantName$1 as VariantName, inferRouterContext };