@i18n-micro/cli 0.0.0-stage → 2.0.1

package/dist/src/commands/rename.d.ts

@@ -0,0 +1,9 @@
+export interface RenameArgs {
+    cwd?: string;
+    translationDir?: string;
+    from: string;
+    to: string;
+    ignore?: string;
+    dryRun?: boolean;
+}
+export default function run(args: RenameArgs): Promise<void>;

package/dist/src/commands/search.d.ts

@@ -0,0 +1,20 @@
+export interface SearchArgs {
+    cwd?: string;
+    translationDir?: string;
+    query?: string;
+    caseSensitive?: boolean;
+    onlyUnused?: boolean;
+    scope: 'global' | 'pages' | 'all';
+    limit?: number;
+    ignore?: string;
+    json?: boolean;
+}
+export interface SearchMatch {
+    scope: string;
+    key: string;
+    translations: Record<string, string | null>;
+    missingLocales: string[];
+    isUsed: boolean;
+    usages: string[];
+}
+export default function run(args: SearchArgs): Promise<void>;

package/dist/src/commands/stats.d.ts

@@ -0,0 +1,20 @@
+export interface StatsArgs {
+    cwd?: string;
+    translationDir?: string;
+    html?: string;
+    json?: boolean;
+    baseRef?: string;
+}
+export interface LocaleCompletion {
+    code: string;
+    totalKeys: number;
+    translatedKeys: number;
+    completion: number;
+}
+export interface LocaleDelta {
+    code: string;
+    completionDelta: number;
+    translatedKeysDelta: number;
+    totalKeysDelta: number;
+}
+export default function run(args: StatsArgs): Promise<void>;

package/dist/src/commands/sync-remote.d.ts

@@ -0,0 +1,30 @@
+import { JsonObject, JsonValue } from '../json.js';
+import { Project } from '../project.js';
+export interface SyncRemoteArgs {
+    cwd?: string;
+    translationDir?: string;
+    pull?: boolean;
+    push?: boolean;
+    force?: boolean;
+    dryRun?: boolean;
+}
+export interface RemoteConfig {
+    type?: string;
+    url?: string;
+    path?: string;
+    token?: string;
+    auth?: {
+        username?: string;
+        password?: string;
+    };
+}
+export type LocaleTranslations = Record<string, JsonObject>;
+interface PullPlan {
+    added: string[];
+    updated: string[];
+    conflicts: string[];
+    apply: Array<[code: string, key: string, value: JsonValue]>;
+}
+export declare function planPull(project: Project, remote: LocaleTranslations, force: boolean): PullPlan;
+export default function run(args: SyncRemoteArgs): Promise<void>;
+export {};

package/dist/src/commands/sync.d.ts

@@ -0,0 +1,20 @@
+import { LocaleSet } from '../project.js';
+export interface SyncArgs {
+    cwd?: string;
+    translationDir?: string;
+    ignore?: string;
+    dryRun?: boolean;
+    force?: boolean;
+}
+export interface ExtraKey {
+    scope: string;
+    key: string;
+}
+/** Keys of `locale` the default locale cannot answer, compared by path: `"a.b"` and `a: { b }` are the same key. */
+export declare function extraKeys(reference: LocaleSet, locale: LocaleSet): ExtraKey[];
+/**
+ * Removes what the default locale does not have. Missing keys stay missing: `''` would hide
+ * them from `fallbackLocale` and from `check`. A delete-only command, so it has the brakes of
+ * `clean`, and one more: a reference that is empty proves nothing.
+ */
+export default function run(args: SyncArgs): Promise<void>;

package/dist/src/commands/text-to-i18n.d.ts

@@ -0,0 +1,10 @@
+export interface TextToI18nArgs {
+    cwd?: string;
+    translationFile?: string;
+    path?: string;
+    context?: string;
+    ignore?: string;
+    dryRun?: boolean;
+    interactive?: boolean;
+}
+export default function run(args: TextToI18nArgs): Promise<void>;

