politty 0.8.0 → 0.9.1

package/dist/index.d.cts

@@ -1,685 +0,0 @@
-import { $ as toKebabCase, A as LogStream, B as SetupContext, C as Example, D as IsEmpty, E as GlobalSetupContext, F as RunCommandOptions, G as isLazyCommand, H as SubCommandsRecord, I as RunResult, J as ResolvedFieldMeta, K as lazy, L as RunResultFailure, M as MainOptions, N as NonRunnableCommand, O as LogEntry, P as PromptResolver, Q as toCamelCase, R as RunResultSuccess, S as CommandBase, T as GlobalCleanupContext, U as UnknownSubcommandHandler, V as SubCommandValue, W as LazyCommand, X as extractFields, Y as UnknownKeysMode, Z as getUnknownKeysMode, _ as AnyCommand, a as EffectContext, b as CollectedLogs, c as arg, d as ResolvedExpandCandidate, f as CompletionDirectiveMask, g as DynamicCompletionResult, h as DynamicCompletionResolver, i as CustomCompletion, j as Logger, k as LogLevel, l as ExpandCandidate, m as DynamicCompletionContext, n as CompletionMeta, o as PromptMeta, p as DynamicCompletionCandidate, q as ExtractedFields, r as CompletionType, s as PromptType, t as ArgMeta, u as ExpandCompletion, v as ArgsSchema, w as GlobalArgs, x as Command, y as CleanupContext, z as RunnableCommand } from "./arg-registry-DDJpsUea.cjs";
-import { I as CompletionOptions, L as CompletionResult, c as withCompletionCommand, d as GenerateBundledCompletionWorkerOptions, f as GenerateBundledCompletionWorkerResult, h as generateBundledCompletionWorker, o as generateCompletion, t as WithCompletionOptions } from "./index-WyViqW59.cjs";
-import { z } from "zod";
-
-//#region src/core/case-types.d.ts
-/**
- * TypeScript utility types for case conversion between camelCase and kebab-case.
- *
- * These types enable dual-case access on CLI args objects,
- * so that both `args.myOption` and `args["my-option"]` are valid.
- */
-/**
- * Convert a kebab-case string to camelCase at the type level.
- *
- * @example
- * type R = CamelCase<"my-option">; // "myOption"
- * type R2 = CamelCase<"already">; // "already"
- */
-type CamelCase<S extends string> = S extends `${infer P}-${infer C}${infer R}` ? `${P}${Uppercase<C>}${CamelCase<R>}` : S;
-/**
- * Internal helper: insert hyphens before uppercase-to-lowercase transitions.
- * Matches the runtime `toKebabCase()` behavior:
- * - `([a-z])([A-Z])` → insert hyphen (e.g. "myOption" → "my-Option")
- * - `([A-Z]+)([A-Z][a-z])` → insert hyphen before last capital in a run
- *   (e.g. "XMLParser" → "XML-Parser" → "xml-parser")
- *
- * Note: TypeScript template literal types have limited ability to match
- * multi-character uppercase runs precisely. This implementation handles
- * common CLI naming patterns (camelCase, PascalCase). For exotic acronym
- * patterns (e.g. "XMLParser"), the type-level result may differ slightly
- * from the runtime result. Dual-case proxy handles runtime resolution.
- */
-type KebabCaseInner<S extends string> = S extends `${infer First}${infer Rest}` ? Rest extends "" ? First extends Lowercase<First> ? First : `-${Lowercase<First>}` : First extends Lowercase<First> ? `${First}${KebabCaseInner<Rest>}` : Rest extends `${infer Next}${infer Tail}` ? Next extends Lowercase<Next> ? `-${Lowercase<First>}${Next}${KebabCaseInner<Tail>}` : `${Lowercase<First>}${KebabCaseInner<Rest>}` : `-${Lowercase<First>}` : S;
-/**
- * Strip a leading hyphen (produced when the first char is uppercase).
- */
-type StripLeadingHyphen<S extends string> = S extends `-${infer R}` ? R : S;
-/**
- * Convert a camelCase string to kebab-case at the type level.
- * Aligned with the runtime `toKebabCase()` function in schema-extractor.ts.
- *
- * @example
- * type R = KebabCase<"myOption">; // "my-option"
- * type R2 = KebabCase<"already">; // "already"
- */
-type KebabCase<S extends string> = StripLeadingHyphen<KebabCaseInner<S>>;
-/**
- * Add both camelCase and kebab-case variants for every key in T.
- *
- * Given `{ "my-option": string }`, produces
- * `{ "my-option": string } & { myOption: string }`.
- *
- * Given `{ myOption: string }`, produces
- * `{ myOption: string } & { "my-option": string }`.
- *
- * Keys that are identical in both cases (e.g. single-word keys) are not duplicated.
- * Uses a distributive conditional type so it works correctly with discriminated unions.
- */
-type WithCaseVariants<T> = T extends unknown ? T & { [K in keyof T as CamelCase<K & string>]: T[K] } & { [K in keyof T as KebabCase<K & string>]: T[K] } : never;
-//#endregion
-//#region src/core/case-proxy.d.ts
-/**
- * Wrap an args object with a Proxy that allows dual-case access.
- *
- * Given `{ "my-option": "value" }`, both `obj["my-option"]` and `obj.myOption`
- * will return `"value"`.
- *
- * - `Object.keys()`, `JSON.stringify()`, and spread return only the original keys.
- * - The `in` operator detects both case variants.
- */
-declare function createDualCaseProxy<T extends Record<string, unknown>>(obj: T): WithCaseVariants<T>;
-//#endregion
-//#region src/core/command.d.ts
-/**
- * Infer args type from schema, defaults to empty object if undefined.
- * Wraps with WithCaseVariants so both camelCase and kebab-case access is typed.
- */
-type InferArgs<TArgsSchema> = TArgsSchema extends z.ZodType ? WithCaseVariants<z.infer<TArgsSchema>> : Record<string, never>;
-/**
- * Merge local args with global args.
- * No-op when TGlobalArgs is empty (default GlobalArgs not extended).
- * Wraps TGlobalArgs with WithCaseVariants for dual-case access.
- */
-type MergedArgs<TLocalArgs, TGlobalArgs> = IsEmpty<TGlobalArgs> extends true ? TLocalArgs : TLocalArgs & WithCaseVariants<TGlobalArgs>;
-/**
- * Resolve merged args from schema and global args type
- */
-type ResolvedArgs<TArgsSchema, TGlobalArgs> = MergedArgs<InferArgs<TArgsSchema>, TGlobalArgs>;
-/**
- * Config for defining a command
- * @template TArgsSchema - The Zod schema type for arguments
- * @template TResult - The return type of run function (void if no run)
- * @template TGlobalArgs - Global args type (from declaration merging or factory)
- */
-interface DefineCommandConfig<TArgsSchema extends ArgsSchema | undefined, TResult, TGlobalArgs> {
-  name: string;
-  description?: string;
-  aliases?: string[];
-  args?: TArgsSchema;
-  subCommands?: SubCommandsRecord;
-  setup?: (context: {
-    args: ResolvedArgs<TArgsSchema, TGlobalArgs>;
-  }) => void | Promise<void>;
-  run?: (args: ResolvedArgs<TArgsSchema, TGlobalArgs>) => TResult;
-  cleanup?: (context: {
-    args: ResolvedArgs<TArgsSchema, TGlobalArgs>;
-    error?: Error | undefined;
-  }) => void | Promise<void>;
-  notes?: string;
-  examples?: Example[];
-}
-/**
- * Config with run function (runnable command)
- */
-interface RunnableConfig<TArgsSchema extends ArgsSchema | undefined, TResult, TGlobalArgs> extends DefineCommandConfig<TArgsSchema, TResult, TGlobalArgs> {
-  run: (args: ResolvedArgs<TArgsSchema, TGlobalArgs>) => TResult;
-}
-/**
- * Config without run function (non-runnable command)
- */
-interface NonRunnableConfig<TArgsSchema extends ArgsSchema | undefined, TGlobalArgs> extends Omit<DefineCommandConfig<TArgsSchema, void, TGlobalArgs>, "run"> {
-  run?: undefined;
-}
-/**
- * Define a CLI command with type-safe arguments
- *
- * @param config - Command configuration
- * @returns A defined command with preserved type information
- *
- * @example
- * ```ts
- * import { z } from "zod";
- * import { arg, defineCommand } from "politty";
- *
- * const command = defineCommand({
- *   name: "greet",
- *   args: z.object({
- *     name: arg(z.string(), { description: "Name to greet", positional: true }),
- *     loud: arg(z.boolean().default(false), { alias: "l", description: "Use uppercase" }),
- *   }),
- *   run: (args) => {
- *     const greeting = `Hello, ${args.name}!`;
- *     console.log(args.loud ? greeting.toUpperCase() : greeting);
- *   },
- * });
- *
- * // Type of command.argsSchema is preserved as z.ZodObject<...>
- * // Type of command.run is (args: { name: string; loud: boolean }) => void
- * ```
- *
- * @example
- * ```ts
- * // With discriminated union for subcommand-like behavior
- * const command = defineCommand({
- *   name: "resource",
- *   args: z.discriminatedUnion("action", [
- *     z.object({
- *       action: z.literal("create"),
- *       name: arg(z.string(), { description: "Resource name" }),
- *     }),
- *     z.object({
- *       action: z.literal("delete"),
- *       id: arg(z.coerce.number(), { description: "Resource ID" }),
- *     }),
- *   ]),
- *   run: (args) => {
- *     if (args.action === "create") {
- *       console.log(`Creating ${args.name}`);
- *     } else {
- *       console.log(`Deleting ${args.id}`);
- *     }
- *   },
- * });
- * ```
- */
-declare function defineCommand<TArgsSchema extends ArgsSchema | undefined = undefined, TResult = void, TGlobalArgs = GlobalArgs>(config: RunnableConfig<TArgsSchema, TResult, TGlobalArgs>): RunnableCommand<TArgsSchema, ResolvedArgs<TArgsSchema, TGlobalArgs>, TResult>;
-declare function defineCommand<TArgsSchema extends ArgsSchema | undefined = undefined, TGlobalArgs = GlobalArgs>(config: NonRunnableConfig<TArgsSchema, TGlobalArgs>): NonRunnableCommand<TArgsSchema, ResolvedArgs<TArgsSchema, TGlobalArgs>>;
-/**
- * Create a typed defineCommand factory with pre-bound global args type.
- * This is the recommended pattern for type-safe global options.
- *
- * @example
- * ```ts
- * // global-args.ts
- * type GlobalArgsType = { verbose: boolean; config?: string };
- * export const defineAppCommand = createDefineCommand<GlobalArgsType>();
- *
- * // commands/build.ts
- * export const buildCommand = defineAppCommand({
- *   name: "build",
- *   args: z.object({ output: arg(z.string().default("dist")) }),
- *   run: (args) => {
- *     args.verbose; // typed via GlobalArgsType
- *     args.output;  // typed via local args
- *   },
- * });
- * ```
- */
-declare function createDefineCommand<TGlobalArgs>(): {
-  <TArgsSchema extends ArgsSchema | undefined = undefined, TResult = void>(config: RunnableConfig<TArgsSchema, TResult, TGlobalArgs>): RunnableCommand<TArgsSchema, ResolvedArgs<TArgsSchema, TGlobalArgs>, TResult>;
-  <TArgsSchema extends ArgsSchema | undefined = undefined>(config: NonRunnableConfig<TArgsSchema, TGlobalArgs>): NonRunnableCommand<TArgsSchema, ResolvedArgs<TArgsSchema, TGlobalArgs>>;
-};
-//#endregion
-//#region src/core/runner.d.ts
-/**
- * Run a command with the given arguments (programmatic/test usage)
- *
- * This function parses arguments, validates them, routes to subcommands,
- * and executes the command. It does NOT call process.exit.
- *
- * @param command - The command to run
- * @param argv - Command line arguments to parse
- * @param options - Run options
- * @returns The result of command execution
- *
- * @example
- * ```ts
- * import { defineCommand, runCommand } from "politty";
- *
- * const command = defineCommand({
- *   name: "my-cli",
- *   args: z.object({ name: z.string() }),
- *   run: ({ name }) => console.log(`Hello, ${name}!`),
- * });
- *
- * // In tests
- * const result = await runCommand(command, ["--name", "World"]);
- * expect(result.exitCode).toBe(0);
- * ```
- */
-declare function runCommand<TResult = unknown>(command: AnyCommand, argv: string[], options?: RunCommandOptions): Promise<RunResult<TResult>>;
-/**
- * Run a CLI command as the main entry point
- *
- * This function:
- * - Uses process.argv for arguments
- * - Handles SIGINT/SIGTERM signals
- * - Calls process.exit with the appropriate exit code
- * - Invokes `command.runMainHook` once before parsing if set, so plug-ins
- *   like `withCompletionCommand` can fire detached background work
- * - Bypasses user `setup`/`cleanup`/`prompt` and required `globalArgs`
- *   for registered hidden subcommands whose name starts with `__`
- *   (e.g. `__refresh-completion`)
- *
- * @param command - The command to run
- * @param options - Main options (version, debug)
- *
- * @example
- * ```ts
- * import { defineCommand, runMain } from "politty";
- *
- * const command = defineCommand({
- *   name: "my-cli",
- *   run: () => console.log("Hello!"),
- * });
- *
- * runMain(command, { version: "1.0.0" });
- * ```
- */
-declare function runMain(command: AnyCommand, options?: MainOptions): Promise<never>;
-//#endregion
-//#region src/output/help-generator.d.ts
-/**
- * Descriptions for built-in options
- */
-interface BuiltinOptionDescriptions {
-  /** Description for --help option */
-  help?: string;
-  /** Description for --help-all option */
-  helpAll?: string;
-  /** Description for --version option */
-  version?: string;
-}
-/**
- * Context for command hierarchy
- */
-interface CommandContext {
-  /** Full command path (e.g., ["config", "get"]) */
-  commandPath?: string[] | undefined;
-  /** Root command name */
-  rootName?: string | undefined;
-  /** Root command version */
-  rootVersion?: string | undefined;
-  /** Extracted fields from global args schema */
-  globalExtracted?: ExtractedFields | undefined;
-  /** When the command was accessed via an alias, the canonical command name */
-  aliasFor?: string | undefined;
-}
-/**
- * Options for help generation
- */
-interface HelpOptions {
-  /** Show subcommand list */
-  showSubcommands?: boolean | undefined;
-  /** Show subcommand options */
-  showSubcommandOptions?: boolean | undefined;
-  /** Custom descriptions for built-in options */
-  descriptions?: BuiltinOptionDescriptions | undefined;
-  /** Command hierarchy context */
-  context?: CommandContext | undefined;
-}
-/**
- * Generate help text for a command
- *
- * @param command - The command to generate help for
- * @param options - Help generation options
- * @returns Formatted help text
- */
-declare function generateHelp(command: AnyCommand, options: HelpOptions): string;
-//#endregion
-//#region src/output/logger.d.ts
-/**
- * Enable or disable color output programmatically
- */
-declare function setColorEnabled(enabled: boolean): void;
-/**
- * Check if color output is currently enabled
- */
-declare function isColorEnabled(): boolean;
-/**
- * Semantic style functions for inline text styling
- */
-declare const styles: {
-  success: (text: string) => string;
-  error: (text: string) => string;
-  warning: (text: string) => string;
-  info: (text: string) => string;
-  bold: (text: string) => string;
-  dim: (text: string) => string;
-  italic: (text: string) => string;
-  underline: (text: string) => string;
-  red: (text: string) => string;
-  green: (text: string) => string;
-  yellow: (text: string) => string;
-  blue: (text: string) => string;
-  magenta: (text: string) => string;
-  cyan: (text: string) => string;
-  white: (text: string) => string;
-  gray: (text: string) => string;
-  command: (text: string) => string;
-  commandName: (text: string) => string;
-  option: (text: string) => string;
-  optionName: (text: string) => string;
-  placeholder: (text: string) => string;
-  defaultValue: (text: string) => string;
-  required: (text: string) => string;
-  description: (text: string) => string;
-  sectionHeader: (text: string) => string;
-  version: (text: string) => string;
-};
-/**
- * Standardized symbols for CLI output
- */
-declare const symbols: {
-  success: string;
-  error: string;
-  warning: string;
-  info: string;
-  bullet: string;
-  arrow: string;
-};
-/**
- * Logger for CLI output
- */
-declare const logger: {
-  /**
-   * Log informational message
-   */
-  info(message: string): void;
-  /**
-   * Log success message
-   */
-  success(message: string): void;
-  /**
-   * Log warning message
-   */
-  warn(message: string): void;
-  /**
-   * Log error message
-   */
-  error(message: string): void;
-  /**
-   * Log raw message without prefix
-   */
-  log(message: string): void;
-  /**
-   * Log empty line
-   */
-  newline(): void;
-  /**
-   * Log debug message with dim color
-   */
-  debug(message: string): void;
-};
-//#endregion
-//#region src/output/markdown-renderer.d.ts
-/**
- * Lightweight Markdown-to-terminal renderer.
- *
- * Supports a subset of Markdown tailored for CLI help notes:
- * - Inline: bold, italic, inline code, links
- * - Block: paragraphs, unordered/ordered lists, blockquotes, headings,
- *          horizontal rules, fenced code blocks
- */
-/**
- * Apply inline Markdown formatting to a string.
- *
- * Processing order matters to avoid conflicts:
- *   1. Inline code (backticks) — content inside is literal, no further processing
- *   2. Bold (**text**)
- *   3. Italic (*text* or _text_)
- *   4. Links [text](url)
- */
-declare function renderInline(text: string): string;
-/**
- * Render a Markdown string to styled terminal output.
- *
- * Block-level processing:
- *   - Splits input into blocks separated by blank lines
- *   - Detects headings, horizontal rules, blockquotes, lists, code blocks, and paragraphs
- *   - Applies inline formatting within each block
- */
-declare function renderMarkdown(markdown: string): string;
-//#endregion
-//#region src/parser/argv-parser.d.ts
-/**
- * Parsed arguments result
- */
-interface ParsedArgv {
-  /** Named options (--flag, -f) */
-  options: Record<string, unknown>;
-  /** Positional arguments */
-  positionals: string[];
-  /** Arguments after -- */
-  rest: string[];
-}
-/**
- * Parser options
- */
-interface ParserOptions {
-  /** Alias map (short -> long) */
-  aliasMap?: Map<string, string>;
-  /** Boolean flags (no value expected) */
-  booleanFlags?: Set<string>;
-  /** Array flags (can be repeated) */
-  arrayFlags?: Set<string>;
-  /**
-   * All known canonical option names (as defined in the schema).
-   * Used to disambiguate negation: when `--no-flag` or `--noFlag` matches
-   * a name in this set, it is treated as a regular option rather than
-   * boolean negation of `flag`.
-   */
-  definedNames?: Set<string>;
-  /**
-   * Map from a custom negation CLI name (and camelCase variant) to the
-   * canonical field name. Used to recognize user-defined boolean negation
-   * options (e.g. `--disable-cache` → `{ cache: false }`).
-   */
-  negationMap?: Map<string, string>;
-  /**
-   * Canonical field names that have a custom `negation` configured.
-   * For these fields the default `--no-<name>` / `--no<Name>` negation
-   * forms are suppressed.
-   */
-  customNegatedFields?: Set<string>;
-}
-/**
- * Parse argv into a flat record
- *
- * Supports:
- * - Long options: --flag, --flag=value, --flag value
- * - Short options: -f, -f=value, -f value
- * - Combined short options: -abc (treated as -a -b -c if all are boolean)
- * - Positional arguments
- * - -- to stop parsing options
- * - Boolean negation: --no-flag, --noFlag (requires `booleanFlags`)
- *
- * **Note:** When using negation detection (`--noFlag` / `--no-flag`),
- * supply `definedNames` so that options whose names happen to start with
- * "no" (e.g. `noDryRun`) are not mistaken for negation of another flag.
- * Without `definedNames`, all `--noX` forms matching a boolean flag will
- * be treated as negation.
- *
- * @param argv - Command line arguments
- * @param options - Parser options
- * @returns Parsed arguments
- */
-declare function parseArgv(argv: string[], options?: ParserOptions): ParsedArgv;
-//#endregion
-//#region src/validator/validation-errors.d.ts
-/**
- * Error thrown when positional argument configuration is invalid
- */
-declare class PositionalConfigError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when a reserved alias is used
- */
-declare class ReservedAliasError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when duplicate field names are detected
- */
-declare class DuplicateFieldError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when duplicate aliases are detected
- */
-declare class DuplicateAliasError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when fields are case variants of each other (e.g. "my-option" and "myOption")
- */
-declare class CaseVariantCollisionError extends Error {
-  constructor(message: string);
-}
-/**
- * Error thrown when a custom boolean negation name collides with another
- * field's name, cliName, alias, or another field's negation (including
- * derived camelCase variants).
- */
-declare class DuplicateNegationError extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region src/validator/command-validator.d.ts
-/**
- * Error detail for command validation
- */
-interface CommandValidationError {
-  /** Path to the command (e.g., ["cli", "build", "watch"]) */
-  commandPath: string[];
-  /** Error type */
-  type: "duplicate_field" | "duplicate_alias" | "invalid_alias" | "positional_config" | "reserved_alias" | "case_variant_collision" | "duplicate_negation";
-  /** Error message */
-  message: string;
-  /** Related field name (if applicable) */
-  field?: string;
-}
-/**
- * Result of command validation
- */
-type CommandValidationResult = {
-  valid: true;
-} | {
-  valid: false;
-  errors: CommandValidationError[];
-};
-/**
- * Options for validateCommand
- */
-interface ValidateCommandOptions {
-  /** Starting command path (for nested validation) */
-  commandPath?: string[];
-}
-/**
- * Validate that no duplicate field names exist
- *
- * @param extracted - Extracted fields from schema
- * @throws {DuplicateFieldError} If duplicate field names are found
- */
-declare function validateDuplicateFields(extracted: ExtractedFields): void;
-/**
- * Validate that no duplicate aliases exist
- *
- * Also checks for conflicts between aliases and field names
- *
- * @param extracted - Extracted fields from schema
- * @throws {DuplicateAliasError} If duplicate aliases are found or alias conflicts with field name
- */
-declare function validateDuplicateAliases(extracted: ExtractedFields): void;
-/**
- * Validate positional argument configuration
- *
- * Rules:
- * - Array positional arguments must be the last positional
- * - No positional arguments can follow an array positional
- * - Required positional arguments cannot follow optional positional arguments
- * - Array positional and optional positional cannot be used together (ambiguous parsing)
- *
- * @param extracted - Extracted fields from schema
- * @throws {PositionalConfigError} If configuration is invalid
- */
-declare function validatePositionalConfig(extracted: ExtractedFields): void;
-/**
- * Validate that no reserved aliases are used without explicit override
- *
- * Reserved aliases:
- * - 'h' is reserved for --help
- * - 'H' is reserved for --help-all
- *
- * Users can override these by setting overrideBuiltinAlias: true
- *
- * @param extracted - Extracted fields from schema
- * @param _hasSubCommands - Whether the command has subcommands (reserved for future use)
- * @throws {ReservedAliasError} If a reserved alias is used without override flag
- */
-declare function validateReservedAliases(extracted: ExtractedFields, _hasSubCommands: boolean): void;
-/**
- * Validate that custom boolean negation names do not collide with anything
- *
- * @param extracted - Extracted fields from schema
- * @throws {DuplicateNegationError} If a colliding negation is found
- */
-declare function validateDuplicateNegations(extracted: ExtractedFields): void;
-/**
- * Validate that no case-variant collisions exist
- *
- * @param extracted - Extracted fields from schema
- * @throws {CaseVariantCollisionError} If case-variant collisions are found
- */
-declare function validateCaseVariantCollisions(extracted: ExtractedFields): void;
-/**
- * Validate that no case-variant collisions exist between two schemas
- * (e.g., global args and command args).
- *
- * @param extractedA - Extracted fields from first schema (e.g., global args)
- * @param extractedB - Extracted fields from second schema (e.g., command args)
- * @throws {CaseVariantCollisionError} If cross-schema case-variant collisions are found
- */
-declare function validateCrossSchemaCollisions(extractedA: ExtractedFields, extractedB: ExtractedFields): void;
-/**
- * Validate a command and all its subcommands recursively
- *
- * This function collects all validation errors without throwing,
- * making it suitable for test assertions.
- *
- * @param command - The command to validate
- * @param options - Validation options
- * @returns Validation result with all errors collected
- *
- * @example
- * ```ts
- * const result = await validateCommand(myCommand);
- * if (!result.valid) {
- *   console.error(result.errors);
- * }
- * ```
- */
-declare function validateCommand(command: AnyCommand, options?: ValidateCommandOptions): Promise<CommandValidationResult>;
-/**
- * Format command validation errors for display
- *
- * @param errors - Array of validation errors
- * @returns Formatted error message
- */
-declare function formatCommandValidationErrors(errors: CommandValidationError[]): string;
-//#endregion
-//#region src/validator/zod-validator.d.ts
-/**
- * Validation error details
- */
-interface ValidationError {
-  /** Path to the invalid field */
-  path: string[];
-  /** Error message */
-  message: string;
-  /** Zod error code */
-  code: string;
-  /** Value that was received */
-  received?: unknown | undefined;
-  /** Expected type or value */
-  expected?: string | undefined;
-}
-/**
- * Validation result
- */
-type ValidationResult<T> = {
-  success: true;
-  data: T;
-} | {
-  success: false;
-  errors: ValidationError[];
-};
-/**
- * Format validation errors for display
- */
-declare function formatValidationErrors(errors: ValidationError[]): string;
-//#endregion
-export { type AnyCommand, type ArgMeta, type ArgsSchema, type BuiltinOptionDescriptions, type CamelCase, CaseVariantCollisionError, type CleanupContext, type CollectedLogs, type Command, type CommandBase, type CommandContext, type CommandValidationError, type CommandValidationResult, type CompletionDirectiveMask, type CompletionMeta, type CompletionOptions, type CompletionResult, type CompletionType, type CustomCompletion, DuplicateAliasError, DuplicateFieldError, DuplicateNegationError, type DynamicCompletionCandidate, type DynamicCompletionContext, type DynamicCompletionResolver, type DynamicCompletionResult, type EffectContext, type Example, type ExpandCandidate, type ExpandCompletion, type ExtractedFields, type GenerateBundledCompletionWorkerOptions, type GenerateBundledCompletionWorkerResult, type GlobalArgs, type GlobalCleanupContext, type GlobalSetupContext, type HelpOptions, type KebabCase, type LazyCommand, type LogEntry, type LogLevel, type LogStream, type Logger, type MainOptions, type MergedArgs, type NonRunnableCommand, type ParsedArgv, type ParserOptions, PositionalConfigError, type PromptMeta, type PromptResolver, type PromptType, ReservedAliasError, type ResolvedExpandCandidate, type ResolvedFieldMeta, type RunCommandOptions, type RunResult, type RunResultFailure, type RunResultSuccess, type RunnableCommand, type SetupContext, type SubCommandValue, type SubCommandsRecord, type UnknownKeysMode, type UnknownSubcommandHandler, type ValidationError, type ValidationResult, type WithCaseVariants, type WithCompletionOptions, arg, createDefineCommand, createDualCaseProxy, defineCommand, extractFields, formatCommandValidationErrors, formatValidationErrors, generateBundledCompletionWorker, generateCompletion, generateHelp, getUnknownKeysMode, isColorEnabled, isLazyCommand, lazy, logger, parseArgv, renderInline, renderMarkdown, runCommand, runMain, setColorEnabled, styles, symbols, toCamelCase, toKebabCase, validateCaseVariantCollisions, validateCommand, validateCrossSchemaCollisions, validateDuplicateAliases, validateDuplicateFields, validateDuplicateNegations, validatePositionalConfig, validateReservedAliases, withCompletionCommand };
-//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/core/case-types.ts","../src/core/case-proxy.ts","../src/core/command.ts","../src/core/runner.ts","../src/output/help-generator.ts","../src/output/logger.ts","../src/output/markdown-renderer.ts","../src/parser/argv-parser.ts","../src/validator/validation-errors.ts","../src/validator/command-validator.ts","../src/validator/zod-validator.ts"],"mappings":"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"}