@navios/commander 0.5.1 → 0.7.0

package/lib/index.d.mts

@@ -1,98 +1,670 @@
-export { Factory } from './_tsup-dts-rollup.mjs';
-export { FactoryOptions } from './_tsup-dts-rollup.mjs';
-export { Injectable } from './_tsup-dts-rollup.mjs';
-export { InjectableOptions } from './_tsup-dts-rollup.mjs';
-export { InjectableScope } from './_tsup-dts-rollup.mjs';
-export { InjectableType } from './_tsup-dts-rollup.mjs';
-export { FactoryNotFound } from './_tsup-dts-rollup.mjs';
-export { FactoryTokenNotResolved } from './_tsup-dts-rollup.mjs';
-export { InstanceDestroying } from './_tsup-dts-rollup.mjs';
-export { InstanceNotFound } from './_tsup-dts-rollup.mjs';
-export { UnknownError } from './_tsup-dts-rollup.mjs';
-export { ErrorsEnum } from './_tsup-dts-rollup.mjs';
-export { DIErrorCode } from './_tsup-dts-rollup.mjs';
-export { DIError } from './_tsup-dts-rollup.mjs';
-export { Factorable } from './_tsup-dts-rollup.mjs';
-export { FactorableWithArgs } from './_tsup-dts-rollup.mjs';
-export { OnServiceInit } from './_tsup-dts-rollup.mjs';
-export { OnServiceDestroy } from './_tsup-dts-rollup.mjs';
-export { getInjectors } from './_tsup-dts-rollup.mjs';
-export { Injectors } from './_tsup-dts-rollup.mjs';
-export { getInjectableToken } from './_tsup-dts-rollup.mjs';
-export { Join } from './_tsup-dts-rollup.mjs';
-export { UnionToIntersection } from './_tsup-dts-rollup.mjs';
-export { UnionToOvlds } from './_tsup-dts-rollup.mjs';
-export { PopUnion } from './_tsup-dts-rollup.mjs';
-export { IsUnion } from './_tsup-dts-rollup.mjs';
-export { UnionToArray } from './_tsup-dts-rollup.mjs';
-export { InjectState } from './_tsup-dts-rollup.mjs';
-export { BaseInstanceHolderManager } from './_tsup-dts-rollup.mjs';
-export { EventsConfig } from './_tsup-dts-rollup.mjs';
-export { EventsNames } from './_tsup-dts-rollup.mjs';
-export { EventsArgs } from './_tsup-dts-rollup.mjs';
-export { ChannelEmitter } from './_tsup-dts-rollup.mjs';
-export { EventEmitterInterface } from './_tsup-dts-rollup.mjs';
-export { EventEmitter } from './_tsup-dts-rollup.mjs';
-export { FactoryContext } from './_tsup-dts-rollup.mjs';
-export { ClassType } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithArgument } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithOptionalArgument } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithInstance } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithInstanceAndArgument } from './_tsup-dts-rollup.mjs';
-export { ClassTypeWithInstanceAndOptionalArgument } from './_tsup-dts-rollup.mjs';
-export { BaseInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
-export { OptionalInjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
-export { InjectionTokenSchemaType } from './_tsup-dts-rollup.mjs';
-export { InjectionToken } from './_tsup-dts-rollup.mjs';
-export { BoundInjectionToken } from './_tsup-dts-rollup.mjs';
-export { FactoryInjectionToken } from './_tsup-dts-rollup.mjs';
-export { AnyInjectableType } from './_tsup-dts-rollup.mjs';
-export { InjectionTokenType } from './_tsup-dts-rollup.mjs';
-export { defaultInjectors } from './_tsup-dts-rollup.mjs';
-export { asyncInject } from './_tsup-dts-rollup.mjs';
-export { inject } from './_tsup-dts-rollup.mjs';
-export { wrapSyncInit } from './_tsup-dts-rollup.mjs';
-export { provideFactoryContext } from './_tsup-dts-rollup.mjs';
-export { FactoryRecord } from './_tsup-dts-rollup.mjs';
-export { Registry } from './_tsup-dts-rollup.mjs';
-export { globalRegistry } from './_tsup-dts-rollup.mjs';
-export { ServiceInstantiator } from './_tsup-dts-rollup.mjs';
-export { ServiceLocator } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorEventBus } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolderStatus } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceEffect } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceDestroyListener } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolderCreating } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolderCreated } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolderDestroying } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolderError } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorInstanceHolder } from './_tsup-dts-rollup.mjs';
-export { ServiceLocatorManager } from './_tsup-dts-rollup.mjs';
-export { createRequestContextHolder } from './_tsup-dts-rollup.mjs';
-export { RequestContextHolder } from './_tsup-dts-rollup.mjs';
-export { DefaultRequestContextHolder } from './_tsup-dts-rollup.mjs';
-export { InjectableTokenMeta } from './_tsup-dts-rollup.mjs';
-export { Container } from './_tsup-dts-rollup.mjs';
-export { CommanderApplicationOptions_alias_1 as CommanderApplicationOptions } from './_tsup-dts-rollup.mjs';
-export { CommanderApplication_alias_1 as CommanderApplication } from './_tsup-dts-rollup.mjs';
-export { CommanderFactory_alias_1 as CommanderFactory } from './_tsup-dts-rollup.mjs';
-export { Command } from './_tsup-dts-rollup.mjs';
-export { CommandOptions } from './_tsup-dts-rollup.mjs';
-export { CliModule } from './_tsup-dts-rollup.mjs';
-export { CliModuleOptions } from './_tsup-dts-rollup.mjs';
-export { Module } from './_tsup-dts-rollup.mjs';
-export { CommandHandler } from './_tsup-dts-rollup.mjs';
-export { getCommandMetadata } from './_tsup-dts-rollup.mjs';
-export { extractCommandMetadata } from './_tsup-dts-rollup.mjs';
-export { hasCommandMetadata } from './_tsup-dts-rollup.mjs';
-export { CommandMetadataKey } from './_tsup-dts-rollup.mjs';
-export { CommandMetadata } from './_tsup-dts-rollup.mjs';
-export { getCliModuleMetadata } from './_tsup-dts-rollup.mjs';
-export { extractCliModuleMetadata } from './_tsup-dts-rollup.mjs';
-export { hasCliModuleMetadata } from './_tsup-dts-rollup.mjs';
-export { CliModuleMetadataKey } from './_tsup-dts-rollup.mjs';
-export { CliModuleMetadata } from './_tsup-dts-rollup.mjs';
-export { CommandWithMetadata } from './_tsup-dts-rollup.mjs';
-export { ModuleLoaderService } from './_tsup-dts-rollup.mjs';
-export { ParsedCliArgs } from './_tsup-dts-rollup.mjs';
-export { CliParserService } from './_tsup-dts-rollup.mjs';
+import { ClassType, ClassTypeWithInstance, Container, InjectionToken, NaviosModule } from "@navios/core";
+import { ZodObject } from "zod";
+export * from "@navios/core";
+
+//#region src/commander.application.d.mts
+
+/**
+ * Configuration options for CommanderApplication.
+ *
+ * @public
+ */
+interface CommanderApplicationOptions {}
+/**
+ * Main application class for managing CLI command execution.
+ *
+ * This class handles module loading, command registration, and command execution.
+ * It provides both programmatic and CLI-based command execution capabilities.
+ *
+ * @example
+ * ```typescript
+ * const app = await CommanderFactory.create(AppModule)
+ * await app.init()
+ * await app.run(process.argv)
+ * ```
+ */
+declare class CommanderApplication {
+  private moduleLoader;
+  private cliParser;
+  protected container: Container;
+  private appModule;
+  private options;
+  /**
+   * Indicates whether the application has been initialized.
+   * Set to `true` after `init()` is called successfully.
+   */
+  isInitialized: boolean;
+  /**
+   * @internal
+   * Sets up the application with the provided module and options.
+   * This is called automatically by CommanderFactory.create().
+   */
+  setup(appModule: ClassTypeWithInstance<NaviosModule>, options?: CommanderApplicationOptions): Promise<void>;
+  /**
+   * Gets the dependency injection container used by this application.
+   *
+   * @returns The Container instance
+   *
+   * @example
+   * ```typescript
+   * const container = app.getContainer()
+   * const service = await container.get(MyService)
+   * ```
+   */
+  getContainer(): Container;
+  /**
+   * Initializes the application by loading all modules and registering commands.
+   *
+   * This method must be called before executing commands or running the CLI.
+   * It traverses the module tree, loads all imported modules, and collects command metadata.
+   *
+   * @throws {Error} If the app module is not set (setup() was not called)
+   *
+   * @example
+   * ```typescript
+   * const app = await CommanderFactory.create(AppModule)
+   * await app.init() // Must be called before run() or executeCommand()
+   * ```
+   */
+  init(): Promise<void>;
+  /**
+   * Executes a command programmatically with the provided options.
+   *
+   * This method is useful for testing, automation, or programmatic workflows.
+   * The options will be validated against the command's Zod schema if one is provided.
+   *
+   * @param commandPath - The command path (e.g., 'greet', 'user:create')
+   * @param options - The command options object (will be validated if schema exists)
+   * @throws {Error} If the application is not initialized
+   * @throws {Error} If the command is not found
+   * @throws {Error} If the command does not implement the execute method
+   * @throws {ZodError} If options validation fails
+   *
+   * @example
+   * ```typescript
+   * await app.executeCommand('greet', {
+   *   name: 'World',
+   *   greeting: 'Hi'
+   * })
+   * ```
+   */
+  executeCommand(commandPath: string, options?: any): Promise<void>;
+  /**
+   * Gets all registered commands with their paths and class references.
+   *
+   * @returns An array of objects containing the command path and class
+   *
+   * @example
+   * ```typescript
+   * const commands = app.getAllCommands()
+   * commands.forEach(({ path }) => {
+   *   console.log(`Available: ${path}`)
+   * })
+   * ```
+   */
+  getAllCommands(): {
+    path: string;
+    class: ClassTypeWithInstance<any>;
+  }[];
+  /**
+   * Runs the CLI application by parsing command-line arguments and executing the appropriate command.
+   *
+   * This is the main entry point for CLI usage. It parses `argv`, validates options,
+   * and executes the matching command. Supports help command (`help`, `--help`, `-h`)
+   * which displays all available commands.
+   *
+   * @param argv - Command-line arguments array (defaults to `process.argv`)
+   * @throws {Error} If the application is not initialized
+   * @throws {Error} If no command is provided
+   * @throws {Error} If the command is not found
+   * @throws {ZodError} If options validation fails
+   *
+   * @example
+   * ```typescript
+   * // Parse and execute from process.argv
+   * await app.run()
+   *
+   * // Or provide custom arguments
+   * await app.run(['node', 'cli.js', 'greet', '--name', 'World'])
+   * ```
+   */
+  run(argv?: string[]): Promise<void>;
+  /**
+   * @internal
+   * Disposes of resources used by the application.
+   */
+  dispose(): Promise<void>;
+  /**
+   * Closes the application and cleans up resources.
+   *
+   * This should be called when the application is no longer needed to free up resources.
+   *
+   * @example
+   * ```typescript
+   * await app.run(process.argv)
+   * await app.close()
+   * ```
+   */
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/commander.factory.d.mts
+/**
+ * Factory class for creating and configuring CLI applications.
+ *
+ * @example
+ * ```typescript
+ * import { CommanderFactory } from '@navios/commander'
+ * import { AppModule } from './app.module'
+ *
+ * async function bootstrap() {
+ *   const app = await CommanderFactory.create(AppModule)
+ *   await app.init()
+ *   await app.run(process.argv)
+ *   await app.close()
+ * }
+ * ```
+ */
+declare class CommanderFactory {
+  /**
+   * Creates a new CommanderApplication instance and configures it with the provided module.
+   *
+   * @param appModule - The root CLI module class that contains commands and/or imports other modules
+   * @param options - Optional configuration options for the application
+   * @returns A promise that resolves to a configured CommanderApplication instance
+   *
+   * @example
+   * ```typescript
+   * const app = await CommanderFactory.create(AppModule)
+   * await app.init()
+   * ```
+   */
+  static create(appModule: ClassTypeWithInstance<NaviosModule>, options?: CommanderApplicationOptions): Promise<CommanderApplication>;
+}
+//#endregion
+//#region src/decorators/command.decorator.d.mts
+/**
+ * Options for the `@Command` decorator.
+ *
+ * @public
+ */
+interface CommandOptions {
+  /**
+   * The command path that users will invoke from the CLI.
+   * Can be a single word (e.g., 'greet') or multi-word with colons (e.g., 'user:create', 'db:migrate').
+   */
+  path: string;
+  /**
+   * Optional Zod schema for validating command options.
+   * If provided, options will be validated and parsed according to this schema.
+   */
+  optionsSchema?: ZodObject;
+}
+/**
+ * Decorator that marks a class as a CLI command.
+ *
+ * The decorated class must implement the `CommandHandler` interface with an `execute` method.
+ * The command will be automatically registered when its module is loaded.
+ *
+ * @param options - Configuration options for the command
+ * @returns A class decorator function
+ *
+ * @example
+ * ```typescript
+ * import { Command, CommandHandler } from '@navios/commander'
+ * import { z } from 'zod'
+ *
+ * const optionsSchema = z.object({
+ *   name: z.string(),
+ *   greeting: z.string().optional().default('Hello')
+ * })
+ *
+ * @Command({
+ *   path: 'greet',
+ *   optionsSchema: optionsSchema
+ * })
+ * export class GreetCommand implements CommandHandler<z.infer<typeof optionsSchema>> {
+ *   async execute(options) {
+ *     console.log(`${options.greeting}, ${options.name}!`)
+ *   }
+ * }
+ * ```
+ */
+declare function Command({
+  path,
+  optionsSchema
+}: CommandOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+//#endregion
+//#region src/decorators/cli-module.decorator.d.mts
+/**
+ * Options for the `@CliModule` decorator.
+ *
+ * @public
+ */
+interface CliModuleOptions {
+  /**
+   * Array or Set of command classes to register in this module.
+   * Commands must be decorated with `@Command`.
+   */
+  commands?: ClassType[] | Set<ClassType>;
+  /**
+   * Array or Set of other CLI modules to import.
+   * Imported modules' commands will be available in this module.
+   */
+  imports?: ClassType[] | Set<ClassType>;
+}
+/**
+ * Decorator that marks a class as a CLI module.
+ *
+ * Modules organize commands and can import other modules to compose larger CLI applications.
+ * The module can optionally implement `NaviosModule` interface for lifecycle hooks.
+ *
+ * @param options - Configuration options for the module
+ * @returns A class decorator function
+ *
+ * @example
+ * ```typescript
+ * import { CliModule } from '@navios/commander'
+ * import { GreetCommand } from './greet.command'
+ * import { UserModule } from './user.module'
+ *
+ * @CliModule({
+ *   commands: [GreetCommand],
+ *   imports: [UserModule]
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare function CliModule({
+  commands,
+  imports
+}?: CliModuleOptions): (target: ClassType, context: ClassDecoratorContext) => ClassType;
+//#endregion
+//#region src/interfaces/command-handler.interface.d.mts
+/**
+ * Interface that all command classes must implement.
+ *
+ * Commands decorated with `@Command` must implement this interface.
+ * The `execute` method is called when the command is invoked.
+ *
+ * @template TOptions - The type of options that the command accepts
+ *
+ * @example
+ * ```typescript
+ * import { Command, CommandHandler } from '@navios/commander'
+ * import { z } from 'zod'
+ *
+ * const optionsSchema = z.object({
+ *   name: z.string()
+ * })
+ *
+ * type Options = z.infer<typeof optionsSchema>
+ *
+ * @Command({ path: 'greet', optionsSchema })
+ * export class GreetCommand implements CommandHandler<Options> {
+ *   async execute(options: Options) {
+ *     console.log(`Hello, ${options.name}!`)
+ *   }
+ * }
+ * ```
+ */
+interface CommandHandler<TOptions = any> {
+  /**
+   * Executes the command with the provided options.
+   *
+   * @param options - The validated command options (validated against the command's schema if provided)
+   * @returns A promise or void
+   */
+  execute(options: TOptions): void | Promise<void>;
+}
+//#endregion
+//#region src/metadata/command.metadata.d.mts
+/**
+ * @internal
+ * Symbol key used to store command metadata on classes.
+ */
+declare const CommandMetadataKey: unique symbol;
+/**
+ * Metadata associated with a command.
+ *
+ * @public
+ */
+interface CommandMetadata {
+  /**
+   * The command path (e.g., 'greet', 'user:create').
+   */
+  path: string;
+  /**
+   * Optional Zod schema for validating command options.
+   */
+  optionsSchema?: ZodObject;
+  /**
+   * Map of custom attributes that can be attached to the command.
+   */
+  customAttributes: Map<string | symbol, any>;
+}
+/**
+ * Gets or creates command metadata for a class.
+ *
+ * @internal
+ * @param target - The command class
+ * @param context - The decorator context
+ * @param path - The command path
+ * @param optionsSchema - Optional Zod schema
+ * @returns The command metadata
+ */
+declare function getCommandMetadata(target: ClassType, context: ClassDecoratorContext, path: string, optionsSchema?: ZodObject): CommandMetadata;
+/**
+ * Extracts command metadata from a class.
+ *
+ * @param target - The command class
+ * @returns The command metadata
+ * @throws {Error} If the class is not decorated with @Command
+ *
+ * @example
+ * ```typescript
+ * const metadata = extractCommandMetadata(GreetCommand)
+ * console.log(metadata.path) // 'greet'
+ * ```
+ */
+declare function extractCommandMetadata(target: ClassType): CommandMetadata;
+/**
+ * Checks if a class has command metadata.
+ *
+ * @param target - The class to check
+ * @returns `true` if the class is decorated with @Command, `false` otherwise
+ */
+declare function hasCommandMetadata(target: ClassType): boolean;
+//#endregion
+//#region src/interfaces/commander-execution-context.interface.d.mts
+/**
+ * Execution context for a command execution.
+ *
+ * Provides access to command metadata, path, and validated options during command execution.
+ * This context is automatically injected and available via the `CommandExecutionContext` token.
+ *
+ * @example
+ * ```typescript
+ * import { inject, Injectable } from '@navios/di'
+ * import { CommandExecutionContext } from '@navios/commander'
+ *
+ * @Injectable()
+ * class CommandLogger {
+ *   private ctx = inject(CommandExecutionContext)
+ *
+ *   log() {
+ *     console.log('Command:', this.ctx.getCommandPath())
+ *     console.log('Options:', this.ctx.getOptions())
+ *   }
+ * }
+ * ```
+ */
+declare class CommanderExecutionContext {
+  private readonly command;
+  private readonly commandPath;
+  private readonly options;
+  /**
+   * @internal
+   * Creates a new execution context.
+   */
+  constructor(command: CommandMetadata, commandPath: string, options: any);
+  /**
+   * Gets the command metadata.
+   *
+   * @returns The command metadata including path and options schema
+   */
+  getCommand(): CommandMetadata;
+  /**
+   * Gets the command path that was invoked.
+   *
+   * @returns The command path (e.g., 'greet', 'user:create')
+   */
+  getCommandPath(): string;
+  /**
+   * Gets the validated command options.
+   *
+   * Options are validated against the command's Zod schema if one was provided.
+   *
+   * @returns The validated options object
+   */
+  getOptions(): any;
+}
+//#endregion
+//#region src/metadata/cli-module.metadata.d.mts
+/**
+ * @internal
+ * Symbol key used to store CLI module metadata on classes.
+ */
+declare const CliModuleMetadataKey: unique symbol;
+/**
+ * Metadata associated with a CLI module.
+ *
+ * @public
+ */
+interface CliModuleMetadata {
+  /**
+   * Set of command classes registered in this module.
+   */
+  commands: Set<ClassType>;
+  /**
+   * Set of other modules imported by this module.
+   */
+  imports: Set<ClassType>;
+  /**
+   * Map of custom attributes that can be attached to the module.
+   */
+  customAttributes: Map<string | symbol, any>;
+}
+/**
+ * Gets or creates CLI module metadata for a class.
+ *
+ * @internal
+ * @param target - The module class
+ * @param context - The decorator context
+ * @returns The module metadata
+ */
+declare function getCliModuleMetadata(target: ClassType, context: ClassDecoratorContext): CliModuleMetadata;
+/**
+ * Extracts CLI module metadata from a class.
+ *
+ * @param target - The module class
+ * @returns The module metadata
+ * @throws {Error} If the class is not decorated with @CliModule
+ *
+ * @example
+ * ```typescript
+ * const metadata = extractCliModuleMetadata(AppModule)
+ * console.log(metadata.commands.size) // Number of commands
+ * ```
+ */
+declare function extractCliModuleMetadata(target: ClassType): CliModuleMetadata;
+/**
+ * Checks if a class has CLI module metadata.
+ *
+ * @param target - The class to check
+ * @returns `true` if the class is decorated with @CliModule, `false` otherwise
+ */
+declare function hasCliModuleMetadata(target: ClassType): boolean;
+//#endregion
+//#region src/services/module-loader.service.d.mts
+/**
+ * Command class with its associated metadata.
+ *
+ * @public
+ */
+interface CommandWithMetadata {
+  /**
+   * The command class constructor.
+   */
+  class: ClassTypeWithInstance<CommandHandler>;
+  /**
+   * The command metadata including path and options schema.
+   */
+  metadata: CommandMetadata;
+}
+/**
+ * Service for loading and managing CLI modules and commands.
+ *
+ * Handles module traversal, command registration, and metadata collection.
+ * This service is used internally by CommanderApplication.
+ *
+ * @public
+ */
+declare class CliModuleLoaderService {
+  protected container: Container;
+  private modulesMetadata;
+  private loadedModules;
+  private commandsMetadata;
+  private initialized;
+  /**
+   * Loads all modules starting from the root app module.
+   *
+   * Traverses the module tree, loads imported modules, and collects command metadata.
+   *
+   * @param appModule - The root CLI module
+   */
+  loadModules(appModule: ClassTypeWithInstance<NaviosModule>): Promise<void>;
+  private traverseModules;
+  private mergeMetadata;
+  /**
+   * Gets all loaded module metadata.
+   *
+   * @returns Map of module names to their metadata
+   */
+  getAllModules(): Map<string, CliModuleMetadata>;
+  /**
+   * Gets all command classes indexed by command class name.
+   *
+   * @returns Map of command class names to command classes
+   */
+  getAllCommands(): Map<string, ClassTypeWithInstance<any>>;
+  /**
+   * Get all commands with their metadata, indexed by command path.
+   * This is populated during loadModules, so path information is available
+   * before parsing CLI argv.
+   */
+  getAllCommandsWithMetadata(): Map<string, CommandWithMetadata>;
+  /**
+   * Get a command by its path, with metadata already extracted.
+   * Returns undefined if command is not found.
+   */
+  getCommandByPath(path: string): CommandWithMetadata | undefined;
+  /**
+   * Disposes of all loaded modules and commands, clearing internal state.
+   */
+  dispose(): void;
+}
+//#endregion
+//#region src/services/cli-parser.service.d.mts
+/**
+ * Result of parsing command-line arguments.
+ *
+ * @public
+ */
+interface ParsedCliArgs {
+  /**
+   * The command path (e.g., 'greet', 'user:create').
+   * Multi-word commands are joined with spaces.
+   */
+  command: string;
+  /**
+   * Parsed options as key-value pairs.
+   * Keys are converted from kebab-case to camelCase.
+   */
+  options: Record<string, any>;
+  /**
+   * Positional arguments that don't match any option flags.
+   */
+  positionals: string[];
+}
+/**
+ * Service for parsing command-line arguments.
+ *
+ * Handles parsing of various CLI argument formats including:
+ * - Long options: `--key value` or `--key=value`
+ * - Short options: `-k value` or `-abc` (multiple flags)
+ * - Boolean flags
+ * - Array options
+ * - Positional arguments
+ *
+ * @public
+ */
+declare class CliParserService {
+  /**
+   * Parses command-line arguments from process.argv
+   * Commands can be multi-word (e.g., 'db migrate', 'cache clear')
+   * Expected format: node script.js command [subcommand...] --flag value --boolean-flag positional1 positional2
+   *
+   * @param argv - Array of command-line arguments (typically process.argv)
+   * @param optionsSchema - Optional Zod schema to determine boolean flags and option types
+   * @returns Parsed command (space-separated if multi-word), options, and positional arguments
+   */
+  parse(argv: string[], optionsSchema?: ZodObject): ParsedCliArgs;
+  /**
+   * Converts kebab-case to camelCase
+   */
+  private camelCase;
+  /**
+   * Attempts to parse string values into appropriate types
+   */
+  private parseValue;
+  /**
+   * Extracts boolean field names from a Zod schema
+   * Handles ZodObject, ZodOptional, and ZodDefault wrappers
+   */
+  private extractBooleanFields;
+  /**
+   * Extracts array field names from a Zod schema
+   * Handles ZodObject, ZodOptional, and ZodDefault wrappers
+   */
+  private extractArrayFields;
+  /**
+   * Checks if a Zod schema represents a boolean type
+   * Unwraps ZodOptional and ZodDefault
+   */
+  private isSchemaBoolean;
+  /**
+   * Checks if a Zod schema represents an array type
+   * Unwraps ZodOptional and ZodDefault
+   */
+  private isSchemaArray;
+  /**
+   * Formats help text listing all available commands.
+   *
+   * @param commands - Array of command objects with path and class
+   * @returns Formatted string listing all commands
+   */
+  formatCommandList(commands: Array<{
+    path: string;
+    class: any;
+  }>): string;
+}
+//#endregion
+//#region src/tokens/execution-context.token.d.mts
+/**
+ * Injection token for accessing the current command execution context.
+ *
+ * Use this token with `inject()` to access the `CommanderExecutionContext` in services
+ * that need information about the currently executing command.
+ *
+ * @example
+ * ```typescript
+ * import { inject, Injectable } from '@navios/di'
+ * import { CommandExecutionContext } from '@navios/commander'
+ *
+ * @Injectable()
+ * class MyService {
+ *   private ctx = inject(CommandExecutionContext)
+ *
+ *   doSomething() {
+ *     const commandPath = this.ctx.getCommandPath()
+ *     const options = this.ctx.getOptions()
+ *     // Use context information...
+ *   }
+ * }
+ * ```
+ */
+declare const CommandExecutionContext: InjectionToken<CommanderExecutionContext, undefined, false>;
+//#endregion
+export { CliModule, CliModuleLoaderService, CliModuleMetadata, CliModuleMetadataKey, CliModuleOptions, CliParserService, Command, CommandExecutionContext, CommandHandler, CommandMetadata, CommandMetadataKey, CommandOptions, CommandWithMetadata, CommanderApplication, CommanderApplicationOptions, CommanderExecutionContext, CommanderFactory, ParsedCliArgs, extractCliModuleMetadata, extractCommandMetadata, getCliModuleMetadata, getCommandMetadata, hasCliModuleMetadata, hasCommandMetadata };
+//# sourceMappingURL=index.d.mts.map