package/dist/src/commands/translate.d.ts

@@ -0,0 +1,14 @@
+export interface TranslateArgs {
+    cwd?: string;
+    translationDir?: string;
+    service?: string;
+    token?: string;
+    options?: string;
+    locale?: string;
+    replace?: boolean;
+    dryRun?: boolean;
+    chunkSize?: number;
+    pluralSeparator: string;
+    glossaryFile?: string;
+}
+export default function run(args: TranslateArgs): Promise<void>;

package/dist/src/csv.d.ts

@@ -0,0 +1,3 @@
+export declare const stringifyCsv: (rows: string[][]) => string;
+/** A quote out of place makes the rest of the file mean something else, so it stops the read. */
+export declare function parseCsv(content: string, name?: string): string[][];

package/dist/src/errors.d.ts

@@ -0,0 +1,22 @@
+export interface CliErrorOptions {
+    code: string;
+    hints?: readonly string[];
+    details?: Record<string, string>;
+    cause?: unknown;
+}
+/** An expected failure: printed as message, details and hints, never as a stack trace. */
+export declare class CliError extends Error {
+    readonly code: string;
+    readonly hints: readonly string[];
+    readonly details: Readonly<Record<string, string>>;
+    constructor(message: string, options: CliErrorOptions);
+}
+export declare const usageError: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+export declare const validationError: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+export declare const notFoundError: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+export declare const commandFailed: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+export declare const remoteConfigError: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+/** The command worked and found something wrong: exit code 1, not a failure of the tool. */
+export declare const findingsError: (message: string, hints?: readonly string[], details?: Record<string, string>) => CliError;
+/** nuxi's look: a red ` ERROR ` badge on a terminal, the clack error symbol in a log; hints after an arrow. */
+export declare function reportError(error: unknown, debug: boolean): void;

package/dist/src/fs.d.ts

@@ -0,0 +1,45 @@
+import { JsonObject } from './json.js';
+/** `path` from `from`, as a report, a key or a glob reads it: `/` on every platform. */
+export declare const relativePath: (from: string, path: string) => string;
+/** Whether `path` is `dir` or below it. `relative` gives an absolute path across Windows drives. */
+export declare function isUnder(dir: string, path: string): boolean;
+/** Every file under `dir` that `accept` wants, sorted, symlinks followed. A missing directory is an empty result. */
+export declare function walkFiles(dir: string, accept?: (path: string) => boolean, skipDir?: (path: string) => boolean): string[];
+export interface WriteOptions {
+    /** The old content does not matter: it is replaced, not edited. */
+    overwrite?: boolean;
+}
+/**
+ * Write a set of files all-or-nothing.
+ *
+ * Everything lands in temp files first, so a full disk, a bad path or a read-only file fails
+ * before the first real file changes. A rename that fails later puts back what the earlier ones
+ * replaced. Only killing the process can leave a mix: of whole files between two renames, and
+ * a cut one in a hard-linked target, see `commit`. The next save clears its temp files.
+ */
+export declare function writeFilesAtomic(files: Array<[path: string, content: string | Buffer]>, options?: WriteOptions): void;
+export declare const writeFileAtomic: (path: string, content: string | Buffer) => void;
+export declare const stringifyJson: (value: unknown, indent?: number | string) => string;
+/** JSON text has no raw newline in a string, so every one of them is a line ending. */
+export declare const matchLineEnding: (previous: string | undefined, text: string) => string;
+/** Saved the way the file was written, so an edit shows up as an edit and not as a whole-file diff. */
+export declare function stringifyLike(previous: string | undefined, value: unknown): string;
+/** Text that survives a save. Bytes that are not UTF-8 would come back as replacement characters. */
+export declare function readUtf8(path: string): string;
+/** For what is only read: a stray byte in a data file or a locale file costs nothing until a save. */
+export declare const readLoose: (path: string) => string;
+/** A BOM comes from Windows editors and Excel; `JSON.parse` stops at it. */
+export declare const readText: (path: string) => string;
+/**
+ * Read a JSON object strictly.
+ *
+ * A broken file must stop the command: treating it as empty is how the next save would
+ * replace somebody's translations with `{}`.
+ */
+export declare function readJsonObject(path: string, options?: {
+    private?: boolean;
+}): JsonObject;
+export declare const readJsonIfExists: (path: string) => JsonObject;
+/** `tests/**`, `*.spec.ts`. A glob without a slash matches at any depth. */
+export declare function globToRegExp(glob: string): RegExp;
+export declare const splitList: (value: string | undefined) => string[];

