@reliverse/rempts 1.7.44 → 1.7.46

package/bin/libs/launcher/launcher-mod.d.ts

@@ -1,162 +0,0 @@
-import type { ReliArgParserOptions } from "@reliverse/reliarg";
-import type { ArgDefinitions, Command, DefineCommandOptions, EmptyArgs, FileBasedOptions } from "./launcher-types.js";
-import type { AnyRouter } from "./trpc-orpc-support/trpc-compat.js";
-import type { Logger, OmeletteInstanceLike, Promptable } from "./trpc-orpc-support/types.js";
-/**
- * Defines a command with metadata, argument definitions,
- * an execution function, and (optional) subCommands.
- */
-export declare function defineCommand<A extends ArgDefinitions = EmptyArgs>(options: DefineCommandOptions<A>): Command<A>;
-/**
- * Show usage for a given command.
- */
-export 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.
- */
-export 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.
- */
-export 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"
- * ]);
- * ```
- */
-export 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"]
- * ```
- */
-export declare function runCmd<A extends ArgDefinitions = EmptyArgs>(command: Command<A>, argv?: string[], parserOptions?: ReliArgParserOptions): Promise<void>;