@babelize/engine 0.0.0-stage → 0.1.2

package/dist/qa/review.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewError = void 0;
+exports.reviewLocaleChanges = reviewLocaleChanges;
+/**
+ * Review the locale changes in a git diff: QA only the entries that changed
+ * (same checks as checkProjectLocales), plus source strings whose
+ * translations weren't updated and new source keys a locale is missing.
+ * Read-only; compares the working tree with HEAD or a base ref.
+ */
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const git_1 = require("../local/git");
+const check_project_1 = require("./check-project");
+const locale_files_1 = require("./locale-files");
+const locale_qa_1 = require("./locale-qa");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+class ReviewError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ReviewError';
+    }
+}
+exports.ReviewError = ReviewError;
+/** Git's empty tree: the base of a repository without commits. */
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, maxBuffer: 256 * 1024 * 1024 });
+    return stdout;
+}
+async function resolveBase(projectDir, base) {
+    if (base !== undefined) {
+        // A ref, never an option (`--output=…`) or a range.
+        if (!/^[\w./@^~{}-]+$/.test(base) || base.startsWith('-') || base.includes('..')) {
+            throw new ReviewError(`"${base}" is not a valid git ref.`, 'bad_base');
+        }
+        try {
+            const sha = (await git(projectDir, ['rev-parse', '--verify', '--quiet', '--end-of-options', `${base}^{commit}`])).trim();
+            return { ref: sha, label: base };
+        }
+        catch {
+            throw new ReviewError(`Unknown git ref "${base}". Use a branch, tag or commit (e.g. main, origin/main, HEAD~1).`, 'bad_base');
+        }
+    }
+    try {
+        const sha = (await git(projectDir, ['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'])).trim();
+        return { ref: sha, label: 'HEAD' };
+    }
+    catch {
+        return { ref: EMPTY_TREE, label: 'empty repository' };
+    }
+}
+const lines = (out) => out.split('\n').map((l) => l.trim()).filter(Boolean);
+function diffKeys(now, old) {
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const [k, v] of Object.entries(now)) {
+        if (!(k in old))
+            added.push(k);
+        else if (old[k] !== v)
+            changed.push(k);
+    }
+    for (const k of Object.keys(old))
+        if (!(k in now))
+            removed.push(k);
+    return { added, changed, removed };
+}
+function clip(text, max = 60) {
+    const one = text.replace(/\s+/g, ' ').trim();
+    return one.length > max ? `${one.slice(0, max - 1)}…` : one;
+}
+async function reviewLocaleChanges(projectDir, options = {}) {
+    try {
+        await (0, git_1.assertGitRepo)(projectDir);
+    }
+    catch (err) {
+        const code = err.code === 'git_missing' ? 'git_missing' : 'not_a_repo';
+        throw new ReviewError(err.message, code);
+    }
+    const { ref, label } = await resolveBase(projectDir, options.base);
+    // Paths relative to projectDir (--relative also limits the diff to it).
+    const changed = new Set([
+        ...lines(await git(projectDir, ['diff', '--name-only', '--relative', ref, '--', '.'])),
+        ...lines(await git(projectDir, ['ls-files', '--others', '--exclude-standard', '--', '.'])),
+    ]);
+    const readOld = async (rel) => {
+        if (ref === EMPTY_TREE)
+            return null;
+        try {
+            return await git(projectDir, ['show', `${ref}:./${rel}`]);
+        }
+        catch {
+            return null; // new file
+        }
+    };
+    const config = await (0, check_project_1.readProjectLocaleConfig)(projectDir);
+    // Sets from the working tree and the base, so deleted locale files count.
+    const basePaths = ref === EMPTY_TREE ? [] : lines(await git(projectDir, ['ls-tree', '-r', '--name-only', ref, '--', '.']));
+    const nowSets = await (0, locale_files_1.findLocaleFileSets)(projectDir, { ignoreDirs: options.ignoreDirs });
+    const sets = (0, locale_files_1.groupLocaleFiles)([...nowSets.flatMap((st) => Object.values(st.files).flat()), ...basePaths], { ignoreDirs: options.ignoreDirs });
+    const sourceLocale = options.sourceLocale ?? config.sourceLocale ?? 'en';
+    const glossary = options.glossary ?? config.glossary;
+    const localeFiles = new Set(sets.flatMap((st) => Object.values(st.files).flat()));
+    const reviews = [];
+    for (const set of sets) {
+        const setFiles = Object.values(set.files).flat();
+        if (!set.files[sourceLocale] || !setFiles.some((f) => changed.has(f)))
+            continue;
+        const srcNow = (await (0, locale_files_1.loadLocale)(projectDir, set, sourceLocale)).messages;
+        const srcOld = (await (0, locale_files_1.loadLocale)(projectDir, set, sourceLocale, readOld)).messages;
+        const source = diffKeys(srcNow, srcOld);
+        const locales = [];
+        const targets = Object.keys(set.files)
+            .filter((l) => l !== sourceLocale && (!options.locales?.length || options.locales.includes(l)))
+            .sort();
+        for (const locale of targets) {
+            const nowLoaded = await (0, locale_files_1.loadLocale)(projectDir, set, locale);
+            const tgtNow = nowLoaded.messages;
+            const tgtOld = (await (0, locale_files_1.loadLocale)(projectDir, set, locale, readOld)).messages;
+            const fileDeleted = set.files[locale].every((f) => changed.has(f)) && Object.keys(tgtNow).length === 0 && nowLoaded.errors.length === 0 && Object.keys(tgtOld).length > 0;
+            const changedTarget = Object.keys(tgtNow).filter((k) => tgtNow[k] !== tgtOld[k]);
+            // Deleted translations whose source key still exists.
+            const removedTarget = Object.keys(tgtOld).filter((k) => !(k in tgtNow) && k in srcNow);
+            const removed = new Set(removedTarget);
+            const keys = fileDeleted
+                ? new Set(Object.keys(srcNow))
+                : new Set([...changedTarget, ...source.added, ...source.changed, ...source.removed.filter((k) => k in tgtNow)].filter((k) => !removed.has(k)));
+            if (keys.size === 0 && removedTarget.length === 0)
+                continue;
+            const report = (0, locale_qa_1.checkLocalePair)(srcNow, tgtNow, locale, { sourceLocale, glossary, keys: [...keys] });
+            if (fileDeleted) {
+                report.issues.unshift({
+                    locale,
+                    key: '*',
+                    code: 'translation_removed',
+                    severity: 'error',
+                    message: `The ${locale} locale file was deleted: all ${Object.keys(srcNow).length} source keys are now missing in ${locale}.`,
+                });
+            }
+            else {
+                for (const key of removedTarget) {
+                    report.issues.push({
+                        locale,
+                        key,
+                        code: 'translation_removed',
+                        severity: 'error',
+                        message: `Translation "${clip(tgtOld[key])}" was deleted but the source still has this key; the app falls back to the source text.`,
+                    });
+                }
+            }
+            for (const key of source.changed) {
+                if (tgtNow[key] !== undefined && tgtNow[key] === tgtOld[key]) {
+                    report.issues.push({
+                        locale,
+                        key,
+                        code: 'stale_translation',
+                        severity: 'warning',
+                        message: `Source changed from "${clip(srcOld[key])}" to "${clip(srcNow[key])}" but this translation wasn't updated.`,
+                    });
+                }
+            }
+            locales.push({ ...(0, locale_qa_1.tallyLocaleIssues)(report), changedKeys: changedTarget.length, removedKeys: removedTarget.length, fileDeleted });
+        }
+        reviews.push({ dir: set.dir, layout: set.layout, sourceLocale, source, locales });
+    }
+    const changedLocaleFiles = [...changed].filter((f) => localeFiles.has(f)).sort();
+    return {
+        base: label,
+        changedLocaleFiles,
+        changedOtherFiles: changed.size - changedLocaleFiles.length,
+        sets: reviews,
+    };
+}

