@i18n-micro/cli 0.0.0-stage → 2.0.0

package/dist/chunks/translate-CmnmgAHX.mjs

@@ -0,0 +1,543 @@
+import { A as log, C as addSecret, E as choose, M as plural, N as spinner, T as ask, _ as findingsError, d as ownValue, g as commandFailed, j as pick, v as notFoundError, w as addUrlSecrets, x as usageError } from "./json-BV_apCMu.mjs";
+import { d as splitList, o as readJsonObject } from "./nuxt-dKxG087V.mjs";
+import { t as Project } from "./project-DgWgr7pF.mjs";
+import { n as requestJson, t as jsonBody } from "./http-whB7a5ye.mjs";
+import { i as restore, n as isIntact, r as protect, t as decodeEntities } from "./protect-D1HIuxmJ.mjs";
+import { trimTrailingSlashes } from "@i18n-micro/utils/app-path";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+// src/glossary.ts
+var optionalString = (value) => typeof value === "string" && value !== "" ? value : void 0;
+function loadGlossary(path) {
+	const raw = readJsonObject(path).entries;
+	if (!Array.isArray(raw)) return { entries: [] };
+	return { entries: raw.flatMap((item) => {
+		const entry = item;
+		if (typeof entry?.source !== "string" || typeof entry.target !== "string") return [];
+		if (entry.source.trim() === "" || entry.target.trim() === "") return [];
+		return [{
+			source: entry.source,
+			target: entry.target,
+			from: optionalString(entry.from),
+			to: optionalString(entry.to)
+		}];
+	}) };
+}
+var matches = (bound, locale) => !bound || bound.toLowerCase() === locale.toLowerCase();
+/** Terms for one language pair, as the lines a translation prompt quotes. At most 100: a prompt has a budget. */
+function glossaryContext(glossary, from, to) {
+	const terms = glossary.entries.filter((entry) => matches(entry.from, from) && matches(entry.to, to)).slice(0, 100);
+	return terms.length === 0 ? void 0 : terms.map((entry) => `${entry.source} => ${entry.target}`).join("\n");
+}
+// src/translate/ai.ts
+var GATEWAY_URL = "https://ai-gateway.vercel.sh/v1";
+var OPENAI_URL = "https://api.openai.com/v1";
+var ANTHROPIC_URL = "https://api.anthropic.com/v1";
+var DEFAULT_GATEWAY_MODEL = "anthropic/claude-sonnet-4.5";
+var OUTPUT_SCHEMA = {
+	type: "object",
+	properties: { translations: {
+		type: "array",
+		items: { type: "string" }
+	} },
+	required: ["translations"],
+	additionalProperties: false
+};
+function systemPrompt({ from, to, options }) {
+	const lines = [
+		`You are a professional localizer translating software UI text from ${from} to ${to}.`,
+		"Rules:",
+		"1. Tags such as <v0/> are placeholders: keep each one exactly as it is, in the place the grammar needs.",
+		"2. Preserve all other HTML/XML tags.",
+		"3. Text separated by \"|\" holds plural forms: keep the separators and translate each form.",
+		"4. Answer with JSON: {\"translations\": [...]}, one string per input string, in the same order. No explanations."
+	];
+	if (options.translationContext) lines.push(`Context: ${options.translationContext}`);
+	if (options.glossaryContext) lines.push("Glossary (must be followed when a term appears):", options.glossaryContext);
+	return lines.join("\n");
+}
+var userPrompt = (texts) => JSON.stringify(texts);
+function parseTranslations(content, reason, count) {
+	if (reason === "length" || reason === "max_tokens") throw usageError("AI: the answer was cut off.", ["Lower --chunkSize or raise --options maxTokens:<n>."]);
+	if (!content) throw usageError("AI: empty answer.");
+	const translations = JSON.parse(content).translations;
+	if (!Array.isArray(translations) || translations.length !== count) throw usageError(`AI: expected ${plural(count, "translation")}.`, ["Lower --chunkSize."]);
+	return translations;
+}
+var envKey = (name) => process.env[name]?.trim() || void 0;
+function resolveKey(provider, token) {
+	const name = `${provider === "gateway" ? "AI_GATEWAY" : provider.toUpperCase()}_API_KEY`;
+	const key = token.trim() || envKey(name);
+	if (!key) throw usageError(`AI provider "${provider}" needs a key.`, [`Set I18N_TRANSLATE_TOKEN or ${name}.`]);
+	addSecret(key);
+	return key;
+}
+async function viaChatCompletions(request, url, model, key, strict) {
+	const { texts, options, http } = request;
+	const { headers, ...payload } = jsonBody({
+		model,
+		max_tokens: options.maxTokens ? Number(options.maxTokens) : void 0,
+		messages: [{
+			role: "system",
+			content: systemPrompt(request)
+		}, {
+			role: "user",
+			content: userPrompt(texts)
+		}],
+		response_format: {
+			type: "json_schema",
+			json_schema: {
+				name: "translations",
+				schema: OUTPUT_SCHEMA,
+				...strict ? { strict: true } : {}
+			}
+		}
+	});
+	const init = {
+		method: "POST",
+		...http,
+		...payload,
+		headers: key ? {
+			...headers,
+			Authorization: `Bearer ${key}`
+		} : headers
+	};
+	const choice = (await requestJson(`${url}/chat/completions`, init)).choices?.[0];
+	if (choice?.message?.refusal) throw usageError(`AI refused: ${choice.message.refusal}`);
+	return parseTranslations(choice?.message?.content, choice?.finish_reason, texts.length);
+}
+/** Anthropic's OpenAI layer ignores `response_format`, so structured output needs the native API. */
+async function viaAnthropic(request, url, model, key) {
+	const { texts, options, http } = request;
+	const { headers, ...payload } = jsonBody({
+		model,
+		max_tokens: Number(options.maxTokens ?? 8192),
+		system: systemPrompt(request),
+		messages: [{
+			role: "user",
+			content: userPrompt(texts)
+		}],
+		output_config: { format: {
+			type: "json_schema",
+			schema: OUTPUT_SCHEMA
+		} }
+	});
+	const data = await requestJson(`${url}/messages`, {
+		method: "POST",
+		...http,
+		...payload,
+		headers: {
+			...headers,
+			"x-api-key": key,
+			"anthropic-version": "2023-06-01"
+		}
+	});
+	return parseTranslations(data.content?.find((block) => block.type === "text")?.text, data.stop_reason, texts.length);
+}
+var aiDriver = {
+	label: "AI",
+	maxBatch: 20,
+	keyOptional: true,
+	translate(request) {
+		const { options, token } = request;
+		const baseUrl = options.baseUrl && trimTrailingSlashes(options.baseUrl);
+		const provider = (options.provider ?? (baseUrl ? "custom" : "gateway")).toLowerCase();
+		const model = options.model ?? (provider === "gateway" ? DEFAULT_GATEWAY_MODEL : void 0);
+		if (!model) throw usageError("AI translation needs a model.", ["Example: --options provider:openai,model:gpt-4o-mini"]);
+		if (provider === "gateway" && !model.includes("/")) throw usageError("Gateway models are written provider/model.", [`Example: --options model:${DEFAULT_GATEWAY_MODEL}`]);
+		const named = provider === "gateway" || provider === "openai" || provider === "anthropic";
+		if (!named && !baseUrl) throw usageError(`Unknown AI provider "${provider}".`, ["Use gateway, openai or anthropic, or set baseUrl to an OpenAI-compatible server."]);
+		const key = named ? resolveKey(provider, token) : token.trim();
+		if (provider === "anthropic") return viaAnthropic(request, baseUrl ?? ANTHROPIC_URL, model, key);
+		if (provider === "openai") return viaChatCompletions(request, baseUrl ?? OPENAI_URL, model, key, true);
+		return viaChatCompletions(request, baseUrl ?? GATEWAY_URL, model, key, false);
+	}
+};
+// src/translate/drivers.ts
+var base = (options, fallback) => trimTrailingSlashes(options.baseUrl ?? fallback);
+var bareLanguage = (code) => code.split(/[-_]/)[0].toLowerCase();
+var fromTable = (table) => (code) => table[code.toLowerCase()] ?? table[bareLanguage(code)] ?? bareLanguage(code);
+var google = {
+	label: "Google Translate",
+	maxBatch: 128,
+	async translate({ texts, from, to, token, options, http }) {
+		const url = `${base(options, "https://translation.googleapis.com")}/language/translate/v2?key=${encodeURIComponent(token)}`;
+		const body = {
+			q: texts,
+			target: to,
+			source: from,
+			format: options.format ?? "html",
+			model: options.model
+		};
+		return ((await requestJson(url, {
+			method: "POST",
+			...http,
+			...jsonBody(body)
+		})).data?.translations ?? []).map((item) => decodeEntities(item.translatedText));
+	}
+};
+/** Spellings of Chinese in Traditional script. The bare `zh` a lookup falls back to means Simplified. */
+var TRADITIONAL = [
+	"zh-tw",
+	"zh-hk",
+	"zh-mo",
+	"zh-hant",
+	"zh-hant-tw",
+	"zh-hant-hk",
+	"zh-hant-mo"
+];
+var traditionalAs = (name) => Object.fromEntries(TRADITIONAL.map((code) => [code, name]));
+var DEEPL_TARGETS = {
+	en: "EN-US",
+	"en-us": "EN-US",
+	"en-gb": "EN-GB",
+	es: "ES",
+	"es-419": "ES-419",
+	pt: "PT-PT",
+	"pt-pt": "PT-PT",
+	"pt-br": "PT-BR",
+	zh: "ZH-HANS",
+	"zh-cn": "ZH-HANS",
+	"zh-hans": "ZH-HANS",
+	...traditionalAs("ZH-HANT")
+};
+var deeplHost = (token) => token.endsWith(":fx") ? "https://api-free.deepl.com" : "https://api.deepl.com";
+var deepl = {
+	label: "DeepL",
+	maxBatch: 50,
+	maxChars: 1e5,
+	sourceLang: (code) => bareLanguage(code).toUpperCase(),
+	targetLang: (code) => DEEPL_TARGETS[code.toLowerCase()] ?? bareLanguage(code).toUpperCase(),
+	async translate({ texts, from, to, token, options, http }) {
+		const body = {
+			text: texts,
+			source_lang: from,
+			target_lang: to,
+			tag_handling: options.tagHandling ?? "xml",
+			formality: options.formality,
+			glossary_id: options.glossaryId,
+			context: options.context,
+			model_type: options.modelType
+		};
+		const { headers, ...payload } = jsonBody(body);
+		return (await requestJson(`${base(options, deeplHost(token))}/v2/translate`, {
+			method: "POST",
+			...http,
+			...payload,
+			headers: {
+				...headers,
+				Authorization: `DeepL-Auth-Key ${token}`
+			}
+		})).translations.map((item) => item.text);
+	}
+};
+var yandexcloud = {
+	label: "Yandex Cloud Translate",
+	maxBatch: 100,
+	maxChars: 1e4,
+	sourceLang: bareLanguage,
+	targetLang: bareLanguage,
+	async translate({ texts, from, to, token, options, http }) {
+		const scheme = options.authScheme ?? "Api-Key";
+		const { headers, ...payload } = jsonBody({
+			texts,
+			sourceLanguageCode: from,
+			targetLanguageCode: to,
+			format: "HTML",
+			folderId: options.folderId,
+			model: options.model
+		});
+		return ((await requestJson(`${base(options, "https://translate.api.cloud.yandex.net")}/translate/v2/translate`, {
+			method: "POST",
+			...http,
+			...payload,
+			headers: {
+				...headers,
+				Authorization: `${scheme} ${token}`
+			}
+		})).translations ?? []).map((item) => item.text ?? "");
+	}
+};
+var azureLang = fromTable({
+	zh: "zh-Hans",
+	"zh-cn": "zh-Hans",
+	...traditionalAs("zh-Hant"),
+	"pt-br": "pt",
+	"pt-pt": "pt-pt"
+});
+var drivers = {
+	ai: aiDriver,
+	azure: {
+		label: "Azure Translator",
+		maxBatch: 1e3,
+		maxChars: 5e4,
+		sourceLang: azureLang,
+		targetLang: azureLang,
+		async translate({ texts, from, to, token, options, http }) {
+			const query = new URLSearchParams({
+				"api-version": "3.0",
+				from,
+				to,
+				textType: "html"
+			});
+			const { headers, ...payload } = jsonBody(texts.map((text) => ({ Text: text })));
+			const auth = { "Ocp-Apim-Subscription-Key": token };
+			if (options.region) auth["Ocp-Apim-Subscription-Region"] = options.region;
+			return (await requestJson(`${base(options, "https://api.cognitive.microsofttranslator.com")}/translate?${query}`, {
+				method: "POST",
+				...http,
+				...payload,
+				headers: {
+					...headers,
+					...auth
+				}
+			})).map((item) => item.translations[0]?.text ?? "");
+		}
+	},
+	deepl,
+	google,
+	libretranslate: {
+		label: "LibreTranslate",
+		maxBatch: 100,
+		keyOptional: true,
+		async translate({ texts, from, to, token, options, http }) {
+			const body = {
+				q: texts,
+				source: from,
+				target: to,
+				format: "html",
+				api_key: token || void 0
+			};
+			return [(await requestJson(`${base(options, "https://libretranslate.com")}/translate`, {
+				method: "POST",
+				...http,
+				...jsonBody(body)
+			})).translatedText].flat();
+		}
+	},
+	yandexcloud
+};
+/** Services the old `nuxt-i18n-micro-cli` had: each name fails with the reason it is gone. */
+var removedServices = {
+	googlefree: "it used an undocumented endpoint. Use libretranslate for free translation.",
+	yandex: "Yandex closed the v1.5 API. Use yandexcloud.",
+	ibm: "IBM withdrew Watson Language Translator in 2024.",
+	lingvatranslate: "public instances return the source text unchanged. Use libretranslate.",
+	modernmt: "ModernMT sunsets on 2026-12-31.",
+	lilt: "its API needs a translation memory per language pair, which this CLI has no model for.",
+	unbabel: "its public API no longer answers.",
+	reverso: "the unofficial endpoint is blocked.",
+	baidu: "it was dropped from the CLI. Use ai, deepl, google or azure.",
+	papago: "it was dropped from the CLI. Use ai, deepl, google or azure.",
+	tencent: "it was dropped from the CLI. Use ai, deepl, google or azure.",
+	systran: "it was dropped from the CLI. Use ai, deepl, google or azure.",
+	mymemory: "its 500-character limit and missing markup mode break placeholders. Use libretranslate for free translation."
+};
+// src/translate/engine.ts
+function resolveDriver(service) {
+	const name = service.toLowerCase();
+	const driver = ownValue(drivers, name);
+	if (driver) return driver;
+	const reason = ownValue(removedServices, name);
+	if (reason) throw usageError(`Translation service "${service}" was removed: ${reason}`);
+	throw usageError(`Unsupported translation service: ${service}`, [`Supported: ${Object.keys(drivers).join(", ")}`]);
+}
+/** Parses `key:value,key:value`. Only the first colon splits: values are often URLs. */
+function parseOptions(text) {
+	const options = {};
+	for (const pair of (text ?? "").split(",")) {
+		const separator = pair.indexOf(":");
+		if (separator <= 0) continue;
+		options[pair.slice(0, separator).trim()] = pair.slice(separator + 1).trim();
+	}
+	return options;
+}
+/** Batches within what the service accepts, by count and by characters. */
+function buildBatches(items, size, maxCount, maxChars = Number.POSITIVE_INFINITY) {
+	const batches = [];
+	let current = [];
+	let chars = 0;
+	for (const item of items) {
+		const itemChars = size(item);
+		if (current.length >= maxCount || current.length > 0 && chars + itemChars > maxChars) {
+			batches.push(current);
+			current = [];
+			chars = 0;
+		}
+		current.push(item);
+		chars += itemChars;
+	}
+	if (current.length > 0) batches.push(current);
+	return batches;
+}
+var httpOptions = (options) => ({
+	retries: options.retries ? Number(options.retries) : void 0,
+	retryDelayMs: options.retryDelayMs ? Number(options.retryDelayMs) : void 0,
+	timeoutMs: options.timeoutMs ? Number(options.timeoutMs) : void 0
+});
+function splitForms(text, separator) {
+	return separator && text.includes(separator) ? text.split(separator).map((part) => part.trim()) : [text];
+}
+/** The finished value of an item, or `null` when a placeholder got lost on the way. */
+function assemble(segments, joiner) {
+	const values = segments.map((segment) => restore(segment.translated, segment.tokens));
+	return values.every((value, position) => value !== "" && isIntact(value, segments[position].tokens)) ? values.join(joiner) : null;
+}
+/**
+* Translate one list of messages, plural forms and placeholders handled, into `to`.
+*
+* `onBatch` hears about every item as soon as its last form is back, so what was paid for can
+* be saved before the next request. A failed request throws, and costs only what it carried.
+*/
+async function translateItems(items, from, to, config, extra = {}, onBatch = () => {}) {
+	const driver = resolveDriver(config.service);
+	const toSegment = (index, form) => {
+		const { masked, tokens } = protect(form);
+		return {
+			index,
+			masked,
+			tokens
+		};
+	};
+	const formsOf = items.map((item, index) => splitForms(item.text, config.pluralSeparator).map((form) => toSegment(index, form)));
+	const segments = formsOf.flat();
+	const options = {
+		...config.options,
+		...extra
+	};
+	const base = {
+		from: driver.sourceLang?.(from) ?? from,
+		to: driver.targetLang?.(to) ?? to,
+		token: config.token,
+		options,
+		http: httpOptions(options)
+	};
+	const total = {
+		translated: [],
+		rejected: []
+	};
+	const joiner = ` ${config.pluralSeparator} `;
+	const maxCount = Math.min(config.chunkSize ?? driver.maxBatch, driver.maxBatch);
+	for (const batch of buildBatches(segments, (segment) => segment.masked.length, maxCount, driver.maxChars)) {
+		const translated = await driver.translate({
+			...base,
+			texts: batch.map((segment) => segment.masked)
+		});
+		if (translated.length !== batch.length) throw commandFailed(`${driver.label} returned ${plural(translated.length, "translation")} for ${plural(batch.length, "string")}.`, ["Nothing from this batch was written."]);
+		for (const [position, segment] of batch.entries()) {
+			const text = translated[position];
+			segment.translated = typeof text === "string" ? text : "";
+		}
+		const done = {
+			translated: [],
+			rejected: []
+		};
+		for (const index of new Set(batch.map((segment) => segment.index))) {
+			if (formsOf[index].some((form) => form.translated === void 0)) continue;
+			const value = assemble(formsOf[index], joiner);
+			if (value === null) done.rejected.push(items[index].key);
+			else done.translated.push({
+				key: items[index].key,
+				value
+			});
+		}
+		onBatch(done);
+		total.translated.push(...done.translated);
+		total.rejected.push(...done.rejected);
+	}
+	return total;
+}
+// src/commands/translate.ts
+var DEFAULT_GLOSSARY = ".i18n-glossary.json";
+function jobsFor(reference, locale, replace) {
+	return reference.scopes.flatMap((scope) => {
+		const items = Object.entries(reference.strings(scope)).filter(([key, text]) => text !== "" && (replace || (locale.resolve(key, scope) ?? "") === "")).map(([key, text]) => ({
+			key,
+			text
+		}));
+		return items.length > 0 ? [{
+			scope,
+			items
+		}] : [];
+	});
+}
+async function resolveService(args) {
+	const service = args.service ?? await choose("Choose a translation service", Object.keys(drivers));
+	if (!service) throw usageError("Translation service is required.", ["Pass --service <name>."]);
+	return service;
+}
+async function resolveToken(args, keyOptional) {
+	const token = args.token ?? process.env.I18N_TRANSLATE_TOKEN;
+	if (token || keyOptional) return token ?? "";
+	const answer = await ask("API key:");
+	if (!answer) throw usageError("This service needs an API key.", ["Set I18N_TRANSLATE_TOKEN or pass --token."]);
+	return answer;
+}
+function resolveGlossary(args, rootDir) {
+	const path = resolve(rootDir, args.glossaryFile ?? DEFAULT_GLOSSARY);
+	if (existsSync(path)) return loadGlossary(path);
+	if (args.glossaryFile) throw notFoundError(`Glossary not found: ${path}`);
+}
+var contextOf = (scope, keys) => {
+	const shown = keys.slice(0, 10).join(", ");
+	return `scope=${scope === "" ? "global" : scope}; keys=${shown}${keys.length > 10 ? ` (+${keys.length - 10} more)` : ""}`;
+};
+function printPlan(project, codes, replace) {
+	const rows = codes.map((code) => {
+		const items = jobsFor(project.reference, project.locale(code), replace).flatMap((job) => job.items);
+		const chars = items.reduce((sum, item) => sum + item.text.length, 0);
+		return [code, `${plural(items.length, "key")}, ${plural(chars, "character")}`];
+	});
+	log.section("To translate");
+	log.rows(rows);
+	log.note("Dry run: nothing was sent.");
+}
+async function run(args) {
+	addSecret(args.token);
+	const project = await Project.load(args);
+	const { reference } = project;
+	const { defaultLocale, rootDir } = project.config;
+	const codes = project.selectLocales(splitList(args.locale));
+	if (args.dryRun) {
+		printPlan(project, codes, Boolean(args.replace));
+		return;
+	}
+	const service = await resolveService(args);
+	const driver = resolveDriver(service);
+	const token = await resolveToken(args, Boolean(driver.keyOptional));
+	addSecret(token);
+	const glossary = resolveGlossary(args, rootDir);
+	const options = parseOptions(args.options);
+	addUrlSecrets(options.baseUrl);
+	const config = {
+		service,
+		token,
+		options,
+		chunkSize: args.chunkSize,
+		pluralSeparator: args.pluralSeparator
+	};
+	const rejected = [];
+	let translated = 0;
+	for (const code of codes) {
+		const locale = project.locale(code);
+		log.note(`Translating locale: ${code}`);
+		spinner.update(`Translating ${code}`);
+		const glossaryText = glossary && glossaryContext(glossary, defaultLocale, code);
+		for (const { scope, items } of jobsFor(reference, locale, Boolean(args.replace))) await translateItems(items, defaultLocale, code, config, {
+			translationContext: contextOf(scope, items.map((item) => item.key)),
+			...glossaryText ? { glossaryContext: glossaryText } : {}
+		}, (result) => {
+			for (const { key, value } of result.translated) {
+				const conflict = locale.set(key, value, scope);
+				if (conflict) rejected.push(`${code}: ${key} (${conflict} already holds a value)`);
+				else translated += 1;
+			}
+			rejected.push(...result.rejected.map((key) => `${code}: ${key} (a placeholder was lost, or the answer held no text)`));
+			project.save();
+		});
+	}
+	log.list("Not written", rejected);
+	log.success(`Translated ${plural(translated, "string")}.`);
+	if (rejected.length > 0) throw findingsError(`${plural(rejected.length, "string")} ${pick(rejected.length, "was", "were")} not written.`, ["Fill them in by hand."]);
+}
+export { run as default };

