@politty/zod 0.0.0

package/dist/field-meta-DMy5BcRr.js

@@ -0,0 +1,146 @@
+//#region ../core/src/adapter/registry.ts
+let registered;
+/**
+* Register the validator adapter core should use for user schemas.
+* Registration unconditionally replaces the current adapter, so every
+* adapter entry module may call this safely — repeated registration of
+* the same adapter has no observable effect.
+*
+* Single-adapter assumption: the registry holds one adapter per process
+* (last registration wins) — a CLI is built against exactly one schema
+* library. If mixing adapters in one process ever becomes a supported
+* scenario, this needs per-schema vendor dispatch instead.
+*/
+function registerValidatorAdapter(adapter) {
+	registered = adapter;
+}
+/**
+* Resolve the registered validator adapter.
+*
+* @throws if no adapter has been registered — i.e. core was imported
+* directly instead of through an adapter package entry.
+*/
+function getValidatorAdapter() {
+	if (!registered) throw new Error("No validator adapter registered. Import politty through an adapter package (e.g. `import { defineCommand } from \"@politty/zod\"` or `from \"politty\"`) so the schema library integration is set up.");
+	return registered;
+}
+
+//#endregion
+//#region ../core/src/adapter/field-meta.ts
+/**
+* Long flag names reserved for built-in handling (parseArgs / scanForSubcommand
+* intercept these before option parsing), so custom negation names must avoid them.
+*/
+const RESERVED_NEGATION_NAMES = /* @__PURE__ */ new Set([
+	"help",
+	"help-all",
+	"version"
+]);
+/**
+* Convert camelCase to kebab-case
+* @example toKebabCase("dryRun") => "dry-run"
+* @example toKebabCase("outputDir") => "output-dir"
+* @example toKebabCase("XMLParser") => "xml-parser"
+*/
+function toKebabCase(str) {
+	return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+/**
+* Convert hyphen-separated sequences to camelCase.
+*
+* Replaces `-x` (hyphen followed by a lowercase letter) with the uppercase
+* variant. Non-hyphenated input (e.g., already camelCase) is returned as-is.
+*
+* @param str - A string that may contain hyphens
+* @example toCamelCase("dry-run") => "dryRun"
+* @example toCamelCase("output-dir") => "outputDir"
+* @example toCamelCase("dryRun") => "dryRun"
+*/
+function toCamelCase(str) {
+	return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+/**
+* Get the combined list of visible + hidden aliases for a field.
+* Used by the parser and validators which treat both equally,
+* while help/docs/completion rely on `field.alias` only.
+*/
+function getAllAliases(field) {
+	if (!field.alias && !field.hiddenAlias) return [];
+	return [...field.alias ?? [], ...field.hiddenAlias ?? []];
+}
+/**
+* Assemble a {@link ResolvedFieldMeta} from adapter-provided introspection.
+* Single source of truth for alias/negation normalization and validation.
+*/
+function resolveFieldMeta(name, intro) {
+	const argMeta = intro.argMeta;
+	const description = argMeta?.description ?? intro.description;
+	const cliName = toKebabCase(name);
+	const aliasPattern = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+	const normalizeAliasList = (input, metaKey) => {
+		if (input == null) return void 0;
+		const normalized = (Array.isArray(input) ? input : [input]).map((a) => {
+			if (typeof a !== "string") throw new Error(`Invalid ${metaKey} for field "${name}": expected string or string[], received ${typeof a}.`);
+			const candidate = a.trim().replace(/^-+/, "");
+			if (candidate.length === 0 || !aliasPattern.test(candidate)) throw new Error(`Invalid ${metaKey} "${a}" for field "${name}": aliases must match ${aliasPattern}.`);
+			return candidate;
+		});
+		const result = Array.from(new Set(normalized));
+		return result.length > 0 ? result : void 0;
+	};
+	const alias = normalizeAliasList(argMeta?.alias, "alias");
+	const visibleSet = new Set(alias ?? []);
+	const hiddenAlias = normalizeAliasList(argMeta?.hiddenAlias, "hiddenAlias")?.filter((a) => !visibleSet.has(a));
+	const hiddenAliasFinal = hiddenAlias && hiddenAlias.length > 0 ? hiddenAlias : void 0;
+	const fieldType = intro.type;
+	const rawNegation = argMeta?.negation;
+	let negation;
+	if (rawNegation !== void 0 && rawNegation !== null) if (typeof rawNegation === "boolean") {
+		if (fieldType !== "boolean") throw new Error(`Invalid negation for field "${name}": negation can only be used on boolean fields.`);
+		negation = rawNegation;
+	} else {
+		if (typeof rawNegation !== "string") throw new Error(`Invalid negation for field "${name}": expected string or boolean, received ${typeof rawNegation}.`);
+		const candidate = rawNegation.trim().replace(/^-+/, "");
+		if (candidate.length === 0 || !aliasPattern.test(candidate)) throw new Error(`Invalid negation "${rawNegation}" for field "${name}": negation names must match ${aliasPattern}.`);
+		if (RESERVED_NEGATION_NAMES.has(candidate)) throw new Error(`Invalid negation "${rawNegation}" for field "${name}": negation cannot use reserved built-in flag names (${[...RESERVED_NEGATION_NAMES].map((n) => `--${n}`).join(", ")}).`);
+		if (fieldType !== "boolean") throw new Error(`Invalid negation for field "${name}": negation can only be used on boolean fields.`);
+		negation = candidate;
+	}
+	const rawNegationDescription = argMeta?.negationDescription;
+	let negationDescription;
+	if (rawNegationDescription !== void 0 && rawNegationDescription !== null) {
+		if (typeof rawNegationDescription !== "string") throw new Error(`Invalid negationDescription for field "${name}": expected string, received ${typeof rawNegationDescription}.`);
+		if (negation === false) throw new Error(`Invalid negationDescription for field "${name}": negationDescription cannot be used when negation is false.`);
+		if (negation === void 0) throw new Error(`Invalid negationDescription for field "${name}": negationDescription requires \`negation\` to be set (string or true).`);
+		const trimmed = rawNegationDescription.trim();
+		if (trimmed.length === 0) throw new Error(`Invalid negationDescription for field "${name}": negationDescription must be a non-empty string.`);
+		negationDescription = trimmed;
+	}
+	const negationDisplay = typeof negation === "string" ? negation : negation === true ? `no-${cliName}` : void 0;
+	const meta = {
+		name,
+		cliName,
+		alias,
+		hiddenAlias: hiddenAliasFinal,
+		description,
+		positional: argMeta?.positional ?? false,
+		placeholder: argMeta?.placeholder,
+		env: argMeta?.env,
+		required: intro.required,
+		defaultValue: intro.defaultValue,
+		type: fieldType,
+		schema: intro.schema,
+		enumValues: intro.enumValues,
+		completion: argMeta?.completion,
+		prompt: argMeta?.prompt,
+		negation,
+		negationDisplay,
+		negationDescription,
+		effect: argMeta?.effect
+	};
+	if (argMeta && "overrideBuiltinAlias" in argMeta && argMeta.overrideBuiltinAlias === true) meta.overrideBuiltinAlias = true;
+	return meta;
+}
+
+//#endregion
+export { getValidatorAdapter as a, toKebabCase as i, resolveFieldMeta as n, registerValidatorAdapter as o, toCamelCase as r, getAllAliases as t };

package/dist/index-CvhsecfS.d.ts

@@ -0,0 +1,455 @@
+import { C as Command, Z as UnknownKeysMode, b as ArgsSchema, f as ResolvedExpandCandidate, g as DynamicCompletionResolver, n as ArgMeta, v as AnyCommand } from "./arg-registry-YaWTVu_x.js";
+//#region ../core/src/adapter/internal-args.d.ts
+/** Runtime brand distinguishing internal descriptors from library schemas. */
+declare const INTERNAL_ARGS_BRAND = "__polittyInternalArgs";
+type InternalFieldKind = "string" | "boolean" | "enum" | "string-array";
+interface InternalFieldSpec {
+  kind: InternalFieldKind;
+  /** Allowed values (enum kind only) */
+  enumValues?: readonly string[] | undefined;
+  /** Whether omitting the value is allowed without a default */
+  optional: boolean;
+  /** Default applied when the value is missing */
+  defaultValue?: unknown;
+  /**
+   * arg()-style metadata (description, positional, alias, ...).
+   * Stored as `ArgMeta<any>`: `ArgMeta`'s `effect` callback makes the type
+   * contravariant in its value parameter, so the precisely-typed metas the
+   * builders accept only unify under `any`.
+   */
+  meta?: ArgMeta<any> | undefined;
+}
+/**
+ * An internal args schema. The `& ArgsSchema` half is a deliberate
+ * type-level fiction: the runtime object has none of a schema library's
+ * methods, but presenting it as an {@link ArgsSchema} lets internal
+ * commands flow through `defineCommand` and `Command<...>` without widening
+ * politty's public types. Nothing ever calls schema methods on it — the
+ * extract/validate facades check {@link isInternalArgsSchema} first.
+ */
+type InternalArgsSchema<TOut extends Record<string, unknown> = Record<string, unknown>> = {
+  readonly [INTERNAL_ARGS_BRAND]: true;
+  readonly fields: Record<string, InternalFieldSpec>;
+  readonly unknownKeys: UnknownKeysMode;
+  readonly __out?: TOut;
+} & ArgsSchema;
+/** Infer the validated output type of an {@link internalArgs} descriptor. */
+type InferInternalArgs<S> = S extends {
+  readonly __out?: infer TOut;
+} ? NonNullable<TOut> : never;
+//#endregion
+//#region ../core/src/completion/types.d.ts
+/**
+ * A single resolved entry in an "expand" lookup table.
+ *
+ * `key` is the tuple of `dependsOn` values that triggers this entry, in the
+ * same order as the originating `dependsOn` array. `candidates` is the
+ * (already deduplicated) list returned by the user's `enumerate` callback
+ * for that combination.
+ */
+interface ExpandTableEntry {
+  readonly key: readonly string[];
+  readonly candidates: readonly ResolvedExpandCandidate[];
+}
+/**
+ * Supported shell types for completion
+ */
+type ShellType = "bash" | "zsh" | "fish";
+/**
+ * Completion script generation mode.
+ *
+ * - `dispatcher`: small runtime script that resolves the executable visible on
+ *   PATH at TAB time and delegates to its `__complete` command.
+ * - `static`: self-contained script with command metadata baked in at
+ *   generation time.
+ */
+type CompletionMode = "dispatcher" | "static";
+/**
+ * Optional published worker artifact lookup.
+ *
+ * Paths are resolved relative to the visible executable's real directory.
+ * Templates may include `{shell}`, `{ext}`, and `{program}`.
+ */
+interface BundledWorkerOptions {
+  /** Disable bundled-worker lookup while keeping cache/dynamic fallbacks. */
+  disabled?: boolean | undefined;
+  /** Shell-specific worker paths relative to the executable directory. */
+  relativePaths?: Partial<Record<ShellType, readonly string[]>> | undefined;
+  /**
+   * Let dispatcher scripts ask the CLI for `__completion-worker-path <shell>`
+   * when package-relative lookup misses. Disabled by default because it starts
+   * the CLI process on that miss path.
+   */
+  queryCommand?: boolean | undefined;
+}
+/**
+ * Options for completion generation
+ */
+interface CompletionOptions {
+  /** The shell type to generate completion for */
+  shell: ShellType;
+  /** The command name as it will be invoked */
+  programName: string;
+  /** Include subcommand completions (default: true) */
+  includeSubcommands?: boolean;
+  /** Include description in completions where supported (default: true) */
+  includeDescriptions?: boolean;
+  /**
+   * Completion script mode.
+   *
+   * `generateCompletion` defaults to `static` when this is omitted. The
+   * `completion <shell>` subcommand passes `dispatcher` explicitly by default.
+   */
+  mode?: CompletionMode;
+  /** Global args schema for deriving global options in completion */
+  globalArgsSchema?: ArgsSchema;
+  /**
+   * Path to the binary whose mtime is the freshness signature.
+   * Defaults to `process.argv[1]`.
+   */
+  binPath?: string;
+  /** Program version to embed in the script header. */
+  programVersion?: string;
+  /**
+   * Cache directory for the loader to write the regenerated script into.
+   * Defaults to `${XDG_CACHE_HOME:-$HOME/.cache}/<programName>` at runtime.
+   * Setting this hardcodes the location into the generated loader.
+   */
+  cacheDir?: string;
+  /**
+   * Internal static-worker generation hook used by dispatcher caches.
+   * Worker scripts define suffixed functions and skip shell registration.
+   */
+  staticWorker?: {
+    functionSuffix: string;
+  };
+  /** Published static-worker artifact lookup used by dispatcher mode. */
+  bundledWorker?: BundledWorkerOptions | undefined;
+}
+/**
+ * Value completion specification for shell scripts.
+ *
+ * Discriminated by `type`. The `dynamic` variant carries a JS resolver that
+ * the static shell scripts delegate to via `<program> __complete`. All
+ * variants share the same optional metadata fields (left undefined where
+ * inapplicable) so consumers can read `vc.choices`/`vc.extensions`/etc.
+ * without narrowing first.
+ */
+type ValueCompletion = ({
+  /** Completion type */
+  type: "choices" | "file" | "directory" | "command" | "none";
+  /** List of valid choices (for "choices" type) */
+  choices?: string[];
+  /** Shell command for dynamic completion (for "command" type) */
+  shellCommand?: string;
+  resolve?: never;
+  dependsOn?: never;
+  table?: never;
+} & ({
+  extensions?: string[];
+  matcher?: never;
+} | {
+  /** Glob patterns for file matching (for "file" type) */ matcher?: string[];
+  extensions?: never;
+})) | {
+  /** In-process dynamic completion via JS callback. */
+  type: "dynamic";
+  resolve: DynamicCompletionResolver;
+  choices?: never;
+  shellCommand?: never;
+  extensions?: never;
+  matcher?: never;
+  dependsOn?: never;
+  table?: never;
+} | {
+  /**
+   * Pre-enumerated completion baked into the generated shell script.
+   * The `table` is the cartesian product of the `dependsOn` arg values
+   * (each having a static `choices` or enum schema). At completion time
+   * the shell dispatches on the runtime values of those args — no Node
+   * is spawned.
+   */
+  type: "expand";
+  dependsOn: readonly string[];
+  table: readonly ExpandTableEntry[];
+  choices?: never;
+  shellCommand?: never;
+  resolve?: never;
+  extensions?: never;
+  matcher?: never;
+} | {
+  /**
+   * Runtime form of `completion.custom.expand` used by `__complete`.
+   * The dispatcher invokes `__complete` at TAB time, so it can call the
+   * user's `enumerate` function against the already typed dependency
+   * values instead of baking a table into the shell script.
+   */
+  type: "runtime-expand";
+  dependsOn: readonly string[];
+  enumerate: (deps: Readonly<Record<string, string>>) => ReadonlyArray<string | {
+    value: string;
+    description?: string;
+  }>;
+  choices?: never;
+  shellCommand?: never;
+  resolve?: never;
+  extensions?: never;
+  matcher?: never;
+  table?: never;
+};
+/**
+ * Information about a completable option
+ */
+interface CompletableOption {
+  /** Long option name (e.g., "verbose") */
+  name: string;
+  /** CLI name (kebab-case, e.g., "dry-run") */
+  cliName: string;
+  /**
+   * Aliases for this option (both short and long).
+   * 1-char entries are short (`-v`); multi-char entries are long (`--to-be`).
+   */
+  alias?: string[] | undefined;
+  /**
+   * Negation name to advertise in shell completions (no `--` prefix),
+   * or `undefined` to hide the negation. Mirrors `ResolvedFieldMeta.negationDisplay`.
+   */
+  negation?: string | undefined;
+  /** Description for the negation option (when distinct from the main description) */
+  negationDescription?: string | undefined;
+  /**
+   * Whether the runtime parser accepts the default `--no-<cliName>` (and
+   * camelCase) form for this boolean option. True only when the user set
+   * `negation: true`; false when unset, `negation: false`, or
+   * `negation: <custom name>`. Used by the completion context parser so
+   * dynamic resolvers see the same `parsedArgs` state the runtime would compute.
+   */
+  defaultNegationAccepted?: boolean;
+  /** Description for completion */
+  description?: string | undefined;
+  /**
+   * True when this option originates from a `globalArgsSchema` and was
+   * propagated into every subcommand frame. The runtime parser keeps
+   * global values visible across subcommand descent, so shell generators
+   * must keep their tracker buckets separate from per-frame state.
+   */
+  isGlobal?: boolean;
+  /** Whether this option takes a value */
+  takesValue: boolean;
+  /** Type of value expected */
+  valueType: "string" | "number" | "boolean" | "array" | "unknown";
+  /** Whether the option is required */
+  required: boolean;
+  /** Value completion specification */
+  valueCompletion?: ValueCompletion | undefined;
+}
+/**
+ * Information about a positional argument for completion
+ */
+interface CompletablePositional {
+  /** Field name */
+  name: string;
+  /** CLI name (kebab-case) */
+  cliName: string;
+  /** Position index (0-based) */
+  position: number;
+  /** Description */
+  description?: string | undefined;
+  /** Whether required */
+  required: boolean;
+  /** Whether this positional accepts multiple values (array type) */
+  variadic?: boolean | undefined;
+  /** Value completion specification */
+  valueCompletion?: ValueCompletion | undefined;
+}
+/**
+ * Information about a subcommand for completion
+ */
+interface CompletableSubcommand {
+  /** Subcommand name */
+  name: string;
+  /** Subcommand description */
+  description?: string | undefined;
+  /** Alternative names (aliases) for this subcommand */
+  aliases?: string[] | undefined;
+  /** Nested subcommands */
+  subcommands: CompletableSubcommand[];
+  /** Options for this subcommand */
+  options: CompletableOption[];
+  /** Positional arguments */
+  positionals: CompletablePositional[];
+}
+/**
+ * Extracted completion data from a command
+ */
+interface CompletionData {
+  /** The root command */
+  command: CompletableSubcommand;
+  /** Program name */
+  programName: string;
+  /** Global options (available to all subcommands) */
+  globalOptions: CompletableOption[];
+}
+/**
+ * Result of completion generation
+ */
+interface CompletionResult {
+  /** The generated completion script */
+  script: string;
+  /** The shell type this script is for */
+  shell: ShellType;
+  /** Instructions for installing the completion */
+  installInstructions: string;
+}
+/**
+ * Generator function type for shell completions
+ */
+type CompletionGenerator = (command: AnyCommand, options: CompletionOptions) => CompletionResult;
+//#endregion
+//#region ../core/src/completion/bundled-worker.d.ts
+interface GenerateBundledCompletionWorkerOptions {
+  /** CLI binary or built JS entry file to invoke. */
+  bin: string;
+  /** Program name embedded in completion metadata. */
+  programName: string;
+  /** Shell worker to generate. */
+  shell: ShellType;
+  /** Output path. Defaults to `dist/completion/<shell>-worker.<ext>`. */
+  outputPath?: string | undefined;
+  /** Verify that `__completion-worker-path <shell>` resolves to the generated file. */
+  verify?: boolean | undefined;
+  /** Working directory used for relative paths. Defaults to `process.cwd()`. */
+  cwd?: string | undefined;
+  /** Extra environment passed to the target binary. */
+  env?: Readonly<Record<string, string | undefined>> | undefined;
+  /** Suppress the success message. */
+  quiet?: boolean | undefined;
+}
+interface GenerateBundledCompletionWorkerResult {
+  /** Absolute generated worker path. */
+  outputPath: string;
+  /** Generated file size in bytes. */
+  size: number;
+  /** Absolute path reported by `__completion-worker-path`, when verified. */
+  reportedPath?: string | undefined;
+}
+declare function bundledWorkerShellExtension(shell: ShellType): string;
+declare function defaultBundledWorkerOutputPath(shell: ShellType): string;
+declare function validateBundledWorkerFile(path: string, programName: string, shell: ShellType): void;
+declare function generateBundledCompletionWorker(options: GenerateBundledCompletionWorkerOptions): Promise<GenerateBundledCompletionWorkerResult>;
+//#endregion
+//#region ../core/src/completion/index.d.ts
+/**
+ * Generate completion script for the specified shell
+ */
+declare function generateCompletion(command: AnyCommand, options: CompletionOptions): CompletionResult;
+/**
+ * Get the list of supported shells
+ */
+declare function getSupportedShells(): ShellType[];
+/**
+ * Detect the current shell from environment
+ */
+declare function detectShell(): ShellType | null;
+/**
+ * Schema for the completion command arguments
+ */
+declare const completionArgsSchema: InternalArgsSchema<{
+  shell: "bash" | "fish" | "zsh" | undefined;
+  instructions: boolean;
+  loader: boolean;
+  install: boolean;
+  static: boolean;
+  dispatcher: boolean;
+  worker: boolean;
+}>;
+type CompletionArgs = InferInternalArgs<typeof completionArgsSchema>;
+declare const refreshArgsSchema: InternalArgsSchema<{
+  shell: "bash" | "fish" | "zsh";
+  target: string | undefined;
+  static: boolean;
+  worker: boolean;
+}>;
+type RefreshArgs = InferInternalArgs<typeof refreshArgsSchema>;
+declare const workerPathArgsSchema: InternalArgsSchema<{
+  shell: "bash" | "fish" | "zsh";
+}>;
+type WorkerPathArgs = InferInternalArgs<typeof workerPathArgsSchema>;
+/**
+ * Create a completion subcommand for your CLI
+ *
+ * This creates a ready-to-use subcommand that generates completion scripts.
+ *
+ * @example
+ * ```typescript
+ * const mainCommand = defineCommand({
+ *   name: "mycli",
+ *   subCommands: {
+ *     completion: createCompletionCommand(mainCommand)
+ *   }
+ * });
+ * ```
+ */
+declare function createCompletionCommand(rootCommand: AnyCommand, programName?: string, globalArgsSchema?: ArgsSchema, extra?: {
+  cacheDir?: string;
+  programVersion?: string;
+  bundledWorker?: BundledWorkerOptions;
+}): Command<typeof completionArgsSchema, CompletionArgs, any>;
+/**
+ * Hidden subcommand that the runMain background hook spawns. It does
+ * the same stat-compare + atomic rewrite as the rc loader, but in a
+ * detached child process so it's invisible to the user.
+ */
+declare function createRefreshCompletionCommand(rootCommand: AnyCommand, programName: string, extra?: {
+  cacheDir?: string;
+  programVersion?: string;
+  globalArgsSchema?: ArgsSchema;
+  bundledWorker?: BundledWorkerOptions;
+}): Command<typeof refreshArgsSchema, RefreshArgs, any>;
+declare function createCompletionWorkerPathCommand(programName: string, extra?: {
+  binPath?: string;
+  bundledWorker?: BundledWorkerOptions;
+}): Command<typeof workerPathArgsSchema, WorkerPathArgs, any>;
+/**
+ * Options for withCompletionCommand
+ */
+interface WithCompletionOptions {
+  /** Override the program name (defaults to command.name) */
+  programName?: string;
+  /** Global args schema for deriving global options in completion */
+  globalArgsSchema?: ArgsSchema;
+  /**
+   * Hardcode the cache directory used by the rc loader and the
+   * background refresh. When omitted, the loader derives
+   * `${XDG_CACHE_HOME:-$HOME/.cache}/<programName>` at runtime, which
+   * is the right answer for almost every CLI.
+   */
+  cacheDir?: string;
+  /** Program version embedded in the script header. */
+  programVersion?: string;
+  /** Published worker artifact lookup used by dispatcher mode. */
+  bundledWorker?: BundledWorkerOptions;
+}
+/**
+ * Wrap a command with a completion subcommand
+ *
+ * This avoids circular references that occur when a command references itself
+ * in its subCommands (e.g., for completion generation).
+ *
+ * @param command - The command to wrap
+ * @param options - Options including programName
+ * @returns A new command with the completion subcommand added
+ *
+ * @example
+ * ```typescript
+ * const mainCommand = withCompletionCommand(
+ *   defineCommand({
+ *     name: "mycli",
+ *     subCommands: { ... },
+ *   }),
+ * );
+ * ```
+ */
+declare function withCompletionCommand<T extends AnyCommand>(command: T, options?: string | WithCompletionOptions): T;
+//#endregion
+export { CompletionResult as C, InternalArgsSchema as D, InferInternalArgs as E, CompletionOptions as S, ValueCompletion as T, CompletablePositional as _, detectShell as a, CompletionGenerator as b, withCompletionCommand as c, bundledWorkerShellExtension as d, defaultBundledWorkerOutputPath as f, CompletableOption as g, BundledWorkerOptions as h, createRefreshCompletionCommand as i, GenerateBundledCompletionWorkerOptions as l, validateBundledWorkerFile as m, createCompletionCommand as n, generateCompletion as o, generateBundledCompletionWorker as p, createCompletionWorkerPathCommand as r, getSupportedShells as s, WithCompletionOptions as t, GenerateBundledCompletionWorkerResult as u, CompletableSubcommand as v, ShellType as w, CompletionMode as x, CompletionData as y };