convoker 0.3.3 → 0.3.4

package/dist/chunk-z5eko27R.mjs

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/color-BuHvMolk.d.mts

@@ -0,0 +1,158 @@
+declare namespace color_d_exports {
+  export { DEFAULT_THEME, Theme, bgBlack, bgBlue, bgBlueBright, bgCyan, bgCyanBright, bgGray, bgGreen, bgGreenBright, bgMagenta, bgMagentaBright, bgRed, bgRedBright, bgWhite, bgWhiteBright, bgYellow, bgYellowBright, black, blue, blueBright, bold, createAnsiColor, cyan, cyanBright, defineTheme, dim, gray, green, greenBright, hidden, inverse, italic, magenta, magentaBright, overline, red, redBright, reset, strikethrough, supportsColor, underline, white, whiteBright, yellow, yellowBright };
+}
+/**
+ * If the runtime supports color.
+ */
+declare const supportsColor: boolean;
+/**
+ * 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;
+declare const reset: (input: any) => string;
+declare const bold: (input: any) => string;
+declare const dim: (input: any) => string;
+declare const italic: (input: any) => string;
+declare const underline: (input: any) => string;
+declare const overline: (input: any) => string;
+declare const inverse: (input: any) => string;
+declare const hidden: (input: any) => string;
+declare const strikethrough: (input: any) => string;
+declare const black: (input: any) => string;
+declare const red: (input: any) => string;
+declare const green: (input: any) => string;
+declare const yellow: (input: any) => string;
+declare const blue: (input: any) => string;
+declare const magenta: (input: any) => string;
+declare const cyan: (input: any) => string;
+declare const white: (input: any) => string;
+declare const gray: (input: any) => string;
+declare const bgBlack: (input: any) => string;
+declare const bgRed: (input: any) => string;
+declare const bgGreen: (input: any) => string;
+declare const bgYellow: (input: any) => string;
+declare const bgBlue: (input: any) => string;
+declare const bgMagenta: (input: any) => string;
+declare const bgCyan: (input: any) => string;
+declare const bgWhite: (input: any) => string;
+declare const bgGray: (input: any) => string;
+declare const redBright: (input: any) => string;
+declare const greenBright: (input: any) => string;
+declare const yellowBright: (input: any) => string;
+declare const blueBright: (input: any) => string;
+declare const magentaBright: (input: any) => string;
+declare const cyanBright: (input: any) => string;
+declare const whiteBright: (input: any) => string;
+declare const bgRedBright: (input: any) => string;
+declare const bgGreenBright: (input: any) => string;
+declare const bgYellowBright: (input: any) => string;
+declare const bgBlueBright: (input: any) => string;
+declare const bgMagentaBright: (input: any) => string;
+declare const bgCyanBright: (input: any) => string;
+declare const bgWhiteBright: (input: any) => string;
+/**
+ * A theme.
+ */
+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;
+  };
+}
+/**
+ * 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;
+//#endregion
+export { green as A, reset as B, color_d_exports as C, defineTheme as D, cyanBright as E, magenta as F, whiteBright as G, supportsColor as H, magentaBright as I, yellow as K, overline as L, hidden as M, inverse as N, dim as O, italic as P, red as R, bold as S, cyan as T, underline as U, strikethrough as V, white as W, bgYellow as _, bgBlueBright as a, blue as b, bgGray as c, bgMagenta as d, bgMagentaBright as f, bgWhiteBright as g, bgWhite as h, bgBlue as i, greenBright as j, gray as k, bgGreen as l, bgRedBright as m, Theme as n, bgCyan as o, bgRed as p, yellowBright as q, bgBlack as r, bgCyanBright as s, DEFAULT_THEME as t, bgGreenBright as u, bgYellowBright as v, createAnsiColor as w, blueBright as x, black as y, redBright as z };

package/dist/color-OlJQTTxb.mjs

@@ -0,0 +1,172 @@
+import { t as __export } from "./chunk-z5eko27R.mjs";
+import { i as merge } from "./utils-ChmY93uA.mjs";
+
+//#region src/color.ts
+var color_exports = /* @__PURE__ */ __export({
+	DEFAULT_THEME: () => DEFAULT_THEME,
+	bgBlack: () => bgBlack,
+	bgBlue: () => bgBlue,
+	bgBlueBright: () => bgBlueBright,
+	bgCyan: () => bgCyan,
+	bgCyanBright: () => bgCyanBright,
+	bgGray: () => bgGray,
+	bgGreen: () => bgGreen,
+	bgGreenBright: () => bgGreenBright,
+	bgMagenta: () => bgMagenta,
+	bgMagentaBright: () => bgMagentaBright,
+	bgRed: () => bgRed,
+	bgRedBright: () => bgRedBright,
+	bgWhite: () => bgWhite,
+	bgWhiteBright: () => bgWhiteBright,
+	bgYellow: () => bgYellow,
+	bgYellowBright: () => bgYellowBright,
+	black: () => black,
+	blue: () => blue,
+	blueBright: () => blueBright,
+	bold: () => bold,
+	createAnsiColor: () => createAnsiColor,
+	cyan: () => cyan,
+	cyanBright: () => cyanBright,
+	defineTheme: () => defineTheme,
+	dim: () => dim,
+	gray: () => gray,
+	green: () => green,
+	greenBright: () => greenBright,
+	hidden: () => hidden,
+	inverse: () => inverse,
+	italic: () => italic,
+	magenta: () => magenta,
+	magentaBright: () => magentaBright,
+	overline: () => overline,
+	red: () => red,
+	redBright: () => redBright,
+	reset: () => reset,
+	strikethrough: () => strikethrough,
+	supportsColor: () => supportsColor,
+	underline: () => underline,
+	white: () => white,
+	whiteBright: () => whiteBright,
+	yellow: () => yellow,
+	yellowBright: () => yellowBright
+});
+/**
+* Detects if the runtime supports colored output.
+* @returns If the runtime supports colored output.
+*/
+function detectColorSupport() {
+	if (typeof window !== "undefined" && typeof window.document !== "undefined") return false;
+	const env = typeof process !== "undefined" ? process.env ?? {} : {};
+	if ("NO_COLOR" in env) return false;
+	if ("FORCE_COLOR" in env) return true;
+	if ("CI" in env) {
+		if ([
+			"TRAVIS",
+			"CIRCLECI",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"GITHUB_ACTIONS",
+			"BUILDKITE",
+			"DRONE"
+		].some((k) => k in env) || env.CI_NAME === "codeship") return true;
+		return false;
+	}
+	if (typeof Deno !== "undefined" && Deno.noColor !== void 0) return !Deno.noColor;
+	if (typeof process !== "undefined" && process.stdout) {
+		const term = env.TERM || "";
+		if ((env.COLORTERM || "").length > 0) return true;
+		if (term === "dumb") return false;
+		return /(color|ansi|cygwin|xterm|vt100)/i.test(term);
+	}
+	return false;
+}
+/**
+* If the runtime supports color.
+*/
+const supportsColor = detectColorSupport();
+/**
+* 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.
+*/
+function createAnsiColor(open, close) {
+	const openCode = `\u001b[${open}m`;
+	const closeCode = `\u001b[${close}m`;
+	if (!supportsColor) return (input) => input + "";
+	return (input) => {
+		if (!input) return openCode + closeCode;
+		return openCode + (input + "").replace(new RegExp(`\u001b\\[${close}m`, "g"), closeCode + openCode) + closeCode;
+	};
+}
+const reset = createAnsiColor(0, 0);
+const bold = createAnsiColor(1, 22);
+const dim = createAnsiColor(2, 22);
+const italic = createAnsiColor(3, 23);
+const underline = createAnsiColor(4, 24);
+const overline = createAnsiColor(53, 55);
+const inverse = createAnsiColor(7, 27);
+const hidden = createAnsiColor(8, 28);
+const strikethrough = createAnsiColor(9, 29);
+const black = createAnsiColor(30, 39);
+const red = createAnsiColor(31, 39);
+const green = createAnsiColor(32, 39);
+const yellow = createAnsiColor(33, 39);
+const blue = createAnsiColor(34, 39);
+const magenta = createAnsiColor(35, 39);
+const cyan = createAnsiColor(36, 39);
+const white = createAnsiColor(37, 39);
+const gray = createAnsiColor(90, 39);
+const bgBlack = createAnsiColor(40, 49);
+const bgRed = createAnsiColor(41, 49);
+const bgGreen = createAnsiColor(42, 49);
+const bgYellow = createAnsiColor(43, 49);
+const bgBlue = createAnsiColor(44, 49);
+const bgMagenta = createAnsiColor(45, 49);
+const bgCyan = createAnsiColor(46, 49);
+const bgWhite = createAnsiColor(47, 49);
+const bgGray = createAnsiColor(100, 49);
+const redBright = createAnsiColor(91, 39);
+const greenBright = createAnsiColor(92, 39);
+const yellowBright = createAnsiColor(93, 39);
+const blueBright = createAnsiColor(94, 39);
+const magentaBright = createAnsiColor(95, 39);
+const cyanBright = createAnsiColor(96, 39);
+const whiteBright = createAnsiColor(97, 39);
+const bgRedBright = createAnsiColor(101, 49);
+const bgGreenBright = createAnsiColor(102, 49);
+const bgYellowBright = createAnsiColor(103, 49);
+const bgBlueBright = createAnsiColor(104, 49);
+const bgMagentaBright = createAnsiColor(105, 49);
+const bgCyanBright = createAnsiColor(106, 49);
+const bgWhiteBright = createAnsiColor(107, 49);
+/**
+* The default theme.
+*/
+const DEFAULT_THEME = {
+	primary: cyan,
+	secondary: gray,
+	success: green,
+	warning: yellow,
+	error: red,
+	symbols: {
+		success: "✔",
+		error: "✖",
+		warning: "⚠"
+	},
+	styles: {
+		bold,
+		italic,
+		underline
+	}
+};
+/**
+* Defines a theme.
+* @param theme The (partial) theme.
+* @returns The theme, merged with the default theme.
+*/
+function defineTheme(theme) {
+	return merge(DEFAULT_THEME, theme);
+}
+
+//#endregion
+export { greenBright as A, strikethrough as B, createAnsiColor as C, dim as D, defineTheme as E, magentaBright as F, yellow as G, underline as H, overline as I, yellowBright as K, red as L, inverse as M, italic as N, gray as O, magenta as P, redBright as R, color_exports as S, cyanBright as T, white as U, supportsColor as V, whiteBright as W, bgYellowBright as _, bgCyan as a, blueBright as b, bgGreen as c, bgMagentaBright as d, bgRed as f, bgYellow as g, bgWhiteBright as h, bgBlueBright as i, hidden as j, green as k, bgGreenBright as l, bgWhite as m, bgBlack as n, bgCyanBright as o, bgRedBright as p, bgBlue as r, bgGray as s, DEFAULT_THEME as t, bgMagenta as u, black as v, cyan as w, bold as x, blue as y, reset as z };

