@the-i18n-kit/cli 4.9.0

package/dist/index-BtSA6-iT.d.ts

@@ -0,0 +1,1130 @@
+import { a as LocaleDir, i as LocaleDefinition, n as defineI18nKitConfig, o as ProjectConfig, r as I18nConfig, t as I18nKitConfig } from "./define-config-Dhg13592.js";
+
+//#region src/core/types.d.ts
+
+interface LocaleDirInfo {
+  layer: string;
+  path: string;
+  aliasOf?: string;
+  fileCount: number;
+  topLevelKeys?: string[];
+  namespaces?: string[];
+}
+interface MutationPreview {
+  locale: string;
+  key: string;
+  value: string;
+}
+interface PlaceholderValidationIssue {
+  locale: string;
+  key: string;
+  missing: string[];
+  extra: string[];
+  /** What failed: placeholder set mismatch (default) or vue-i18n plural
+   *  variant-count mismatch. Optional for backwards compatibility. */
+  kind?: 'placeholder' | 'plural-count';
+  /** Present for kind 'plural-count': variant counts of source and target. */
+  sourceVariants?: number;
+  targetVariants?: number;
+}
+interface PlaceholderValidationResult {
+  ok: boolean;
+  placeholders: string[];
+  errors: PlaceholderValidationIssue[];
+}
+interface LocaleRefInfo {
+  code: string;
+  language?: string;
+  file?: string;
+  name?: string;
+}
+/**
+ * A locale ref in the request that matched no known locale. Its values were
+ * not written; the keys still appear in `written` because other locales
+ * succeeded, so this field is the only signal the write did less than asked.
+ */
+interface UnresolvedLocaleRef {
+  ref: string;
+  /** Keys whose value for this ref was dropped. */
+  keys: string[];
+  /** "Did you mean …?", when a near match exists. */
+  suggestion?: string;
+}
+interface MutationResult {
+  applied: string[];
+  skipped: string[];
+  warnings: string[];
+  filesWritten: number;
+  preview?: MutationPreview[];
+  placeholderValidation?: PlaceholderValidationResult;
+  /** Present only when a ref resolved to nothing. */
+  unresolvedLocales?: UnresolvedLocaleRef[];
+  /** Present only when a ref matched several locales and precedence picked one. */
+  ambiguousLocales?: LocaleRefAmbiguity[];
+}
+interface AddTranslationsResult {
+  /** Present when dryRun=true */
+  dryRun?: boolean;
+  wouldAdd?: MutationPreview[];
+  /** Present when dryRun=false */
+  added?: string[];
+  skipped: string[];
+  filesWritten?: number;
+  warnings?: string[];
+  /** Present only when a locale ref resolved to nothing — see UnresolvedLocaleRef. */
+  unresolvedLocales?: UnresolvedLocaleRef[];
+  /** Present only when a locale ref matched several locales. */
+  ambiguousLocales?: LocaleRefAmbiguity[];
+  placeholderValidation?: PlaceholderValidationResult;
+  summary?: {
+    keysToAdd: number;
+    keysSkipped: number;
+    message: string;
+  };
+  skippedKeys?: string[];
+}
+interface WriteTranslationsResult {
+  /** Present when dryRun=true */
+  dryRun?: boolean;
+  wouldWrite?: MutationPreview[];
+  /** Present when dryRun=false */
+  written?: string[];
+  skipped: string[];
+  filesWritten?: number;
+  warnings?: string[];
+  placeholderValidation?: PlaceholderValidationResult;
+  /** Present only when a locale ref resolved to nothing — see UnresolvedLocaleRef. */
+  unresolvedLocales?: UnresolvedLocaleRef[];
+  /** Present only when a locale ref matched several locales. */
+  ambiguousLocales?: LocaleRefAmbiguity[];
+  summary?: {
+    keysWritten: number;
+    keysSkipped: number;
+    message: string;
+  };
+  skippedKeys?: string[];
+}
+interface UpdateTranslationsResult {
+  /** Present when dryRun=true */
+  dryRun?: boolean;
+  wouldUpdate?: MutationPreview[];
+  /** Present when dryRun=false */
+  updated?: string[];
+  skipped: string[];
+  filesWritten?: number;
+  /** Present only when a locale ref resolved to nothing — see UnresolvedLocaleRef. */
+  unresolvedLocales?: UnresolvedLocaleRef[];
+  /** Present only when a locale ref matched several locales. */
+  ambiguousLocales?: LocaleRefAmbiguity[];
+  placeholderValidation?: PlaceholderValidationResult;
+  summary?: {
+    keysToUpdate: number;
+    keysSkipped: number;
+    message: string;
+  };
+  skippedKeys?: string[];
+}
+/**
+ * The config `init` emits. Only fields the matched adapter cannot derive:
+ * writing a copy of what the framework already states creates a second source
+ * of truth that drifts silently (#305). The generic path is the exception —
+ * without localeDirs and defaultLocale nothing resolves at all.
+ */
+interface GeneratedProjectConfig {
+  $schema: string;
+  context: string;
+  glossary: Record<string, string>;
+  translationPrompt: string;
+  localeNotes: Record<string, string>;
+  /** Matches localeDirEntrySchema: a bare path, or a path bound to a layer. */
+  localeDirs?: Array<string | {
+    path: string;
+    layer: string;
+  }>;
+  defaultLocale?: string;
+  locales?: string[];
+}
+interface InitProjectConfigResult {
+  config: GeneratedProjectConfig;
+  detected: {
+    adapter: string;
+    label: string;
+    /** Detection score. 0 when nothing matched and generic was assumed. */
+    confidence: number;
+    /**
+     * Whether the matched adapter resolves locales, layers and the default
+     * locale from framework config. False only for the generic adapter, which
+     * cannot resolve without them written into `.i18n-mcp.json`. Independent
+     * of whether this run carried locale settings forward from an existing
+     * file under `--force`.
+     */
+    derivesLocaleConfig: boolean;
+    /** Other adapters that also scored, best first. */
+    runnersUp?: Array<{
+      name: string;
+      confidence: number;
+    }>;
+    /** Present when init could not find anything to point the config at. */
+    note?: string;
+  };
+  /** Path relative to the project dir. */
+  configPath: string;
+  written: boolean;
+  overwritten: boolean;
+}
+interface MissingTranslationsResult {
+  /** Absent when the full report went to `reportFile` instead. */
+  missing?: Record<string, Record<string, string[]>>;
+  summary: {
+    referenceLocale: string | LocaleRefInfo;
+    targetLocales: Array<string | LocaleRefInfo>;
+    layersScanned: string[];
+    totalMissingKeys: number;
+  };
+  /** Present when reportOutput is configured */
+  reportFile?: string;
+}
+interface LocaleStatus extends LocaleRefInfo {
+  total: number;
+  translated: number;
+  missing: number;
+  /** Present but empty-string — scaffolded and never filled. */
+  empty: number;
+  completion: number;
+  /** Listed in protectedLocales: maintained by hand. */
+  protected?: true;
+  /** Protected locales are reported but kept out of the overall figure. */
+  excludedFromOverall?: true;
+}
+interface LayerStatus {
+  layer: string;
+  total: number;
+  translated: number;
+  missing: number;
+  empty: number;
+  completion: number;
+}
+interface TranslationStatusSummary {
+  referenceLocale: LocaleRefInfo;
+  layersScanned: string[];
+  localesChecked: number;
+  protectedLocales: string[];
+  totalKeys: number;
+  translatedKeys: number;
+  missingKeys: number;
+  emptyKeys: number;
+  /** Overall completion, protected locales excluded. Read by --fail-under. */
+  completionPercent: number;
+}
+interface TranslationStatusResult {
+  locales?: LocaleStatus[];
+  layers?: LayerStatus[];
+  summary: TranslationStatusSummary;
+  /** Present when the full breakdown went to a file instead. */
+  reportFile?: string;
+}
+interface EmptyTranslationsResult {
+  /** Absent when the full report went to `reportFile` instead. */
+  emptyKeys?: Record<string, Record<string, string[]>>;
+  summary: {
+    totalEmpty: number;
+    localesChecked: string[];
+    layersChecked: string[];
+  };
+  /** Present when reportOutput is configured */
+  reportFile?: string;
+}
+interface SearchMatch {
+  layer: string;
+  locale: string;
+  key: string;
+  value: unknown;
+}
+interface SearchTranslationsResult {
+  matches: SearchMatch[];
+  totalMatches: number;
+}
+interface RemoveTranslationsPreview {
+  locale: string;
+  key: string;
+  oldValue: unknown;
+}
+interface RemoveTranslationsResult {
+  /** Present when dryRun=true */
+  dryRun?: boolean;
+  wouldRemove?: RemoveTranslationsPreview[];
+  /** Present when dryRun=false */
+  removed?: string[];
+  removedPerLocale?: string[];
+  notFound?: string[];
+  filesWritten?: number;
+  summary?: {
+    keysFound: number;
+    message: string;
+  };
+}
+interface RenameTranslationKeyPreview {
+  locale: string;
+  oldKey: string;
+  newKey: string;
+  value: unknown;
+}
+interface RenameTranslationKeyResult {
+  /** Present when dryRun=true */
+  dryRun?: boolean;
+  wouldRename?: RenameTranslationKeyPreview[];
+  /** Present when dryRun=false */
+  renamed?: string[];
+  filesWritten?: number;
+  oldKey?: string;
+  newKey?: string;
+  notFoundInLocales?: string[];
+  conflictsInLocales?: string[];
+  skippedDueToConflict?: string[];
+  summary?: {
+    localesAffected: number;
+    message: string;
+    warning?: string;
+  };
+}
+/** How a translate run was (or would be) executed. */
+type TranslateMode = 'provider' | 'agent' | 'dry-run';
+/** Why a key could not be translated. */
+type TranslateFailReason = 'provider-error' | 'omitted-by-model' | 'placeholder-mismatch' | 'plural-mismatch' | 'write-error' | 'truncated';
+/** Why a key or locale was intentionally not attempted. */
+type TranslateSkipReason = 'no-provider' | 'already-translated' | 'protected-locale';
+interface TranslateMissingLocaleResult {
+  mode: TranslateMode;
+  /** Number of missing keys found for this locale. Always equals
+   *  translated + wouldTranslate + failed + skipped. */
+  missing: number;
+  translated: string[];
+  /** Dry-run only: keys that would be translated. */
+  wouldTranslate?: string[];
+  failed: Array<{
+    key: string;
+    reason: TranslateFailReason;
+  }>;
+  skipped: Array<{
+    key: string;
+    reason: TranslateSkipReason;
+  }>;
+  batches?: number;
+  model?: string;
+  writeError?: string;
+  placeholderValidation?: PlaceholderValidationResult;
+}
+/** One locale's digest in compact mode: counts rather than key lists. */
+interface TranslateMissingCompactEntry {
+  locale: string;
+  mode: TranslateMode;
+  missing: number;
+  translated: number;
+  failed: number;
+  skipped: number;
+  wouldTranslate?: number;
+  batches?: number;
+  model?: string;
+  writeError?: string;
+}
+interface TranslateMissingResult {
+  /** Absent in compact mode, which returns `summary.byLocale` instead. */
+  results?: Record<string, TranslateMissingLocaleResult>;
+  fallbackContexts?: Record<string, Record<string, unknown>>;
+  summary: {
+    /** Compact mode only: a per-locale digest in place of full `results`. */
+    byLocale?: TranslateMissingCompactEntry[];
+    mode: TranslateMode;
+    totalTranslated: number;
+    totalFailed: number;
+    totalSkipped: number;
+    totalWouldTranslate?: number;
+    layer: string;
+    referenceLocale: string | LocaleRefInfo;
+    targetLocales: Array<string | LocaleRefInfo>;
+    dryRun: boolean;
+    /** Surface-owned guidance (set by the CLI command or MCP tool, not the core). */
+    message?: string;
+  };
+}
+/**
+ * Per-layer totals in the all-layers translate summary (`summary.byLayer`).
+ * Field names mirror the cross-layer summary totals so consumers parse both
+ * with the same accessors. `totalWouldTranslate` is always present (0 outside
+ * dry runs).
+ */
+/** Aggregated summary across every locale-backed layer. */
+interface TranslateAllLayersSummary {
+  mode: TranslateMode;
+  totalTranslated: number;
+  totalFailed: number;
+  totalSkipped: number;
+  totalWouldTranslate?: number;
+  /** Layer names that were translated. */
+  layers: string[];
+  byLayer: TranslateLayerTotals[];
+  dryRun: boolean;
+  referenceLocale?: string | LocaleRefInfo;
+  targetLocales?: Array<string | LocaleRefInfo>;
+  /** Surface-owned guidance (set by the CLI command or MCP tool). */
+  message?: string;
+}
+/**
+ * All-layers mode (`--layer` omitted): one result per layer plus an aggregated
+ * summary. Discriminate with `'layers' in result` — both members carry a
+ * `summary`, and both summaries carry `mode`, so mode checks need no narrowing.
+ */
+interface TranslateAllLayersResult {
+  layers: Record<string, TranslateMissingResult>;
+  summary: TranslateAllLayersSummary;
+}
+/** What translateMissing returns: depends on whether a layer was named. */
+type TranslateMissingOutcome = TranslateMissingResult | TranslateAllLayersResult;
+interface TranslateLayerTotals {
+  layer: string;
+  totalTranslated: number;
+  totalFailed: number;
+  totalSkipped: number;
+  totalWouldTranslate: number;
+}
+interface TranslateKeyLocaleIssue {
+  locale: string;
+  reason: TranslateFailReason | 'read-error';
+  detail?: string;
+}
+interface TranslateKeyResult {
+  key: string;
+  sourceLocale: LocaleRefInfo;
+  updatedSource: boolean;
+  mode: TranslateMode;
+  translated: string[];
+  /** Dry-run only: locales that would be translated. */
+  wouldTranslate?: string[];
+  skipped: Array<{
+    locale: string;
+    reason: TranslateSkipReason;
+  }>;
+  failed: TranslateKeyLocaleIssue[];
+  filesWritten: number;
+  dryRun: boolean;
+  model?: string;
+  placeholderValidation: PlaceholderValidationResult;
+  preview?: Record<string, string>;
+  fallbackContext?: Record<string, unknown>;
+  /** Surface-owned guidance (set by the CLI command or MCP tool, not the core). */
+  message?: string;
+}
+/** A key referenced only from apps outside its layer's consumption scope. */
+interface MisplacedUsageRef {
+  key: string;
+  /** Layer the key is defined in. */
+  layer: string;
+  /** Out-of-scope scan units (apps or layers) where the key was found. */
+  usingApps: string[];
+}
+interface DynamicKeyRef {
+  expression: string;
+  /** Absent for context-free bare candidates, which have no single call site. */
+  file?: string;
+  line?: number;
+}
+interface UnresolvedKeyWarningRef {
+  expression: string;
+  file: string;
+  line: number;
+  callee: string;
+  suggestedIgnorePattern?: string;
+}
+interface FindOrphanKeysResult {
+  /** Absent when the full report went to `reportFile` instead. */
+  orphanKeys?: Record<string, string[]>;
+  uncertainKeys?: Record<string, string[]>;
+  /** Keys used only from apps that do not consume the owning layer. */
+  misplacedUsages?: MisplacedUsageRef[];
+  misplacedUsageNote?: string;
+  summary: {
+    totalKeys: number;
+    orphanCount: number;
+    uncertainCount?: number;
+    misplacedCount?: number;
+    dynamicMatchedCount?: number;
+    ignoredCount?: number;
+    usedCount?: number;
+    filesScanned: number;
+    layersChecked?: string[];
+    dirsScanned?: string[];
+    scanScope?: Record<string, string[]>;
+    locale?: string;
+    message?: string;
+  };
+  dynamicKeyWarning?: string;
+  dynamicKeys?: DynamicKeyRef[];
+  unresolvedKeyWarnings?: UnresolvedKeyWarningRef[];
+  /** Present when reportOutput is configured */
+  reportFile?: string;
+}
+/** Where each requested key is referenced in source. */
+interface CodeUsageResult {
+  /** Absent when the full report went to `reportFile` instead. */
+  usages?: Record<string, CodeUsageRef[]>;
+  /** Requested keys with no reference anywhere in the scanned source. */
+  notFoundInCode?: string[];
+  /** Dynamic expressions that could reach the requested keys. */
+  dynamicKeys?: DynamicKeyRef[];
+  summary: {
+    uniqueKeysFound: number;
+    totalReferences: number;
+    filesScanned: number;
+    dirsScanned?: string[];
+    message?: string;
+  };
+  /** Present when the full report went to a file instead. */
+  reportFile?: string;
+}
+interface CodeUsageRef {
+  file: string;
+  line: number;
+  callee: string;
+}
+interface ScanCodeUsageResult {
+  usages: Record<string, CodeUsageRef[]>;
+  summary: {
+    uniqueKeysFound: number;
+    totalReferences: number;
+    filesScanned: number;
+    dirsScanned: string[];
+  };
+  notFoundInCode?: string[];
+  dynamicKeys?: DynamicKeyRef[];
+  /** Present when reportOutput is configured */
+  reportFile?: string;
+}
+interface RemoveOrphanKeysResult {
+  orphanKeys?: Record<string, string[]>;
+  removed?: Record<string, string[]>;
+  uncertainKeys?: Record<string, string[]>;
+  misplacedUsages?: MisplacedUsageRef[];
+  misplacedUsageNote?: string;
+  summary: {
+    dryRun?: boolean;
+    totalKeys: number;
+    orphanCount?: number;
+    removedCount?: number;
+    uncertainCount?: number;
+    misplacedCount?: number;
+    dynamicMatchedCount?: number;
+    ignoredCount?: number;
+    usedCount?: number;
+    remainingCount?: number;
+    filesScanned?: number;
+    filesWritten?: number;
+    layersChecked?: string[];
+    dirsScanned?: string[];
+    scanScope?: Record<string, string[]>;
+    locale?: string;
+    message?: string;
+  };
+  dynamicKeyWarning?: string;
+  dynamicKeys?: DynamicKeyRef[];
+  unresolvedKeyWarnings?: UnresolvedKeyWarningRef[];
+  /** Present when reportOutput is configured */
+  reportFile?: string;
+}
+interface ScaffoldLocaleFileInfo {
+  locale: string;
+  layer: string;
+  file: string;
+  keys: number;
+  namespace?: string;
+}
+interface ScaffoldLocaleResult {
+  created: ScaffoldLocaleFileInfo[];
+  skipped: ScaffoldLocaleFileInfo[];
+  dryRun: boolean;
+}
+interface TranslateRequest {
+  systemPrompt: string;
+  userMessage: string;
+  maxTokens: number;
+}
+interface TranslateResponse {
+  text: string;
+  model: string;
+  /** True when the provider stopped early (finish/stop reason = token limit).
+   *  The response text is incomplete and must not be parsed as a full batch. */
+  truncated?: boolean;
+}
+type TranslateFn = (opts: TranslateRequest) => Promise<TranslateResponse>;
+type ProgressFn = (message: string) => Promise<void>;
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/core/shared.d.ts
+/** Fields a locale ref may match, in resolution precedence order. */
+declare const LOCALE_MATCH_FIELDS: readonly ["code", "language", "file"];
+type LocaleMatchField = (typeof LOCALE_MATCH_FIELDS)[number];
+interface LocaleRefAmbiguity {
+  ref: string;
+  /** The field that matched more than one locale. */
+  matchedBy: LocaleMatchField;
+  /** Codes of every locale the ref matched, in config order. */
+  candidates: string[];
+  /** The one that was used — the first candidate. */
+  resolvedTo: string;
+}
+declare function findLocaleImpl(config: I18nConfig, localeRef: string): LocaleDefinition | undefined;
+/**
+ * Resolve the reference locale for scan operations: the requested ref or the
+ * project default. Throws LOCALE_NOT_FOUND listing the available codes.
+ */
+//#endregion
+//#region src/core/ops-translate.d.ts
+/**
+ * Resolve the config's `protectedLocales` entries (any locale ref: code,
+ * language tag, or file name) against the known locales. Entries that do not
+ * match a known locale are ignored with a warning. Returns the resolved
+ * definitions, deduplicated by canonical code.
+ */
+declare function resolveProtectedLocales(config: I18nConfig): LocaleDefinition[];
+/**
+ * Find keys missing in target locales and translate them.
+ *
+ * When translateFn is provided, uses it to translate via LLM.
+ * When translateFn is absent, returns fallback contexts for the agent.
+ *
+ * When `layer` is omitted, every canonical locale-backed layer is translated
+ * in one run and the results are aggregated (see translateMissingAllLayers).
+ */
+declare function translateMissing(opts: {
+  layer?: string;
+  referenceLocale?: string;
+  targetLocales?: string[];
+  locales?: string[];
+  keys?: string[];
+  batchSize?: number;
+  dryRun?: boolean;
+  compact?: boolean;
+  projectDir?: string;
+  translateFn?: TranslateFn;
+  progressFn?: ProgressFn;
+  /** Called once after the pre-scan with the computed total number of progress steps. */
+  onProgressTotal?: (total: number) => void;
+}): Promise<TranslateMissingOutcome>;
+/**
+ * Translate one key from a source locale into target locales. Unlike
+ * translate_missing, this can overwrite stale existing target values.
+ */
+declare function translateKey(opts: {
+  layer: string;
+  key: string;
+  sourceLocale: string;
+  sourceValue?: string;
+  targetLocales?: string[] | 'all';
+  overwrite?: boolean;
+  dryRun?: boolean;
+  includePreview?: boolean;
+  projectDir?: string;
+  translateFn?: TranslateFn;
+}): Promise<TranslateKeyResult>;
+//# sourceMappingURL=ops-translate.d.ts.map
+//#endregion
+//#region src/core/ops-read.d.ts
+/**
+ * Detect the i18n configuration from the project, always bypassing the
+ * config cache (clears it first).
+ */
+declare function detectConfig(projectDir?: string): Promise<I18nConfig>;
+/**
+ * List all i18n locale directories in the project, grouped by layer.
+ */
+declare function listLocaleDirs(projectDir?: string): Promise<LocaleDirInfo[]>;
+/**
+ * Get translation values for given key paths from a specific locale and layer.
+ */
+declare function getTranslations(opts: {
+  layer: string;
+  locale: string;
+  keys: string[];
+  compact?: boolean;
+  projectDir?: string;
+}): Promise<Record<string, Record<string, unknown>>>;
+/**
+ * Find translation keys that exist in the reference locale but are missing in other locales.
+ */
+declare function getMissingTranslations(opts: {
+  layer?: string;
+  referenceLocale?: string;
+  targetLocales?: string[];
+  locales?: string[];
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<MissingTranslationsResult>;
+/**
+ * Find translation keys that have empty string values in locale files.
+ */
+declare function findEmptyTranslations(opts: {
+  layer?: string;
+  locale?: string;
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<EmptyTranslationsResult>;
+/**
+ * Search translation files by key pattern or value substring.
+ */
+declare function searchTranslations(opts: {
+  query: string;
+  searchIn?: 'keys' | 'values' | 'both';
+  layer?: string;
+  locale?: string;
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<{
+  matches: SearchMatch[];
+  totalMatches: number;
+} | {
+  reportFile: string;
+  summary: {
+    totalMatches: number;
+  };
+}>;
+interface NamespaceNode {
+  keyCount: number;
+  children?: Record<string, NamespaceNode>;
+}
+interface ListNamespacesResult {
+  layers: Record<string, {
+    namespaces: Record<string, NamespaceNode>;
+  }>;
+}
+/**
+ * Build a prefix tree of all translation keys grouped by layer and namespace.
+ * Useful for agents to browse available keys without guesswork.
+ */
+declare function listNamespaces(opts: {
+  layer?: string;
+  locale?: string;
+  projectDir?: string;
+}): Promise<ListNamespacesResult>;
+//# sourceMappingURL=ops-read.d.ts.map
+//#endregion
+//#region src/core/ops-write.d.ts
+/**
+ * Write translation keys to the specified layer with mode control.
+ *
+ * Mode:
+ *   - 'upsert' (default): Adds new keys and updates existing ones. Never skips.
+ *   - 'add': Only creates new keys, skipping existing ones.
+ *   - 'update': Only modifies existing keys, skipping missing ones.
+ */
+declare function writeTranslations(opts: {
+  layer: string;
+  translations: Record<string, Record<string, string>>;
+  mode?: 'add' | 'update' | 'upsert';
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<WriteTranslationsResult>;
+/**
+ * Add new translation keys to the specified layer.
+ *
+ * @deprecated Use writeTranslations with mode: 'add' instead.
+ */
+declare function addTranslations(opts: {
+  layer: string;
+  translations: Record<string, Record<string, string>>;
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<AddTranslationsResult>;
+/**
+ * Update existing translation keys in the specified layer.
+ *
+ * @deprecated Use writeTranslations with mode: 'update' instead.
+ */
+declare function updateTranslations(opts: {
+  layer: string;
+  translations: Record<string, Record<string, string>>;
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<UpdateTranslationsResult>;
+/**
+ * Remove one or more translation keys from ALL locale files in the specified layer.
+ */
+declare function removeTranslations(opts: {
+  layer: string;
+  keys: string[];
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<RemoveTranslationsResult>;
+/**
+ * Rename/move a translation key across ALL locale files in a layer.
+ */
+declare function renameTranslationKey(opts: {
+  layer: string;
+  oldKey: string;
+  newKey: string;
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<RenameTranslationKeyResult>;
+/**
+ * Create empty locale files for new languages.
+ */
+declare function scaffoldLocaleFiles(opts: {
+  locales?: string[];
+  layer?: string;
+  dryRun?: boolean;
+  projectDir?: string;
+}): Promise<ScaffoldLocaleResult>;
+//# sourceMappingURL=ops-write.d.ts.map
+//#endregion
+//#region src/core/ops-status.d.ts
+/**
+ * Coverage for a project: per locale, per layer, and one overall figure.
+ *
+ * Protected locales are counted and reported but excluded from the overall
+ * percentage — they are maintained by hand, so counting their gaps as project
+ * debt makes a healthy project read as failing and moves a number nobody can
+ * act on.
+ */
+declare function getTranslationStatus(opts: {
+  layer?: string;
+  referenceLocale?: string;
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<TranslationStatusResult>;
+//# sourceMappingURL=ops-status.d.ts.map
+
+//#endregion
+//#region src/core/ops-orphans.d.ts
+/**
+ * Find translation keys that exist in locale files but are not referenced in source code.
+ */
+declare function findOrphanKeys(opts: {
+  layer?: string;
+  locale?: string;
+  /**
+   * Explicit scan roots — manual scope control. When set, all layers are
+   * checked against one combined usage set from these dirs (no per-layer
+   * scoping, no misplaced-usage detection). When absent, a scope-aware plan
+   * from the layer graph is used: each layer is checked against the apps
+   * that consume it.
+   */
+  scanDirs?: string[];
+  excludeDirs?: string[];
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<FindOrphanKeysResult>;
+/**
+ * Scan Vue/TS source files to find where translation keys are referenced.
+ */
+declare function scanCodeUsage(opts: {
+  keys?: string[];
+  scanDirs?: string[];
+  excludeDirs?: string[];
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<CodeUsageResult>;
+/**
+ * Find translation keys not referenced in source code and remove them.
+ */
+declare function removeOrphanKeys(opts: {
+  layer?: string;
+  locale?: string;
+  /** Explicit scan roots — manual scope control, same semantics as {@link findOrphanKeys}. */
+  scanDirs?: string[];
+  excludeDirs?: string[];
+  dryRun?: boolean;
+  projectDir?: string;
+  outputFile?: string;
+  /** Also write the orphan findings as a GitLab Code Quality JSON array to this path. */
+  codequalityOutput?: string;
+}): Promise<RemoveOrphanKeysResult>;
+//# sourceMappingURL=ops-orphans.d.ts.map
+//#endregion
+//#region src/core/ops-duplicates.d.ts
+/**
+ * Cross-layer duplicate-key detection: keys defined in both a shared layer
+ * and a consuming child layer, compared in one reference locale.
+ */
+interface DuplicateKeyCollision {
+  key: string;
+  sharedLayer: string;
+  childLayer: string;
+  sharedValue: unknown;
+  childValue: unknown;
+  divergent: boolean;
+}
+interface FindDuplicateKeysSummary {
+  totalCollisions: number;
+  divergentCount: number;
+  pairsChecked: number;
+  locale: string;
+  message?: string;
+}
+interface FindDuplicateKeysResult {
+  collisions: DuplicateKeyCollision[];
+  guidance: string;
+  summary: FindDuplicateKeysSummary;
+}
+/**
+ * Find keys defined in both a shared layer and a consuming child layer,
+ * comparing values in a single reference locale (default: the project
+ * default locale). Pure locale-file I/O — no source scanning.
+ */
+declare function findDuplicateKeys(opts?: {
+  locale?: string;
+  projectDir?: string;
+  outputFile?: string;
+}): Promise<FindDuplicateKeysResult | {
+  reportFile: string;
+  summary: FindDuplicateKeysSummary;
+}>;
+//# sourceMappingURL=ops-duplicates.d.ts.map
+//#endregion
+//#region src/core/ops-check.d.ts
+/**
+ * Used-but-undefined key detection — the inverse of orphan scanning.
+ *
+ * A key referenced in source code but defined in no locale file of the
+ * using app's consumed layers renders as a raw key at runtime. Nothing
+ * else catches this direction (orphan scanning only computes
+ * locale − code; this computes code − locale, per scan unit).
+ */
+interface KeyUsageLocation {
+  /** Source file path, relative to the project dir. */
+  file: string;
+  line: number;
+}
+interface UndefinedKeyFinding {
+  key: string;
+  /** Scan unit the usage lives in (app name, layer name, or project-root). */
+  app: string;
+  /** Layers whose keys this unit can resolve — all were searched. */
+  searchedLayers: string[];
+  usages: KeyUsageLocation[];
+}
+interface UncertainKeyFinding extends UndefinedKeyFinding {
+  /** Why this is not a hard finding. */
+  reason: string;
+}
+interface CheckUndefinedKeysSummary {
+  /** Distinct statically referenced keys across all scan units. */
+  usedKeysChecked: number;
+  undefinedCount: number;
+  uncertainCount: number;
+  /** Unresolvable keys excluded by orphanScan ignorePatterns. */
+  ignoredCount: number;
+  filesScanned: number;
+  locale: string;
+  /** Scan unit → layers searched for that unit's key usages. */
+  searchedLayersByApp: Record<string, string[]>;
+  message: string;
+}
+interface CheckUndefinedKeysResult {
+  undefinedKeys: UndefinedKeyFinding[];
+  uncertainKeys: UncertainKeyFinding[];
+  limitation: string;
+  summary: CheckUndefinedKeysSummary;
+}
+/**
+ * Find keys referenced in source code that resolve to no definition in the
+ * using app's consumed layers (reference locale, default: project default).
+ *
+ * Mirrors the orphan scan's per-unit structure: with no explicit scanDirs,
+ * the scope-aware plan from the layer graph decides which layers each scan
+ * unit's code can resolve (the inversion of the orphan scan's
+ * scopeByLayer — a unit resolves exactly the layers it vouches for). The
+ * graph's degenerate semantics carry over: with no app info every layer is
+ * resolvable everywhere, so only keys defined in NO layer are flagged.
+ */
+declare function checkUndefinedKeys(opts?: {
+  locale?: string;
+  /**
+   * Explicit scan roots — manual scope control. Every layer is treated as
+   * resolvable from every scanned dir (global behavior, no per-app scoping).
+   */
+  scanDirs?: string[];
+  excludeDirs?: string[];
+  projectDir?: string;
+  outputFile?: string;
+  /** Also write the findings as a GitLab Code Quality JSON array to this path. */
+  codequalityOutput?: string;
+}): Promise<CheckUndefinedKeysResult | {
+  reportFile: string;
+  summary: CheckUndefinedKeysSummary;
+}>;
+//# sourceMappingURL=ops-check.d.ts.map
+//#endregion
+//#region src/config/detector.d.ts
+declare function detectI18nConfig(projectDir: string): Promise<I18nConfig>;
+declare function clearConfigCache(): void;
+declare function getCachedConfig(): I18nConfig | null;
+//# sourceMappingURL=detector.d.ts.map
+
+//#endregion
+//#region src/config/layer-graph.d.ts
+/**
+ * Queryable view over the layer topology a resolved {@link I18nConfig}
+ * already carries: which locale dirs are canonical (alias-free), which
+ * layer owns an aliased dir, and which apps consume which layers.
+ *
+ * This is a pure derivation — no filesystem access, no config-shape
+ * changes. Cross-layer tooling (duplicate detection, scope-aware orphan
+ * scanning) builds on these queries instead of name-matching heuristics.
+ *
+ * ## Degenerate-case semantics
+ *
+ * These are load-bearing for consumers (scope-aware scanning must never
+ * wrongly narrow its scan scope):
+ *
+ * - **No app info** (`config.apps` empty or absent, e.g. hand-built
+ *   configs): consumption edges are unknowable. `appsUsingLayer` and
+ *   `layersOfApp` return `[]`, and `sharedLayers` conservatively contains
+ *   *every* canonical layer — with no ownership information, every
+ *   layer's keys must be treated as globally visible.
+ * - **Single-app config** (generic/Laravel/Vue/React adapters, or a Nuxt
+ *   project with one app): the strict definition applies, so
+ *   `sharedLayers` is empty (no layer is consumed by more than one app)
+ *   and `appsUsingLayer` returns that one app for the layers it consumes.
+ *   Per-layer scope then equals the whole project, which is correct.
+ * - **Canonical layer consumed by no app** (in a multi-app config):
+ *   `appsUsingLayer` returns `[]` and the layer is not in `sharedLayers`.
+ *   Callers should treat such layers conservatively (global scope).
+ */
+interface LayerGraph {
+  /**
+   * Alias-free locale dirs, in `config.localeDirs` order. Aliased entries
+   * (e.g. `app-outlook` pointing at `app-shop`'s dir) are excluded.
+   */
+  canonicalLayers: LocaleDir[];
+  /**
+   * Resolve a layer name to the canonical layer that owns its locale dir.
+   * Follows chained `aliasOf` links (an alias may point at a layer that
+   * was itself demoted to an alias). Identity for canonical names and for
+   * names unknown to `localeDirs` (e.g. layers without locale dirs).
+   */
+  ownerOf: (layer: string) => string;
+  /**
+   * Names of apps whose consumed layers include the given layer. The
+   * queried name and each app's layer list are alias-resolved via
+   * {@link ownerOf} first, so querying an alias name yields the owner's
+   * consumers. Returns `[]` when no app info exists.
+   */
+  appsUsingLayer: (layer: string) => string[];
+  /**
+   * Canonical layers consumed by more than one app — e.g. a shared root
+   * layer in a multi-app monorepo, identified purely from consumption
+   * edges (no name matching). When no app info exists, contains every
+   * canonical layer (see degenerate-case semantics above).
+   */
+  sharedLayers: LocaleDir[];
+  /**
+   * Canonical layers the given app consumes (alias entries in the app's
+   * layer list resolve to their owners; layers without locale dirs are
+   * omitted). Returns `[]` for unknown apps or when no app info exists.
+   */
+  layersOfApp: (app: string) => LocaleDir[];
+}
+/**
+ * Build a {@link LayerGraph} from a resolved config's `localeDirs`
+ * (with their `aliasOf` markers) and `apps` (app → consumed-layers edges).
+ */
+declare function buildLayerGraph(config: I18nConfig): LayerGraph;
+//# sourceMappingURL=layer-graph.d.ts.map
+//#endregion
+//#region src/io/locale-data.d.ts
+declare function readLocaleData(config: I18nConfig, layer: string, locale: LocaleDefinition): Promise<Record<string, unknown>>;
+/**
+ * Read, mutate, and write back locale data for a locale in a layer.
+ *
+ * The mutation function receives the merged locale object (same shape as readLocaleData)
+ * and may modify it in-place. After mutation:
+ *
+ * - Nuxt: Writes the entire object back to the single JSON file
+ * - Laravel / Next.js / React: Splits by top-level namespace keys and writes each to its file.
+ *   New namespaces create new files. Empty namespaces delete the content (write empty object).
+ *
+ * Returns the set of file paths that were written.
+ */
+//#endregion
+//#region src/utils/errors.d.ts
+/** Extract a human-readable message from any thrown value. */
+declare function toErrorMessage(error: unknown): string;
+declare class ToolError extends Error {
+  readonly code: string;
+  constructor(message: string, code: string);
+}
+//# sourceMappingURL=errors.d.ts.map
+//#endregion
+//#region src/llm/providers.d.ts
+type LlmProvider = 'openai' | 'anthropic' | 'google';
+/** How a provider failure should be handled by the caller. */
+type TranslateProviderErrorKind = 'auth' | 'rate-limit' | 'provider' | 'config';
+/**
+ * A classified provider failure. `auth` errors are not retryable (the caller
+ * should abort the run), `rate-limit` errors should be retried with backoff,
+ * and `provider` covers everything else (server errors, network, …).
+ * `config` marks an unusable provider setup and is raised while building the
+ * TranslateFn, before any request exists — so it surfaces from the command
+ * and never reaches the retry loop.
+ */
+declare class TranslateProviderError extends Error {
+  readonly kind: TranslateProviderErrorKind;
+  readonly status?: number;
+  constructor(message: string, kind: TranslateProviderErrorKind, status?: number);
+}
+/**
+ * Classify an SDK error into a TranslateProviderError:
+ * 401/403 → auth, 429 → rate-limit, anything else → provider.
+ * Already-classified errors pass through unchanged.
+ */
+declare function classifyProviderError(error: unknown): TranslateProviderError;
+interface LlmProviderConfig {
+  provider: LlmProvider;
+  model: string;
+  /** Override API key. Falls back to env vars */
+  apiKey?: string;
+  /** Base URL override for proxies / compatible APIs */
+  baseUrl?: string;
+}
+/** Environment variable carrying the provider base URL override. */
+declare const BASE_URL_ENV = "I18N_BASE_URL";
+/**
+ * Resolve the provider base URL from its three sources, highest precedence
+ * first: an explicit flag, the I18N_BASE_URL env var, then the project
+ * config's `providerBaseUrl`.
+ *
+ * Blank values count as unset. Shells produce them routinely — `--baseUrl
+ * "$UNSET"` or an exported-but-empty variable — and a blank must not shadow a
+ * real endpoint configured further down the chain. A blank in the config file
+ * is a different case: it cannot arise by accident, so the strict schema
+ * rejects it at load time rather than letting it reach this function.
+ */
+declare function resolveProviderBaseUrl(sources: {
+  flag?: string;
+  env?: string;
+  config?: string;
+}): string | undefined;
+/**
+ * Create a TranslateFn from an LLM provider config.
+ * Throws if the provider SDK is not installed or API key is missing.
+ */
+declare function createTranslateFn(config: LlmProviderConfig): Promise<TranslateFn>;
+//# sourceMappingURL=providers.d.ts.map
+//#endregion
+//#region src/config/project-config.d.ts
+/**
+ * Load the project's declared configuration, from either place it can be
+ * declared: `i18n-kit.config.ts` and `.i18n-mcp.json`. Both are searched from
+ * projectDir upwards, the way ESLint, Prettier and tsconfig resolve configs.
+ *
+ * Returns null when neither exists — the case that must keep behaving exactly
+ * as it did before there were two. Throws ConfigError when either file is
+ * present but unusable, or when the two disagree.
+ *
+ * Every adapter funnels through here, which is what makes the typed config
+ * work for all of them rather than for whichever one was taught about it.
+ */
+declare function loadProjectConfig(projectDir: string): Promise<ProjectConfig | null>;
+//# sourceMappingURL=project-config.d.ts.map
+
+//#endregion
+export { AddTranslationsResult, BASE_URL_ENV, type CheckUndefinedKeysResult, type CheckUndefinedKeysSummary, CodeUsageRef, CodeUsageResult, type DuplicateKeyCollision, DynamicKeyRef, EmptyTranslationsResult, type FindDuplicateKeysResult, type FindDuplicateKeysSummary, FindOrphanKeysResult, GeneratedProjectConfig, type I18nConfig, type I18nKitConfig, InitProjectConfigResult, type KeyUsageLocation, type LayerGraph, LayerStatus, type LlmProvider, type LlmProviderConfig, type LocaleDefinition, type LocaleDir, LocaleDirInfo, type LocaleRefAmbiguity, LocaleRefInfo, LocaleStatus, MisplacedUsageRef, MissingTranslationsResult, MutationPreview, MutationResult, PlaceholderValidationIssue, PlaceholderValidationResult, ProgressFn, type ProjectConfig, RemoveOrphanKeysResult, RemoveTranslationsPreview, RemoveTranslationsResult, RenameTranslationKeyPreview, RenameTranslationKeyResult, ScaffoldLocaleFileInfo, ScaffoldLocaleResult, ScanCodeUsageResult, SearchMatch, SearchTranslationsResult, ToolError, TranslateAllLayersResult, TranslateAllLayersSummary, TranslateFailReason, TranslateFn, TranslateKeyLocaleIssue, TranslateKeyResult, TranslateLayerTotals, TranslateMissingCompactEntry, TranslateMissingLocaleResult, TranslateMissingOutcome, TranslateMissingResult, TranslateMode, TranslateProviderError, type TranslateProviderErrorKind, TranslateRequest, TranslateResponse, TranslateSkipReason, TranslationStatusResult, TranslationStatusSummary, type UncertainKeyFinding, type UndefinedKeyFinding, UnresolvedKeyWarningRef, UnresolvedLocaleRef, UpdateTranslationsResult, WriteTranslationsResult, addTranslations, buildLayerGraph, checkUndefinedKeys, classifyProviderError, clearConfigCache, createTranslateFn, defineI18nKitConfig, detectConfig, detectI18nConfig, findDuplicateKeys, findEmptyTranslations, findLocaleImpl, findOrphanKeys, getCachedConfig, getMissingTranslations, getTranslationStatus, getTranslations, listLocaleDirs, listNamespaces, loadProjectConfig, readLocaleData, removeOrphanKeys, removeTranslations, renameTranslationKey, resolveProtectedLocales, resolveProviderBaseUrl, scaffoldLocaleFiles, scanCodeUsage, searchTranslations, toErrorMessage, translateKey, translateMissing, updateTranslations, writeTranslations };
+//# sourceMappingURL=index-BtSA6-iT.d.ts.map