gunshi 0.27.0-beta.2 → 0.27.0-beta.4

package/README.md

@@ -28,8 +28,15 @@ Gunshi is designed to simplify the creation of modern command-line interfaces:
 - 🌍 **Internationalization**: Built with global users in mind, featuring locale-aware design, resource management, and multi-language support.
 - 🔌 **Pluggable**: Extensible plugin system with dependency management and lifecycle hooks for modular CLI development.
 
+## 📡 Status
+
+- v0.26.3: stable
+- v0.27: beta
+
 ## 💿 Installation
 
+### Stable
+
 ```sh
 # npm
 npm install --save gunshi
@@ -41,12 +48,31 @@ pnpm add gunshi
 yarn add gunshi
 
 ## deno
-deno add jsr:@kazupon/gunshi
+deno add jsr:@gunshi/gunshi
 
 ## bun
 bun add gunshi
 ```
 
+### v0.27 Beta
+
+```sh
+# npm
+npm install --save gunshi@beta
+
+## pnpm
+pnpm add gunshi@beta
+
+## yarn
+yarn add gunshi@beta
+
+## deno (you can specify version with `@`)
+deno add jsr:@gunshi/gunshi@0.27.2
+
+## bun
+bun add gunshi@beta
+```
+
 ## 🚀 Usage
 
 ```js

package/lib/bone.d.ts

@@ -1,6 +1,10 @@
-import { ArgSchema, ArgToken, ArgValues, Args, Awaitable, CliOptions, Command, CommandCallMode, CommandContext, CommandContextCore, CommandContextExtension, CommandDecorator, CommandEnvironment, CommandExamplesFetcher, CommandLoader, CommandRunner, Commandable, DefaultGunshiParams, ExtendContext, ExtractArgExplicitlyProvided, ExtractArgs, ExtractExtensions, GunshiParams, GunshiParamsConstraint, LazyCommand, NormalizeToGunshiParams, Prettify, RendererDecorator, RenderingOptions, ValidationErrorsDecorator } from "./types-DpGOiC0p.js";
+import { A as ValidationErrorsDecorator, C as GunshiParams, D as Prettify, E as NormalizeToGunshiParams, O as RendererDecorator, S as ExtractExtensions, T as LazyCommand, _ as Commandable, a as Awaitable, b as ExtractArgExplicitlyProvided, c as CommandCallMode, d as CommandContextExtension, f as CommandDecorator, g as CommandRunner, h as CommandLoader, i as Args, k as RenderingOptions, l as CommandContext, m as CommandExamplesFetcher, n as ArgToken, o as CliOptions, p as CommandEnvironment, r as ArgValues, s as Command, t as ArgSchema, u as CommandContextCore, v as DefaultGunshiParams, w as GunshiParamsConstraint, x as ExtractArgs, y as ExtendContext } from "./types-DIfsK4mZ.js";
 
 //#region src/cli/bone.d.ts
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
 
 /**
  * Run the command.

package/lib/bone.js

@@ -1,9 +1,13 @@
-import "./context-CaqWZ3MF.js";
-import "./utils-Bh4TdPy8.js";
-import { cliCore } from "./core-clRbigv-.js";
+import "./context-DRQZ3doU.js";
+import "./utils-DA31tfdY.js";
+import { t as cliCore } from "./core-D15eimMG.js";
 
 //#region src/cli/bone.ts
 /**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Run the command.
 *
 * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.

package/lib/{cli-B121JwoR.js → cli-CTN-xtKX.js}

@@ -1,9 +1,13 @@
-import { cliCore } from "./core-clRbigv-.js";
-import { plugin } from "./plugin-BRVcC8lF.js";
-import { COMMON_ARGS, namespacedId, renderer } from "./src-hz2EqFqR.js";
+import { t as cliCore } from "./core-D15eimMG.js";
+import { t as plugin } from "./plugin-bQlPfOlH.js";
+import { a as namespacedId, s as COMMON_ARGS, t as renderer } from "./src-DZnfAAwF.js";
 
 //#region ../plugin-global/src/types.ts
 /**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * The unique identifier for the global options plugin.
 */
 const pluginId = namespacedId("global");
@@ -11,6 +15,10 @@ const pluginId = namespacedId("global");
 //#endregion
 //#region ../plugin-global/src/decorator.ts
 /**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Decorator function to extend the command with global options.
 *
 * @param baseRunner - The base command runner
@@ -84,6 +92,35 @@ function extension(ctx) {
 //#endregion
 //#region ../plugin-global/src/index.ts
 /**
+* The entry point of global options plugin
+*
+* @example
+* ```js
+* import global from '@gunshi/plugin-global'
+* import { cli } from 'gunshi'
+*
+* const entry = (ctx) => {
+*   // ...
+* }
+*
+* await cli(process.argv.slice(2), entry, {
+*   // ...
+*
+*   plugins: [
+*     global()
+*   ],
+*
+*   // ...
+* })
+* ```
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * global options plugin
 *
 * @returns A defined plugin as global options
@@ -103,6 +140,10 @@ function global() {
 //#endregion
 //#region src/cli/builtin.ts
 /**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Run the command.
 *
 * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
@@ -117,4 +158,4 @@ async function cli(args, entry, options = {}) {
 }
 
 //#endregion
-export { cli };
+export { cli as t };

package/lib/{context-C7rkDQK3.d.ts → context-CMrZI9J4.d.ts}

@@ -1,4 +1,4 @@
-import { ArgToken, ArgValues, Args, CliOptions, Command, CommandCallMode, CommandContext, CommandContextExtension, DefaultGunshiParams, ExtendContext, ExtractArgExplicitlyProvided, ExtractArgs, GunshiParams, GunshiParamsConstraint, LazyCommand } from "./types-DpGOiC0p.js";
+import { C as GunshiParams, T as LazyCommand, b as ExtractArgExplicitlyProvided, c as CommandCallMode, d as CommandContextExtension, i as Args, l as CommandContext, n as ArgToken, o as CliOptions, r as ArgValues, s as Command, v as DefaultGunshiParams, w as GunshiParamsConstraint, x as ExtractArgs, y as ExtendContext } from "./types-DIfsK4mZ.js";
 
 //#region src/context.d.ts
 
@@ -94,4 +94,4 @@ declare function createCommandContext<G extends GunshiParamsConstraint = Default
   extensions: ExtractExtensions<E>;
 }>>>>;
 //#endregion
-export { CommandContextParams, ExtractExtensions, createCommandContext };
+export { ExtractExtensions as n, createCommandContext as r, CommandContextParams as t };

package/lib/{context-CaqWZ3MF.js → context-DRQZ3doU.js}

@@ -1,4 +1,4 @@
-import { create, deepFreeze, isLazyCommand, log } from "./utils-Bh4TdPy8.js";
+import { a as log, n as deepFreeze, r as isLazyCommand, t as create } from "./utils-DA31tfdY.js";
 
 //#region src/constants.ts
 const ANONYMOUS_COMMAND_NAME = "(anonymous)";
@@ -27,6 +27,21 @@ const CLI_OPTIONS_DEFAULT = {
 //#endregion
 //#region src/context.ts
 /**
+* The entry for gunshi context.
+* This module is exported for the purpose of testing the command.
+*
+* @example
+* ```js
+* import { createCommandContext } from 'gunshi/context'
+* ```
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Create a command context.
 *
 * @param param - A {@link CommandContextParams | parameters} to create a command context.
@@ -98,4 +113,4 @@ function getCommandName(cmd) {
 }
 
 //#endregion
-export { ANONYMOUS_COMMAND_NAME, CLI_OPTIONS_DEFAULT, NOOP, createCommandContext };
+export { NOOP as i, ANONYMOUS_COMMAND_NAME as n, CLI_OPTIONS_DEFAULT as r, createCommandContext as t };

package/lib/context.d.ts

@@ -1,3 +1,3 @@
-import "./types-DpGOiC0p.js";
-import { CommandContextParams, ExtractExtensions, createCommandContext } from "./context-C7rkDQK3.js";
+import "./types-DIfsK4mZ.js";
+import { n as ExtractExtensions, r as createCommandContext, t as CommandContextParams } from "./context-CMrZI9J4.js";
 export { CommandContextParams, ExtractExtensions, createCommandContext };

package/lib/context.js

@@ -1,4 +1,4 @@
-import { createCommandContext } from "./context-CaqWZ3MF.js";
-import "./utils-Bh4TdPy8.js";
+import { t as createCommandContext } from "./context-DRQZ3doU.js";
+import "./utils-DA31tfdY.js";
 
 export { createCommandContext };

package/lib/{core-clRbigv-.js → core-D15eimMG.js}

@@ -1,9 +1,9 @@
-import { ANONYMOUS_COMMAND_NAME, CLI_OPTIONS_DEFAULT, NOOP, createCommandContext } from "./context-CaqWZ3MF.js";
-import { create, isLazyCommand, resolveLazyCommand } from "./utils-Bh4TdPy8.js";
+import { i as NOOP, n as ANONYMOUS_COMMAND_NAME, r as CLI_OPTIONS_DEFAULT, t as createCommandContext } from "./context-DRQZ3doU.js";
+import { o as resolveLazyCommand, r as isLazyCommand, t as create } from "./utils-DA31tfdY.js";
 import { parseArgs, resolveArgs } from "args-tokens";
 
 //#region src/decorators.ts
-const EMPTY_RENDERER = async () => "";
+const EMPTY_RENDERER = () => Promise.resolve("");
 /**
 * Factory function for creating a decorators manager.
 *
@@ -162,6 +162,10 @@ function resolveDependencies(plugins) {
 //#endregion
 //#region src/cli/core.ts
 /**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Run the command.
 *
 * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
@@ -179,7 +183,7 @@ async function cliCore(argv, entry, options, plugins) {
 	const cliOptions = normalizeCliOptions(options, decorators, pluginContext);
 	const tokens = parseArgs(argv);
 	const subCommand = getSubCommand(tokens);
-	const { commandName: name, command, callMode } = await resolveCommand(subCommand, entry, cliOptions);
+	const { commandName: name, command, callMode } = resolveCommand(subCommand, entry, cliOptions);
 	if (!command) throw new Error(`Command not found: ${name || ""}`);
 	const args = resolveArguments(pluginContext, getCommandArgs(command));
 	const { explicit, values, positionals, rest, error } = resolveArgs(args, tokens, {
@@ -262,9 +266,9 @@ function getSubCommand(tokens) {
 	return firstToken && firstToken.kind === "positional" && firstToken.index === 0 && firstToken.value ? firstToken.value : "";
 }
 const CANNOT_RESOLVE_COMMAND = { callMode: "unexpected" };
-async function resolveCommand(sub, entry, options) {
+function resolveCommand(sub, entry, options) {
 	const omitted = !sub;
-	async function doResolveCommand() {
+	function doResolveCommand() {
 		if (typeof entry === "function") if ("commandName" in entry && entry.commandName) return {
 			commandName: entry.commandName,
 			command: entry,
@@ -332,4 +336,4 @@ async function executeCommand(cmd, ctx, decorators) {
 }
 
 //#endregion
-export { cliCore };
+export { cliCore as t };

package/lib/{definition-BPAFRYmH.d.ts → definition-BWGhvqMF.d.ts}

@@ -1,6 +1,10 @@
-import { Args, Command, CommandLoader, DefaultGunshiParams, ExtendContext, ExtractArgs, ExtractExtensions, GunshiParams, GunshiParamsConstraint, LazyCommand, Prettify } from "./types-DpGOiC0p.js";
+import { C as GunshiParams, D as Prettify, S as ExtractExtensions, T as LazyCommand, h as CommandLoader, i as Args, s as Command, v as DefaultGunshiParams, w as GunshiParamsConstraint, x as ExtractArgs, y as ExtendContext } from "./types-DIfsK4mZ.js";
 
 //#region src/definition.d.ts
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
 
 /**
  * Infer command properties excluding for {@link define} function
@@ -44,8 +48,8 @@ type CommandDefinitionResult<G extends GunshiParamsConstraint = DefaultGunshiPar
  * @param definition - A {@link Command | command} definition
  * @returns A defined {@link Command | command}
  */
-declare function define<G extends GunshiParamsConstraint = DefaultGunshiParams, A extends Args = ExtractArgs<G>, C extends InferCommandProps<G> = InferCommandProps<G>>(definition: C & Command<{
-  args: A;
+declare function define<G extends GunshiParamsConstraint = DefaultGunshiParams, A$1 extends Args = ExtractArgs<G>, C extends InferCommandProps<G> = InferCommandProps<G>>(definition: C & Command<{
+  args: A$1;
   extensions: ExtractExtensions<G>;
 }>): CommandDefinitionResult<G, C>;
 /**
@@ -55,14 +59,14 @@ declare function define<G extends GunshiParamsConstraint = DefaultGunshiParams,
  *
  * @internal
  */
-type DefineWithTypesReturn<DefaultExtensions extends ExtendContext, DefaultArgs extends Args> = <A extends DefaultArgs = DefaultArgs, C extends Partial<Command<{
-  args: A;
+type DefineWithTypesReturn<DefaultExtensions extends ExtendContext, DefaultArgs extends Args> = <A$1 extends DefaultArgs = DefaultArgs, C extends Partial<Command<{
+  args: A$1;
   extensions: DefaultExtensions;
 }>> = {}>(definition: C & Command<{
-  args: A;
+  args: A$1;
   extensions: DefaultExtensions;
 }>) => CommandDefinitionResult<{
-  args: A;
+  args: A$1;
   extensions: DefaultExtensions;
 }, C>;
 /**
@@ -109,11 +113,11 @@ declare function defineWithTypes<G extends GunshiParamsConstraint>(): DefineWith
  * @param loader - A {@link CommandLoader | command loader}
  * @returns A {@link LazyCommand | lazy command} with loader
  */
-declare function lazy<A extends Args>(loader: CommandLoader<{
-  args: A;
+declare function lazy<A$1 extends Args>(loader: CommandLoader<{
+  args: A$1;
   extensions: {};
 }>): LazyCommand<{
-  args: A;
+  args: A$1;
   extensions: {};
 }, {}>;
 /**
@@ -151,17 +155,17 @@ declare function lazy<A extends Args>(loader: CommandLoader<{
  * @param definition - An optional {@link Command | command} definition
  * @returns A {@link LazyCommand | lazy command} that can be executed later
  */
-declare function lazy<G extends GunshiParamsConstraint = DefaultGunshiParams, A extends ExtractArgs<G> = ExtractArgs<G>, D extends Partial<Command<{
-  args: A;
+declare function lazy<G extends GunshiParamsConstraint = DefaultGunshiParams, A$1 extends ExtractArgs<G> = ExtractArgs<G>, D extends Partial<Command<{
+  args: A$1;
   extensions: {};
 }>> = Partial<Command<{
-  args: A;
+  args: A$1;
   extensions: {};
 }>>>(loader: CommandLoader<{
-  args: A;
+  args: A$1;
   extensions: {};
 }>, definition: D): LazyCommand<{
-  args: A;
+  args: A$1;
   extensions: {};
 }, D>;
 /**
@@ -232,4 +236,4 @@ type LazyWithTypesReturn<FullG extends GunshiParamsConstraint> = <D extends Part
  */
 declare function lazyWithTypes<G extends GunshiParamsConstraint>(): LazyWithTypesReturn<NormalizeGunshiParams<G>>;
 //#endregion
-export { define, defineWithTypes, lazy, lazyWithTypes };
+export { lazyWithTypes as i, defineWithTypes as n, lazy as r, define as t };

package/lib/{definition-qbPc8FcH.js → definition-D5821Sur.js}

@@ -106,4 +106,4 @@ function lazyWithTypes() {
 }
 
 //#endregion
-export { define, defineWithTypes, lazy, lazyWithTypes };
+export { lazyWithTypes as i, defineWithTypes as n, lazy as r, define as t };

package/lib/definition.d.ts

@@ -1,4 +1,4 @@
-import { ArgSchema, ArgValues, Args, Command, CommandLoader, CommandRunner, DefaultGunshiParams, ExtendContext, GunshiParams, LazyCommand } from "./types-DpGOiC0p.js";
-import { CommandContextParams, createCommandContext } from "./context-C7rkDQK3.js";
-import { define, defineWithTypes, lazy, lazyWithTypes } from "./definition-BPAFRYmH.js";
+import { C as GunshiParams, T as LazyCommand, g as CommandRunner, h as CommandLoader, i as Args, r as ArgValues, s as Command, t as ArgSchema, v as DefaultGunshiParams, y as ExtendContext } from "./types-DIfsK4mZ.js";
+import { r as createCommandContext, t as CommandContextParams } from "./context-CMrZI9J4.js";
+import { i as lazyWithTypes, n as defineWithTypes, r as lazy, t as define } from "./definition-BWGhvqMF.js";
 export { ArgSchema, ArgValues, Args, Command, CommandContextParams, CommandLoader, CommandRunner, DefaultGunshiParams, ExtendContext, GunshiParams, LazyCommand, createCommandContext, define, defineWithTypes, lazy, lazyWithTypes };

package/lib/definition.js

@@ -1,5 +1,5 @@
-import { createCommandContext } from "./context-CaqWZ3MF.js";
-import "./utils-Bh4TdPy8.js";
-import { define, defineWithTypes, lazy, lazyWithTypes } from "./definition-qbPc8FcH.js";
+import { t as createCommandContext } from "./context-DRQZ3doU.js";
+import "./utils-DA31tfdY.js";
+import { i as lazyWithTypes, n as defineWithTypes, r as lazy, t as define } from "./definition-D5821Sur.js";
 
 export { createCommandContext, define, defineWithTypes, lazy, lazyWithTypes };

package/lib/generator.d.ts

@@ -1,4 +1,4 @@
-import { CliOptions, Command, DefaultGunshiParams, GunshiParamsConstraint, LazyCommand } from "./types-DpGOiC0p.js";
+import { T as LazyCommand, o as CliOptions, s as Command, v as DefaultGunshiParams, w as GunshiParamsConstraint } from "./types-DIfsK4mZ.js";
 
 //#region src/generator.d.ts
 

package/lib/generator.js

@@ -1,12 +1,26 @@
-import "./context-CaqWZ3MF.js";
-import { create } from "./utils-Bh4TdPy8.js";
-import "./core-clRbigv-.js";
-import "./plugin-BRVcC8lF.js";
-import "./src-hz2EqFqR.js";
-import { cli } from "./cli-B121JwoR.js";
+import "./context-DRQZ3doU.js";
+import { t as create } from "./utils-DA31tfdY.js";
+import "./core-D15eimMG.js";
+import "./plugin-bQlPfOlH.js";
+import "./src-DZnfAAwF.js";
+import { t as cli } from "./cli-CTN-xtKX.js";
 
 //#region src/generator.ts
 /**
+* The entry for usage generator.
+*
+* @example
+* ```js
+* import { generate } from 'gunshi/generator'
+* ```
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
 * Generate the command usage.
 *
 * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command parameters.

package/lib/index-BDRk6VtJ.d.ts

@@ -0,0 +1,158 @@
+import { C as GunshiParams, T as LazyCommand, g as CommandRunner, i as Args$1, o as CliOptions, s as Command, v as DefaultGunshiParams, w as GunshiParamsConstraint, y as ExtendContext } from "./types-DIfsK4mZ.js";
+import { parseArgs as parseArgs$1, resolveArgs as resolveArgs$1 } from "args-tokens";
+
+//#region ../plugin-i18n/src/types.d.ts
+
+/**
+ * Translation adapter factory options.
+ */
+interface TranslationAdapterFactoryOptions {
+  /**
+   * A locale (BCP 47 language tag).
+   */
+  locale: string;
+  /**
+   * A fallback locale.
+   *
+   * @default DEFAULT_LOCALE ('en-US')
+   */
+  fallbackLocale: string;
+}
+/**
+ * Translation adapter.
+ *
+ * This adapter is used to custom message formatter like {@link https://github.com/intlify/vue-i18n/blob/master/spec/syntax.ebnf | Intlify message format}, {@link https://github.com/tc39/proposal-intl-messageformat | `Intl.MessageFormat` (MF2)}, and etc.
+ * This adapter will support localization with your preferred message format.
+ */
+interface TranslationAdapter<MessageResource = string> {
+  /**
+   * Get a resource of locale.
+   *
+   * @param locale - A Locale at the time of command execution. That is Unicord locale ID (BCP 47)
+   * @returns A resource of locale. if resource not found, return `undefined`.
+   */
+  getResource(locale: string): Record<string, string> | undefined;
+  /**
+   * Set a resource of locale.
+   *
+   * @param locale - A Locale at the time of command execution. That is Unicord locale ID (BCP 47)
+   * @param resource - A resource of locale
+   */
+  setResource(locale: string, resource: Record<string, string>): void;
+  /**
+   * Get a message of locale.
+   *
+   * @param locale - A Locale at the time of command execution. That is Unicord locale ID (BCP 47)
+   * @param key - A key of message resource
+   * @returns A message of locale. if message not found, return `undefined`.
+   */
+  getMessage(locale: string, key: string): MessageResource | undefined;
+  /**
+   * Translate a message.
+   *
+   * @param locale - A Locale at the time of command execution. That is Unicord locale ID (BCP 47)
+   * @param key - A key of message resource
+   * @param values - A values to be resolved in the message
+   * @returns A translated message, if message is not translated, return `undefined`.
+   */
+  translate(locale: string, key: string, values?: Record<string, unknown>): string | undefined;
+}
+//#endregion
+//#region ../plugin-i18n/src/translation.d.ts
+/**
+ * Default implementation of {@linkcode TranslationAdapter}.
+ */
+declare class DefaultTranslation implements TranslationAdapter {
+  #private;
+  /**
+   * Creates a new instance of DefaultTranslation.
+   *
+   * @param options - Options for the translation adapter, see {@linkcode TranslationAdapterFactoryOptions}
+   */
+  constructor(options: TranslationAdapterFactoryOptions);
+  /**
+   * Get a resource of locale.
+   *
+   * @param locale - A locale of resource (BCP 47 language tag)
+   * @returns A resource of locale. If resource not found, return `undefined`.
+   */
+  getResource(locale: string): Record<string, string> | undefined;
+  /**
+   * Set a resource of locale.
+   *
+   * @param locale - A locale of resource (BCP 47 language tag)
+   * @param resource - A resource of locale
+   */
+  setResource(locale: string, resource: Record<string, string>): void;
+  /**
+   * Get a message of locale.
+   *
+   * @param locale - A locale of message (BCP 47 language tag)
+   * @param key - A key of message resource
+   * @returns A message of locale. If message not found, return `undefined`.
+   */
+  getMessage(locale: string, key: string): string | undefined;
+  /**
+   * Translate a message.
+   *
+   * @param locale - A locale of message (BCP 47 language tag)
+   * @param key - A key of message resource
+   * @param values - A values to interpolate in the message
+   * @returns A translated message, if message is not translated, return `undefined`.
+   */
+  translate(locale: string, key: string, values?: Record<string, unknown>): string | undefined;
+}
+//#endregion
+//#region src/cli/builtin.d.ts
+/**
+ * Run the command.
+ *
+ * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
+ *
+ * @param args - Command line arguments
+ * @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options - A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@linkcode CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<G extends GunshiParamsConstraint>(args: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+/**
+ * Run the command.
+ *
+ * @typeParam A - The type of {@linkcode Args | arguments} defined in the command and cli options.
+ *
+ * @param args - Command line arguments
+ * @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options - A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@linkcode CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<A extends Args$1 = Args$1, G extends GunshiParams = {
+  args: A;
+  extensions: {};
+}>(args: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+/**
+ * Run the command.
+ *
+ * @typeParam E - An {@linkcode ExtendContext} type to specify the shape of command and cli options.
+ *
+ * @param args - Command line arguments
+ * @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options - A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@linkcode CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<E extends ExtendContext = ExtendContext, G extends GunshiParams = {
+  args: Args$1;
+  extensions: E;
+}>(args: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+/**
+ * Run the command.
+ *
+ * @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
+ *
+ * @param args - Command line arguments
+ * @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+ * @param options - A {@link CliOptions | CLI options}
+ * @returns A rendered usage or undefined. if you will use {@linkcode CliOptions.usageSilent} option, it will return rendered usage string.
+ */
+declare function cli<G extends GunshiParams = DefaultGunshiParams>(args: string[], entry: Command<G> | CommandRunner<G> | LazyCommand<G>, options?: CliOptions<G>): Promise<string | undefined>;
+//#endregion
+export { DefaultTranslation as i, resolveArgs$1 as n, cli as r, parseArgs$1 as t };