@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/types-CgUCkFU1.d.ts

@@ -0,0 +1,707 @@
+//#region src/runtime/types.d.ts
+/** Where a locale may come from, in `routing.strategy` order. */
+type LocaleStrategy = "url" | "cookie" | "header" | "localStorage" | "default";
+/** URL codec strategies (Nuxt i18n names); domains are `routing.domains` on top of `prefix_except_default`. */
+type UrlStrategy = "prefix_except_default" | "prefix" | "prefix_and_default" | "no_prefix";
+declare global {
+  /**
+   * Defined by `vi18n:config` (`true` in `vite dev`, `false` in builds). Runtime
+   * code reads it as `typeof __VI18N_DEV__ !== "undefined" && __VI18N_DEV__`, so
+   * code bundled without the plugin behaves as production. `var`, not `const`:
+   * the two pack configs each inline this file into their own `.d.ts` chunk,
+   * and a consumer importing both would hit a block-scoped redeclaration.
+   */
+  var __VI18N_DEV__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether the config has `routing.paths` or
+   * `routing.domains`. Code bundled without the plugin keeps the support
+   * (`typeof __VI18N_ROUTES__ === "undefined" || __VI18N_ROUTES__`), and a
+   * plugin build of a config without either folds it out (PLAN §6).
+   */
+  var __VI18N_ROUTES__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `ssr.payload` is `"preload"`. Code
+   * bundled without the plugin keeps the support (a Nitro-built `/server`
+   * copy reads the registration's config), and a plugin build of the default
+   * config folds it out of the engine and `/server` (PLAN §6).
+   */
+  var __VI18N_PRELOAD__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `output.compactIds` is on. Only the
+   * plugin's boot module imports the engine, so undefined reads as false.
+   */
+  var __VI18N_COMPACT__: boolean | undefined;
+  /**
+   * Defined by `vi18n:config`: whether `output.perLocale` is on. Undefined
+   * is false, as for `__VI18N_COMPACT__`.
+   */
+  var __VI18N_INLINE__: boolean | undefined;
+}
+//#endregion
+//#region src/core/types.d.ts
+type Severity = "error" | "warning" | "info";
+/**
+ * Every problem vi18n reports has one of these codes. The CLI prints them in
+ * `--json` and as GitHub annotation titles (`vi18n(<code>)`).
+ */
+type DiagnosticCode = "icu-syntax" | "icu-missing-other" | "icu-unsupported-type" | "icu-pattern-style" | "icu-pound-nested" | "icu-unknown-skeleton" | "icu-unknown-currency" | "icu-unknown-unit" | "icu-bidi-control" | "icu-unbalanced-isolate" | "icu-argument-mismatch" | "icu-tag-mismatch" | "icu-plural-missing-category" | "icu-plural-unused-category" | "icu-plural-one-literal" | "icu-apostrophe" | "icu-max-length" | "extract-dynamic-message" | "extract-non-literal-option" | "extract-invalid-manual-id" | "extract-module-scope" | "extract-html-sink" | "extract-captured-value" | "extract-wrapper-unused" | "extract-outside-include" | "extract-parse-error" | "extract-missing-compiler" | "extract-empty-root" | "id-collision" | "id-scheme-mismatch" | "catalog-parse" | "catalog-duplicate" | "catalog-wrapped" | "catalog-foreign-context" | "catalog-source-mismatch" | "catalog-fuzzy" | "catalog-invalid-translation" | "catalog-missing-translation" | "catalog-unused-entry" | "catalog-obsolete-dropped" | "catalog-safety-limit" | "catalog-drift" | "catalog-write-conflict" | "keep-missing-entry" | "import-parse" | "import-skipped" | "restore-git" | "merge-conflict" | "config-invalid" | "config-not-found" | "build-guard-skipped" | "build-dead-messages" | "ai-validation-failed" | "ai-identical-output" | "ai-provider-error" | "ai-missing-key" | "ai-cost-limit" | "migrate-dynamic-key" | "migrate-date-placeholder" | "migrate-manual" | "migrate-unconverted";
+interface Diagnostic {
+  code: DiagnosticCode;
+  severity: Severity;
+  /** One sentence, no trailing period, naming what to do when there is a fix. */
+  message: string;
+  /** Posix path relative to the config root (or absolute outside it). */
+  file?: string;
+  /** 1-based; 0 or absent when unknown. */
+  line?: number;
+  column?: number;
+  locale?: string;
+  /** Message id or manual id concerned. */
+  id?: string;
+  /** Other places involved, e.g. the second text of a collision. */
+  related?: {
+    file?: string;
+    line?: number;
+    column?: number;
+    message: string;
+  }[];
+  /** Offsets in the scanned code; set only under `ScanOptions.ranges` (the `/lint` rules report at them). */
+  range?: [number, number];
+}
+/**
+ * Errors thrown by core functions (codec, parsers, loaders) carry the
+ * diagnostic, so callers in any module can report them without `instanceof`.
+ */
+interface DiagnosticError extends Error {
+  diagnostic: Diagnostic;
+}
+/** UTF-16 offsets into the parsed string (after NFC and LF normalisation). */
+interface IcuLoc {
+  start: number;
+  end: number;
+}
+type IcuNode = IcuLiteral | IcuArgument | IcuFormatted | IcuSelect | IcuPlural | IcuPound | IcuTag;
+/** A parsed message: nodes in order; adjacent literals are merged; `[]` is the empty message. */
+type IcuMessage = IcuNode[];
+/** Literal text with quoting removed (`''` → `'`, `'{'` → `{`). Never empty. */
+interface IcuLiteral {
+  type: "literal";
+  value: string;
+  loc?: IcuLoc;
+}
+/** `{name}` */
+interface IcuArgument {
+  type: "argument";
+  name: string;
+  loc?: IcuLoc;
+}
+/** `{name, number|date|time[, style]}` */
+interface IcuFormatted {
+  type: "number" | "date" | "time";
+  name: string;
+  style: IcuStyle | null;
+  /**
+   * Intl options resolved by the parser (FormatJS `formats` tables for
+   * keywords, skeleton conversion for `::…`). Null when Intl defaults apply.
+   */
+  options: {
+    [option: string]: string | number | boolean;
+  } | null;
+  loc?: IcuLoc;
+}
+/**
+ * A style as written, normalised: keywords as-is; skeletons without the
+ * leading `::`, tokens separated by exactly one space.
+ */
+type IcuStyle = {
+  kind: "keyword";
+  value: "integer" | "percent" | "short" | "medium" | "long" | "full";
+} | {
+  kind: "skeleton";
+  value: string;
+};
+/** One branch of a select or plural, in source order. */
+interface IcuOption {
+  /** Select value, `=N` normalised to `"=" + String(Number(N))` (`=01` is `=1`), or a CLDR category / `other`. */
+  key: string;
+  value: IcuMessage;
+  loc?: IcuLoc;
+}
+/** `{name, select, …}` */
+interface IcuSelect {
+  type: "select";
+  name: string;
+  options: IcuOption[];
+  loc?: IcuLoc;
+}
+/** `{name, plural|selectordinal, [offset:N] …}` */
+interface IcuPlural {
+  type: "plural";
+  pluralType: "cardinal" | "ordinal";
+  name: string;
+  /** 0 when absent. */
+  offset: number;
+  options: IcuOption[];
+  loc?: IcuLoc;
+}
+/** `#` in an immediate plural/selectordinal branch (also inside tags there). */
+interface IcuPound {
+  type: "pound";
+  loc?: IcuLoc;
+}
+/** `<name>…</name>`, or `<name/>` when `children` is null. No attributes. */
+interface IcuTag {
+  type: "tag";
+  name: string;
+  children: IcuMessage | null;
+  loc?: IcuLoc;
+}
+/**
+ * The one place that turns source text into ids. Built by `createCodec(length)`
+ * (`src/core/codec.ts`). Wave-1 modules receive it as a parameter.
+ */
+interface MessageCodec {
+  /** `ids.length`, 8–16. */
+  readonly idLength: number;
+  /** `sha256-b64u-<idLength>-v2` (PO `X-Vi18n-Id`, JSON `idScheme`). */
+  readonly idScheme: string;
+  /** NFC + LF, parse, canonical print. Throws a {@link DiagnosticError} (`icu-*`) on invalid ICU. */
+  canonicalize(source: string): string;
+  /**
+   * Parse after NFC + LF normalisation; memoised, so the same AST object is
+   * returned for the same string and must not be mutated. Throws like `canonicalize`.
+   */
+  parse(source: string): IcuMessage;
+  /** `base64url(sha256(utf8(canonical + "\u001F")))`, 43 characters. */
+  sourceHash(canonical: string): string;
+  /** The first `idLength` characters of `sourceHash`: a generated id, or a manual entry's label. */
+  label(canonical: string): string;
+}
+/** How a message argument reached vi18n. */
+type CalleeKind = "t" | "msg" | "rich" | "richHtml" | "richParts" | "alias" | "global" | "translator";
+/** One message at one call site. JSON-serialisable: it is cached and stored in `meta.vi18n`. */
+interface MessageOccurrence {
+  /** Generated id (`label`) or the manual id. */
+  id: string;
+  manual: boolean;
+  /** The exact JS string value at the call site (a `sources.json` key). */
+  source: string;
+  canonical: string;
+  /** 43-character hash of `canonical`. */
+  sourceHash: string;
+  /** Generated id of `canonical`; equals `id` when `manual` is false. */
+  label: string;
+  /** The `context` note as written (may span lines). */
+  context?: string;
+  maxLength?: number;
+  callee: CalleeKind;
+  /** Posix path relative to the config root (a `#:` reference). */
+  file: string;
+  /** 1-based position in the original file; 0 when not yet located. */
+  line: number;
+  column: number;
+}
+//#endregion
+//#region src/ai/types.d.ts
+/** Whatever a provider needs to answer one request. One target locale per request. */
+interface ProviderRequest {
+  sourceLocale: string;
+  targetLocale: string;
+  /**
+   * Stable system prefix (product description, tone, ICU rules, required plural
+   * categories); identical across batches of a locale so implicit caching applies.
+   */
+  system: string;
+  /** Items to translate, deduplicated across routes; 40–80 per request. */
+  items: AiItem[];
+  /** JSON Schema of the expected answer (Gemini `responseJsonSchema`). */
+  responseSchema: JsonSchema;
+}
+/** One item, sent as data. Text is masked: URLs, e-mail addresses and HTML entities become `@@PHn@@`. */
+interface AiItem {
+  /** Catalog key: generated id or manual id. Results are mapped back by this. */
+  id: string;
+  /** Canonical source, masked. */
+  source: string;
+  /** The developer's `context` notes, joined with "\n" (D3). */
+  context?: string;
+  /**
+   * Route and file context: the config-relative files that use the message
+   * (at most 5, sorted). A file-based router's path names the screen.
+   */
+  files?: string[];
+  /** Argument names in the source, in first-use order. */
+  placeholders: string[];
+  /** Tag names in the source. */
+  tags: string[];
+  maxLength?: number;
+  /** Plural categories the target locale needs, when the message has a plural. */
+  pluralCategories?: {
+    cardinal: string[];
+    ordinal: string[];
+  };
+  /** Nearest non-`ai` translations in the target locale (masked). Never AI output. */
+  examples: {
+    source: string;
+    translation: string;
+  }[];
+  /** Retries only: the checks the previous answer failed. */
+  failingChecks?: string[];
+}
+/** A provider's answer. `items` may be partial; missing ids count as failures. */
+interface ProviderResponse {
+  items: {
+    id: string;
+    translation: string;
+  }[];
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+/** What the pipeline passes with each request. */
+interface TranslateOptions {
+  signal?: AbortSignal;
+  /**
+   * Call on every rate limit (HTTP 429, `RESOURCE_EXHAUSTED`) before waiting
+   * it out, with the delay the server asked for when it named one: the
+   * pipeline halves its concurrency and holds new requests that long.
+   */
+  onRateLimit?: (retryAfterMs: number | null) => void;
+}
+/** A pluggable translation backend (`ai.provider`). */
+interface TranslationProvider {
+  /** `"gemini"`, `"openai-compatible"`, or a custom name. */
+  readonly name: string;
+  readonly model: string;
+  translate(request: ProviderRequest, options?: TranslateOptions): Promise<ProviderResponse>;
+  /**
+   * `--dry-run` / `--max-cost`: estimated USD for the given token counts, from a
+   * pinned price table; `NaN` when the model has no known price.
+   */
+  estimateCost?(usage: {
+    inputTokens: number;
+    outputTokens: number;
+  }): number;
+  /**
+   * The environment variable the key is read from, null when no key is sent.
+   * The CLI redacts its value from all output.
+   */
+  readonly apiKeyEnv?: string | null;
+  /** The `ai-missing-key` a call would fail with now, or null; asked before the first request. */
+  missingKey?(): Diagnostic | null;
+  /** The same provider with another model (`--model`). */
+  withModel?(model: string): TranslationProvider;
+  /**
+   * P2 Batch tier (`--tier batch`): answers many requests in asynchronous
+   * jobs at a lower price, in request order. A request the job failed is a
+   * `DiagnosticError` (`ai-provider-error`) in its place; a failed job throws.
+   */
+  translateBatch?(requests: readonly ProviderRequest[], options?: BatchOptions): Promise<(ProviderResponse | DiagnosticError)[]>;
+}
+interface BatchOptions {
+  signal?: AbortSignal;
+  /** Progress while a job runs (its name and state), for the terminal. */
+  onProgress?: (progress: {
+    job: string;
+    state: string;
+    requests: number;
+  }) => void;
+}
+/** P2 Gemini service tiers (`--tier`); Flex and Batch cost half, Batch answers asynchronously. */
+type Tier = "standard" | "flex" | "batch";
+/** Options shared by provider factories. Keys come only from the environment. */
+interface ProviderOptions {
+  model?: string;
+  /** Name of the env variable holding the key. */
+  apiKeyEnv?: string;
+  /** A key is only sent to a host other than the provider's default when `apiKeyEnv` is set explicitly. */
+  baseURL?: string;
+  /** Gemini only. Default `"standard"`. */
+  tier?: Tier;
+  /** Injected in tests (recorded fixtures). Defaults to `globalThis.fetch`. */
+  fetch?: typeof fetch;
+  /** Injected in tests. Defaults to `process.env`. */
+  env?: {
+    readonly [name: string]: string | undefined;
+  };
+}
+/** `openaiCompatible(options)`: any `/chat/completions` API (OpenAI, OpenRouter, Ollama, Gemini's OpenAI endpoint). */
+interface OpenAICompatibleOptions extends Omit<ProviderOptions, "tier"> {
+  model: string;
+  /** Default `https://api.openai.com/v1`. */
+  baseURL?: string;
+  /**
+   * Env variable holding the key, sent as `Authorization: Bearer`. Default
+   * `OPENAI_API_KEY`, and only to the default host: another host gets no key
+   * unless this names one (Ollama needs none).
+   */
+  apiKeyEnv?: string;
+  /**
+   * How the answer's shape is requested: `json_schema` (structured output,
+   * the default), `json_object`, or `text` (the prompt alone). A server that
+   * refuses one is asked again with the next.
+   */
+  responseFormat?: "json_schema" | "json_object" | "text";
+  /** USD per 1M input and output tokens, for `--dry-run` and `--max-cost`; without it the cost is unknown. */
+  prices?: {
+    input: number;
+    output: number;
+  };
+}
+/** A JSON Schema object (the Gemini `responseJsonSchema` subset). */
+type JsonSchema = {
+  [keyword: string]: unknown;
+};
+//#endregion
+//#region src/config/types.d.ts
+/** Severity of a `strict` rule. */
+type Level = "off" | "warn" | "error";
+/** The two generated pseudo-locales (PLAN §4.7, §5.21). */
+type PseudoLocale = "en-XA" | "ar-XB";
+/** `vi18n.config.ts` as written. Every key is optional except where noted. */
+interface Vi18nConfig {
+  /** Default `"en"`. Also the default locale of URL strategies and negotiation. */
+  sourceLocale?: string;
+  /** Default `[sourceLocale]`. Must contain `sourceLocale`. */
+  locales?: string[];
+  /** Default `[]`. Listed pseudo-locales are active in `vite dev` and in builds whose mode is not `production`. */
+  pseudoLocales?: PseudoLocale[];
+  /** Appended after the tag-derived chain (`de-CH` → `de`), before `sourceLocale`. */
+  fallbacks?: {
+    [locale: string]: string[];
+  };
+  project?: {
+    /** Directories or files, relative to the config file. Default `["src"]`. */
+    include?: string[];
+    extensions?: string[];
+    /** gitignore-style: a pattern without `/` matches any path segment; one with `/` (a leading `/` too) is a glob from the config root. */
+    exclude?: string[];
+  };
+  extraction?: {
+    /** Appended to the defaults `@menapo/vi18n` and `@menapo/vi18n/server`, which always apply. */
+    importSources?: string[];
+    /** Other exported names that behave like `t` (matched only when imported from an import source). */
+    aliases?: string[];
+    /** Import-free template callees such as Vue's `$t` (bare, `_ctx.` and `$setup.` forms). */
+    globals?: string[];
+    /** Ids that always ship (dynamic keys); `base` in SPAs, `shared` otherwise. */
+    keep?: string[];
+    /**
+     * Published packages (by name) whose code vi18n extracts and rewrites
+     * like the app's, and whose catalogs it reads under the app's own
+     * (`package.json#vi18n`). Default `[]`.
+     */
+    dependencies?: string[];
+  };
+  ids?: {
+    /** Base64url characters of every generated id, 8–16. Default 12. Changing it is a re-key. */
+    length?: number;
+  };
+  catalogs?: {
+    format?: "po" | "json";
+    /** Relative to the config file, with `{locale}`. Default `locales/{locale}.po` (`.json` for JSON). */
+    path?: string;
+    msgid?: "source" | "id";
+    /**
+     * PO only: mark every entry `#, icu-message-format`, which turns on
+     * Weblate's ICU MessageFormat checks. vi18n owns the flag: `vi18n extract`
+     * adds it to every entry, or removes it when false. Default false.
+     */
+    icuFlag?: boolean;
+  };
+  output?: OutputOptions;
+  routing?: {
+    strategy?: LocaleStrategy[];
+    routeStrategies?: {
+      [pattern: string]: LocaleStrategy[];
+    };
+    url?: UrlStrategy;
+    redirectRoot?: boolean;
+    propagate?: "header" | false;
+    switch?: "in-place" | "navigate";
+    cookie?: {
+      name?: string;
+      maxAge?: number;
+    };
+    /**
+     * The path the app's pages live under, as the URL codec reads it
+     * (`/de/pricing` under `/` names German). Default: Vite's `base`. Set it
+     * where Vite's base is an asset prefix instead (Nuxt: `app.baseURL`,
+     * while Vite's base is `/_nuxt/` in dev). null is the default.
+     */
+    base?: string | null;
+    /**
+     * Localized paths: route path → locale → that locale's path, e.g.
+     * `{ "/about": { de: "/ueber-uns" } }` puts the German page at
+     * `/de/ueber-uns` while the router still sees `/about`. Paths are
+     * base-free; a `*` segment stands for one segment and a final `**` for
+     * any number, and each translation keeps them in order
+     * (`{ "/blog/*": { de: "/artikel/*" } }`).
+     */
+    paths?: {
+      [path: string]: {
+        [locale: string]: string;
+      };
+    };
+    /**
+     * Domain routing: host → the locale it serves, e.g.
+     * `{ "example.com": "en", "example.de": "de" }`. A key is a host
+     * (`https` assumed) or an origin (`http://localhost:5173`); a locale's
+     * first host is where links to it go. Every locale needs a host, and
+     * `url` stays `prefix_except_default`: on a listed host its locale is
+     * unprefixed, on any other host (dev servers, previews) the prefixes
+     * apply. The hosts are an allowlist: links and redirects never name
+     * another.
+     */
+    domains?: {
+      [host: string]: string;
+    };
+  };
+  ssr?: {
+    timeZone?: string;
+    timeZoneFrom?: {
+      [pattern: string]: "config" | "request";
+    };
+    /**
+     * `"bundles"` (default): the page's client bundles are inlined into its
+     * SSR payload. `"preload"`: the payload names them and the page gets one
+     * `<link rel="preload" as="fetch" crossorigin>` per bundle instead, which
+     * the client runtime's fetch takes over, so bundles cache across pages.
+     */
+    payload?: "bundles" | "preload";
+    /**
+     * Where a Vite-built server reads its catalogs. `"modules"`: lazy JSON
+     * modules in the server bundle. `"assets"`: files in the client output
+     * (`vi18n/<v>/<locale>/`), read through the Workers static-assets binding
+     * `env.ASSETS`, at most `maxLoadedLocales` locales loaded. `"auto"`
+     * (default): `"assets"` in a server environment that targets workerd
+     * (its resolve conditions include `workerd`, as @cloudflare/vite-plugin's
+     * do) of a build with a client entry, `"modules"` everywhere else.
+     */
+    catalogs?: "auto" | "modules" | "assets";
+    /**
+     * With catalogs read from static assets: how many locales a server
+     * instance keeps loaded, the source locale included; the least recently
+     * used beyond it is dropped and read again when a request needs it.
+     * Default 8.
+     */
+    maxLoadedLocales?: number;
+    normalizeSpaces?: boolean;
+  };
+  ai?: {
+    /** `"gemini"` (default) or a provider object: `openaiCompatible({ … })` or a custom one. */
+    provider?: "gemini" | TranslationProvider;
+    model?: string;
+    /**
+     * What AI never translates: configured locales, message ids, and globs
+     * (with `/` or `*`) over the config-relative files that use a message.
+     */
+    exclude?: string[];
+    /**
+     * Required translations of source terms per locale (a language such as
+     * `de` covers `de-CH`): `{ workspace: { de: "Arbeitsbereich" } }`.
+     */
+    glossary?: {
+      [term: string]: {
+        [locale: string]: string;
+      };
+    };
+    /** Names copied unchanged into every locale, e.g. `["Tidepool", "Wi-Fi"]`. */
+    doNotTranslate?: string[];
+    /** Tone and formality per locale, e.g. `{ de: "informal (du)" }`. */
+    tone?: {
+      [locale: string]: string;
+    };
+    /** Product description for the stable system prompt prefix. */
+    description?: string;
+    /** Environment variable holding the key. Default `GEMINI_API_KEY`. */
+    apiKeyEnv?: string;
+    /** Items per request, 40–80. Default 60. */
+    batchSize?: number;
+    /** Most requests in flight; halved on rate limits and regained gradually. Default 4. */
+    concurrency?: number;
+    /**
+     * P2: in `vite dev`, translate new messages in the background (debounced,
+     * off the transform path) and write them as `ai` entries. Default false.
+     */
+    dev?: boolean;
+  };
+  /**
+   * Global rich-text tag handlers (PLAN §5.16): the element a message tag
+   * renders as when a call passes no handler of its own, in `richHtml()`
+   * and, in React, Preact and Vue, in `rich()`.
+   */
+  defaults?: {
+    tags?: {
+      [tag: string]: TagDefault;
+    };
+  };
+  /**
+   * `vite dev` only: Alt+click on text opens the in-context editor, which
+   * writes translations into the catalogs (INTERNALS §2.18). Builds never
+   * carry it. Default `false`.
+   */
+  devtools?: boolean;
+  /** `true` sets every rule to `"error"`. */
+  strict?: boolean | {
+    missing?: Level;
+    invalid?: Level;
+    moduleScope?: Level;
+  };
+}
+/** `output.*`: settings that matter to the build alone, also accepted inline by `vi18n({ output })`. */
+interface OutputOptions {
+  split?: {
+    shared?: "per-set" | "single";
+    /** Source-locale bytes below which a set shared by several roots is duplicated. */
+    dupBelow?: number;
+    /** `s.*` bundles smaller than this coalesce into `shared`. */
+    minBytes?: number;
+    /** Cap on `s.*` bundles per root (spike S4); extra sets coalesce into `shared`. Default: no cap. */
+    maxBundlesPerRoot?: number | null;
+  };
+  guard?: "auto" | "always" | "off";
+  /** Stable URL outside `assetsDir`, relative to `base`, with `{locale}`. */
+  manifestPath?: string;
+  /** `"module"` puts the manifest into the runtime chunk (build-time `ssr:false` shells). */
+  manifest?: "data" | "module";
+  /** Globs on facade module ids that act as `base` entries in SSR builds. */
+  baseEntries?: string[];
+  /**
+   * Bundles as JSON arrays of messages, mapped to ids by position through one
+   * `ids.<v>.json` per build version that every locale shares. Default false.
+   */
+  compactIds?: boolean;
+  /**
+   * One client build per locale with its translations inlined into the
+   * JavaScript (static SPAs): no bundle fetches, and switching locale loads
+   * the other locale's build. Default false.
+   */
+  perLocale?: boolean;
+}
+/**
+ * The validated config with every default applied. Paths are absolute;
+ * `catalogs.path` keeps its `{locale}` placeholder.
+ */
+interface ResolvedConfig {
+  /** Directory of `vi18n.config.ts`, or the Vite root / cwd when there is none. */
+  root: string;
+  /** Absolute path of the config file; null in zero-config mode. */
+  configFile: string | null;
+  sourceLocale: string;
+  locales: string[];
+  pseudoLocales: PseudoLocale[];
+  fallbacks: {
+    [locale: string]: string[];
+  };
+  project: {
+    include: string[];
+    extensions: string[];
+    exclude: string[];
+  };
+  extraction: {
+    importSources: string[];
+    aliases: string[];
+    globals: string[];
+    keep: string[];
+    dependencies: string[];
+  };
+  ids: {
+    length: number;
+  };
+  catalogs: {
+    format: "po" | "json";
+    path: string;
+    msgid: "source" | "id";
+    icuFlag: boolean;
+  };
+  output: {
+    split: {
+      shared: "per-set" | "single";
+      dupBelow: number;
+      minBytes: number;
+      maxBundlesPerRoot: number | null;
+    };
+    guard: "auto" | "always" | "off";
+    manifestPath: string;
+    manifest: "data" | "module";
+    baseEntries: string[];
+    compactIds: boolean;
+    perLocale: boolean;
+  };
+  routing: {
+    strategy: LocaleStrategy[];
+    routeStrategies: {
+      [pattern: string]: LocaleStrategy[];
+    };
+    url: UrlStrategy;
+    redirectRoot: boolean;
+    propagate: "header" | false;
+    switch: "in-place" | "navigate";
+    cookie: {
+      name: string;
+      maxAge: number;
+    };
+    /** `routing.base`; null: the environment's Vite `base`. */
+    base: string | null;
+    paths: {
+      [path: string]: {
+        [locale: string]: string;
+      };
+    };
+    /** Keys in origin form: `https://example.de`, `http://localhost:5173`. */
+    domains: {
+      [origin: string]: string;
+    };
+  };
+  ssr: {
+    timeZone: string;
+    timeZoneFrom: {
+      [pattern: string]: "config" | "request";
+    };
+    payload: "bundles" | "preload";
+    catalogs: "auto" | "modules" | "assets";
+    maxLoadedLocales: number;
+    normalizeSpaces: boolean;
+  };
+  ai: {
+    provider: "gemini" | TranslationProvider;
+    model: string;
+    exclude: string[];
+    glossary: {
+      [term: string]: {
+        [locale: string]: string;
+      };
+    };
+    doNotTranslate: string[];
+    tone: {
+      [locale: string]: string;
+    };
+    description: string | null;
+    apiKeyEnv: string;
+    batchSize: number;
+    concurrency: number;
+    dev: boolean;
+  };
+  defaults: {
+    tags: {
+      [tag: string]: TagDefault;
+    };
+  };
+  devtools: boolean;
+  strict: {
+    missing: Level;
+    invalid: Level;
+    moduleScope: Level;
+  };
+}
+/** A `defaults.tags` entry: an HTML element name, or the element with fixed attributes. */
+type TagDefault = string | {
+  element: string;
+  attributes?: {
+    [name: string]: string;
+  };
+};
+//#endregion
+export { MessageOccurrence as _, Vi18nConfig as a, OpenAICompatibleOptions as c, ProviderResponse as d, Tier as f, MessageCodec as g, Diagnostic as h, ResolvedConfig as i, ProviderOptions as l, TranslationProvider as m, OutputOptions as n, AiItem as o, TranslateOptions as p, PseudoLocale as r, BatchOptions as s, Level as t, ProviderRequest as u, LocaleStrategy as v, UrlStrategy as y };