package/dist/src/glossary.d.ts

@@ -0,0 +1,12 @@
+export interface GlossaryEntry {
+    source: string;
+    target: string;
+    from?: string;
+    to?: string;
+}
+export interface Glossary {
+    entries: GlossaryEntry[];
+}
+export declare function loadGlossary(path: string): Glossary;
+/** Terms for one language pair, as the lines a translation prompt quotes. At most 100: a prompt has a budget. */
+export declare function glossaryContext(glossary: Glossary, from: string, to: string): string | undefined;

package/dist/src/help.d.ts

@@ -0,0 +1,3 @@
+import { CommandSpec } from './spec.js';
+export declare function rootUsage(version: string): string;
+export declare function commandUsage(name: string, spec: CommandSpec, version: string): string;

package/dist/src/http.d.ts

@@ -0,0 +1,10 @@
+export interface RequestOptions extends Omit<RequestInit, 'signal'> {
+    timeoutMs?: number;
+    retries?: number;
+    retryDelayMs?: number;
+}
+export declare const request: (url: string, options?: RequestOptions) => Promise<Response>;
+export declare function requestJson<T>(url: string, options?: RequestOptions): Promise<T>;
+export declare const jsonBody: (value: unknown) => Pick<RequestInit, "body"> & {
+    headers: Record<string, string>;
+};

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { runCli } from './runner.js';
+export { COMMAND_GROUPS, commands } from './spec.js';
+export type { ArgSpec, CommandGroup, CommandSpec } from './spec.js';

package/dist/src/json.d.ts

@@ -0,0 +1,34 @@
+export type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export declare const isObject: (value: unknown) => value is JsonObject;
+/** A lookup by a name from outside: `constructor` is not an entry of a table. */
+export declare const ownValue: <T>(table: Record<string, T>, name: string) => T | undefined;
+/**
+ * `{ a: { b: 'x' } }` -> `{ 'a.b': 'x' }`. Arrays and empty objects are leaves. No prototype:
+ * callers look keys up in the result, and `constructor` is a key like any other.
+ */
+export declare function flatten(tree: JsonObject, prefix?: string, out?: Record<string, JsonValue>): Record<string, JsonValue>;
+/** Only the string leaves: the part of a tree that is text to translate. */
+export declare function flattenStrings(tree: JsonObject): Record<string, string>;
+export declare function getPath(tree: JsonObject, path: string): JsonValue | undefined;
+/**
+ * What writing `path` would destroy: a text above it, or the keys below it. Every write that
+ * comes from outside the file (import, pull, translation, generated key) asks this first.
+ */
+export declare function pathConflict(tree: JsonObject, path: string): string | null;
+/** What can go between quotes in a template and a script, and be stored. */
+export declare const isWritableKey: (key: string) => boolean;
+export declare function setPath(tree: JsonObject, path: string, value: JsonValue): void;
+/** Remove one leaf and the parents it leaves empty. Everything else stays exactly as written. */
+export declare function deletePath(tree: JsonObject, path: string): boolean;
+/** The first key an object repeats. `JSON.parse` keeps the last and says nothing, and a save would lose the other. */
+export declare function findDuplicateKey(text: string): string | null;
+/** The merge and the writers skip this key, so it would vanish on a save. */
+export declare function hasProtoKey(value: JsonValue): boolean;
+/** The path of an integer `JSON.parse` could not hold exactly. */
+export declare function findUnsafeInteger(value: JsonValue, path?: string): string | null;
+/** `Map.groupBy`, which Node 20 does not have. */
+export declare function groupBy<T, K>(items: T[], keyOf: (item: T) => K): Map<K, T[]>;
+export declare function sortKeys(value: JsonValue): JsonValue;