package/dist/color.d.mts

@@ -0,0 +1,2 @@
+import { A as green, B as reset, D as defineTheme, E as cyanBright, F as magenta, G as whiteBright, H as supportsColor, I as magentaBright, K as yellow, L as overline, M as hidden, N as inverse, O as dim, P as italic, R as red, S as bold, T as cyan, U as underline, V as strikethrough, W as white, _ as bgYellow, a as bgBlueBright, b as blue, c as bgGray, d as bgMagenta, f as bgMagentaBright, g as bgWhiteBright, h as bgWhite, i as bgBlue, j as greenBright, k as gray, l as bgGreen, m as bgRedBright, n as Theme, o as bgCyan, p as bgRed, q as yellowBright, r as bgBlack, s as bgCyanBright, t as DEFAULT_THEME, u as bgGreenBright, v as bgYellowBright, w as createAnsiColor, x as blueBright, y as black, z as redBright } from "./color-BuHvMolk.mjs";
+export { DEFAULT_THEME, Theme, bgBlack, bgBlue, bgBlueBright, bgCyan, bgCyanBright, bgGray, bgGreen, bgGreenBright, bgMagenta, bgMagentaBright, bgRed, bgRedBright, bgWhite, bgWhiteBright, bgYellow, bgYellowBright, black, blue, blueBright, bold, createAnsiColor, cyan, cyanBright, defineTheme, dim, gray, green, greenBright, hidden, inverse, italic, magenta, magentaBright, overline, red, redBright, reset, strikethrough, supportsColor, underline, white, whiteBright, yellow, yellowBright };