package/dist/cli.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { t as runCli } from "./chunks/runner-wHXdhRdA.mjs";
+// src/cli.ts
+await runCli(process.argv.slice(2));

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { t as runCli } from "./chunks/runner-wHXdhRdA.mjs";
+import { a as commands, n as COMMAND_GROUPS } from "./chunks/spec-BwZlT28L.mjs";
+export { COMMAND_GROUPS, commands, runCli };

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,28 @@
+import { Project } from '../project.js';
+import { ProjectScan } from '../source.js';
+import { CheckType } from '../spec.js';
+export interface CheckArgs {
+    cwd?: string;
+    translationDir?: string;
+    only?: string;
+    ignore?: string;
+    duplicates?: boolean;
+    json?: boolean;
+}
+export interface Finding {
+    type: CheckType;
+    /** Absent for what is not about one locale. */
+    locale?: string;
+    file: string;
+    key: string;
+    detail?: string;
+}
+export interface CheckReport {
+    ok: boolean;
+    summary: Record<string, number>;
+    findings: Finding[];
+    /** Why `unused` was not checked: nothing can be called unused while some keys are computed at runtime. */
+    unusedSkipped?: string[];
+}
+export declare function runChecks(project: Project, scan: ProjectScan, types: Set<CheckType>, askedForUnused?: boolean): CheckReport;
+export default function run(args: CheckArgs): Promise<void>;

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

