convoker 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1196 @@
+import { StandardSchemaV1 as StandardSchemaV1_2 } from '../../../../../../../../../../src/standard-schema';
+import { Theme as Theme_2 } from '../../../../../../../../../../src/color';
+
+/**
+ * Command action function.
+ */
+export declare type ActionFn<T extends Input> = (input: InferInput<T>) => void | Promise<void>;
+
+/**
+ * Creates a new positional argument.
+ * @param kind The kind of positional argument.
+ * @returns A new positional argument.
+ */
+declare function argument<T extends Kind>(kind: T): Positional<T>;
+
+/**
+ * Base options for prompts.
+ */
+declare interface BaseOpts<T> {
+    /**
+     * The message of the prompt.
+     */
+    message: string;
+    /**
+     * An `AbortSignal` to cancel the prompt.
+     */
+    signal?: AbortSignal;
+    /**
+     * The default value.
+     */
+    default?: T;
+    /**
+     * The theme of the prompt.
+     */
+    theme?: Theme_2;
+    /**
+     * A validator function, or a Standard Schema validator.
+     */
+    validate?: StandardSchemaV1_2<any, T> | ((value: T) => boolean | T);
+}
+
+/**
+ * A basic input type.
+ */
+declare type BasicKind = "boolean" | "string" | "number" | "bigint";
+
+declare const bgBlack: (input: any) => string;
+
+declare const bgBlue: (input: any) => string;
+
+declare const bgBlueBright: (input: any) => string;
+
+declare const bgCyan: (input: any) => string;
+
+declare const bgCyanBright: (input: any) => string;
+
+declare const bgGray: (input: any) => string;
+
+declare const bgGreen: (input: any) => string;
+
+declare const bgGreenBright: (input: any) => string;
+
+declare const bgMagenta: (input: any) => string;
+
+declare const bgMagentaBright: (input: any) => string;
+
+declare const bgRed: (input: any) => string;
+
+declare const bgRedBright: (input: any) => string;
+
+declare const bgWhite: (input: any) => string;
+
+declare const bgWhiteBright: (input: any) => string;
+
+declare const bgYellow: (input: any) => string;
+
+declare const bgYellowBright: (input: any) => string;
+
+declare const black: (input: any) => string;
+
+declare const blue: (input: any) => string;
+
+declare const blueBright: (input: any) => string;
+
+declare const bold: (input: any) => string;
+
+/**
+ * Builder for commands.
+ */
+export declare type Builder = (c: Command<any>) => Command<any> | void;
+
+/**
+ * Clears `lines` amount of lines.
+ * @param lines Amount of lines to clear.
+ */
+declare function clearLines(lines?: number): void;
+
+export declare namespace color {
+    export {
+        createAnsiColor,
+        defineTheme,
+        supportsColor,
+        reset,
+        bold,
+        dim,
+        italic,
+        underline,
+        overline,
+        inverse,
+        hidden,
+        strikethrough,
+        black,
+        red,
+        green,
+        yellow,
+        blue,
+        magenta,
+        cyan,
+        white,
+        gray,
+        bgBlack,
+        bgRed,
+        bgGreen,
+        bgYellow,
+        bgBlue,
+        bgMagenta,
+        bgCyan,
+        bgWhite,
+        bgGray,
+        redBright,
+        greenBright,
+        yellowBright,
+        blueBright,
+        magentaBright,
+        cyanBright,
+        whiteBright,
+        bgRedBright,
+        bgGreenBright,
+        bgYellowBright,
+        bgBlueBright,
+        bgMagentaBright,
+        bgCyanBright,
+        bgWhiteBright,
+        Theme,
+        DEFAULT_THEME
+    }
+}
+
+/**
+ * A command.
+ */
+export declare class Command<T extends Input = Input> {
+    /**
+     * The names (aliases) of this command.
+     */
+    $names: string[];
+    /**
+     * The description of this command.
+     */
+    $description: string | undefined;
+    /**
+     * The theme of this command
+     */
+    $theme: Theme | undefined;
+    /**
+     * The version of this command.
+     */
+    $version: string | undefined;
+    /**
+     * The children of this command.
+     */
+    $children: Map<string, CommandAlias>;
+    /**
+     * The parent of this command.
+     */
+    $parent: Command<any> | undefined;
+    /**
+     * If this command allows unknown options.
+     */
+    $allowUnknownOptions: boolean;
+    /**
+     * The input this command takes.
+     */
+    $input: T;
+    /**
+     * The action function of this command.
+     */
+    $fn: ActionFn<T> | undefined;
+    /**
+     * The error handler of this command.
+     */
+    $errorFn: ErrorFn<T> | undefined;
+    /**
+     * Creates a new command.
+     * @param names The names (aliases).
+     * @param desc The description.
+     * @param version The version.
+     */
+    constructor(names: string | string[], desc?: string, version?: string);
+    /**
+     * Adds a set of aliases to this command.
+     * @param aliases The aliases to add.
+     * @returns this
+     */
+    alias(...aliases: string[]): this;
+    /**
+     * Adds a description to this command.
+     * @param desc The description.
+     * @returns this
+     */
+    description(desc: string): this;
+    /**
+     * Adds a version to this command.
+     * @param version The version.
+     * @returns this
+     */
+    version(version: string): this;
+    /**
+     * Sets the input for this command.
+     * @param version The input.
+     * @returns this
+     */
+    input<TInput extends Input>(input: TInput): Command<TInput>;
+    /**
+     * Sets the action function for this command.
+     * @param fn The action.
+     * @returns this
+     */
+    action(fn: ActionFn<T>): this;
+    /**
+     * Sets the error function for this command.
+     * @param fn The error handler.
+     * @returns this
+     */
+    error(fn: ErrorFn<T>): this;
+    /**
+     * Adds an existing command to this.
+     * @param command The command.
+     * @returns this
+     */
+    add(command: Command<any>): this;
+    /**
+     * Creates a new subcommand and adds it.
+     * @param names The aliases of the subcommand.
+     * @param builder A builder to create the command.
+     */
+    subCommand(names: string | string[], builder: Builder): this;
+    /**
+     * Creates a new subcommand and adds it.
+     * @param names The aliases of the subcommand.
+     * @param desc The description of the subcommand.
+     * @param version The version of the subcommand.
+     */
+    subCommand(names: string | string[], desc?: string, version?: string): Command<any>;
+    /**
+     * Allows unknown options.
+     * @returns this
+     */
+    allowUnknownOptions(): this;
+    /**
+     * Parses a set of command-line arguments.
+     * @param argv The arguments to parse.
+     * @returns A parse result.
+     */
+    parse(argv: string[]): Promise<ParseResult<T>>;
+    private buildInputMap;
+    /**
+     * Gets the full command path (name including parents).
+     * @returns The full command path.
+     */
+    fullCommandPath(): string;
+    /**
+     * The default error screen.
+     * @param errors The errors.
+     */
+    defaultErrorScreen(errors: Error[]): void;
+    /**
+     * Handles a set of errors.
+     * @param errors The errors to handle.
+     * @param input The parsed input, if possible.
+     * @returns this
+     */
+    handleErrors(errors: Error[], input?: Partial<InferInput<T>>): Promise<this>;
+    /**
+     * Runs a command.
+     * @param argv The arguments to run the command with. Defaults to your runtime's `argv` equivalent.
+     * @returns this
+     */
+    run(argv?: string[]): Promise<this>;
+}
+
+/**
+ * What the command is an alias for.
+ */
+export declare interface CommandAlias<T extends Input = Input> {
+    /**
+     * A pointer to the command.
+     */
+    command: Command<T>;
+    /**
+     * The name of the command this is an alias for.
+     */
+    alias?: string;
+}
+
+/**
+ * Prompts the user to confirm an action.
+ * @param opts Options for confirm input.
+ * @returns If the user picked Yes.
+ */
+declare function confirm_2(opts: ConfirmOpts): Promise<boolean>;
+
+/**
+ * Options for confirm input.
+ */
+declare interface ConfirmOpts extends BaseOpts<boolean> {
+    /**
+     * What gets displayed for the Yes option.
+     */
+    yesLabel?: string;
+    /**
+     * What gets displayed for the No option.
+     */
+    noLabel?: string;
+}
+
+/**
+ * Converts a value from a Kind to a TypeScript type.
+ * @param kind The kind to convert to.
+ * @param value The value to convert.
+ * @returns The converted value.
+ */
+declare function convert<TKind extends Kind>(kind: TKind, value: string): Promise<TypeOf<TKind>>;
+
+/**
+ * Creates a function that wraps a string in ANSI codes.
+ * @param open The opening ANSI code.
+ * @param close The closing ANSI code.
+ * @returns A function that wraps the string in ANSI codes.
+ */
+declare function createAnsiColor(open: number, close: number): (input: any) => string;
+
+/**
+ * Moves the cursor down `n` times.
+ * @param n The amount of steps to move.
+ */
+declare function cursorDown(n?: number): void;
+
+/**
+ * Moves the cursor up `n` times.
+ * @param n The amount of steps to move.
+ */
+declare function cursorUp(n?: number): void;
+
+declare const cyan: (input: any) => string;
+
+declare const cyanBright: (input: any) => string;
+
+/**
+ * The default theme.
+ */
+declare const DEFAULT_THEME: Theme;
+
+/**
+ * Defines a theme.
+ * @param theme The (partial) theme.
+ * @returns The theme, merged with the default theme.
+ */
+declare function defineTheme(theme: Partial<Theme>): Theme;
+
+declare const dim: (input: any) => string;
+
+/**
+ * Opens the system editor, or asks for input in the terminal as fallback.
+ * @param opts Options for opening the system editor.
+ * @returns The result of the system editor.
+ */
+declare function editor(opts: EditorOpts): Promise<string>;
+
+/**
+ * Options for opening the system editor.
+ */
+declare interface EditorOpts extends BaseOpts<string> {
+    /**
+     * The initial value.
+     */
+    initial?: string;
+    /**
+     * The language of the value.
+     */
+    language?: string;
+    /**
+     * If the input is required for continuing or not.
+     */
+    required?: boolean;
+}
+
+export declare namespace error {
+    export {
+        InputValidationError,
+        LunarCLIError,
+        HelpAskedError,
+        TooManyArgumentsError,
+        UnknownOptionError,
+        MissingRequiredOptionError,
+        MissingRequiredArgumentError
+    }
+}
+
+/**
+ * Prints errors.
+ * @param msgs The messages to write.
+ */
+declare function error_2(...msgs: any[]): Promise<void>;
+
+/**
+ * Command error handler.
+ */
+export declare type ErrorFn<T extends Input> = (command: Command<T>, errors: Error[], input: Partial<InferInput<T>>) => void | Promise<void>;
+
+/**
+ * Prints errors and exits.
+ * @param msgs The messages to write.
+ */
+declare function fatal(...msgs: any[]): Promise<void>;
+
+declare const gray: (input: any) => string;
+
+declare const green: (input: any) => string;
+
+declare const greenBright: (input: any) => string;
+
+/**
+ * When the user asks for help.
+ */
+declare class HelpAskedError extends LunarCLIError {
+    /**
+     * Creates a new help asked error.
+     * @param command The command.
+     */
+    constructor(command: Command<any>);
+}
+
+declare const hidden: (input: any) => string;
+
+export declare namespace i {
+    export {
+        convert,
+        option,
+        positional,
+        argument,
+        Input,
+        BasicKind,
+        Kind,
+        TypeOf,
+        InferInput,
+        InferEntry,
+        Option_2 as Option,
+        Positional
+    }
+}
+
+/**
+ * Infers a TypeScript type from an option or positional.
+ */
+declare type InferEntry<T> = T extends {
+    $kind: infer TKind extends Kind;
+    $required: infer Required;
+    $list: infer List;
+} ? List extends true ? Required extends true ? TypeOf<TKind>[] : TypeOf<TKind>[] | undefined : Required extends true ? TypeOf<TKind> : TypeOf<TKind> | undefined : never;
+
+/**
+ * Infers TypeScript types from an input object.
+ */
+declare type InferInput<T extends Input> = {
+    [K in keyof T]: InferEntry<T[K]>;
+};
+
+/**
+ * Prints information.
+ * @param msgs The messages to write.
+ */
+declare function info(...msgs: any[]): Promise<void>;
+
+/**
+ * An input object.
+ */
+declare interface Input {
+    [x: string]: Option_2<any, any, any> | Positional<any, any, any>;
+}
+
+/**
+ * Thrown when the command fails to validate an input.
+ */
+declare class InputValidationError extends Error {
+    /**
+     * A list of messages.
+     */
+    messages: string[];
+    /**
+     * Creates a new input validation error.
+     * @param messages The messages.
+     */
+    constructor(messages: string[]);
+}
+
+declare const inverse: (input: any) => string;
+
+declare const italic: (input: any) => string;
+
+/**
+ * An input type.
+ */
+declare type Kind = BasicKind | StandardSchemaV1<any, any>;
+
+export declare namespace log {
+    export {
+        setTheme_2 as setTheme,
+        setConfig,
+        setup,
+        trace,
+        info,
+        warn,
+        error_2 as error,
+        fatal,
+        LogConfig
+    }
+}
+
+/**
+ * The logger configuration.
+ */
+declare interface LogConfig {
+    /**
+     * The format to print as.
+     */
+    format: "text" | "json" | "xml" | "yaml" | "csv";
+    /**
+     * Standard output.
+     */
+    stdout: WritableStream<string>;
+    /**
+     * Standard error.
+     */
+    stderr: WritableStream<string>;
+    /**
+     * Standard input.
+     */
+    stdin: ReadableStream<string>;
+}
+
+/**
+ * A LunarCLI-related error. These are usually handled by default.
+ */
+declare class LunarCLIError extends Error {
+    /**
+     * The command this error happened on.
+     */
+    command: Command<any>;
+    /**
+     * Creates a new LunarCLI error.
+     * @param message The message.
+     * @param command The command.
+     */
+    constructor(message: string, command: Command<any>);
+    /**
+     * Prints the error's message.
+     */
+    print(): void;
+}
+
+declare const magenta: (input: any) => string;
+
+declare const magentaBright: (input: any) => string;
+
+declare class MissingRequiredArgumentError extends LunarCLIError {
+    /**
+     * The argument key.
+     */
+    key: string;
+    /**
+     * The argument entry.
+     */
+    entry: Positional<any, any, any>;
+    /**
+     * Creates a new missing required argument error.
+     * @param command The command.
+     * @param key The key.
+     * @param entry The entry.
+     */
+    constructor(command: Command<any>, key: string, entry: Positional<any, any, any>);
+}
+
+/**
+ * When a required option is missing.
+ */
+declare class MissingRequiredOptionError extends LunarCLIError {
+    /**
+     * The option key.
+     */
+    key: string;
+    /**
+     * The option entry.
+     */
+    entry: Option_2<any, any, any>;
+    /**
+     * Creates a new missing required option error.
+     * @param command The command.
+     * @param key The key.
+     * @param entry The entry.
+     */
+    constructor(command: Command<any>, key: string, entry: Option_2<any, any, any>);
+}
+
+/**
+ * Prompts the user to select multiple options.
+ * @param opts Options for select input.
+ * @returns The selected options.
+ */
+declare function multiselect<T>(opts: SelectOpts<T>): Promise<T[]>;
+
+/**
+ * Creates a new option.
+ * @param kind The kind of option.
+ * @param names The names of the option.
+ * @returns A new option.
+ */
+declare function option<T extends Kind>(kind: T, ...names: string[]): Option_2<T>;
+
+/**
+ * An option.
+ */
+declare class Option_2<TKind extends Kind, TRequired extends boolean = true, TList extends boolean = false> {
+    /**
+     * The kind of this option.
+     */
+    $kind: TKind;
+    /**
+     * The aliases of this option.
+     */
+    $names: string[];
+    /**
+     * The description of this option.
+     */
+    $description: string | undefined;
+    /**
+     * The default value of this option.
+     */
+    $default: TypeOf<TKind> | undefined;
+    /**
+     * If this option is required.
+     */
+    $required: TRequired;
+    /**
+     * If this option is a list.
+     */
+    $list: TList;
+    /**
+     * Creates a new option.
+     * @param kind The type of this option.
+     * @param names The names of this option.
+     */
+    constructor(kind: TKind, names: string[]);
+    /**
+     * Makes this option a list.
+     * @returns this
+     */
+    list(): Option_2<TKind, TRequired, true>;
+    /**
+     * Makes this option required.
+     * @returns this
+     */
+    required(): Option_2<TKind, true, TList>;
+    /**
+     * Makes this option optional.
+     * @returns this
+     */
+    optional(): Option_2<TKind, false, TList>;
+    /**
+     * Sets a default value.
+     * @param value The default value.
+     * @returns this
+     */
+    default(value: TypeOf<TKind>): this;
+    /**
+     * Sets a description.
+     * @param desc The description.
+     * @returns this
+     */
+    description(desc: string): this;
+}
+
+declare const overline: (input: any) => string;
+
+/**
+ * The result of the `Command.parse` function.
+ */
+export declare interface ParseResult<T extends Input> {
+    /**
+     * A pointer to the command to run.
+     */
+    command: Command<T>;
+    /**
+     * The input to pass into the command.
+     */
+    input: InferInput<T>;
+    /**
+     * Errors collected during parsing.
+     */
+    errors: LunarCLIError[];
+    /**
+     * If this should result in displaying the version of the command.
+     */
+    isVersion: boolean;
+    /**
+     * If this should result in displaying a help screen.
+     */
+    isHelp: boolean;
+}
+
+/**
+ * Prompts the user for a password.
+ * @param opts Options for password input.
+ * @returns The password.
+ */
+declare function password(opts: PasswordOpts): Promise<string>;
+
+/**
+ * Options for password input.
+ */
+declare interface PasswordOpts extends TextOpts {
+    /**
+     * The mask for the password input.
+     */
+    mask?: string;
+    /**
+     * If the user should be asked to confirm the password, by typing it again.
+     */
+    confirm?: boolean;
+}
+
+/**
+ * A positional argument.
+ */
+declare class Positional<TKind extends Kind, TRequired extends boolean = true, TList extends boolean = false> {
+    /**
+     * The type of this argument.
+     */
+    $kind: TKind;
+    /**
+     * The default value of this argument.
+     */
+    $default: TypeOf<TKind> | undefined;
+    /**
+     * The description of this argument.
+     */
+    $description: string | undefined;
+    /**
+     * If this argument is required.
+     */
+    $required: TRequired;
+    /**
+     * If this argument is a list.
+     */
+    $list: TList;
+    /**
+     * Creates a new positional argument.
+     * @param kind The positional argument.
+     */
+    constructor(kind: TKind);
+    /**
+     * Makes this argument a list.
+     * @returns this
+     */
+    list(): Positional<TKind, TRequired, true>;
+    /**
+     * Makes this argument required.
+     * @returns this
+     */
+    required(): Positional<TKind, true, TList>;
+    /**
+     * Makes this argument optional.
+     * @returns this
+     */
+    optional(): Positional<TKind, false, TList>;
+    /**
+     * Sets a default value.
+     * @param value The default value.
+     * @returns this
+     */
+    default(value: TypeOf<TKind>): this;
+    /**
+     * Sets a description.
+     * @param desc The description.
+     * @returns this
+     */
+    description(desc: string): this;
+}
+
+/**
+ * Creates a new positional argument.
+ * @param kind The kind of positional argument.
+ * @returns A new positional argument.
+ */
+declare function positional<T extends Kind>(kind: T): Positional<T>;
+
+export declare namespace prompt_2 {
+    export {
+        setTheme,
+        text,
+        password,
+        select,
+        multiselect,
+        search,
+        confirm_2 as confirm,
+        editor,
+        BaseOpts,
+        TextOpts,
+        PasswordOpts,
+        SelectOption,
+        SelectOpts,
+        SearchOpts,
+        ConfirmOpts,
+        EditorOpts,
+        raw
+    }
+}
+
+declare namespace raw {
+    export {
+        readLine,
+        readKey,
+        clearLines,
+        cursorUp,
+        cursorDown
+    }
+}
+
+/**
+ * Reads a single key from stdin.
+ * @returns The key that was read.
+ */
+declare function readKey(): Promise<string>;
+
+/**
+ * Reads a line from standard input.
+ * @param message The message.
+ * @param def Default value.
+ * @param opts Options for reading a line.
+ * @returns The line that was read.
+ */
+declare function readLine(message?: string, def?: string, opts?: {
+    masked?: boolean;
+    maskChar?: string;
+    multiline?: boolean;
+}): Promise<string>;
+
+declare const red: (input: any) => string;
+
+declare const redBright: (input: any) => string;
+
+declare const reset: (input: any) => string;
+
+/**
+ * Prompts the user to search through a list of options.
+ * @param opts Options for search input.
+ * @returns The selected option.
+ */
+declare function search<T>(opts: SearchOpts<T>): Promise<T>;
+
+/**
+ * Options for search input.
+ */
+declare interface SearchOpts<T> extends BaseOpts<T> {
+    /**
+     * Every option the user can search through.
+     */
+    options: SelectOption<T>[];
+    /**
+     * Placeholder for the search input.
+     */
+    placeholder?: string;
+    /**
+     * Minimum length for a query string.
+     */
+    minQueryLength?: number;
+    /**
+     * Filters a single option.
+     * @param query The search query.
+     * @param option The option to filter.
+     */
+    filter?(query: string, option: SelectOption<T>): boolean;
+}
+
+/**
+ * Prompts the user to select a single option.
+ * @param opts Options for select input.
+ * @returns The selected option's value.
+ */
+declare function select<T>(opts: SelectOpts<T>): Promise<T>;
+
+/**
+ * An option for select input.
+ */
+declare interface SelectOption<T> {
+    /**
+     * The label (what gets displayed) of the select option.
+     */
+    label: string;
+    /**
+     * The value (what gets returned) of the select option.
+     */
+    value: T;
+    /**
+     * A description of the option.
+     */
+    hint?: string;
+    /**
+     * If this option is disabled.
+     */
+    disabled?: boolean;
+}
+
+/**
+ * Options for select input.
+ */
+declare interface SelectOpts<T> extends BaseOpts<T> {
+    /**
+     * Every option the user can pick from.
+     */
+    options: SelectOption<T>[];
+    /**
+     * The initial option selected.
+     */
+    initialIndex?: number;
+}
+
+/**
+ * Sets new configuration.
+ * @param c The config.
+ */
+declare function setConfig(c: Partial<LogConfig>): Promise<void>;
+
+/**
+ * Sets the theme of the prompts.
+ * @param t The new theme.
+ */
+declare function setTheme(t: Theme_2): void;
+
+/**
+ * Sets a new theme.
+ * @param t The theme.
+ */
+declare function setTheme_2(t: Theme): void;
+
+/**
+ * Sets default configuration.
+ */
+declare function setup(): Promise<void>;
+
+/** The Standard Schema interface. */
+declare interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<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) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<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 InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+
+declare const strikethrough: (input: any) => string;
+
+/**
+ * If the runtime supports color.
+ */
+declare const supportsColor: boolean;
+
+/**
+ * Prompts the user for text input.
+ * @param opts Options for text input.
+ * @returns The text the user typed in, or the default.
+ */
+declare function text(opts: TextOpts): Promise<string>;
+
+/**
+ * Options for text input.
+ */
+declare interface TextOpts extends BaseOpts<string> {
+    /**
+     * A placeholder, displayed when the user hasn't typed anything yet.
+     */
+    placeholder?: string;
+    /**
+     * Minimum length of the input.
+     */
+    minLength?: number;
+    /**
+     * Maximum length of the input.
+     */
+    maxLength?: number;
+}
+
+/**
+ * A theme.
+ */
+declare interface Theme {
+    /**
+     * Wraps a string in a background ANSI code.
+     * @param a The string to wrap.
+     */
+    background?(a: string): string;
+    /**
+     * Wraps a string in a foreground ANSI code.
+     * @param a The string to wrap.
+     */
+    foreground?(a: string): string;
+    /**
+     * Wraps a string in a primary ANSI code.
+     * @param a The string to wrap.
+     */
+    primary(a: string): string;
+    /**
+     * Wraps a string in a secondary ANSI code.
+     * @param a The string to wrap.
+     */
+    secondary(a: string): string;
+    /**
+     * Wraps a string in a accent ANSI code.
+     * @param a The string to wrap.
+     */
+    accent?(a: string): string;
+    /**
+     * Wraps a string in a success ANSI code.
+     * @param a The string to wrap.
+     */
+    success(a: string): string;
+    /**
+     * Wraps a string in a warning ANSI code.
+     * @param a The string to wrap.
+     */
+    warning(a: string): string;
+    /**
+     * Wraps a string in a error ANSI code.
+     * @param a The string to wrap.
+     */
+    error(a: string): string;
+    /**
+     * Wraps a string in a info ANSI code.
+     * @param a The string to wrap.
+     */
+    info?(a: string): string;
+    /**
+     * Set of symbols for logging.
+     */
+    symbols?: {
+        /**
+         * Success message symbol.
+         */
+        success: string;
+        /**
+         * Error message symbol.
+         */
+        error: string;
+        /**
+         * Warning message symbol.
+         */
+        warning: string;
+        /**
+         * Information message symbol.
+         */
+        info?: string;
+    };
+    /**
+     * Optional styles.
+     */
+    styles?: {
+        /**
+         * Wraps a string in a bold ANSI code.
+         * @param a The string to wrap.
+         */
+        bold?(a: string): string;
+        /**
+         * Wraps a string in an italic ANSI code.
+         * @param a The string to wrap.
+         */
+        italic?(a: string): string;
+        /**
+         * Wraps a string in an underline ANSI code.
+         * @param a The string to wrap.
+         */
+        underline?(a: string): string;
+    };
+}
+
+/**
+ * When you pass too many arguments.
+ */
+declare class TooManyArgumentsError extends LunarCLIError {
+    /**
+     * Creates a new too many arguments error.
+     * @param command The command.
+     */
+    constructor(command: Command<any>);
+}
+
+/**
+ * Prints debug information.
+ * @param msgs The messages to write.
+ */
+declare function trace(...msgs: any[]): Promise<void>;
+
+/**
+ * Converts a Kind to a TypeScript type.
+ */
+declare type TypeOf<T extends Kind> = T extends StandardSchemaV1<any, infer Out> ? Out : T extends "boolean" ? boolean : T extends "string" ? string : T extends "number" ? number : T extends "bigint" ? bigint : never;
+
+declare const underline: (input: any) => string;
+
+/**
+ * When you pass an unknown option, when unknown options aren't allowed.
+ */
+declare class UnknownOptionError extends LunarCLIError {
+    /**
+     * The option key.
+     */
+    key: string;
+    /**
+     * Creates a new unknown option error.
+     * @param command The command.
+     * @param key The key.
+     */
+    constructor(command: Command<any>, key: string);
+}
+
+/**
+ * Prints warnings.
+ * @param msgs The messages to write.
+ */
+declare function warn(...msgs: any[]): Promise<void>;
+
+declare const white: (input: any) => string;
+
+declare const whiteBright: (input: any) => string;
+
+declare const yellow: (input: any) => string;
+
+declare const yellowBright: (input: any) => string;
+
+export { }