package/dist/src/lint-rules.d.ts

@@ -0,0 +1,9 @@
+import { LintRuleName } from './spec.js';
+export interface LintRule {
+    name: string;
+    description: string;
+    isValid: (value: string) => boolean;
+    fix?: (value: string) => string;
+}
+/** Rules for what is wrong in any language. Whether a text ends in a period is not one of them. */
+export declare const lintRules: Record<LintRuleName, Pick<LintRule, 'isValid' | 'fix'>>;

package/dist/src/log.d.ts

@@ -0,0 +1,88 @@
+/** Anything printed from now on shows `***` instead. Shorter than a real key, it would only garble the text. */
+export declare function addSecret(value: string | undefined): void;
+/**
+ * A URL up to its query, split around the last `@` there: one in the query is no part of the address.
+ * Not a `.*` regex: that stops at a line end and leaves the password in the text.
+ */
+export declare function urlParts(url: string): {
+    scheme: string;
+    credentials?: string;
+    host: string;
+};
+/** A URL somebody typed: what is after its path and before its host can be a key, whatever a server echoes back. */
+export declare function addUrlSecrets(url: string | undefined): void;
+/** A live terminal: a pipe or a CI log gets no header, spinner or timing, so its text stays the same run after run. */
+export declare const isInteractive: (stream?: NodeJS.WriteStream) => boolean;
+/** The symbols of @clack/prompts, which nuxi prints its log lines with. */
+export declare const symbols: {
+    info: string;
+    success: string;
+    warn: string;
+    error: string;
+    step: string;
+    arrow: string;
+    frames: string[];
+};
+declare const SGR: {
+    readonly bold: readonly [1, 22];
+    readonly dim: readonly [2, 22];
+    readonly underline: readonly [4, 24];
+    readonly red: readonly [31, 39];
+    readonly green: readonly [32, 39];
+    readonly yellow: readonly [33, 39];
+    readonly blue: readonly [34, 39];
+    readonly magenta: readonly [35, 39];
+    readonly cyan: readonly [36, 39];
+    readonly gray: readonly [90, 39];
+    readonly black: readonly [30, 39];
+    readonly bgRed: readonly [41, 49];
+    readonly bgYellow: readonly [43, 49];
+};
+export type Style = keyof typeof SGR;
+/** Always styled: the writer strips it again for a stream without colors. */
+export declare const style: (names: Style | Style[], text: string) => string;
+/** On stderr, and on a live terminal only: stdout stays clean for `--json` and pipes. */
+export declare const spinner: {
+    start(text: string): void;
+    update(text: string): void;
+    /** Wipes the frame; the next tick draws it again under what was printed. */
+    clear(): void;
+    stop(): void;
+};
+/** `4.2ms`, `420ms`, `4.20s`, `42.0s`, `4m 02s`: the precision nuxi gives its timings. */
+export declare function formatDuration(ms: number): string;
+/** The word for a count: `pick(1, 'was', 'were')`. */
+export declare const pick: (count: number, one: string, many: string) => string;
+/** A count and its noun, in agreement: `1 key`, `2 keys`. */
+export declare const plural: (count: number, one: string, many?: string) => string;
+export declare const log: {
+    setSilent(value: boolean): void;
+    /** A bare line, for text that is part of a block. */
+    info(message: string): void;
+    /** A line of its own: what the command is doing or found. */
+    note(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    /** A blank line when a group or a table came last, once. */
+    gap(): string;
+    error(message: string): void;
+    /** Stderr as is: the error report builds its own lines. */
+    raw(message: string): void;
+    /** Machine-readable output: not muted by `--logLevel silent`. */
+    json(value: unknown): void;
+    section(title: string): void;
+    rows(rows: Array<[label: string, value: string | number]>): void;
+    /** A titled group with its count; cells of a row are aligned as a table. */
+    list(title: string, items: Array<string | string[]>): void;
+};
+/**
+ * One line of input. Closed stdin (CI, a pipe that ended) answers `null`, never hangs.
+ *
+ * A single reader for the whole run: readline buffers ahead, so a second one would miss
+ * lines a pipe already delivered.
+ */
+export declare function ask(question: string): Promise<string | null>;
+export declare function closePrompts(): void;
+export declare function confirm(question: string): Promise<boolean>;
+export declare function choose(question: string, options: string[]): Promise<string | null>;
+export {};

package/dist/src/nuxt.d.ts

@@ -0,0 +1,66 @@
+export interface LocaleEntry {
+    code: string;
+}
+export interface ProjectConfig {
+    rootDir: string;
+    /** Where `pages/`, `components/` and friends live: `app/` on Nuxt 4. */
+    srcDir: string;
+    /** The project's own translation directory: the only one the CLI writes to. */
+    translationDir: string;
+    /** Lowest priority first, the project's own directory last. */
+    translationDirs: string[];
+    /** The ones the module reads top-level `{locale}.json` from, never `pages/`. */
+    additionalDirs: string[];
+    /** Every layer's root, the project's included. */
+    layerRoots: string[];
+    /** `dir.pages` of every layer. */
+    pagesDirs: string[];
+    /** Source folders outside the root that aliases and auto-imports reach into. */
+    extraSourceDirs: string[];
+    defaultLocale: string;
+    /** `DEFAULT_LOCALE` in the shell chose another locale than nuxt.config. */
+    defaultLocaleOverridden: boolean;
+    locales: LocaleEntry[];
+    disablePageLocales: boolean;
+}
+interface I18nOptions {
+    locales?: Array<string | (LocaleEntry & {
+        disabled?: boolean;
+    })>;
+    defaultLocale?: string;
+    translationDir?: string;
+    disablePageLocales?: boolean;
+    additionalTranslationDirs?: Array<string | {
+        path?: string;
+    }>;
+}
+interface LayerConfig {
+    rootDir?: string;
+    srcDir?: string;
+    dir?: {
+        pages?: string;
+    };
+}
+interface ResolvedNuxtConfig extends LayerConfig {
+    i18n?: I18nOptions;
+    modules?: unknown[];
+    alias?: Record<string, string>;
+    components?: unknown;
+    imports?: {
+        dirs?: unknown;
+    };
+    _layers?: ReadonlyArray<{
+        config?: LayerConfig;
+    }>;
+}
+export declare function findNuxtRoot(startDir: string): string | null;
+/** A folder outside the root is still this app's code when an alias or auto-import points at it. */
+export declare function extraSourceDirsOf(config: ResolvedNuxtConfig, rootDir: string): string[];
+/**
+ * Resolved i18n configuration of the project at or above `cwd`.
+ *
+ * `loadNuxtConfig`, not `loadNuxt`: the CLI needs options and layers, and booting Nuxt runs
+ * every module of the app just to read them.
+ */
+export declare function loadProjectConfig(cwd: string): Promise<ProjectConfig>;
+export {};

package/dist/src/po.d.ts

@@ -0,0 +1,14 @@
+/** The small part of gettext the CLI exchanges: a flat catalog of msgid -> msgstr, with msgctxt as a key prefix. */
+export interface PoMessage {
+    key: string;
+    value: string;
+    /** The default-locale text: what a translator works from. */
+    source?: string;
+}
+export declare function compilePo(messages: PoMessage[]): string;
+export interface PoCatalog {
+    messages: Record<string, string>;
+    /** Marked fuzzy: a guess nobody confirmed, not a translation. A translator's work all the same. */
+    fuzzy: Record<string, string>;
+}
+export declare function parsePo(content: string): PoCatalog;

package/dist/src/project.d.ts

@@ -0,0 +1,64 @@
+import { JsonObject, JsonValue } from './json.js';
+import { ProjectConfig } from './nuxt.js';
+/** Not a word: a page may be called `global`. */
+export declare const GLOBAL_SCOPE = "";
+export interface LocaleLayer {
+    global: JsonObject;
+    pages: Record<string, JsonObject>;
+}
+/** `de.json` or `pages/about/de.json`: the one place a scope turns into a path. */
+export declare const relativeFile: (code: string, scope: string, extension?: string) => string;
+export declare class LocaleSet {
+    readonly inherited: LocaleLayer;
+    readonly own: LocaleLayer;
+    global: JsonObject;
+    pages: Record<string, JsonObject>;
+    modified: boolean;
+    constructor(merged: LocaleLayer, inherited: LocaleLayer, own: LocaleLayer);
+    get pageScopes(): string[];
+    /** The global scope first, then every page. */
+    get scopes(): string[];
+    tree(scope: string): JsonObject;
+    /** The project's file as it was read. */
+    ownTree(scope: string): JsonObject;
+    inheritedTree(scope: string): JsonObject;
+    /** The project's file as it stands now: edits in, layers out. */
+    fileTree(scope: string): JsonObject;
+    replaceTree(scope: string, tree: JsonObject): void;
+    strings(scope?: string): Record<string, string>;
+    leaves(scope?: string): Record<string, JsonValue>;
+    get(key: string, scope?: string): JsonValue | undefined;
+    /** What the app reads on `scope`: the page's value, then the global one. */
+    resolve(key: string, scope: string): JsonValue | undefined;
+    /** Writes `value`, or returns the key that blocks it: a write never destroys another value. */
+    set(key: string, value: JsonValue, scope?: string): string | null;
+    delete(key: string, scope?: string): void;
+}
+export interface SaveOptions {
+    /** Force an indentation; by default each file keeps its own. */
+    indent?: number;
+    /** Rewrite files whose content did not change: `format`. */
+    rewrite?: boolean;
+    sort?: boolean;
+}
+export declare class Project {
+    readonly config: ProjectConfig;
+    private readonly locales;
+    private constructor();
+    static load(options: {
+        cwd?: string;
+        translationDir?: string;
+    }): Promise<Project>;
+    get codes(): string[];
+    /** Locales to fill in from the default one. */
+    get targetCodes(): string[];
+    /** The comma list of a `--locale` flag, or every target locale. */
+    selectLocales(list: string[]): string[];
+    locale(code: string): LocaleSet;
+    get reference(): LocaleSet;
+    private filesOf;
+    /** The writes a save would make, for a caller that has other files to change in the same step. */
+    pendingFiles(options?: SaveOptions): Array<[string, string]>;
+    /** Write modified locales in one step, see `writeFilesAtomic`. Returns the paths written. */
+    save(options?: SaveOptions): string[];
+}

package/dist/src/runner.d.ts

@@ -0,0 +1,6 @@
+import { ArgsDef, CommandDef } from 'citty';
+export declare const packageName: string;
+export declare const version: string;
+export declare const main: CommandDef<ArgsDef>;
+/** Run the CLI. Failures set `process.exitCode`; nothing here throws. */
+export declare function runCli(rawArgs: string[]): Promise<void>;

package/dist/src/source.d.ts

@@ -0,0 +1,109 @@
+import { ProjectConfig } from './nuxt.js';
+export declare const NODE_TYPES: {
+    ELEMENT: number;
+    TEXT: number;
+    COMMENT: number;
+    INTERPOLATION: number;
+    ATTRIBUTE: number;
+    DIRECTIVE: number;
+};
+export declare const isCodeFile: (path: string) => boolean;
+export interface KeyRef {
+    key: string;
+    file: string;
+    line: number;
+    /** The key's text in the file, without quotes. -1 when it came from text no parser read. */
+    start: number;
+    end: number;
+    /** `$has` asks whether a key exists: it does not need one to exist. */
+    guard: boolean;
+    /** Text after `$t(key, params, 'text')`. */
+    defaultText?: string;
+    /** Inside `<i18n-group>` the code holds only the part after this. */
+    keyPrefix?: string;
+}
+export interface DynamicKey {
+    file: string;
+    line: number;
+    expression: string;
+    /** Static text before the first interpolation: every key under it may be in use. */
+    prefix: string;
+    /** `<i18n-group prefix>`: a known prefix, not a key computed at runtime. */
+    group?: boolean;
+    /** A function that may not translate at all. Build output is full of them. */
+    guess?: boolean;
+}
+export interface FileScan {
+    refs: KeyRef[];
+    dynamic: DynamicKey[];
+    /** Strings that look like a key, and where each one is: a key can travel through a variable. */
+    literals: Map<string, string[]>;
+    /** Strings ending in a dot: `'errors.' + code`. */
+    prefixes: Set<string>;
+    /** Why this file could not be read completely. */
+    unproven: string[];
+}
+export interface AstNode {
+    type: string;
+    start?: number;
+    end?: number;
+    [key: string]: unknown;
+}
+export declare const lineOf: (content: string, offset: number) => number;
+export declare function staticString(node: AstNode | undefined): string | null;
+/**
+ * The syntax tree, or `null` when the code does not parse. A file with a recoverable error
+ * (a duplicate declaration, say) still gives a whole tree; `strict` refuses it, for telling
+ * an expression from a statement.
+ */
+export declare function parseCode(code: string, lang?: string, strict?: boolean): unknown | null;
+/** Every use of a translation key in one file, with positions. Comments do not count. */
+export declare function scanFile(content: string, file: string): FileScan;
+/** Route name Nuxt gives a page file: the name of its `locales/pages/<name>/` directory. */
+export declare function pageNameOf(pagePath: string): string;
+export declare function pageScopeOf(file: string, pagesRoot: string, content: string): string;
+export interface ScopedRef extends KeyRef {
+    /** Route name when the file is a page. */
+    page: string | null;
+    /** A test or a fixture: proof of use, but no reason to add a key. */
+    test: boolean;
+}
+export interface ProjectScan {
+    refs: ScopedRef[];
+    dynamic: DynamicKey[];
+    literals: Map<string, string[]>;
+    prefixes: Set<string>;
+    /** Words of JSON and YAML files: keys can live in data that code feeds to `$t`. */
+    dataTokens: Set<string>;
+    dataFiles: string[];
+    unproven: Array<{
+        file: string;
+        reason: string;
+    }>;
+    files: number;
+}
+export interface ScanOptions {
+    /** Globs relative to the project root. */
+    ignore?: string[];
+}
+/** Evidence only, never saved: a stray byte in a notes file must not stop anything. */
+export declare const dataTokensOf: (path: string) => string[];
+/** Everything of the project a key can hide in, once each, whatever folder it lives in. */
+export declare function projectFiles(config: ProjectConfig, options?: ScanOptions): string[];
+export declare const isTestFile: (config: ProjectConfig, file: string) => boolean;
+/**
+ * Whether a write may touch this source. The scan reads layers and alias targets to prove use;
+ * they belong to whoever else builds on them, and their locale files stay as they are.
+ */
+export declare function isOwnSource(config: ProjectConfig, file: string): boolean;
+export declare function scanProject(config: ProjectConfig, options?: ScanOptions): ProjectScan;
+/**
+ * Whether a key may be read. One answer for `clean`, `check` and `search`.
+ *
+ * Any trace counts, not only a call: a string equal to the key can reach `$t` through a
+ * variable, a prop or a data file. A dead key that stays is a line of noise; a live key that
+ * goes is a broken page.
+ */
+export declare function usageIndex(scan: ProjectScan): (key: string) => boolean;
+/** Why "no source file uses this key" cannot be trusted in this project. Empty when it can. */
+export declare function usageDoubts(scan: ProjectScan): string[];