package/dist/runtime/config.d.ts

@@ -0,0 +1,8 @@
+import type { EngineConfigV2 } from './types';
+/**
+ * Runtime config validation for the backend engine (v2).
+ *
+ * This mirrors the existing backend contract used by workers/controllers.
+ * (A separate Zod schema exists for the internal v2 modules.)
+ */
+export declare function validateEngineConfigV2(config: Partial<EngineConfigV2>): EngineConfigV2;

package/dist/runtime/config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEngineConfigV2 = validateEngineConfigV2;
+/**
+ * Runtime config validation for the backend engine (v2).
+ *
+ * This mirrors the existing backend contract used by workers/controllers.
+ * (A separate Zod schema exists for the internal v2 modules.)
+ */
+function validateEngineConfigV2(config) {
+    if (!config.workspacePath) {
+        throw new Error('workspacePath is required');
+    }
+    const confidenceThreshold = config.confidenceThreshold ?? 80;
+    if (confidenceThreshold < 0 || confidenceThreshold > 100) {
+        throw new Error(`confidenceThreshold must be between 0 and 100, got ${confidenceThreshold}`);
+    }
+    return {
+        workspacePath: config.workspacePath,
+        inputType: config.inputType || 'github',
+        sourceLocale: config.sourceLocale || 'en',
+        targetLocales: config.targetLocales || [],
+        framework: config.framework,
+        confidenceThreshold,
+        dryRun: config.dryRun ?? false,
+        forceTranslation: config.forceTranslation ?? false,
+        onProgress: config.onProgress,
+        signal: config.signal,
+        projectId: config.projectId,
+        filesToProcess: config.filesToProcess,
+        byok: config.byok,
+        providers: config.providers,
+        formatConfig: config.formatConfig,
+        staticRuntime: config.staticRuntime,
+        installDependencies: config.installDependencies,
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export type { EngineConfigV2, EngineResultV2 } from './types';
+export { validateEngineConfigV2 } from './config';
+export { runEngineV2 } from '../orchestrator';

package/dist/runtime/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEngineV2 = exports.validateEngineConfigV2 = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "validateEngineConfigV2", { enumerable: true, get: function () { return config_1.validateEngineConfigV2; } });
+// `runEngineV2` is implemented in `../orchestrator` as the single wiring point.
+var orchestrator_1 = require("../orchestrator");
+Object.defineProperty(exports, "runEngineV2", { enumerable: true, get: function () { return orchestrator_1.runEngineV2; } });

package/dist/runtime/types.d.ts

@@ -0,0 +1,427 @@
+/**
+ * Engine v2 runtime types (backend-facing).
+ *
+ * This file intentionally keeps the operational contract that the backend
+ * workers/controllers already rely on (stats/locales/injections/diffs), while
+ * allowing the v2 engine to add richer metrics needed for Target.md.
+ */
+import type { ByokProvider, FormatLocaleConfig, Framework } from '@babelize/types';
+import type { EngineProviders, TranslationFailure } from '../providers/types';
+import type { EngineLogger } from '../utils/logger';
+export interface EngineConfigV2 {
+    /** Path to the workspace directory */
+    workspacePath: string;
+    /** Source input type */
+    inputType: 'github' | 'zip';
+    /** Source locale code (e.g., 'en') */
+    sourceLocale: string;
+    /** Target locale codes (e.g., ['fr', 'de', 'es']) */
+    targetLocales: string[];
+    /** Detected or specified framework */
+    framework?: Framework;
+    /** Minimum confidence level for AST injection (0-100) */
+    confidenceThreshold: number;
+    /** If true, don't write any files - just return what would be changed */
+    dryRun: boolean;
+    /** Force translation even if locale files exist */
+    forceTranslation?: boolean;
+    /** Project ID for scoping lockfile/memory */
+    projectId?: string;
+    /**
+     * Directory holding `.babelize/<projectId>/babelize-lock.json`. Default:
+     * $BABELIZE_DATA_DIR, else the process cwd (the cloud backend). Local runs
+     * pass their temp copy, so concurrent runs never share global state.
+     */
+    dataDir?: string;
+    /** Logger for this run only (default: the one set with setEngineLogger). */
+    logger?: EngineLogger;
+    /**
+     * Stops the run cooperatively: checked at every progress report, so the
+     * pipeline ends at the next phase or translation batch after it fires. The
+     * result then has `aborted` set to the signal's reason (e.g. 'cancelled',
+     * 'timeout').
+     */
+    signal?: AbortSignal;
+    /** Callback for progress updates */
+    onProgress?: (message: string, step?: string, status?: 'running' | 'success' | 'error' | 'warning') => void;
+    /**
+     * Infrastructure the engine uses (translator, translation memory, project
+     * glossary/brand voice, cache). Anything omitted is simply not used.
+     */
+    providers?: EngineProviders;
+    /** BYOK (Bring Your Own Key) translation provider config */
+    byok?: {
+        provider: ByokProvider;
+        apiKey: string;
+        /** Optional model override (used by OpenRouter, Groq, etc.) */
+        model?: string;
+    };
+    /**
+     * Run the package manager when finalization adds i18n dependencies to
+     * package.json. Default true; local CLI runs pass false and tell the user
+     * to install instead.
+     */
+    installDependencies?: boolean;
+    /** Optional: only scan and process these specific files (e.g. for sync-triggered runs) */
+    filesToProcess?: string[];
+    /** Format localization config. null/undefined = skip format localization entirely. */
+    formatConfig?: FormatLocaleConfig;
+    /**
+     * What the run's translator can do. `icu`: translate ICU plural messages
+     * (an LLM provider). Defaults to true with BYOK or an injected translator,
+     * false for the NLLB service — then JSX sentences keep a plain `{count}`.
+     */
+    capabilities?: {
+        icu?: boolean;
+    };
+    /** Static HTML runtime options */
+    staticRuntime?: {
+        injectSwitcher?: boolean;
+        wrapMixedContent?: boolean;
+    };
+}
+export interface WorkspaceInfo {
+    path: string;
+    framework: Framework;
+    sourceDirs: string[];
+    hasLocalesDir: boolean;
+    existingLocales: string[];
+    publicDir: string;
+    packageJson?: Record<string, any>;
+    /** Output locale file format (e.g., 'json' for React, 'po' for Django) */
+    localeFormat: 'json' | 'po' | 'arb';
+    /**
+     * Django: the project root (the directory holding manage.py, i.e. BASE_DIR),
+     * relative to the workspace. For gettext projects `publicDir` is the locale
+     * directory (LOCALE_PATHS), relative to the workspace.
+     */
+    djangoRoot?: string;
+    /** Format localization config propagated from EngineConfigV2 */
+    formatConfig?: FormatLocaleConfig;
+    /** Static HTML runtime options propagated from EngineConfigV2 */
+    staticRuntime?: {
+        injectSwitcher?: boolean;
+        wrapMixedContent?: boolean;
+    };
+}
+/**
+ * Frameworks that the engine pipeline will actively process.
+ * Runtime detection may produce other identifiers (e.g. 'unknown');
+ * those are validated against this list and rejected if not supported.
+ *
+ * @deprecated Import SUPPORTED_FRAMEWORKS from @babelize/types instead
+ */
+export type FormatClass = 'currency' | 'date' | 'number' | 'unknown';
+export interface DetectedFormat {
+    class: FormatClass;
+    rawValue: string;
+    originalString: string;
+    confidence: number;
+    detectedCurrency?: string;
+    dateOptions?: Intl.DateTimeFormatOptions;
+    dateSource?: string;
+    numberOptions?: Intl.NumberFormatOptions;
+}
+export interface ExtractedString {
+    text: string;
+    file: string;
+    line: number;
+    column: number;
+    context: 'jsx-text' | 'jsx-attr' | 'string-literal' | 'template-literal' | 'hardcoded-date' | 'hardcoded-currency' | 'format-string';
+    id: string;
+    variables?: string[];
+    parentContext?: string;
+    siblingGroupId?: string;
+    detectedFormat?: DetectedFormat;
+    /**
+     * A whole JSX sentence (text + `{expressions}` + inline elements) as one ICU
+     * message with named placeholders, rich-text tags and possibly a plural.
+     * Keys are named from its words only, and the message carries its own
+     * plural forms (no `_one`/`_other` key variants).
+     */
+    icuMessage?: boolean;
+    /**
+     * Source offsets of every node this id stands for. Injection replaces
+     * exactly these nodes (not others with the same text on the same line).
+     */
+    offsets?: number[];
+    /**
+     * gettext message (Django): `text` is the msgid. Keys are derived from the
+     * message itself, and the PO catalogue — not a key — is what code looks up.
+     */
+    gettext?: GettextInfo;
+}
+export interface GettextInfo {
+    msgid: string;
+    msgidPlural?: string;
+    msgctxt?: string;
+    /** PO flags (python-format, python-brace-format). */
+    flags: string[];
+    /** Translator comments from the code (`# Translators: …`). */
+    comments: string[];
+    /** Already marked in the code (gettext call / trans tag); otherwise the injector wraps it. */
+    wrapped: boolean;
+    /**
+     * Translate a plural message as one ICU plural (an LLM can produce every
+     * CLDR category); otherwise singular and plural are translated separately.
+     */
+    icu?: boolean;
+}
+export interface ExtractionResult {
+    strings: ExtractedString[];
+    filesAnalyzed: string[];
+    skippedFiles: SkippedFile[];
+    warnings?: Warning[];
+    /** UI strings found but deliberately not extracted (e.g. module-level constants that are also data). */
+    notInjected?: NotInjectedString[];
+}
+export interface GeneratedKey {
+    key: string;
+    namespace: string;
+    value: string;
+    extractionId: string;
+    isPlural?: boolean;
+    pluralCategory?: 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+    parentContext?: string;
+    extractionContext?: string;
+    /** gettext message this key translates, and which part of it (Django). */
+    gettext?: GettextInfo & {
+        form: 'single' | 'icu' | 'singular' | 'plural';
+    };
+}
+export interface KeyGenerationResult {
+    keys: GeneratedKey[];
+    duplicates: Array<{
+        original: string;
+        renamed: string;
+    }>;
+}
+export interface LocaleData {
+    [key: string]: string | LocaleData;
+}
+export interface LocaleFile {
+    locale: string;
+    path: string;
+    data: LocaleData;
+    isNew: boolean;
+    isRTL?: boolean;
+    /**
+     * Exact file content to write at `path` (e.g. a merged .po catalogue).
+     * When set, hosts write this instead of serializing `data` as JSON.
+     */
+    content?: string;
+    /**
+     * There is no file for this locale (the source language of a gettext
+     * project: the code itself is the catalogue). Hosts write nothing.
+     */
+    noFile?: boolean;
+    /** Further files generated for this locale (e.g. a compiled .mo next to the .po). */
+    extraFiles?: Array<{
+        path: string;
+        content: string;
+        encoding: 'utf8' | 'base64';
+    }>;
+}
+export interface LocaleHandlingResult {
+    sourceLocale: LocaleFile;
+    newKeysCount: number;
+    existingKeysCount: number;
+}
+export interface TranslationEntry {
+    key: string;
+    value: string;
+    confidence?: number;
+    engine?: string;
+    warnings?: string[];
+    parentContext?: string;
+    extractionContext?: string;
+}
+export interface TranslationRequest {
+    sourceLang: string;
+    targetLang: string;
+    entries: TranslationEntry[];
+}
+export interface TranslationResponse {
+    translations: TranslationEntry[];
+    metadata?: {
+        dictVersion?: string;
+        processingTimeMs?: number;
+        dictionaryHits?: number;
+        modelTranslations?: number;
+    };
+}
+export interface TranslationResult {
+    locales: LocaleFile[];
+    errors: Array<{
+        locale: string;
+        error: string;
+    }>;
+    /** Keys with no translation for a locale this run (not written, retried next run). */
+    failures?: TranslationFailure[];
+}
+export interface InjectionLocation {
+    file: string;
+    line: number;
+    column: number;
+    original: string;
+    replacement: string;
+    key: string;
+    confidence: number;
+    formatClass?: string;
+}
+export interface FileInjection {
+    file: string;
+    originalContent: string;
+    modifiedContent: string;
+    injections: InjectionLocation[];
+    importAdded: boolean;
+    hookAdded: boolean;
+    /** The run created this file (it was not in the project before), e.g. a generated i18n config. */
+    created?: boolean;
+}
+export interface InjectionResult {
+    modifiedFiles: FileInjection[];
+    skippedFiles: SkippedFile[];
+    totalInjections: number;
+}
+export interface SkippedFile {
+    file: string;
+    reason: 'syntax-error' | 'low-confidence' | 'already-translated' | 'binary' | 'excluded' | 'parse-error' | 'format-injection-failed' | 'format-ast-build-failed';
+    details?: string;
+}
+export interface Warning {
+    type: 'low-confidence' | 'duplicate-key' | 'complex-expression' | 'dynamic-string' | 'malformed-ast' | 'parse-warning' | 'hardcoded-currency' | 'hardcoded-date' | 'hardcoded-plural' | 'ambiguous-format' | 'overflow' | 'rtl';
+    file: string;
+    line?: number;
+    key?: string;
+    locale?: string;
+    severity?: 'warning' | 'critical';
+    dismissible?: boolean;
+    message: string;
+}
+export interface DiffMetadata {
+    file: string;
+    changeType: 'created' | 'modified';
+    linesAdded: number;
+    linesRemoved: number;
+    diff?: string;
+}
+export interface ProcessingStats {
+    filesScanned: number;
+    filesWithStrings: number;
+    stringsExtracted: number;
+    keysGenerated: number;
+    filesModified: number;
+    injectionsApplied: number;
+    localeFilesCreated: number;
+    processingTimeMs: number;
+    stringsNeedingTranslation?: number;
+    translationsFromMemory?: number;
+    translationsFromLockfile?: number;
+    translationsFromHF?: number;
+    /** True when engine ran with a project-scoped lockfile */
+    lockfileUsed?: boolean;
+    /** Keys sent to the translator (new + source-changed + missing locale) */
+    lockfileKeysTranslated?: number;
+    /** Keys whose source text changed vs the lockfile */
+    lockfileKeysChanged?: number;
+    /**
+     * (key, locale) translations the translator actually produced this run —
+     * the billable work. Excludes lockfile, translation-memory and cache reuse,
+     * and failed keys.
+     */
+    translatedThisRun?: number;
+}
+export interface NotInjectedString {
+    file: string;
+    key: string;
+    text: string;
+    reason: string;
+}
+export interface KeyUsageReport {
+    /**
+     * Source-locale keys that no code references any more (and weren't
+     * extracted this run). Not translated, not deleted.
+     */
+    unused: string[];
+    /**
+     * Files with translation calls whose key isn't a literal. When non-empty,
+     * every key is treated as live and `unused` is empty.
+     */
+    dynamicFiles: string[];
+}
+export interface EngineResultV2 {
+    success: boolean;
+    error?: string;
+    /** Set when the run was stopped through `signal`: the abort reason. */
+    aborted?: string;
+    /**
+     * Only with `aborted`: strings freshly translated (and written to the
+     * translation cache and TM) before the stop. A later run reuses them for
+     * free, so the caller bills them rather than refunding the whole run.
+     */
+    partialTranslations?: number;
+    /**
+     * Keys that could not be translated, per locale, with the reason. They are
+     * absent from the locale files and the lockfile, so the next run retries
+     * them. Never filled with source text.
+     */
+    translationFailures?: TranslationFailure[];
+    stats: ProcessingStats;
+    locales: LocaleFile[];
+    injections: InjectionResult;
+    warnings: Warning[];
+    skipped: SkippedFile[];
+    diffs: DiffMetadata[];
+    /**
+     * Human-readable notes from finalization (dependencies added to
+     * package.json, i18n config created, ...) that need the user's attention.
+     */
+    notes?: string[];
+    /** Which source keys are still used (lockfile runs only). */
+    keyUsage?: KeyUsageReport;
+    /**
+     * Strings that were extracted and got a key (and translations) but could
+     * not be wired into the code, so the literal is still there.
+     */
+    notInjected?: NotInjectedString[];
+    results?: {
+        source: Record<string, string>;
+        targets: Record<string, Record<string, string>>;
+        metadata?: Record<string, Record<string, any>>;
+    };
+}
+export interface Phase0Result {
+    workspace: WorkspaceInfo;
+}
+export interface Phase1Result {
+    extraction: ExtractionResult;
+}
+export interface Phase2Result {
+    keyGeneration: KeyGenerationResult;
+}
+export interface Phase3Result {
+    localeHandling: LocaleHandlingResult;
+}
+export interface Phase4Result {
+    translation: TranslationResult;
+}
+export interface Phase5Result {
+    injection: InjectionResult;
+}
+export interface Phase6Result {
+    stats: ProcessingStats;
+    warnings: Warning[];
+    diffs: DiffMetadata[];
+}
+export interface Phase7Result {
+    finalization: {
+        dependenciesInvalid: boolean;
+        configFileCreated: boolean;
+        entryPointModified: boolean;
+        warnings: string[];
+    };
+}
+export declare const SUPPORTED_EXTENSIONS: string[];
+export declare const EXCLUDED_PATTERNS: string[];
+export declare const JSX_TRANSLATABLE_ATTRS: string[];