@@ -0,0 +1,26 @@
+import { Project } from '../project.js';
+import { ProjectScan } from '../source.js';
+export interface CleanArgs {
+    cwd?: string;
+    translationDir?: string;
+    include?: string;
+    exclude?: string;
+    ignore?: string;
+    dryRun?: boolean;
+    force?: boolean;
+}
+export interface UnusedKey {
+    code: string;
+    scope: string;
+    key: string;
+}
+/**
+ * Keys of this project's own files that nothing in the project can read. A key used anywhere
+ * stays in every scope: a page's route name is not always knowable from its file.
+ */
+export declare function findUnused(project: Project, scan: ProjectScan): UnusedKey[];
+/** Why removing keys cannot be trusted here. Empty when it can. */
+export declare function deletionDoubts(project: Project, scan: ProjectScan): string[];
+/** Nothing scanned proves nothing: no flag changes that. */
+export declare function assertScanned(scan: ProjectScan): void;
+export default function run(args: CleanArgs): Promise<void>;

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

@@ -0,0 +1,10 @@
+export interface ExportArgs {
+    cwd?: string;
+    translationDir?: string;
+    format: 'po' | 'csv';
+    dir?: string;
+    force?: boolean;
+}
+export declare const defaultExchangeDir: (format: string) => string;
+export declare function readManifest(dir: string): Record<string, unknown>;
+export default function run(args: ExportArgs): Promise<void>;

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