package/dist/color.mjs

@@ -0,0 +1,4 @@
+import "./utils-ChmY93uA.mjs";
+import { A as greenBright, B as strikethrough, C as createAnsiColor, D as dim, E as defineTheme, F as magentaBright, G as yellow, H as underline, I as overline, K as yellowBright, L as red, M as inverse, N as italic, O as gray, P as magenta, R as redBright, T as cyanBright, U as white, V as supportsColor, W as whiteBright, _ as bgYellowBright, a as bgCyan, b as blueBright, c as bgGreen, d as bgMagentaBright, f as bgRed, g as bgYellow, h as bgWhiteBright, i as bgBlueBright, j as hidden, k as green, l as bgGreenBright, m as bgWhite, n as bgBlack, o as bgCyanBright, p as bgRedBright, r as bgBlue, s as bgGray, t as DEFAULT_THEME, u as bgMagenta, v as black, w as cyan, x as bold, y as blue, z as reset } from "./color-OlJQTTxb.mjs";
+
+export { DEFAULT_THEME, bgBlack, bgBlue, bgBlueBright, bgCyan, bgCyanBright, bgGray, bgGreen, bgGreenBright, bgMagenta, bgMagentaBright, bgRed, bgRedBright, bgWhite, bgWhiteBright, bgYellow, bgYellowBright, black, blue, blueBright, bold, createAnsiColor, cyan, cyanBright, defineTheme, dim, gray, green, greenBright, hidden, inverse, italic, magenta, magentaBright, overline, red, redBright, reset, strikethrough, supportsColor, underline, white, whiteBright, yellow, yellowBright };

