@i18nprune/core 0.1.0

package/dist/root-2-kCaBvQ.d.ts

@@ -0,0 +1,1110 @@
+import { z } from 'zod';
+import { R as RuntimePathPort } from './path-Bfn3SAts.js';
+import { R as RuntimeFsPort } from './fs-BUYD8ZhA.js';
+import { T as TranslationProviderId } from './providers-0uMEfT6q.js';
+
+/**
+ * Minimal path surface for computing {@link LocaleSegmentSource} without importing a concrete runtime.
+ */
+type LocaleLeafPathApi = {
+    basename(path: string, suffix?: string): string;
+    dirname(path: string): string;
+    join(...paths: string[]): string;
+    relative(from: string, to: string): string;
+    isAbsolute(path: string): boolean;
+};
+/**
+ * On-disk locale JSON segment that contributed a normalized translation row.
+ *
+ * @remarks Distinct from {@link TranslationSurfaceLeaf.source} (structured JSON metadata on disk).
+ */
+type LocaleSegmentSource = {
+    file: string;
+    locale: string;
+    relativePath: string;
+};
+
+/** Single user rule for directory or file basename, or an extension token (see `ScanExcludeConfig.extensions`). */
+type ScanExcludeRule = string | RegExp;
+/** Built-in presets for scan exclusion defaults. */
+type ScanExcludePreset = 'production';
+/**
+ * Optional scan exclusions (directories while walking, files, extensions, path patterns).
+ * Used by {@link listSourceFiles} and extractor project scans. Omitted fields mean “no extra rule”.
+ *
+ * `useDefaultSkip` defaults to **true** when `exclude` is absent or the field is omitted — built-in
+ * directory skips (e.g. `node_modules`, `dist`) stay on unless explicitly disabled.
+ *
+ * **Validation:** empty string rules are ignored. **`RegExp`** values are used as-is; a bad pattern can
+ * still throw when the walk runs (same as any invalid regex in app code). There is no silent disk I/O
+ * or scan-tree warning channel in core — hosts that want UX warnings should validate config before calling.
+ */
+type ScanExcludeConfig = {
+    /**
+     * Optional built-in preset. At resolve time, preset `dirs` / `files` / `extensions` / `patterns` are merged **before**
+     * the same fields from this config object (preset first, then your lists). **`useDefaultSkip`** uses your value when set,
+     * otherwise the preset’s. **CLI** may append `--exclude` directory names after load.
+     */
+    preset?: ScanExcludePreset;
+    /** Skip directory entries with this basename while recursing (string equality or `RegExp.test(name)`). */
+    dirs?: ScanExcludeRule[];
+    /** After a path matches a scanned source extension, skip if basename matches. */
+    files?: ScanExcludeRule[];
+    /**
+     * Skip if any suffix of the basename after the first dot matches (e.g. `d.ts`, `ts`, `stories.tsx`).
+     * Strings are normalized: trimmed, lowercased, leading `.` stripped. Regexes are tested on each suffix.
+     */
+    extensions?: ScanExcludeRule[];
+    /** Skip when the path relative to the scan root (POSIX `/`) matches any regex. */
+    patterns?: RegExp[];
+    /**
+     * When true (default), apply built-in directory skips in addition to `dirs`.
+     * When false, only `dirs` / `files` / `extensions` / `patterns` apply.
+     */
+    useDefaultSkip?: boolean;
+};
+
+/**
+ * How parallel file scanning is scheduled.
+ * - **`auto`** — host picks serial vs concurrent.
+ * - **`serial`** — single-threaded walk (predictable, slower on huge trees).
+ * - **`concurrent`** — bounded worker pool up to **`concurrency`** / **`hardCap`**.
+ */
+type ScannerExecutionMode = 'serial' | 'concurrent' | 'auto';
+/** Optional tuning for source-tree scans (extractor / discovery). Safe defaults apply when omitted. */
+type ScannerConfigInput = {
+    /**
+     * Execution strategy hint.
+     * - **`auto`**: runtime chooses strategy.
+     * - **`serial`**: force single-worker execution.
+     * - **`concurrent`**: allow multi-worker execution with limits.
+     */
+    mode?: ScannerExecutionMode;
+    /**
+     * Requested worker count when mode is **`concurrent`** (or **`auto`** if runtime supports it).
+     * Clamped to **`[1, hardCap]`** by core resolver.
+     */
+    concurrency?: number;
+    /**
+     * Safety ceiling for worker count. Core clamps this to at least 1.
+     * Hosts may still apply stricter runtime-specific ceilings.
+     */
+    hardCap?: number;
+};
+type ScannerConfigResolved = {
+    mode: ScannerExecutionMode;
+    concurrency: number;
+    hardCap: number;
+    effectiveConcurrency: number;
+};
+type ResolveScannerConfigOptions = {
+    defaultMode?: ScannerExecutionMode;
+    defaultConcurrency?: number;
+    defaultHardCap?: number;
+};
+
+/**
+ * Public translate-policy surface.
+ *
+ * Locked verb dictionary, per-outcome action keys, and defaults that drive
+ * `runGenerate`'s provider chain through `resolveProviderActionFor` (step 5).
+ * SDK consumers author this shape inside `defineConfig({ translate: { policy } })`.
+ *
+ * Source of truth: `translate-policy (shipped)` §3 (schema) + §4 (verb
+ * dictionary) + §6 (defaults). When the plan moves a key, this file moves with it.
+ */
+/**
+ * Single action verb returned by the policy resolver for one observed outcome.
+ *
+ * The verb names *what the orchestrator does*, not which outcome triggered it. The
+ * resolver consults the matching `on*` key in {@link TranslatePolicy} (e.g.
+ * `onRateLimit` for `rate_limited`) and returns one verb from this set.
+ *
+ * - `'retry'`     — re-attempt the leaf on the **same** provider; counts toward `maxAttempts`.
+ * - `'backoff'`   — pause via `ProviderHealthMonitor` (`Retry-After` or fallback decay), then `'retry'`.
+ * - `'fallback'`  — advance to the next entry in `providers[]`; resume from the partial locale.
+ * - `'prompt'`    — TTY: open the handoff picker (step 7); non-TTY: degrade to `'fallback'` if
+ *                   eligible, else `'abort'`.
+ * - `'abort'`     — stop the run with a structured issue. Reserved for auth / hard-stop.
+ * - `'flag'`      — only used by `onIdentityOutput`: write source as the leaf and continue;
+ *                   the structured leaf gets `needsReview: true` when `--metadata` is on.
+ */
+type TranslatePolicyVerb = 'retry' | 'backoff' | 'fallback' | 'prompt' | 'abort' | 'flag';
+/** Verbs accepted by `onRateLimit`. */
+type OnRateLimitVerb = 'backoff' | 'retry' | 'fallback' | 'abort';
+/** Verbs accepted by `onTransientFailure`. */
+type OnTransientFailureVerb = 'retry' | 'fallback' | 'abort';
+/** Verbs accepted by `onQuotaExceeded`. */
+type OnQuotaExceededVerb = 'fallback' | 'prompt' | 'abort';
+/** Verbs accepted by `onAuthFailure`. */
+type OnAuthFailureVerb = 'abort' | 'prompt';
+/** Verbs accepted by `onProviderUnavailable`. */
+type OnProviderUnavailableVerb = 'fallback' | 'abort';
+/** Verbs accepted by `onIdentityOutput`. */
+type OnIdentityOutputVerb = 'flag' | 'fallback' | 'abort';
+/** Verbs accepted by `onIncompleteRun`. */
+type OnIncompleteRunVerb = 'confirm' | 'write' | 'discard';
+/** Chain mode. `'single'` runs one provider; `'auto'` walks `providers[]` on retryable failures. */
+type TranslateRoutingMode = 'single' | 'auto';
+/**
+ * Mid-run handoff picker mode (step 7).
+ * - `'auto'` — TTY: prompt when `routing: 'single'`; non-TTY: silent fallback.
+ * - `'on'`   — always prompt (TTY only; non-TTY degrades to fallback).
+ * - `'off'`  — never prompt.
+ */
+type TranslateHandoffMode = 'auto' | 'on' | 'off';
+/**
+ * Resolved per-outcome translate-policy. **All keys optional** — defaults are documented
+ * in {@link TRANSLATE_POLICY_DEFAULTS} and applied during config parse.
+ *
+ * Authored under `defineConfig({ translate: { policy } })`. Consumers should never
+ * read partial fields directly; use the resolved policy from `runGenerate` context
+ * (or `parseI18nPruneConfig`'s output) which has every key filled in.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'i18nprune/core/config';
+ *
+ * export default defineConfig({
+ *   locales: {
+ *     source: 'en',
+ *     directory: 'locales',
+ *   },
+ *   src: 'src',
+ *   functions: ['t'],
+ *   translate: {
+ *     primary: 'google',
+ *     providers: [{ id: 'google' }, { id: 'mymemory', enabled: false }],
+ *     policy: {
+ *       routing: 'auto',
+ *       onRateLimit: 'backoff',
+ *       onQuotaExceeded: 'fallback',
+ *       handoff: 'auto',
+ *     },
+ *   },
+ * });
+ * ```
+ */
+type TranslatePolicy = {
+    routing?: TranslateRoutingMode;
+    /** Action when the provider returns HTTP 429 / "too many requests". */
+    onRateLimit?: OnRateLimitVerb;
+    /** Action for transient network blips and `ECONNRESET`-style errors. */
+    onTransientFailure?: OnTransientFailureVerb;
+    /** Action when the provider explicitly says daily/monthly quota is exhausted. */
+    onQuotaExceeded?: OnQuotaExceededVerb;
+    /** Action for HTTP 401 / 403. Defaults to `'abort'` — never silently swap on auth failure. */
+    onAuthFailure?: OnAuthFailureVerb;
+    /** Action for sustained 5xx / DNS / "wall of unavailable". */
+    onProviderUnavailable?: OnProviderUnavailableVerb;
+    /** Action when the provider returned the source string unchanged. */
+    onIdentityOutput?: OnIdentityOutputVerb;
+    /**
+     * Action when a run can't finish all leaves (cap hit, abort verb fired, or interrupt).
+     * Step 10 of the plan wires this into a host hook.
+     */
+    onIncompleteRun?: OnIncompleteRunVerb;
+    /**
+     * Cross-provider attempts per leaf. Default = `providers.length` (one shot per provider in chain).
+     * On cap hit, the leaf is **flagged** (per `onIdentityOutput`) — the run is **never** aborted.
+     */
+    maxAttempts?: number;
+    /** Mid-run rescue prompt control (step 7). */
+    handoff?: TranslateHandoffMode;
+};
+/**
+ * Frozen defaults for {@link TranslatePolicy}. Mirrors `translate-policy (shipped)` §6.
+ * `maxAttempts` is intentionally absent here — it's resolved against `providers.length` at parse time.
+ *
+ * @remarks
+ * Step 4 of `translate-policy (shipped)`. Consumed by `parseI18nPruneConfig` /
+ * `defineConfig`'s policy merge and by step 5's resolver as the fallback for missing keys.
+ */
+declare const TRANSLATE_POLICY_DEFAULTS: Readonly<Required<Omit<TranslatePolicy, 'maxAttempts'>>>;
+
+/** Locale bundle paths and layout hints (`locales` config block). */
+type LocalesFilesystemConfig$1 = {
+    source: string;
+    directory: string;
+    mode?: 'flat_file' | 'locale_directory';
+    structure?: 'locale_file' | 'locale_per_dir' | 'feature_bundle';
+};
+
+/**
+ * How JSON key paths that may be referenced only via partial/dynamic templates are treated
+ * for destructive or shape-changing operations (sync, cleanup, generate, …).
+ */
+type UncertainKeyPolicy = 'protect' | 'allow' | 'warn_only';
+/**
+ * Secondary signal: locale **string value** appears as a literal substring in `src/`
+ * (via ripgrep). Does not prove static key usage; orthogonal to key-path extraction.
+ */
+type StringPresencePolicy = 'guard' | 'warn' | 'off';
+/**
+ * Defaults merged with optional per-operation overrides (see `ReferenceConfig.commands` — property name mirrors config file keys).
+ */
+type ReferenceDefaults = {
+    /**
+     * When false, translation calls inside comments do not contribute uncertain prefixes
+     * or runtime evidence (dynamic sites with `commented` / `isCommented`).
+     * @default false
+     */
+    treatCommentedCallSitesAsRuntime?: boolean;
+    /**
+     * When false, sites with `isSourceFile === false` are ignored for uncertainty.
+     * @default false
+     */
+    treatNonSourceFileSitesAsRuntime?: boolean;
+    /**
+     * `protect` — do not remove / do not generate resume candidates / keep extras on sync under uncertain prefixes.
+     * `allow` — ignore uncertain-prefix protection (risky).
+     * `warn_only` — same protection as `protect` for now; reserved for softer UX.
+     * @default 'protect'
+     */
+    uncertainKeyPolicy?: UncertainKeyPolicy;
+    /**
+     * `guard` — skip cleanup removal if rg finds the locale string in src.
+     * `warn` — log rg hit locations but still allow removal when uncertain policy allows.
+     * `off` — do not run rg.
+     * @default 'guard'
+     */
+    stringPresence?: StringPresencePolicy;
+    /** Max rg JSON matches recorded per key (performance). @default 5 */
+    stringPresenceMaxHitsPerKey?: number;
+    /**
+     * When true (default), `generate --resume` skips paths matching `policies.preserve`. Other operations ignore this.
+     * @default true
+     */
+    respectPreserve?: boolean;
+};
+/**
+ * Override block for one **`reference.commands`** entry (same fields as **`ReferenceDefaults`**).
+ * Type name uses “Command” because keys mirror config JSON — not every CLI subcommand.
+ */
+type ReferenceCommandOverrides = ReferenceDefaults;
+/**
+ * Per-operation entries under **`reference.commands`** in config.
+ * Known keys: **`cleanup`**, **`sync`**, **`generate`** — each overrides **`defaults`** for that operation only.
+ */
+type ReferenceCommands = {
+    /** Reference policy when running **`i18nprune cleanup`**. */
+    cleanup?: ReferenceCommandOverrides;
+    /** Reference policy when running **`i18nprune sync`**. */
+    sync?: ReferenceCommandOverrides;
+    /** Reference policy when running **`i18nprune generate`**. */
+    generate?: ReferenceCommandOverrides;
+};
+/** Root **`reference`** namespace: uncertainty + string-presence defaults and per-operation overrides. */
+type ReferenceConfig = {
+    /** Baseline policy merged before any **`commands.*`** block. */
+    defaults?: ReferenceDefaults;
+    /**
+     * Per-operation overrides (**`cleanup`**, **`sync`**, **`generate`**) deep-merged onto **`defaults`**.
+     * Unknown keys are preserved for forward compatibility.
+     */
+    commands?: ReferenceCommands & Record<string, ReferenceCommandOverrides | undefined>;
+};
+/**
+ * Fully merged reference policy for one operation (defaults + optional **`commands.<op>`** slice).
+ */
+type EffectiveReferenceConfig = Required<Pick<ReferenceDefaults, 'treatCommentedCallSitesAsRuntime' | 'treatNonSourceFileSitesAsRuntime' | 'uncertainKeyPolicy' | 'stringPresence' | 'stringPresenceMaxHitsPerKey' | 'respectPreserve'>>;
+/** Config slice required to resolve effective reference policy (matches `I18nPruneConfig.reference`). */
+type ReferenceConfigSource = {
+    reference?: ReferenceConfig;
+};
+/**
+ * Aggregated key-path evidence from keySites + dynamic scans for policy-driven operations.
+ */
+type KeyReferenceContext = {
+    /** Literal + template_resolved keys (after optional per-file comment filtering in orchestrate). */
+    provenKeys: ReadonlySet<string>;
+    /**
+     * Dotted key path prefixes that may cover runtime-only suffixes (`${…}`, partial templates).
+     */
+    uncertainPrefixes: string[];
+};
+
+/**
+ * Fine-grained exclusions for parity / “still matches source?” checks (**`quality`**, **`generate --resume`**, …).
+ */
+type ParityPolicy = {
+    /** Dotted keys ignored when comparing target vs source for drift / source-identical hints. */
+    excludeKeys?: string[];
+    /** Key prefixes ignored for the same checks. */
+    excludePrefixes?: string[];
+    /** Concrete string values ignored (e.g. placeholder **`TODO`**). */
+    excludeValues?: string[];
+};
+
+/**
+ * Dotted key paths that must always be copied verbatim from the **source** locale during merge/sync
+ * (and are respected by **`generate --resume`** when **`respectPreserve`** is on).
+ */
+type PreservePolicy = {
+    /** Exact dotted keys to preserve (e.g. **`brand.tagline`**). */
+    copyKeys?: string[];
+    /** Any key whose path starts with one of these prefixes is preserved. */
+    copyPrefixes?: string[];
+};
+
+/** Supported auto-patch recipe (today: lazy **`loader_generated`** bundle). */
+type PatchingRecipeId = 'loader_generated';
+/** Commands that may trigger patching side effects after locale writes. */
+type PatchingCommandName = 'generate' | 'sync' | 'locales-delete';
+/** Whether patching is upserting locale rows or removing them from generated config. */
+type PatchingAction = 'upsert_locales' | 'delete_locales';
+/**
+ * **`warn_skip`** — log/skip on analyzer issues; **`strict`** — fail the run when auto-patch preconditions break.
+ */
+type PatchingMode = 'warn_skip' | 'strict';
+/** User-facing **`patching`** block in **`i18nprune` config** (optional; default off). */
+type PatchingConfigInput = {
+    /** Master switch: when **`false`** or omitted, **`patch`** / **`--patch`** no-op aside from diagnostics. */
+    enabled?: boolean;
+    /** Which patch strategy to run (only **`loader_generated`** today). */
+    recipe?: PatchingRecipeId;
+    /** Path to the CLI-owned generated loader module (typically `src/i18n/loaders.generated.ts`). */
+    loaderPath?: string;
+    /** App-owned **`config.json`** (or similar) listing locale codes for the loader. */
+    configPath?: string;
+    /**
+     * Directory of locale `*.json` files, expressed **relative to the directory that contains your
+     * `i18nprune` config file** (the CLI passes that as `projectRoot`, usually the repo root). Use the same path
+     * segment as top-level **`localesDir`** when locales live beside **`src`** — typically **`locales`**.
+     *
+     * **`import()` inside `loaders.generated.ts`** is always rewritten as a path **relative to the directory
+     * containing `loaderPath`** (e.g. **`../../locales`** when **`loaders.generated.ts`** sits under **`src/i18n/`**
+     * and **`localeJsonImportBase`** is **`locales`** at repo root). You configure the locales root here; core
+     * derives the literal import prefix automatically.
+     *
+     * Hosts/tests that omit **`projectRoot`** resolve this segment **relative to **`loaderPath`**’s directory** instead.
+     */
+    localeJsonImportBase?: string;
+    /** Max bytes read per patched file before skipping (guard against huge accidental paths). */
+    sizeLimitBytes?: number;
+    /** Analyzer / applier strictness when preconditions fail. */
+    mode?: PatchingMode;
+};
+type ResolvedPatchingConfig = {
+    enabled: boolean;
+    recipe: PatchingRecipeId;
+    loaderPath: string;
+    configPath: string;
+    localeJsonImportBase: string;
+    sizeLimitBytes: number;
+    mode: PatchingMode;
+};
+type PatchingSkipReason = 'disabled' | 'missing_path' | 'not_found' | 'not_file' | 'too_large' | 'unsupported_pattern' | 'parse_error' | 'no_changes' | 'apply_failed' | 'strict_mode_failure';
+type PatchingDiagnostic = {
+    severity: 'info' | 'warn' | 'error';
+    code: string;
+    message: string;
+    docPath?: string;
+    path?: string;
+};
+type LocaleDirection = 'ltr' | 'rtl';
+type PatchingLocaleRecord = {
+    code: string;
+    englishName: string;
+    nativeName: string;
+    direction: LocaleDirection;
+    [extra: string]: unknown;
+};
+/** Catalog vs config row mismatch (resolver output). */
+type LocaleConfigMismatch = {
+    code: string;
+    field: 'englishName' | 'nativeName' | 'direction';
+    current: string;
+    recommended: string;
+};
+/** Result of {@link resolvePatchingConfigLocales} (patching `config.json` locale metadata). */
+type ResolvePatchingLocalesResult = {
+    ok: false;
+    error: 'parse_error' | 'invalid_schema';
+    message: string;
+} | {
+    ok: true;
+    nextConfigText: string;
+    autofilled: Array<{
+        code: string;
+        field: 'englishName' | 'nativeName' | 'direction';
+        value: string;
+    }>;
+    mismatches: LocaleConfigMismatch[];
+    changed: boolean;
+};
+/**
+ * Summary for hosts that apply locale-row metadata repair to patching `config.json`
+ * (CLI wraps with logging / prompts; values align with {@link resolvePatchingConfigLocales} failures).
+ */
+type RepairPatchingConfigLocalesResult = {
+    detectedCount: number;
+    autofilledCount: number;
+    correctedCount: number;
+    skipped: boolean;
+    metadataRepairBlocked?: Extract<ResolvePatchingLocalesResult, {
+        ok: false;
+    }>['error'];
+};
+type PatchingAnalyzeOutput = {
+    config: ResolvedPatchingConfig;
+    localeRecords: PatchingLocaleRecord[];
+    configOnlyCodes: string[];
+    fileOnlyCodes: string[];
+    diagnostics: PatchingDiagnostic[];
+    hasError: boolean;
+    canAutoPatch: boolean;
+};
+type PatchingFileEdit = {
+    path: string;
+    before: string;
+    after: string;
+    kind: 'loader' | 'config' | 'generated';
+};
+type PatchingPlan = {
+    recipe: PatchingRecipeId;
+    action: PatchingAction;
+    changedLocaleCodes: string[];
+    edits: PatchingFileEdit[];
+};
+type PatchingRuntimePorts = {
+    fs: RuntimeFsPort;
+    path: RuntimePathPort;
+};
+/** How generated loaders import locale JSON for a layout mode. */
+type PatchingLocaleImportSpec = {
+    kind: 'flat_file';
+} | {
+    kind: 'locale_per_dir';
+    segmentBasenames: readonly string[];
+} | {
+    kind: 'feature_bundle';
+    featureBasenames: readonly string[];
+};
+type PatchingResult = {
+    ok: boolean;
+    applied: boolean;
+    skipped: boolean;
+    recipe?: PatchingRecipeId;
+    action?: PatchingAction;
+    changedFiles: string[];
+    skipReason?: PatchingSkipReason;
+    diagnostics: PatchingDiagnostic[];
+};
+
+/**
+ * Zod schema for `i18nprune` project config. Field `.describe()` text is surfaced in parse errors
+ * and documents the runtime shape of `I18nPruneConfig`.
+ */
+
+/** Locale bundle paths and optional storage layout (flat files today; directory topologies later). */
+declare const localesFilesystemSchema: z.ZodObject<{
+    source: z.ZodString;
+    directory: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        flat_file: "flat_file";
+        locale_directory: "locale_directory";
+    }>>;
+    structure: z.ZodOptional<z.ZodEnum<{
+        locale_file: "locale_file";
+        locale_per_dir: "locale_per_dir";
+        feature_bundle: "feature_bundle";
+    }>>;
+}, z.core.$strict>;
+type LocalesFilesystemConfig = z.infer<typeof localesFilesystemSchema>;
+declare const configSchema: z.ZodObject<{
+    locales: z.ZodObject<{
+        source: z.ZodString;
+        directory: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
+            flat_file: "flat_file";
+            locale_directory: "locale_directory";
+        }>>;
+        structure: z.ZodOptional<z.ZodEnum<{
+            locale_file: "locale_file";
+            locale_per_dir: "locale_per_dir";
+            feature_bundle: "feature_bundle";
+        }>>;
+    }, z.core.$strict>;
+    src: z.ZodString;
+    functions: z.ZodArray<z.ZodString>;
+    exclude: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodEnum<{
+            production: "production";
+        }>>;
+        dirs: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>>>;
+        extensions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>>>;
+        patterns: z.ZodOptional<z.ZodArray<z.ZodCustom<RegExp, RegExp>>>;
+        useDefaultSkip: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    output: z.ZodOptional<z.ZodObject<{
+        list: z.ZodOptional<z.ZodObject<{
+            top: z.ZodOptional<z.ZodNumber>;
+            full: z.ZodOptional<z.ZodBoolean>;
+            maxCap: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    scanner: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            serial: "serial";
+            concurrent: "concurrent";
+            auto: "auto";
+        }>>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        hardCap: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        dir: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodEnum<{
+            safe: "safe";
+            balanced: "balanced";
+            fast: "fast";
+        }>>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            readWrite: "readWrite";
+            readOnly: "readOnly";
+        }>>;
+        rebuild: z.ZodOptional<z.ZodEnum<{
+            partial: "partial";
+            full: "full";
+        }>>;
+        fullRescanThresholdPercent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    policies: z.ZodOptional<z.ZodObject<{
+        preserve: z.ZodOptional<z.ZodObject<{
+            copyKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            copyPrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        parity: z.ZodOptional<z.ZodObject<{
+            excludeKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            excludePrefixes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            excludeValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    reference: z.ZodOptional<z.ZodObject<{
+        defaults: z.ZodOptional<z.ZodObject<{
+            treatCommentedCallSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+            treatNonSourceFileSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+            uncertainKeyPolicy: z.ZodOptional<z.ZodEnum<{
+                protect: "protect";
+                allow: "allow";
+                warn_only: "warn_only";
+            }>>;
+            stringPresence: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                guard: "guard";
+                warn: "warn";
+            }>>;
+            stringPresenceMaxHitsPerKey: z.ZodOptional<z.ZodNumber>;
+            respectPreserve: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>;
+        commands: z.ZodOptional<z.ZodObject<{
+            cleanup: z.ZodOptional<z.ZodObject<{
+                treatCommentedCallSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                treatNonSourceFileSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                uncertainKeyPolicy: z.ZodOptional<z.ZodEnum<{
+                    protect: "protect";
+                    allow: "allow";
+                    warn_only: "warn_only";
+                }>>;
+                stringPresence: z.ZodOptional<z.ZodEnum<{
+                    off: "off";
+                    guard: "guard";
+                    warn: "warn";
+                }>>;
+                stringPresenceMaxHitsPerKey: z.ZodOptional<z.ZodNumber>;
+                respectPreserve: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$loose>>;
+            sync: z.ZodOptional<z.ZodObject<{
+                treatCommentedCallSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                treatNonSourceFileSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                uncertainKeyPolicy: z.ZodOptional<z.ZodEnum<{
+                    protect: "protect";
+                    allow: "allow";
+                    warn_only: "warn_only";
+                }>>;
+                stringPresence: z.ZodOptional<z.ZodEnum<{
+                    off: "off";
+                    guard: "guard";
+                    warn: "warn";
+                }>>;
+                stringPresenceMaxHitsPerKey: z.ZodOptional<z.ZodNumber>;
+                respectPreserve: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$loose>>;
+            generate: z.ZodOptional<z.ZodObject<{
+                treatCommentedCallSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                treatNonSourceFileSitesAsRuntime: z.ZodOptional<z.ZodBoolean>;
+                uncertainKeyPolicy: z.ZodOptional<z.ZodEnum<{
+                    protect: "protect";
+                    allow: "allow";
+                    warn_only: "warn_only";
+                }>>;
+                stringPresence: z.ZodOptional<z.ZodEnum<{
+                    off: "off";
+                    guard: "guard";
+                    warn: "warn";
+                }>>;
+                stringPresenceMaxHitsPerKey: z.ZodOptional<z.ZodNumber>;
+                respectPreserve: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    localeLeaves: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            legacy_string: "legacy_string";
+            structured: "structured";
+        }>>;
+        sync: z.ZodOptional<z.ZodObject<{
+            stripMetadata: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    patching: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        recipe: z.ZodOptional<z.ZodEnum<{
+            loader_generated: "loader_generated";
+        }>>;
+        loaderPath: z.ZodOptional<z.ZodString>;
+        configPath: z.ZodOptional<z.ZodString>;
+        localeJsonImportBase: z.ZodOptional<z.ZodString>;
+        sizeLimitBytes: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            strict: "strict";
+            warn_skip: "warn_skip";
+        }>>;
+    }, z.core.$strict>>;
+    missing: z.ZodOptional<z.ZodObject<{
+        placeholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    translate: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        primary: z.ZodEnum<{
+            google: "google";
+            mymemory: "mymemory";
+            deepl: "deepl";
+            libre: "libre";
+            llm: "llm";
+        }>;
+        providers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodLiteral<"google">;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            rateLimit: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                rpm: z.ZodOptional<z.ZodNumber>;
+                rps: z.ZodOptional<z.ZodNumber>;
+                intervalMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodTransform<{
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            }, {
+                maxConcurrency?: number | undefined;
+                rpm?: number | undefined;
+                rps?: number | undefined;
+                intervalMs?: number | undefined;
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodLiteral<"mymemory">;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            contactEmail: z.ZodOptional<z.ZodString>;
+            rateLimit: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                rpm: z.ZodOptional<z.ZodNumber>;
+                rps: z.ZodOptional<z.ZodNumber>;
+                intervalMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodTransform<{
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            }, {
+                maxConcurrency?: number | undefined;
+                rpm?: number | undefined;
+                rps?: number | undefined;
+                intervalMs?: number | undefined;
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodLiteral<"libre">;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            rateLimit: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                rpm: z.ZodOptional<z.ZodNumber>;
+                rps: z.ZodOptional<z.ZodNumber>;
+                intervalMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodTransform<{
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            }, {
+                maxConcurrency?: number | undefined;
+                rpm?: number | undefined;
+                rps?: number | undefined;
+                intervalMs?: number | undefined;
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodLiteral<"deepl">;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            apiKey: z.ZodOptional<z.ZodString>;
+            rateLimit: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                rpm: z.ZodOptional<z.ZodNumber>;
+                rps: z.ZodOptional<z.ZodNumber>;
+                intervalMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodTransform<{
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            }, {
+                maxConcurrency?: number | undefined;
+                rpm?: number | undefined;
+                rps?: number | undefined;
+                intervalMs?: number | undefined;
+            }>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodLiteral<"llm">;
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            apiKey: z.ZodOptional<z.ZodString>;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            rateLimit: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+                maxConcurrency: z.ZodOptional<z.ZodNumber>;
+                rpm: z.ZodOptional<z.ZodNumber>;
+                rps: z.ZodOptional<z.ZodNumber>;
+                intervalMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodTransform<{
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            }, {
+                maxConcurrency?: number | undefined;
+                rpm?: number | undefined;
+                rps?: number | undefined;
+                intervalMs?: number | undefined;
+            }>>>;
+        }, z.core.$strict>], "id">>;
+        policy: z.ZodDefault<z.ZodObject<{
+            routing: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                single: "single";
+            }>>;
+            onRateLimit: z.ZodDefault<z.ZodEnum<{
+                retry: "retry";
+                backoff: "backoff";
+                fallback: "fallback";
+                abort: "abort";
+            }>>;
+            onTransientFailure: z.ZodDefault<z.ZodEnum<{
+                retry: "retry";
+                fallback: "fallback";
+                abort: "abort";
+            }>>;
+            onQuotaExceeded: z.ZodDefault<z.ZodEnum<{
+                fallback: "fallback";
+                prompt: "prompt";
+                abort: "abort";
+            }>>;
+            onAuthFailure: z.ZodDefault<z.ZodEnum<{
+                prompt: "prompt";
+                abort: "abort";
+            }>>;
+            onProviderUnavailable: z.ZodDefault<z.ZodEnum<{
+                fallback: "fallback";
+                abort: "abort";
+            }>>;
+            onIdentityOutput: z.ZodDefault<z.ZodEnum<{
+                fallback: "fallback";
+                abort: "abort";
+                flag: "flag";
+            }>>;
+            onIncompleteRun: z.ZodDefault<z.ZodEnum<{
+                confirm: "confirm";
+                write: "write";
+                discard: "discard";
+            }>>;
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            handoff: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                on: "on";
+                off: "off";
+            }>>;
+        }, z.core.$strict>>;
+        workers: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodTransform<{
+        primary: "google" | "mymemory" | "deepl" | "libre" | "llm";
+        providers: ({
+            id: "google";
+            enabled?: boolean | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "mymemory";
+            enabled?: boolean | undefined;
+            contactEmail?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "libre";
+            enabled?: boolean | undefined;
+            baseUrl?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "deepl";
+            enabled?: boolean | undefined;
+            apiKey?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "llm";
+            enabled?: boolean | undefined;
+            apiKey?: string | undefined;
+            baseUrl?: string | undefined;
+            model?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        })[];
+        policy: {
+            maxAttempts: number;
+            routing: "auto" | "single";
+            onRateLimit: "retry" | "backoff" | "fallback" | "abort";
+            onTransientFailure: "retry" | "fallback" | "abort";
+            onQuotaExceeded: "fallback" | "prompt" | "abort";
+            onAuthFailure: "prompt" | "abort";
+            onProviderUnavailable: "fallback" | "abort";
+            onIdentityOutput: "fallback" | "abort" | "flag";
+            onIncompleteRun: "confirm" | "write" | "discard";
+            handoff: "auto" | "on" | "off";
+        };
+        workers: number;
+    }, {
+        primary: "google" | "mymemory" | "deepl" | "libre" | "llm";
+        providers: ({
+            id: "google";
+            enabled?: boolean | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "mymemory";
+            enabled?: boolean | undefined;
+            contactEmail?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "libre";
+            enabled?: boolean | undefined;
+            baseUrl?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "deepl";
+            enabled?: boolean | undefined;
+            apiKey?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        } | {
+            id: "llm";
+            enabled?: boolean | undefined;
+            apiKey?: string | undefined;
+            baseUrl?: string | undefined;
+            model?: string | undefined;
+            rateLimit?: {
+                maxConcurrency: number | undefined;
+                rpm: number | undefined;
+                rps: number | undefined;
+                intervalMs: number | undefined;
+            } | undefined;
+        })[];
+        policy: {
+            routing: "auto" | "single";
+            onRateLimit: "retry" | "backoff" | "fallback" | "abort";
+            onTransientFailure: "retry" | "fallback" | "abort";
+            onQuotaExceeded: "fallback" | "prompt" | "abort";
+            onAuthFailure: "prompt" | "abort";
+            onProviderUnavailable: "fallback" | "abort";
+            onIdentityOutput: "fallback" | "abort" | "flag";
+            onIncompleteRun: "confirm" | "write" | "discard";
+            handoff: "auto" | "on" | "off";
+            maxAttempts?: number | undefined;
+        };
+        workers?: number | undefined;
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Direct **`z.infer`** of {@link configSchema}. Internal — used by **`schema/define.ts`** /
+ * **`defaults/app.ts`** to type the spread / merge bodies. Public callers should use the friendly
+ * **`I18nPruneConfig`** from **`@i18nprune/core/config`** (or the root barrel).
+ *
+ * The two shapes are runtime-identical; the friendly version retypes **`reference`**,
+ * **`translate`**, and **`policies`** with stricter authoring-time interfaces.
+ */
+type I18nPruneConfigParsed = z.infer<typeof configSchema>;
+/** Optional per-backend rate-limit knobs (merged with provider defaults when omitted). */
+type TranslateRateLimitConfig = {
+    maxConcurrency?: number;
+    rpm?: number;
+    rps?: number;
+    intervalMs?: number;
+};
+type TranslateProviderRowGoogle = {
+    id: 'google';
+    enabled?: boolean;
+    rateLimit?: TranslateRateLimitConfig;
+};
+type TranslateProviderRowMymemory = {
+    id: 'mymemory';
+    enabled?: boolean;
+    contactEmail?: string;
+    rateLimit?: TranslateRateLimitConfig;
+};
+type TranslateProviderRowLibre = {
+    id: 'libre';
+    enabled?: boolean;
+    baseUrl?: string;
+    rateLimit?: TranslateRateLimitConfig;
+};
+type TranslateProviderRowDeepL = {
+    id: 'deepl';
+    enabled?: boolean;
+    apiKey?: string;
+    rateLimit?: TranslateRateLimitConfig;
+};
+type TranslateProviderRowLlm = {
+    id: 'llm';
+    enabled?: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    rateLimit?: TranslateRateLimitConfig;
+};
+type TranslateProviderRow = TranslateProviderRowGoogle | TranslateProviderRowMymemory | TranslateProviderRowLibre | TranslateProviderRowDeepL | TranslateProviderRowLlm;
+type TranslateMaxWorkersConfig = number;
+type TranslatePolicyConfig = TranslatePolicy;
+type Policies = {
+    preserve?: PreservePolicy;
+    parity?: ParityPolicy;
+};
+type LocaleLeavesConfig = {
+    mode?: 'structured' | 'legacy_string';
+    sync?: {
+        stripMetadata?: boolean;
+    };
+};
+type MissingCommandConfig = {
+    placeholder?: string;
+};
+type OutputListConfig = {
+    top?: number;
+    full?: boolean;
+    maxCap?: number;
+};
+type OutputConfig = {
+    list?: OutputListConfig;
+};
+type CacheConfig = {
+    enabled?: boolean;
+    dir?: string;
+    mode?: 'readWrite' | 'readOnly';
+};
+type PatchingConfig = PatchingConfigInput;
+type TranslateConfig = {
+    primary: TranslationProviderId;
+    providers: TranslateProviderRow[];
+    policy?: TranslatePolicyConfig;
+    workers?: TranslateMaxWorkersConfig;
+};
+/**
+ * Fully merged i18nprune project config (file + defaults + parse normalization).
+ */
+type I18nPruneConfig = Omit<I18nPruneConfigParsed, 'reference' | 'translate' | 'policies'> & {
+    locales: LocalesFilesystemConfig;
+    src: string;
+    functions: string[];
+    output?: OutputConfig;
+    cache?: CacheConfig;
+    exclude?: ScanExcludeConfig;
+    scanner?: ScannerConfigInput;
+    policies?: Policies;
+    reference?: ReferenceConfig;
+    localeLeaves?: LocaleLeavesConfig;
+    missing?: MissingCommandConfig;
+    patching?: PatchingConfig;
+    translate?: TranslateConfig;
+};
+/**
+ * Thrown by **`parseI18nPruneConfig`** (and **`loadCoreConfigFromPath`**) when an input value
+ * fails the zod schema. Carries the underlying **`zodError`** so callers can surface field-level
+ * issues (CLI uses it to emit **`ConfigValidationError`** issue codes).
+ */
+declare class ConfigValidationError extends Error {
+    readonly zodError?: z.ZodError | undefined;
+    readonly issueCode?: string | undefined;
+    constructor(message: string, zodError?: z.ZodError | undefined, issueCode?: string | undefined);
+}
+/**
+ * Recognize {@link ConfigValidationError} across bundle boundaries (CLI loads
+ * `i18nprune/core/config` for `defineConfig` while handling errors from `dist/cli.js`).
+ */
+declare function isConfigValidationError(err: unknown): err is ConfigValidationError;
+/**
+ * Validate a raw object against the zod-backed config schema and return the public friendly
+ * **`I18nPruneConfig`**. Throws **`ConfigValidationError`** on invalid input.
+ *
+ * Use this when accepting config from untrusted sources (REST, DB, CLI args, generated
+ * fixtures). For files on disk prefer **`loadCoreConfigFromPath`** — it handles TS / JS
+ * loaders, layering with **`DEFAULT_CONFIG`**, and warning collection on top of this primitive.
+ *
+ * The returned value drops straight into **`createCoreContext`** and **`createTranslateContext`**
+ * with no further cast.
+ *
+ * @example
+ * ```ts
+ * import { parseI18nPruneConfig } from '@i18nprune/core';
+ *
+ * const config = parseI18nPruneConfig(await db.fetchProjectConfig(projectId));
+ * const ctx = createCoreContext({ config, adapters, env, paths });
+ * ```
+ */
+declare function parseI18nPruneConfig(raw: unknown): I18nPruneConfig;
+
+export { type OnIncompleteRunVerb as $, isConfigValidationError as A, localesFilesystemSchema as B, type CacheConfig as C, parseI18nPruneConfig as D, type EffectiveReferenceConfig as E, type LocaleSegmentSource as F, type ScanExcludeConfig as G, type TranslatePolicyVerb as H, type I18nPruneConfig as I, type PatchingCommandName as J, type PatchingAction as K, type LocalesFilesystemConfig as L, type MissingCommandConfig as M, type PatchingLocaleRecord as N, type OutputConfig as O, type ParityPolicy as P, type PatchingConfigInput as Q, type ResolveScannerConfigOptions as R, type StringPresencePolicy as S, type TranslatePolicy as T, type UncertainKeyPolicy as U, type PatchingRuntimePorts as V, type KeyReferenceContext as W, type LocaleConfigMismatch as X, type LocaleDirection as Y, type OnAuthFailureVerb as Z, type OnIdentityOutputVerb as _, type PreservePolicy as a, type OnProviderUnavailableVerb as a0, type OnQuotaExceededVerb as a1, type OnRateLimitVerb as a2, type OnTransientFailureVerb as a3, type PatchingAnalyzeOutput as a4, type PatchingDiagnostic as a5, type PatchingFileEdit as a6, type PatchingLocaleImportSpec as a7, type PatchingMode as a8, type PatchingPlan as a9, type PatchingRecipeId as aa, type PatchingResult as ab, type PatchingSkipReason as ac, type ReferenceConfigSource as ad, type RepairPatchingConfigLocalesResult as ae, type ResolvePatchingLocalesResult as af, type ResolvedPatchingConfig as ag, type ScanExcludePreset as ah, type ScanExcludeRule as ai, type ScannerExecutionMode as aj, TRANSLATE_POLICY_DEFAULTS as ak, type TranslateHandoffMode as al, type TranslateRoutingMode as am, type LocalesFilesystemConfig$1 as b, type LocaleLeafPathApi as c, type ScannerConfigInput as d, type ScannerConfigResolved as e, type I18nPruneConfigParsed as f, type ReferenceCommandOverrides as g, ConfigValidationError as h, type LocaleLeavesConfig as i, type OutputListConfig as j, type PatchingConfig as k, type Policies as l, type ReferenceCommands as m, type ReferenceConfig as n, type ReferenceDefaults as o, type TranslateConfig as p, type TranslateMaxWorkersConfig as q, type TranslatePolicyConfig as r, type TranslateProviderRow as s, type TranslateProviderRowDeepL as t, type TranslateProviderRowGoogle as u, type TranslateProviderRowLibre as v, type TranslateProviderRowLlm as w, type TranslateProviderRowMymemory as x, type TranslateRateLimitConfig as y, configSchema as z };