@@ -0,0 +1,6 @@
+export interface ExtractArgs {
+    cwd?: string;
+    translationDir?: string;
+    ignore?: string;
+}
+export default function run(args: ExtractArgs): Promise<void>;

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

@@ -0,0 +1,8 @@
+export interface FormatArgs {
+    cwd?: string;
+    translationDir?: string;
+    indent: number;
+    sortKeys?: boolean;
+    check?: boolean;
+}
+export default function run(args: FormatArgs): Promise<void>;

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

@@ -0,0 +1,8 @@
+export interface ImportArgs {
+    cwd?: string;
+    translationDir?: string;
+    format: 'po' | 'csv';
+    dir?: string;
+    dryRun?: boolean;
+}
+export default function run(args: ImportArgs): Promise<void>;

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

@@ -0,0 +1,5 @@
+export interface InfoArgs {
+    cwd?: string;
+    json?: boolean;
+}
+export default function run(args: InfoArgs): Promise<void>;

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

@@ -0,0 +1,16 @@
+export interface LintArgs {
+    cwd?: string;
+    translationDir?: string;
+    rules?: string;
+    fix?: boolean;
+    json?: boolean;
+}
+export interface LintResult {
+    file: string;
+    locale: string;
+    scope: string;
+    key: string;
+    value: string;
+    rule: string;
+}
+export default function run(args: LintArgs): Promise<void>;

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

@@ -0,0 +1,9 @@
+export interface PseudoArgs {
+    cwd?: string;
+    translationDir?: string;
+    sourceLocale?: string;
+    targetLocale: string;
+    replace?: boolean;
+}
+export declare function pseudoLocalize(text: string): string;
+export default function run(args: PseudoArgs): Promise<void>;