package/dist/command-BXmfoT-l.d.mts

@@ -0,0 +1,331 @@
+import { n as Theme } from "./color-BuHvMolk.mjs";
+import { i as Input, o as Option, r as InferInput, s as Positional } from "./input-B12iaqb8.mjs";
+
+//#region src/error.d.ts
+declare namespace error_d_exports {
+  export { ConvokerError, HelpAskedError, InputValidationError, MissingRequiredArgumentError, MissingRequiredOptionError, TooManyArgumentsError, UnknownOptionError };
+}
+/**
+ * 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[]);
+}
+/**
+ * A Convoker-related error. These are usually handled by default.
+ */
+declare class ConvokerError extends Error {
+  /**
+   * The command this error happened on.
+   */
+  command: Command<any>;
+  /**
+   * Creates a new Convoker error.
+   * @param message The message.
+   * @param command The command.
+   */
+  constructor(message: string, command: Command<any>);
+  /**
+   * Prints the error's message.
+   */
+  print(): void;
+}
+/**
+ * When the user asks for help.
+ */
+declare class HelpAskedError extends ConvokerError {
+  /**
+   * Creates a new help asked error.
+   * @param command The command.
+   */
+  constructor(command: Command<any>);
+}
+/**
+ * When you pass too many arguments.
+ */
+declare class TooManyArgumentsError extends ConvokerError {
+  /**
+   * Creates a new too many arguments error.
+   * @param command The command.
+   */
+  constructor(command: Command<any>);
+}
+/**
+ * When you pass an unknown option, when unknown options aren't allowed.
+ */
+declare class UnknownOptionError extends ConvokerError {
+  /**
+   * 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);
+}
+/**
+ * When a required option is missing.
+ */
+declare class MissingRequiredOptionError extends ConvokerError {
+  /**
+   * The option key.
+   */
+  key: string;
+  /**
+   * The option entry.
+   */
+  entry: Option<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<any, any, any>);
+}
+declare class MissingRequiredArgumentError extends ConvokerError {
+  /**
+   * 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>);
+}
+//#endregion
+//#region src/command.d.ts
+/**
+ * What the command is an alias for.
+ */
+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;
+}
+/**
+ * The result of the `Command.parse` function.
+ */
+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: ConvokerError[];
+  /**
+   * If this should result in displaying the version of the command.
+   */
+  isVersion: boolean;
+  /**
+   * If this should result in displaying a help screen.
+   */
+  isHelp: boolean;
+}
+/**
+ * Command action function.
+ */
+type ActionFn<T extends Input> = (input: InferInput<T>) => any | Promise<any>;
+/**
+ * Command middleware function.
+ */
+type MiddlewareFn<T extends Input = Input> = (input: InferInput<T>, next: () => Promise<any>) => any | Promise<any>;
+/**
+ * Command error handler.
+ */
+type ErrorFn<T extends Input> = (command: Command<T>, errors: Error[], input: Partial<InferInput<T>>) => void | Promise<void>;
+/**
+ * Builder for commands.
+ */
+type Builder = (c: Command<any>) => Command<any> | void;
+/**
+ * A command.
+ */
+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;
+  /**
+   * If you should be able to surpass the amount of positional arguments defined in the input.
+   */
+  $allowSurpassArgLimit: boolean;
+  /**
+   * The input this command takes.
+   */
+  $input: T;
+  /**
+   * The action function of this command.
+   */
+  $fn: ActionFn<T> | undefined;
+  /**
+   * The middlewares associated with this command.
+   */
+  $middlewares: MiddlewareFn<T>[];
+  /**
+   * 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>;
+  /**
+   * Adds a chain of middlewares.
+   * @param fns The middlewares to use.
+   * @returns this
+   */
+  use(...fns: MiddlewareFn<T>[]): this;
+  /**
+   * 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;
+  /**
+   * Allows surpassing the amount of arguments specified.
+   * @returns this
+   */
+  allowSurpassArgLimit(): this;
+  /**
+   * 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>;
+}
+//#endregion
+export { ErrorFn as a, ConvokerError as c, MissingRequiredArgumentError as d, MissingRequiredOptionError as f, error_d_exports as h, CommandAlias as i, HelpAskedError as l, UnknownOptionError as m, Builder as n, MiddlewareFn as o, TooManyArgumentsError as p, Command as r, ParseResult as s, ActionFn as t, InputValidationError as u };