padrone 1.9.0 → 2.0.0

package/dist/index.d.mts

@@ -1,902 +1,38 @@
-import { a as ColorConfig, i as AnsiStyle, n as HelpFormat, o as ColorTheme, r as HelpInfo, s as colorThemes, t as HelpDetail } from "./formatter-CY3KrOEd.mjs";
-import { $ as PadroneLogger, A as InterceptorParseResult, B as RegisteredInterceptor, C as InterceptorErrorContext, Ct as PadroneSpinnerPreset, D as InterceptorFactory, E as InterceptorExecuteResult, F as InterceptorValidateContext, G as OtelSpan, H as WrapResult, I as InterceptorValidateResult, J as PadroneTracer, K as OtelTracer, L as PadroneContextInterceptor, M as InterceptorRouteContext, N as InterceptorShutdownContext, O as InterceptorMeta, P as InterceptorStartContext, Q as PadroneLogLevel, R as PadroneInterceptor, S as InterceptorDefBuilder, St as PadroneSpinnerConfig, T as InterceptorExecuteContext, U as PadroneServePreferences, V as WrapConfig, W as PadroneMcpPreferences, X as WithTracing, Y as PadroneTracingConfig, Z as padroneTracing, _ as PadroneCommand, _t as PadroneProgressOptions, a as DefineCommandContext, at as PossibleCommands, b as ExtractInterceptorRequires, bt as PadroneRuntime, c as PadroneProgram, ct as WithInterceptor, d as PadroneParseResult, dt as InteractiveMode, et as PadroneLoggerConfig, f as PadroneReplPreferences, ft as InteractivePromptConfig, g as PadroneActionContext, gt as PadroneProgress, h as GetArgsMeta, ht as PadroneBarConfig, i as DefineCommandBuilder, it as PickCommandByName, j as InterceptorPhases, k as InterceptorParseContext, l as PadroneCommandResult, lt as AsyncPadroneSchema, m as CommandTypesBase, mt as PadroneBarChar, n as AnyPadroneProgram, nt as padroneLogger, o as PadroneBuilder, ot as WithAsync, p as AnyPadroneCommand, pt as PadroneBarAnimation, q as OtelTracerProvider, r as DefineCommand, rt as Drained, s as PadroneExtension, st as WithCommand, t as AnyPadroneBuilder, tt as WithLogger, u as PadroneDrainResult, ut as PadroneSchema, v as PadroneProgramMeta, vt as PadroneProgressShow, w as InterceptorErrorResult, wt as REPL_SIGINT, x as InterceptorBaseContext, xt as PadroneSignal, y as ExtractInterceptorContext, yt as PadroneProgressUpdate, z as PadroneInterceptorFn } from "./index-C3Ed1LYN.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-import * as _$ink from "ink";
-
-//#region src/core/commands.d.ts
-/**
- * Builds a completer function for the REPL from the command tree.
- * Completes command names, subcommand names, option names (--foo), and aliases (-f).
- * Also includes dot-prefixed built-in REPL commands (.exit, .clear, .scope, .help, .history).
- */
-declare function buildReplCompleter(rootCommand: AnyPadroneCommand, builtins: {
-  inScope?: boolean;
-}): (line: string) => [string[], string];
-//#endregion
-//#region src/extension/help.d.ts
-type HelpArgs = {
-  command?: string[];
-  detail?: HelpDetail;
-  format?: HelpFormat;
-  all?: boolean;
-};
-type HelpCommand = PadroneCommand<'help', '', PadroneSchema<HelpArgs>, string, [], ['h', ''], false>;
-type WithHelp<T> = WithCommand<T, 'help', HelpCommand>;
-/**
- * Extension that adds help support:
- * - `help` command with aliases `h` and `` (empty = executes on root when no subcommand matches)
- * - `--help` / `-h` flags
- * - `<cmd> help` reverse syntax
- * - Default help display when a command has no action
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneHelp())
- * ```
- */
-declare function padroneHelp(): <T extends CommandTypesBase>(builder: T) => WithHelp<T>;
-//#endregion
-//#region src/extension/version.d.ts
-type VersionCommand = PadroneCommand<'version', '', PadroneSchema<void>, string, [], [], false>;
-type WithVersion<T> = WithCommand<T, 'version', VersionCommand>;
-/**
- * Extension that adds version support:
- * - `version` command
- * - `--version` / `-v` / `-V` flags (root command only)
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneVersion())
- * ```
- */
-declare function padroneVersion(): <T extends CommandTypesBase>(builder: T) => WithVersion<T>;
-//#endregion
-//#region src/core/results.d.ts
-/**
- * Brands a schema as async, signaling that its `validate()` may return a Promise.
- * When an async-branded schema is passed to `.arguments()`, `.configFile()`, or `.env()`,
- * the command's `parse()` and `cli()` will return Promises.
- */
-declare function asyncSchema<T extends PadroneSchema>(schema: T): T & {
-  '~async': true;
-};
-//#endregion
-//#region src/core/create.d.ts
-/**
- * Options for configuring which built-in extensions are applied by default.
- */
-type PadroneBuiltins = {
-  /** Enable `help` command, `--help` / `-h` flags, and default help display. Defaults to `true`. */help?: boolean; /** Enable `version` command and `--version` / `-v` / `-V` flags. Defaults to `true`. */
-  version?: boolean; /** Enable `repl` command and `--repl` flag. Defaults to `true`. */
-  repl?: boolean; /** Enable `--color` / `--no-color` flag support. Defaults to `true`. */
-  color?: boolean; /** Enable "Did you mean?" suggestions for unknown commands and options. Defaults to `true`. */
-  suggestions?: boolean; /** Enable signal handling (SIGINT, SIGTERM, SIGHUP). Defaults to `true`. */
-  signal?: boolean; /** Enable automatic result output for `cli()`. Defaults to `true`. */
-  autoOutput?: boolean; /** Enable stdin piping support. Defaults to `true`. */
-  stdin?: boolean; /** Enable interactive prompting for missing arguments. Defaults to `true`. */
-  interactive?: boolean;
-};
-type PadroneOptions = {
-  builtins?: PadroneBuiltins;
-};
-type DefaultBuiltins = {};
-type BuiltinCommands<B> = [...(B extends {
-  help: false;
-} ? [] : [HelpCommand]), ...(B extends {
-  version: false;
-} ? [] : [VersionCommand])];
-declare function createPadrone<TProgramName extends string, const TBuiltins extends PadroneBuiltins = DefaultBuiltins>(name: TProgramName, options?: {
-  builtins?: TBuiltins;
-}): PadroneProgram<TProgramName, '', '', PadroneSchema<void>, void, BuiltinCommands<TBuiltins>>;
-/**
- * Identity helper that contextually types a command builder callback while preserving its full return type.
- * Use this when defining commands in separate files — the parent program retains exact type information
- * about the subcommand's args, result, and nested commands.
- *
- * The builder's context includes `DefineCommandContext` by default (optional `logger`, `tracing`, `progress`).
- * Override globally via module augmentation on `DefineCommandContext`, or per-command via `.requires()`.
- *
- * @example Direct form (most common)
- * ```ts
- * export const myCommand = defineCommand((c) =>
- *   c.arguments(z.object({ name: z.string() }))
- *    .action((args) => console.log(args.name))
- * );
- * ```
- *
- * @example With required interceptor context
- * ```ts
- * export const adminCommand = defineCommand()
- *   .requires<{ adminDb: AdminDB }>()
- *   .define((c) => c.action((_args, ctx) => ctx.context.adminDb.query(...)));
- * ```
- */
-declare function defineCommand<TContext = unknown, TOut extends CommandTypesBase = CommandTypesBase>(fn: (builder: PadroneBuilder<string, string, string, PadroneSchema<void>, void, [], any, false, TContext, DefineCommandContext>) => TOut): typeof fn;
-declare function defineCommand(): DefineCommandBuilder;
-//#endregion
-//#region src/core/errors.d.ts
-type PadroneErrorOptions = {
-  /** Process exit code. Defaults to 1. */exitCode?: number; /** Actionable suggestions shown to the user (e.g. "Use --env production"). */
-  suggestions?: string[]; /** The command path that produced the error (e.g. "deploy staging"). */
-  command?: string; /** The phase where the error occurred. */
-  phase?: 'parse' | 'validate' | 'execute' | 'config'; /** Original cause for error chaining. */
-  cause?: unknown;
-};
-/**
- * Base error class for all Padrone errors.
- * Carries structured metadata for user-friendly formatting and programmatic handling.
- *
- * @example
- * ```ts
- * throw new PadroneError('Something went wrong', {
- *   exitCode: 1,
- *   suggestions: ['Try --help for usage information'],
- * });
- * ```
- */
-declare class PadroneError extends Error {
-  readonly exitCode: number;
-  readonly suggestions: string[];
-  readonly command?: string;
-  readonly phase?: 'parse' | 'validate' | 'execute' | 'config';
-  constructor(message: string, options?: PadroneErrorOptions);
-  /**
-   * Returns a serializable representation of the error,
-   * suitable for non-terminal runtimes (web UIs, APIs, etc.).
-   */
-  toJSON(): {
-    name: string;
-    message: string;
-    exitCode: number;
-    suggestions: string[];
-    command?: string;
-    phase?: string;
-  };
-}
-/**
- * Thrown when command routing fails — unknown command, unexpected arguments, etc.
- */
-declare class RoutingError extends PadroneError {
-  constructor(message: string, options?: PadroneErrorOptions);
-}
-/**
- * Thrown when argument or schema validation fails.
- * Carries the structured issues from the schema validator.
- */
-declare class ValidationError extends PadroneError {
-  readonly issues: readonly {
-    path?: PropertyKey[];
-    message: string;
-  }[];
-  constructor(message: string, issues: readonly {
-    path?: PropertyKey[];
-    message: string;
-  }[], options?: PadroneErrorOptions);
-  toJSON(): {
-    issues: {
-      path: string[] | undefined;
-      message: string;
-    }[];
-    name: string;
-    message: string;
-    exitCode: number;
-    suggestions: string[];
-    command?: string;
-    phase?: string;
-  };
-}
-/**
- * Thrown when config file loading or validation fails.
- */
-declare class ConfigError extends PadroneError {
-  constructor(message: string, options?: PadroneErrorOptions);
-}
-/**
- * Thrown from user action handlers to surface structured errors with exit codes and suggestions.
- * This is the primary error class users should throw from their command actions.
- *
- * @example
- * ```ts
- * throw new ActionError('Missing environment', {
- *   exitCode: 1,
- *   suggestions: ['Use --env production or --env staging'],
- * });
- * ```
- */
-declare class ActionError extends PadroneError {
-  constructor(message: string, options?: PadroneErrorOptions);
-}
-/**
- * Thrown when command execution is interrupted by a process signal (SIGINT, SIGTERM, SIGHUP).
- * Carries the signal name and the conventional exit code (128 + signal number).
- */
-declare class SignalError extends PadroneError {
-  readonly signal: PadroneSignal;
-  constructor(signal: PadroneSignal, options?: {
-    cause?: unknown;
-  });
-}
-//#endregion
-//#region src/core/interceptors.d.ts
-/**
- * Creates a self-contained interceptor value by attaching static metadata to the factory function.
- * The returned value can be passed directly to `.intercept()` or exported from a package.
- *
- * Two-arg form — define metadata and factory in one call:
- * ```ts
- * export const myInterceptor = defineInterceptor(
- *   { name: 'my-interceptor', order: 10 },
- *   () => ({
- *     execute(ctx, next) { return next(); },
- *   }),
- * );
- * ```
- *
- * Single-arg form — chain `.requires<T>()` for typed context, then `.factory()`:
- * ```ts
- * export const myInterceptor = defineInterceptor({ name: 'with-db' })
- *   .requires<{ db: DB }>()
- *   .factory(() => ({
- *     execute(ctx, next) {
- *       ctx.context.db; // typed!
- *       return next();
- *     },
- *   }));
- * ```
- */
-declare function defineInterceptor<TArgs = unknown, TResult = unknown>(meta: InterceptorMeta, factory: InterceptorFactory<TArgs, TResult>): PadroneInterceptorFn<TArgs, TResult>;
-declare function defineInterceptor(meta: InterceptorMeta): InterceptorDefBuilder;
-//#endregion
-//#region src/output/styling.d.ts
-/**
- * Styling functions for semantic text roles.
- * Used by formatters to apply visual styles (ANSI, HTML, Markdown, etc.)
- * to different types of content.
- */
-type Styler = {
-  command: (text: string) => string;
-  arg: (text: string) => string;
-  type: (text: string) => string;
-  description: (text: string) => string;
-  label: (text: string) => string;
-  section: (text: string) => string;
-  meta: (text: string) => string;
-  example: (text: string) => string;
-  exampleValue: (text: string) => string;
-  deprecated: (text: string) => string;
-};
-/**
- * Layout configuration for formatters.
- */
-type LayoutConfig = {
-  newline: string;
-  indent: (level: number) => string;
-  join: (parts: string[]) => string;
-  wrapDocument?: (content: string) => string;
-};
-/** Resolved formatting context used by output primitives. */
-type OutputFormat = 'text' | 'ansi' | 'json' | 'markdown' | 'html';
-type OutputContext = {
-  format: OutputFormat;
-  styler: Styler;
-  layout: LayoutConfig;
-  terminalWidth?: number;
-};
-//#endregion
-//#region src/output/primitives.d.ts
-type TableOptions = {
-  /** Explicit column keys to display (default: infer from first row's keys). */columns?: string[]; /** Column key → display header name mapping. */
-  headers?: Record<string, string>; /** Column key → text alignment. */
-  align?: Record<string, 'left' | 'right' | 'center'>; /** Maximum column width before truncation. */
-  maxColumnWidth?: number; /** Show borders (default: true for ansi/text, false for others). */
-  border?: boolean;
-};
-type TreeNode = {
-  label: string;
-  children?: TreeNode[];
-};
-type TreeOptions = {
-  /** Characters per indent level (default: 2). */indent?: number; /** Show tree guide lines (default: true for ansi/text). */
-  guides?: boolean;
-};
-type ListItem = string | {
-  label: string;
-  description?: string;
-};
-type ListOptions = {
-  /** Bullet character (default: '•' for ansi, '-' for text). */bullet?: string; /** Use numbered list instead of bullets. */
-  numbered?: boolean; /** Indent level (default: 0). */
-  indent?: number;
-};
-type KeyValueOptions = {
-  /** Separator between key and value (default: ': '). */separator?: string; /** Align values by padding keys to the same width. */
-  align?: boolean; /** Key → display label mapping. */
-  labels?: Record<string, string>;
-};
-//#endregion
-//#region src/output/output-indicator.d.ts
-/**
- * Runtime output helper injected into action context as `ctx.context.output`.
- * Provides format-aware output primitives (table, tree, list, key-value).
- *
- * Each method renders data using the resolved format (ANSI, text, JSON, markdown, HTML)
- * and writes it to the runtime's output function.
- */
-type PadroneOutputIndicator = {
-  /** Render data as a table. */table(data: Record<string, unknown>[], options?: TableOptions): void; /** Render data as a tree. */
-  tree(data: TreeNode | TreeNode[], options?: TreeOptions): void; /** Render data as a list. */
-  list(data: ListItem[], options?: ListOptions): void; /** Render data as aligned key-value pairs. */
-  kv(data: Record<string, unknown>, options?: KeyValueOptions): void; /** Write raw output (same as runtime.output but sets the "already called" flag). */
-  raw(...args: unknown[]): void; /** Whether any output method has been called. */
-  readonly called: boolean;
-};
-/** Declarative output configuration for a command. */
-type OutputPrimitiveType = 'table' | 'tree' | 'list' | 'kv' | 'json';
-type OutputConfig = OutputPrimitiveType | {
-  type: OutputPrimitiveType;
-  options?: TableOptions | TreeOptions | ListOptions | KeyValueOptions;
-};
-//#endregion
-//#region src/extension/auto-output.d.ts
-type PadroneAutoOutputOptions = {
-  /** Disable auto-output entirely. */disabled?: boolean;
-  /**
-   * Declarative output format for the command's return value.
-   * When set, auto-output formats the return value through the specified primitive
-   * instead of passing it raw to `runtime.output`.
-   * Ignored when the action calls `ctx.context.output.*` explicitly.
-   *
-   * ```ts
-   * // Format return value as a table
-   * c.extend(padroneAutoOutput({ output: 'table' }))
-   *
-   * // Format with options
-   * c.extend(padroneAutoOutput({ output: { type: 'table', options: { border: false } } }))
-   * ```
-   */
-  output?: OutputConfig;
-  /**
-   * Automatically print unhandled errors to stderr in CLI mode.
-   * Skips errors already handled by other extensions (routing, validation, signal).
-   * @default true
-   */
-  errorOutput?: boolean;
-};
-/**
- * Extension that automatically writes a command's return value to output after execution.
- *
- * - Values are passed directly to the runtime's `output` function (no stringification).
- * - Promises are awaited before output.
- * - Iterators and async iterators are consumed, outputting each yielded value as it arrives.
- *   The result is replaced with the collected array so `drain()` still works.
- * - `undefined` and `null` results produce no output.
- *
- * Also injects `ctx.context.output` with format-aware output primitives (table, tree, list, kv).
- * When action handlers use these methods, auto-output skips to avoid double output.
- *
- * Included in the default extensions. Can also be applied per-command:
- * ```ts
- * createPadrone('my-cli')
- *   .command('users', (c) =>
- *     c.extend(padroneAutoOutput({ output: 'table' }))
- *       .action(() => fetchUsers())
- *   )
- * ```
- */
-declare function padroneAutoOutput(options?: PadroneAutoOutputOptions): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/color.d.ts
-/**
- * Extension that handles `--color` / `--no-color` flags:
- * - `--color` or `--color=true` → use default theme
- * - `--color=false` or `--no-color` → disable colors (text format)
- * - `--color=<theme>` → use the named theme
- *
- * Modifies the runtime's format and theme accordingly.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneColor())
- * ```
- */
-declare function padroneColor(): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/completion.d.ts
-type CompletionArgs = {
-  shell?: string;
-  setup?: boolean;
-};
-type CompletionCommand = PadroneCommand<'completion', '', PadroneSchema<CompletionArgs>, string, [], [], true>;
-type WithCompletion<T> = WithCommand<T, 'completion', CompletionCommand>;
-/**
- * Extension that adds the `completion` command for shell completion script generation.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneCompletion())
- * ```
- */
-declare function padroneCompletion(): <T extends CommandTypesBase>(builder: T) => WithCompletion<T>;
-//#endregion
-//#region src/extension/config.d.ts
-type PadroneConfigOptions = {
-  /** Config file names to auto-detect (e.g. `['config.json', '.myapprc']`). First found is used. */files?: string | string[]; /** Schema to validate and transform config file data into the args shape. */
-  schema?: StandardSchemaV1; /** Disable this extension. */
-  disabled?: boolean; /** Whether to add `--config` / `-c` flag support. Defaults to `true`. */
-  flag?: boolean; /** Whether subcommands inherit this interceptor. Defaults to `true`. */
-  inherit?: boolean;
-  /**
-   * Search for config files in the user's platform-specific config directory.
-   * - `true` — use the program name as the subdirectory (e.g. program `'myapp'` → `~/.config/myapp/`).
-   * - `string` — use a custom app name as the subdirectory.
-   * - `false` — disable (default).
-   *
-   * Directories searched (after cwd):
-   * - **Linux**: `$XDG_CONFIG_HOME/<app>` or `~/.config/<app>`
-   * - **macOS**: `~/Library/Application Support/<app>` (or `$XDG_CONFIG_HOME/<app>` when set)
-   * - **Windows**: `%APPDATA%\<app>`
-   *
-   * Config files found in cwd always take precedence over XDG paths.
-   */
-  xdg?: string | boolean;
-  /**
-   * Custom config loader. When provided, replaces the built-in file system loader.
-   * Useful for testing or non-CLI environments.
-   */
-  loadConfig?: (files: string | string[], xdgAppName?: string) => Record<string, unknown> | undefined | Promise<Record<string, unknown> | undefined>;
-};
-/**
- * Extension that handles config file loading, validation, and merging into command arguments.
- *
- * Features:
- * - `--config` / `-c` flag for explicit config file path (can be disabled via `flag: false`)
- * - Auto-detection of config files from a list of candidate names
- * - Optional schema validation and transformation of config data
- * - Directly accesses the file system (gracefully no-ops in non-CLI environments)
- *
- * Config values have the lowest precedence (CLI > stdin > env > config).
- *
- * Not included in the default built-in extensions — must be explicitly added:
- * ```ts
- * createPadrone('my-cli')
- *   .extend(padroneConfig({
- *     files: ['config.json', '.myapprc'],
- *     schema: z.object({ port: z.number(), host: z.string() }),
- *   }))
- * ```
- */
-declare function padroneConfig(options?: PadroneConfigOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
-//#endregion
-//#region src/extension/env.d.ts
-type PadroneEnvOptions = {
-  /** Env modes to load (e.g. `['production']`). Loads `.env.{mode}` files. */modes?: string[]; /** Whether to load `.env.local` and `.env.{mode}.local` files. @default true */
-  local?: boolean; /** Directory to search for `.env` files. @default process.cwd() */
-  dir?: string; /** When `true`, file values override `process.env` values. @default false */
-  override?: boolean; /** When `false`, the base `.env` (and `.env.local`) files are not loaded. @default true */
-  base?: boolean;
-};
-/**
- * Extension that reads environment variables, validates them against a schema,
- * and merges the transformed values into command arguments.
- *
- * Supports loading `.env` files with mode-based overrides and variable expansion.
- *
- * ```ts
- * // Schema only (reads process.env)
- * .extend(padroneEnv(
- *   z.object({ PORT: z.string() }).transform(e => ({ port: Number(e.PORT) }))
- * ))
- *
- * // Schema + .env file loading
- * .extend(padroneEnv(
- *   z.object({ PORT: z.string() }).transform(e => ({ port: Number(e.PORT) })),
- *   { modes: ['production'] }
- * ))
- *
- * // .env file loading only (no schema validation)
- * .extend(padroneEnv({ modes: ['production'] }))
- * ```
- *
- * Env values have lower precedence than CLI args and stdin, but higher than config files.
- */
-declare function padroneEnv(schema: StandardSchemaV1): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
-declare function padroneEnv(schema: StandardSchemaV1, options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
-declare function padroneEnv(options: PadroneEnvOptions): <T extends CommandTypesBase>(builder: T) => WithAsync<T>;
-//#endregion
-//#region src/extension/ink.d.ts
-/** Checks whether a value is a React element (JSX) by inspecting its `$$typeof` symbol. */
-declare function isReactElement(value: unknown): boolean;
-type InkOptions = {
-  /** Whether to wait for the Ink app to unmount before resolving. Defaults to `true`. */waitUntilExit?: boolean; /** Options forwarded to Ink's `render()`. */
-  render?: _$ink.RenderOptions;
-};
-/**
- * Extension that renders React (Ink) components returned from command actions.
- *
- * When a command's action returns a React element (JSX), this extension
- * renders it using Ink instead of passing it to the normal output path.
- *
- * Requires `ink` and `react` as peer dependencies.
- *
- * ```ts
- * import { createPadrone, padroneInk } from 'padrone';
- *
- * const program = createPadrone('my-tui')
- *   .extend(padroneInk())
- *   .command('dashboard', (c) =>
- *     c.action(() => <Dashboard />)
- *   );
- * ```
- */
-declare function padroneInk(options?: InkOptions): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/interactive.d.ts
-/**
- * Extension that handles interactive prompting for missing arguments.
- * Extracts `--interactive` / `-i` flags, resolves effective interactivity,
- * and prompts for missing fields before passing filled args to validation.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneInteractive())
- * ```
- */
-declare function padroneInteractive(): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/man.d.ts
-type ManArgs = {
-  setup?: boolean;
-  remove?: boolean;
-};
-type ManCommand = PadroneCommand<'man', '', PadroneSchema<ManArgs>, string, [], [], true>;
-type WithMan<T> = WithCommand<T, 'man', ManCommand>;
-/**
- * Extension that adds the `man` command for man page generation.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneMan())
- * ```
- */
-declare function padroneMan(): <T extends CommandTypesBase>(builder: T) => WithMan<T>;
-//#endregion
-//#region src/extension/mcp.d.ts
-type McpArgs = {
-  transport?: string;
-  port?: string;
-  host?: string;
-  basePath?: string;
-};
-type McpCommand = PadroneCommand<'mcp', '', PadroneSchema<McpArgs>, void, [], [], true>;
-type WithMcp<T> = WithCommand<T, 'mcp', McpCommand>;
-/**
- * Extension that adds the `mcp` command for starting a Model Context Protocol server.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneMcp())
- * ```
- */
-declare function padroneMcp(defaults?: PadroneMcpPreferences): <T extends CommandTypesBase>(builder: T) => WithMcp<T>;
-//#endregion
-//#region src/extension/progress-renderer.d.ts
-/** Factory function that creates a `PadroneProgress`. */
-type PadroneProgressRenderer = (message: string, options?: PadroneProgressOptions) => PadroneProgress;
-/**
- * Creates a terminal progress indicator (spinner, bar, or both).
- * Returns a no-op indicator in non-TTY/CI environments.
- */
-declare function createTerminalProgress(message: string, options?: PadroneProgressOptions): PadroneProgress;
-//#endregion
-//#region src/extension/progress.d.ts
-/** A progress message value: a plain string, `null` to suppress, or an object with a message and custom indicator icon. */
-type PadroneProgressMessage = string | null | {
-  message?: string | null;
-  indicator?: string;
-};
-/** Per-phase message configuration for progress indicators. */
-type PadroneProgressMessages<TRes = unknown> = {
-  /** Message shown during async validation. Defaults to `''` (spinner only). */validation?: string; /** Message shown while the command's action is running. */
-  progress?: string; /** Message shown when the command succeeds. `null` to suppress. Defaults to the `progress` message. */
-  success?: PadroneProgressMessage | ((result: TRes) => PadroneProgressMessage); /** Message shown when the command fails. `null` to suppress. Defaults to the error message. */
-  error?: PadroneProgressMessage | ((error: unknown) => PadroneProgressMessage);
-};
-/**
- * Progress indicator configuration with messages, visual options, and renderer.
- */
-type PadroneProgressConfig<TRes = unknown> = {
-  /** Per-phase messages. A string sets the `progress` message; an object configures individual phases. */message?: string | PadroneProgressMessages<TRes>; /** Spinner configuration. Default `show` is `'auto'` (visible when bar is not shown). `true` forces spinner to always show (even alongside a bar). */
-  spinner?: PadroneSpinnerConfig; /** Enable a progress bar. `true` for defaults (`show: 'always'`), or a `PadroneBarConfig` object. `false` to disable entirely. When omitted, bar defaults to `show: 'auto'`. */
-  bar?: boolean | PadroneBarConfig; /** Show elapsed time since the indicator started. Can also be started on demand via `update({ time: true })`. */
-  time?: boolean; /** Show estimated time remaining based on progress rate. Requires numeric `update()` calls. */
-  eta?: boolean;
-  /**
-   * Custom renderer factory. Called to create the progress indicator.
-   * Defaults to the built-in terminal renderer (`createTerminalProgress`).
-   */
-  renderer?: PadroneProgressRenderer; /** Suppress all progress output. The `progress` interface is still provided on the context as a no-op. */
-  silent?: boolean;
-};
-/**
- * Shared progress defaults that can be provided via context instead of repeating
- * at each call site. Per-instance message fields are excluded — those always come
- * from the constructor argument.
- *
- * Provide via context as `{ progressConfig: PadroneProgressDefaults }`.
- */
-type PadroneProgressDefaults = Pick<PadroneProgressConfig, 'message' | 'spinner' | 'bar' | 'time' | 'eta' | 'renderer' | 'silent'>;
-/** Builder/program type after applying `padroneProgress()`. Adds `{ progress: PadroneProgress }` to the command context. */
-type WithProgress<T> = WithInterceptor<T, {
-  progress: PadroneProgress;
-}>;
-/**
- * Extension that adds an auto-managed progress indicator to the command pipeline.
- *
- * - `string` — a single message used for all states.
- * - `PadroneProgressConfig` — separate messages for validation, progress, success, and error.
- *
- * The indicator is automatically started before validation, updated at each phase transition,
- * and stopped on success (`.succeed()`) or failure (`.fail()`).
- *
- * Provides `{ progress: PadroneProgress }` on the command context.
- * Access it in action handlers as `ctx.context.progress`.
- *
- * Uses the built-in terminal renderer by default. Pass a custom `renderer` for non-terminal
- * environments (web UIs, testing, etc).
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli')
- *   .command('sync', (c) =>
- *     c.extend(padroneProgress('Syncing...'))
- *       .action((_args, ctx) => {
- *         ctx.context.progress.update('halfway');
- *       })
- *   )
- * ```
- */
-declare function padroneProgress<T extends CommandTypesBase>(config?: string | PadroneProgressConfig): (builder: T) => WithProgress<T>;
-//#endregion
-//#region src/extension/repl.d.ts
-type ReplArgs = {
-  scope?: string;
-};
-type ReplCommand = PadroneCommand<'repl', '', PadroneSchema<ReplArgs>, void, [], [], true>;
-type WithRepl<T> = WithCommand<T, 'repl', ReplCommand>;
-/**
- * Extension that adds REPL support:
- * - `repl` command that starts an interactive REPL
- * - `--repl` flag that starts the REPL from any invocation
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneRepl())
- * ```
- */
-declare function padroneRepl(defaults?: PadroneReplPreferences & {
-  disabled?: boolean;
-}): <T extends CommandTypesBase>(builder: T) => WithRepl<T>;
-//#endregion
-//#region src/extension/serve.d.ts
-type ServeArgs = {
-  port?: string;
-  host?: string;
-  basePath?: string;
-};
-type ServeCommand = PadroneCommand<'serve', '', PadroneSchema<ServeArgs>, void, [], [], true>;
-type WithServe<T> = WithCommand<T, 'serve', ServeCommand>;
-/**
- * Extension that adds the `serve` command for starting a REST HTTP server.
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli').extend(padroneServe())
- * ```
- */
-declare function padroneServe(defaults?: PadroneServePreferences): <T extends CommandTypesBase>(builder: T) => WithServe<T>;
-//#endregion
-//#region src/extension/signal.d.ts
-/**
- * Extension that wires process signal handling (SIGINT, SIGTERM, SIGHUP) into the interceptor lifecycle.
- *
- * - Creates an `AbortController` whose signal is propagated to all downstream phases.
- * - Subscribes to `runtime.onSignal` to forward OS signals to the abort controller.
- * - Implements SIGINT double-tap: two SIGINTs within 2 seconds force-exits the process.
- * - Attaches `signal` and `exitCode` to results and errors when interrupted.
- * - Cleans up the signal subscription on completion or failure.
- *
- * Included in the default extensions. Runs at order `-2000` (outermost).
- */
-declare function padroneSignalHandling(options?: {
-  disabled?: boolean;
-}): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/stdin.d.ts
-/**
- * Extension that reads stdin data into the argument field specified by `meta.stdin`.
- * Included by default via `createPadrone()`.
- *
- * Read mode is inferred from the schema type:
- * - `string` field → reads all stdin as a single string
- * - `string[]` field → reads stdin line-by-line into an array
- * - `AsyncIterable` field → returns a stream for line-by-line async consumption
- *
- * Stdin is only read when piped (not a TTY) and the field wasn't already provided via CLI flags.
- */
-declare function padroneStdin(options?: {
-  disabled?: boolean;
-}): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/suggestions.d.ts
-declare function padroneSuggestions(): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/extension/timing.d.ts
-interface PadroneTimingOptions {
-  /** Enable timing by default without requiring `--time` flag. Default: `false`. */
-  enabled?: boolean;
-}
-/**
- * Extension that tracks command execution time.
- *
- * - `--time` / `--timing` → enables timing output
- * - `--no-time` / `--no-timing` → disables timing output
- *
- * Pass `{ enabled: true }` to enable timing by default (can be disabled via `--no-time`).
- *
- * Usage:
- * ```ts
- * // Opt-in via flag
- * createPadrone('my-cli').extend(padroneTiming())
- *
- * // Always on, opt-out via --no-time
- * createPadrone('my-cli').extend(padroneTiming({ enabled: true }))
- * ```
- */
-declare function padroneTiming(options?: PadroneTimingOptions): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/feature/update-check.d.ts
-/**
- * Configuration for the update check feature.
- */
-type UpdateCheckConfig = {
-  /**
-   * The npm package name to check. Defaults to the program name.
-   */
-  packageName?: string;
-  /**
-   * Registry to check for updates.
-   * - `'npm'` — checks the npm registry (default)
-   * - A URL string — custom registry endpoint that returns JSON with a `version` or `dist-tags.latest` field
-   */
-  registry?: 'npm' | string;
-  /**
-   * How often to check for updates. Accepts shorthand like `'1d'`, `'12h'`, `'30m'`.
-   * Defaults to `'1d'` (once per day).
-   */
-  interval?: string;
-  /**
-   * Path to the cache file for storing the last check timestamp and latest version.
-   * Defaults to `~/.config/<programName>-update-check.json`.
-   */
-  cache?: string;
-  /**
-   * Environment variable name to disable update checks (e.g. `'MYAPP_NO_UPDATE_CHECK'`).
-   * When set to a truthy value, update checks are skipped.
-   * Defaults to `'<PROGRAM_NAME>_NO_UPDATE_CHECK'` (uppercased, hyphens to underscores).
-   */
-  disableEnvVar?: string;
-};
-//#endregion
-//#region src/extension/update-check.d.ts
-/**
- * Extension that adds background update checking:
- * - Checks for newer versions on npm (or custom registry) in the background
- * - Shows an update notification after command execution
- * - Respects `--no-update-check` flag to suppress
- *
- * Usage:
- * ```ts
- * createPadrone('my-cli')
- *   .extend(padroneUpdateCheck({ packageName: 'my-cli' }))
- * ```
- */
-declare function padroneUpdateCheck(config?: UpdateCheckConfig): <T extends CommandTypesBase>(builder: T) => T;
-//#endregion
-//#region src/util/stream.d.ts
-interface AsyncStreamMeta {
-  [x: string]: unknown;
-  readonly asyncStream: number;
-  readonly itemSchema?: StandardSchemaV1;
-}
-/**
- * Returns metadata to mark a schema field as an async stream via `.meta()`.
- *
- * When used with `stdin`, padrone pipes stdin data as an `AsyncIterable` instead of
- * buffering it. Each line is validated against the item schema (if provided) as it arrives.
- *
- * @param itemSchema - Optional item schema for per-item validation.
- *   Non-string schemas cause each stdin line to be `JSON.parse`'d before validation.
- *
- * @example
- * ```ts
- * import { asyncStream } from 'padrone';
- *
- * // String lines
- * z.object({ lines: z.custom<AsyncIterable<string>>().meta(asyncStream()) })
- *
- * // Typed items — each line JSON.parse'd and validated
- * z.object({ records: z.custom<AsyncIterable<{ name: string }>>().meta(asyncStream(recordSchema)) })
- * ```
- */
-declare function asyncStream<T = string>(itemSchema?: PadroneSchema<T>): AsyncStreamMeta;
-//#endregion
-//#region src/util/type-helpers.d.ts
-/**
- * Extracts the input type of the arguments schema from a command.
- * @example
- * ```ts
- * type Args = InferArgsInput<typeof myCommand>;
- * ```
- */
-type InferArgsInput<T extends AnyPadroneCommand> = T['~types']['argsInput'];
-/**
- * Extracts the output type of the arguments schema from a command.
- * @example
- * ```ts
- * type Args = InferArgsOutput<typeof myCommand>;
- * ```
- */
-type InferArgsOutput<T extends AnyPadroneCommand> = T['~types']['argsOutput'];
-/**
- * Extracts the user-defined context type from a command (excludes interceptor-provided context).
- * @example
- * ```ts
- * type Ctx = InferContext<typeof myCommand>;
- * ```
- */
-type InferContext<T extends AnyPadroneCommand> = T['~types']['context'];
-/**
- * Extracts the interceptor-provided context type from a command.
- * @example
- * ```ts
- * type Provided = InferContextProvided<typeof myCommand>;
- * ```
- */
-type InferContextProvided<T extends AnyPadroneCommand> = T['~types']['contextProvided'];
-/**
- * Extracts the context type that a context-providing interceptor injects.
- * @example
- * ```ts
- * type AuthCtx = InferInterceptorContext<typeof withAuth>;
- * ```
- */
-type InferInterceptorContext<T extends PadroneContextInterceptor<any>> = T['~context'];
-/**
- * Extracts the required context type from an interceptor with `.requires()`.
- * @example
- * ```ts
- * type Requires = InferInterceptorRequires<typeof withAuth>;
- * ```
- */
-type InferInterceptorRequires<T extends PadroneInterceptorFn & {
-  '~contextRequires': any;
-}> = T['~contextRequires'] extends ((ctx: infer R) => void) ? R : unknown;
-/**
- * Gets a command type by its path from a program or command tree.
- * Supports both full paths (e.g., "config set") and alias paths.
- * @example
- * ```ts
- * const program = createPadrone('cli')
- *   .command('config', c => c
- *     .command('set', c => c.arguments(...).action(...))
- *     .command('get', c => c.arguments(...).action(...))
- *   );
- *
- * type SetCommand = InferCommand<typeof program, 'config set'>;
- * type GetCommand = InferCommand<typeof program, 'config get'>;
- * ```
- */
-type InferCommand<T extends AnyPadroneCommand | AnyPadroneProgram, TPath extends PossibleCommands<T extends AnyPadroneCommand ? [T] : T['~types']['commands'], true, true>> = T extends AnyPadroneProgram ? PickCommandByName<[PadroneCommand<'', '', any, any, T['~types']['commands']>], TPath> : T extends AnyPadroneCommand ? PickCommandByName<[T], TPath> : never;
-//#endregion
-export { ActionError, type AnsiStyle, type AnyPadroneBuilder, type AnyPadroneCommand, type AnyPadroneProgram, type AsyncPadroneSchema, type AsyncStreamMeta, type ColorConfig, type ColorTheme, type CommandTypesBase, ConfigError, type DefineCommand, type DefineCommandBuilder, type DefineCommandContext, type Drained, type ExtractInterceptorContext, type ExtractInterceptorRequires, type GetArgsMeta, type HelpCommand, type HelpDetail, type HelpFormat, type HelpInfo, type InferArgsInput, type InferArgsOutput, type InferCommand, type InferContext, type InferContextProvided, type InferInterceptorContext, type InferInterceptorRequires, type InkOptions, type InteractiveMode, type InteractivePromptConfig, type InterceptorBaseContext, type InterceptorDefBuilder, type InterceptorErrorContext, type InterceptorErrorResult, type InterceptorExecuteContext, type InterceptorExecuteResult, type InterceptorFactory, type InterceptorMeta, type InterceptorParseContext, type InterceptorParseResult, type InterceptorPhases, type InterceptorRouteContext, type InterceptorShutdownContext, type InterceptorStartContext, type InterceptorValidateContext, type InterceptorValidateResult, type KeyValueOptions, type ListItem, type ListOptions, type OtelSpan, type OtelTracer, type OtelTracerProvider, type OutputContext, type OutputFormat, type PadroneActionContext, type PadroneBarAnimation, type PadroneBarChar, type PadroneBarConfig, type PadroneBuilder, type PadroneCommand, type PadroneCommandResult, type PadroneContextInterceptor, type PadroneDrainResult, PadroneError, type PadroneErrorOptions, type PadroneExtension, type PadroneInterceptor, type PadroneInterceptorFn, type PadroneLogLevel, type PadroneLogger, type PadroneLoggerConfig, type PadroneMcpPreferences, type PadroneOptions, type PadroneOutputIndicator, type PadroneParseResult, type PadroneProgram, type PadroneProgramMeta, type PadroneProgress, type PadroneProgressConfig, type PadroneProgressDefaults, type PadroneProgressMessage, type PadroneProgressMessages, type PadroneProgressOptions, type PadroneProgressRenderer, type PadroneProgressShow, type PadroneProgressUpdate, type PadroneRuntime, type PadroneSchema, type PadroneSignal, type PadroneSpinnerConfig, type PadroneSpinnerPreset, type PadroneTracer, type PadroneTracingConfig, REPL_SIGINT, type RegisteredInterceptor, RoutingError, SignalError, type TableOptions, type TreeNode, type TreeOptions, type UpdateCheckConfig, ValidationError, type VersionCommand, type WithAsync, type WithCompletion, type WithHelp, type WithLogger, type WithMan, type WithMcp, type WithProgress, type WithRepl, type WithServe, type WithTracing, type WithVersion, type WrapConfig, type WrapResult, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineCommand, defineInterceptor, isReactElement, padroneAutoOutput, padroneColor, padroneCompletion, padroneConfig, padroneEnv, padroneHelp, padroneInk, padroneInteractive, padroneLogger, padroneMan, padroneMcp, padroneProgress, padroneRepl, padroneServe, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneTracing, padroneUpdateCheck, padroneVersion };
-//# sourceMappingURL=index.d.mts.map
+import { AnsiStyle, ColorConfig, ColorTheme, colorThemes } from "./output/colorizer.mjs";
+import { HelpDetail, HelpFormat, HelpInfo } from "./output/formatter.mjs";
+import { InteractiveMode, InteractivePromptConfig, PadroneBarAnimation, PadroneBarChar, PadroneBarConfig, PadroneProgress, PadroneProgressOptions, PadroneProgressShow, PadroneProgressUpdate, PadroneRuntime, PadroneSignal, PadroneSpinnerConfig, PadroneSpinnerPreset, REPL_SIGINT } from "./core/runtime.mjs";
+import { AsyncPadroneSchema, PadroneSchema } from "./types/schema.mjs";
+import { Drained, WithAsync } from "./util/type-utils.mjs";
+import { PadroneLogLevel, PadroneLogger, PadroneLoggerConfig, WithLogger, padroneLogger } from "./extension/logger.mjs";
+import { WrapConfig, WrapResult } from "./feature/wrap.mjs";
+import { ExtractInterceptorContext, ExtractInterceptorRequires, InterceptorBaseContext, InterceptorDefBuilder, InterceptorErrorContext, InterceptorErrorResult, InterceptorExecuteContext, InterceptorExecuteResult, InterceptorFactory, InterceptorMeta, InterceptorParseContext, InterceptorParseResult, InterceptorPhases, InterceptorRouteContext, InterceptorShutdownContext, InterceptorStartContext, InterceptorValidateContext, InterceptorValidateResult, PadroneContextInterceptor, PadroneInterceptor, PadroneInterceptorFn, RegisteredInterceptor } from "./types/interceptor.mjs";
+import { AnyPadroneCommand, CommandTypesBase, GetArgsMeta, PadroneActionContext, PadroneCommand, PadroneProgramMeta } from "./types/command.mjs";
+import { PadroneCommandResult, PadroneDrainResult, PadroneParseResult } from "./types/result.mjs";
+import { AnyPadroneBuilder, AnyPadroneProgram, DefineCommand, DefineCommandBuilder, DefineCommandContext, PadroneBuilder, PadroneExtension, PadroneProgram } from "./types/builder.mjs";
+import { buildReplCompleter } from "./core/commands.mjs";
+import { HelpCommand, WithHelp, padroneHelp } from "./extension/help.mjs";
+import { VersionCommand, WithVersion, padroneVersion } from "./extension/version.mjs";
+import { asyncSchema } from "./core/results.mjs";
+import { PadroneOptions, createPadrone, defineCommand } from "./core/create.mjs";
+import { ActionError, ConfigError, PadroneError, PadroneErrorOptions, RoutingError, SignalError, ValidationError } from "./core/errors.mjs";
+import { defineInterceptor } from "./core/interceptors.mjs";
+import { OutputContext, OutputFormat } from "./output/styling.mjs";
+import { KeyValueOptions, ListItem, ListOptions, TableOptions, TreeNode, TreeOptions } from "./output/primitives.mjs";
+import { PadroneOutputIndicator } from "./output/output-indicator.mjs";
+import { padroneAutoOutput } from "./extension/auto-output.mjs";
+import { padroneColor } from "./extension/color.mjs";
+import { padroneConfig } from "./extension/config.mjs";
+import { padroneEnv } from "./extension/env.mjs";
+import { padroneInteractive } from "./extension/interactive.mjs";
+import { PadroneProgressRenderer, createTerminalProgress } from "./extension/progress-renderer.mjs";
+import { PadroneProgressConfig, PadroneProgressDefaults, PadroneProgressMessage, PadroneProgressMessages, WithProgress, padroneProgress } from "./extension/progress.mjs";
+import { WithRepl, padroneRepl } from "./extension/repl.mjs";
+import { padroneSignalHandling } from "./extension/signal.mjs";
+import { padroneStdin } from "./extension/stdin.mjs";
+import { padroneSuggestions } from "./extension/suggestions.mjs";
+import { padroneTiming } from "./extension/timing.mjs";
+import { UpdateCheckConfig } from "./feature/update-check.mjs";
+import { padroneUpdateCheck } from "./extension/update-check.mjs";
+import { AsyncStreamMeta, asyncStream } from "./util/stream.mjs";
+import { InferArgsInput, InferArgsOutput, InferCommand, InferContext, InferContextProvided, InferInterceptorContext, InferInterceptorRequires } from "./util/type-helpers.mjs";
+export { ActionError, type AnsiStyle, type AnyPadroneBuilder, type AnyPadroneCommand, type AnyPadroneProgram, type AsyncPadroneSchema, type AsyncStreamMeta, type ColorConfig, type ColorTheme, type CommandTypesBase, ConfigError, type DefineCommand, type DefineCommandBuilder, type DefineCommandContext, type Drained, type ExtractInterceptorContext, type ExtractInterceptorRequires, type GetArgsMeta, type HelpCommand, type HelpDetail, type HelpFormat, type HelpInfo, type InferArgsInput, type InferArgsOutput, type InferCommand, type InferContext, type InferContextProvided, type InferInterceptorContext, type InferInterceptorRequires, type InteractiveMode, type InteractivePromptConfig, type InterceptorBaseContext, type InterceptorDefBuilder, type InterceptorErrorContext, type InterceptorErrorResult, type InterceptorExecuteContext, type InterceptorExecuteResult, type InterceptorFactory, type InterceptorMeta, type InterceptorParseContext, type InterceptorParseResult, type InterceptorPhases, type InterceptorRouteContext, type InterceptorShutdownContext, type InterceptorStartContext, type InterceptorValidateContext, type InterceptorValidateResult, type KeyValueOptions, type ListItem, type ListOptions, type OutputContext, type OutputFormat, type PadroneActionContext, type PadroneBarAnimation, type PadroneBarChar, type PadroneBarConfig, type PadroneBuilder, type PadroneCommand, type PadroneCommandResult, type PadroneContextInterceptor, type PadroneDrainResult, PadroneError, type PadroneErrorOptions, type PadroneExtension, type PadroneInterceptor, type PadroneInterceptorFn, type PadroneLogLevel, type PadroneLogger, type PadroneLoggerConfig, type PadroneOptions, type PadroneOutputIndicator, type PadroneParseResult, type PadroneProgram, type PadroneProgramMeta, type PadroneProgress, type PadroneProgressConfig, type PadroneProgressDefaults, type PadroneProgressMessage, type PadroneProgressMessages, type PadroneProgressOptions, type PadroneProgressRenderer, type PadroneProgressShow, type PadroneProgressUpdate, type PadroneRuntime, type PadroneSchema, type PadroneSignal, type PadroneSpinnerConfig, type PadroneSpinnerPreset, REPL_SIGINT, type RegisteredInterceptor, RoutingError, SignalError, type TableOptions, type TreeNode, type TreeOptions, type UpdateCheckConfig, ValidationError, type VersionCommand, type WithAsync, type WithHelp, type WithLogger, type WithProgress, type WithRepl, type WithVersion, type WrapConfig, type WrapResult, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineCommand, defineInterceptor, padroneAutoOutput, padroneColor, padroneConfig, padroneEnv, padroneHelp, padroneInteractive, padroneLogger, padroneProgress, padroneRepl, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneUpdateCheck, padroneVersion };