@cgaravitoq/i18n-ai 0.2.3

package/dist/cli.js

@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_dotenv = require("dotenv");
+var import_commander = require("commander");
+var import_node_path2 = require("path");
+var import_promises3 = require("fs/promises");
+
+// src/core/sync.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+var import_p_queue = __toESM(require("p-queue"));
+
+// src/core/lock.ts
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_proper_lockfile = require("proper-lockfile");
+var hash = (text) => (0, import_node_crypto.createHash)("sha256").update(text).digest("hex").slice(0, 32);
+var hashesMatch = (current, stored) => current === stored || stored.length === 16 && current.startsWith(stored);
+async function loadLock(path) {
+  try {
+    return JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return { locales: {} };
+    if (e instanceof SyntaxError)
+      throw new Error(`Lock file corrupted: ${path}`);
+    throw e;
+  }
+}
+async function saveLock(path, lock) {
+  await (0, import_promises.writeFile)(path, `${JSON.stringify(lock, null, 2)}
+`);
+}
+async function withLockFile(path, fn) {
+  let lock = await loadLock(path);
+  if (Object.keys(lock.locales).length === 0) await saveLock(path, lock);
+  const release = await (0, import_proper_lockfile.lock)(path, {
+    retries: { retries: 5, factor: 2, minTimeout: 1e3, maxTimeout: 5e3 },
+    stale: 3e4
+  });
+  try {
+    lock = await loadLock(path);
+    const result = await fn(lock);
+    await saveLock(path, lock);
+    return result;
+  } finally {
+    await release();
+  }
+}
+function analyzeLocale(base, target, locale, lock) {
+  const result = {
+    locale,
+    toTranslate: [],
+    toPreserve: /* @__PURE__ */ new Map(),
+    toRemove: /* @__PURE__ */ new Set(),
+    manualEdits: /* @__PURE__ */ new Map()
+  };
+  const localeData = lock.locales[locale] ?? {};
+  for (const [key, text] of base) {
+    const entry = localeData[key];
+    const current = target.get(key);
+    const currentHash = hash(text);
+    if (!entry) {
+      current ? result.toPreserve.set(key, current) : result.toTranslate.push({ key, text, status: "new" });
+    } else if (!hashesMatch(currentHash, entry.sourceHash)) {
+      result.toTranslate.push({ key, text, status: "modified" });
+    } else if (current && current !== entry.translation) {
+      result.manualEdits.set(key, current);
+    } else {
+      result.toPreserve.set(key, current ?? entry.translation);
+    }
+  }
+  for (const key of target.keys()) {
+    if (!base.has(key)) result.toRemove.add(key);
+  }
+  return result;
+}
+function updateLock(lock, locale, base, final) {
+  lock.locales[locale] ??= {};
+  const localeData = lock.locales[locale];
+  for (const [key, translation] of final) {
+    const sourceText = base.get(key);
+    if (sourceText) {
+      localeData[key] = {
+        sourceHash: hash(sourceText),
+        sourceText,
+        translation
+      };
+    }
+  }
+  for (const key of Object.keys(localeData)) {
+    if (!base.has(key)) delete localeData[key];
+  }
+}
+
+// src/core/translator.ts
+var import_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
+var import_ai = require("ai");
+var z2 = __toESM(require("zod"));
+
+// src/env.ts
+var import_env_core = require("@t3-oss/env-core");
+var z = __toESM(require("zod"));
+var env = (0, import_env_core.createEnv)({
+  server: {
+    OPENROUTER_API_KEY: z.string()
+  },
+  runtimeEnv: process.env
+});
+
+// src/core/translator.ts
+var DEFAULT_MODEL = "google/gemini-2.5-flash";
+var translationSchema = z2.object({
+  translations: z2.array(
+    z2.object({
+      key: z2.string(),
+      value: z2.string()
+    })
+  )
+});
+var openrouter = null;
+var getOpenRouter = () => openrouter ?? (openrouter = (0, import_ai_sdk_provider.createOpenRouter)({ apiKey: env.OPENROUTER_API_KEY }));
+var SYSTEM_PROMPT = `You are a professional translator.
+
+RULES:
+1. Translate the provided key-value pairs from the source language to the target language
+2. Return an array of translations with the EXACT same keys and their translated values
+3. Do NOT translate variables in curly braces: {name}, {count}, etc. Keep them exactly as-is
+4. Maintain original tone and context
+5. For single words or short phrases, translate directly`;
+async function withRetry(fn, maxAttempts = 3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const msg = error.message?.toLowerCase() ?? "";
+      const retryable = msg.includes("network") || msg.includes("timeout") || msg.includes("econnreset") || msg.includes("429") || msg.includes("503") || msg.includes("502");
+      if (attempt === maxAttempts || !retryable) throw error;
+      await new Promise((r) => setTimeout(r, 2 ** (attempt - 1) * 1e3));
+    }
+  }
+  throw new Error("Unreachable");
+}
+async function translateBatch(batch) {
+  if (batch.entries.length === 0) return /* @__PURE__ */ new Map();
+  const inputArray = batch.entries.map((e) => ({ key: e.key, text: e.text }));
+  return withRetry(async () => {
+    const { output } = await (0, import_ai.generateText)({
+      model: getOpenRouter().languageModel(DEFAULT_MODEL),
+      output: import_ai.Output.object({
+        schema: translationSchema
+      }),
+      system: SYSTEM_PROMPT,
+      prompt: `Translate from "${batch.sourceLang}" to "${batch.targetLang}":
+
+${JSON.stringify(inputArray, null, 2)}
+
+Return the translations array with the same keys and translated values.`
+    });
+    if (!output.translations || output.translations.length === 0) {
+      throw new Error("Translation returned empty result");
+    }
+    const resultMap = new Map(output.translations.map((t) => [t.key, t.value]));
+    const missingKeys = batch.entries.filter((e) => !resultMap.has(e.key));
+    if (missingKeys.length > 0) {
+      throw new Error(
+        `Missing translations for keys: ${missingKeys.map((e) => e.key).join(", ")}`
+      );
+    }
+    return resultMap;
+  });
+}
+
+// src/core/sync.ts
+var chunk = (arr, n) => Array.from(
+  { length: Math.ceil(arr.length / n) },
+  (_, i) => arr.slice(i * n, (i + 1) * n)
+);
+var flatten = (obj, prefix = "") => {
+  const result = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(obj)) {
+    const path = prefix ? `${prefix}.${k}` : k;
+    typeof v === "string" ? result.set(path, v) : flatten(v, path).forEach((val, p) => result.set(p, val));
+  }
+  return result;
+};
+var unflatten = (flat) => {
+  const result = {};
+  for (const [path, value] of flat) {
+    const keys = path.split(".");
+    let cur = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+      cur = cur[keys[i]] ??= {};
+    }
+    cur[keys.at(-1)] = value;
+  }
+  return result;
+};
+var readJson = async (path) => {
+  try {
+    return JSON.parse(await (0, import_promises2.readFile)(path, "utf-8"));
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+};
+var writeJsonAtomic = async (path, data) => {
+  const tmp = `${path}.tmp`;
+  await (0, import_promises2.writeFile)(tmp, `${JSON.stringify(data, null, 2)}
+`);
+  await (0, import_promises2.rename)(tmp, path);
+};
+var TranslationService = class {
+  constructor(config) {
+    this.config = config;
+    this.queue = new import_p_queue.default({ concurrency: config.concurrency ?? 10 });
+    this.batchSize = config.batchSize ?? 20;
+  }
+  queue;
+  batchSize;
+  async sync() {
+    const basePath = (0, import_node_path.join)(
+      this.config.messagesDir,
+      `${this.config.defaultLocale}.json`
+    );
+    const baseObj = await readJson(basePath);
+    if (!baseObj) throw new Error(`Base locale file not found: ${basePath}`);
+    const base = flatten(baseObj);
+    console.log(
+      `[ok] Loaded ${this.config.defaultLocale}.json (${base.size} keys)`
+    );
+    await withLockFile(this.config.lockFilePath, async (lock) => {
+      const locales = this.config.locales.filter(
+        (l) => l !== this.config.defaultLocale
+      );
+      await Promise.all(
+        locales.map((locale) => this.syncLocale(locale, base, lock))
+      );
+    });
+    console.log("\n[done] Synchronization complete!");
+  }
+  async syncLocale(locale, base, lock) {
+    const targetPath = (0, import_node_path.join)(this.config.messagesDir, `${locale}.json`);
+    const targetObj = await readJson(targetPath) ?? {};
+    const target = flatten(targetObj);
+    const changes = analyzeLocale(base, target, locale, lock);
+    const hasWork = changes.toTranslate.length > 0 || changes.toRemove.size > 0 || changes.manualEdits.size > 0;
+    console.log(
+      `
+[${locale}] ${changes.toTranslate.length} to translate, ${changes.toRemove.size} obsolete`
+    );
+    if (!hasWork) {
+      console.log("  [ok] Already synchronized");
+      return;
+    }
+    const translations = await this.translateAll(changes);
+    const final = new Map([
+      ...changes.toPreserve,
+      ...changes.manualEdits,
+      ...translations
+    ]);
+    changes.toRemove.forEach((k) => final.delete(k));
+    updateLock(lock, locale, base, final);
+    await writeJsonAtomic(targetPath, unflatten(final));
+    console.log(`  [ok] Updated ${targetPath}`);
+  }
+  async translateAll(changes) {
+    if (changes.toTranslate.length === 0) return /* @__PURE__ */ new Map();
+    const batches = chunk(changes.toTranslate, this.batchSize);
+    const results = await Promise.all(
+      batches.map(
+        (batch) => this.queue.add(
+          () => translateBatch({
+            entries: batch,
+            sourceLang: this.config.defaultLocale,
+            targetLang: changes.locale,
+            apiKey: this.config.apiKey,
+            model: this.config.model
+          })
+        )
+      )
+    );
+    return results.reduce(
+      (acc, r) => r ? new Map([...acc, ...r]) : acc,
+      /* @__PURE__ */ new Map()
+    );
+  }
+};
+
+// src/cli.ts
+var import_prompts = __toESM(require("prompts"));
+var import_chalk = __toESM(require("chalk"));
+(0, import_dotenv.config)({ path: (0, import_node_path2.resolve)(process.cwd(), ".env") });
+var VERSION = "0.2.3";
+var program = new import_commander.Command();
+program.name("i18n-ai").description("AI-powered translation CLI").version(VERSION);
+var CONFIG_FILE = "i18n.config.json";
+async function loadConfig() {
+  try {
+    const configPath = (0, import_node_path2.join)(process.cwd(), CONFIG_FILE);
+    const content = await (0, import_promises3.readFile)(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+program.command("init").description("Initialize i18n-ai configuration").action(async () => {
+  console.log(import_chalk.default.bold("\u{1F680} Initializing i18n-ai configuration\n"));
+  const response = await (0, import_prompts.default)([
+    {
+      type: "text",
+      name: "messagesDir",
+      message: "Where are your messages located?",
+      initial: "messages",
+      validate: (value) => value.length > 0 ? true : "Directory cannot be empty"
+    },
+    {
+      type: "text",
+      name: "defaultLocale",
+      message: "What is your default locale?",
+      initial: "en"
+    },
+    {
+      type: "list",
+      name: "locales",
+      message: "Which other locales do you support? (comma separated)",
+      initial: "es, fr",
+      separator: ","
+    }
+  ]);
+  if (!response.messagesDir || !response.defaultLocale) {
+    console.log(import_chalk.default.red("\n\u274C Initialization canceled"));
+    return;
+  }
+  const allLocales = [
+    response.defaultLocale,
+    ...response.locales.map((l) => l.trim()).filter((l) => l && l !== response.defaultLocale)
+  ];
+  const config = {
+    defaultLocale: response.defaultLocale,
+    locales: allLocales,
+    messagesDir: response.messagesDir
+  };
+  await (0, import_promises3.writeFile)((0, import_node_path2.join)(process.cwd(), CONFIG_FILE), JSON.stringify(config, null, 2));
+  console.log(import_chalk.default.green(`
+\u2705 Created ${CONFIG_FILE}`));
+  const absMessagesDir = (0, import_node_path2.resolve)(process.cwd(), response.messagesDir);
+  await (0, import_promises3.mkdir)(absMessagesDir, { recursive: true });
+  const baseFilePath = (0, import_node_path2.join)(absMessagesDir, `${response.defaultLocale}.json`);
+  try {
+    await (0, import_promises3.readFile)(baseFilePath);
+  } catch {
+    await (0, import_promises3.writeFile)(baseFilePath, JSON.stringify({ welcome: "Hello World" }, null, 2));
+    console.log(import_chalk.default.green(`\u2705 Created base file ${response.messagesDir}/${response.defaultLocale}.json`));
+  }
+  if (process.env.OPENROUTER_API_KEY) {
+    console.log(import_chalk.default.green("\u2705 OPENROUTER_API_KEY detected in .env"));
+  } else {
+    console.log(import_chalk.default.yellow("\n\u26A0\uFE0F  OPENROUTER_API_KEY not found in .env"));
+    console.log(import_chalk.default.dim("   Add it to your .env file: OPENROUTER_API_KEY=your_key"));
+    console.log(import_chalk.default.dim("   Get one at: https://openrouter.ai"));
+  }
+  console.log(import_chalk.default.blue('\n\u{1F389} Setup complete! You can now run "i18n-ai sync"'));
+});
+program.command("sync").description("Synchronize translations using AI").option("-d, --dir <path>", "Messages directory").option("-l, --locales <items>", "Comma separated list of locales").option("--default <locale>", "Default locale").option("--lock <path>", "Lock file path", "translation-lock.json").option("--api-key <key>", "OpenRouter API key (or set OPENROUTER_API_KEY)").option("--model <model>", "AI model to use", "google/gemini-2.5-flash").action(async (options) => {
+  try {
+    const cwd = process.cwd();
+    const config = await loadConfig();
+    const messagesDir = options.dir ? (0, import_node_path2.resolve)(cwd, options.dir) : config?.messagesDir ? (0, import_node_path2.resolve)(cwd, config.messagesDir) : (0, import_node_path2.resolve)(cwd, "messages");
+    const locales = options.locales ? options.locales.split(",").map((l) => l.trim()).filter(Boolean) : config?.locales ?? [];
+    const defaultLocale = options.default ?? config?.defaultLocale ?? "en";
+    if (locales.length === 0) {
+      console.error(import_chalk.default.red('No locales found. Run "i18n-ai init" or specify --locales.'));
+      process.exit(1);
+    }
+    console.log(import_chalk.default.dim(`Using Config: Default=${defaultLocale}, Locales=${locales.join(",")}, Dir=${messagesDir}`));
+    const service = new TranslationService({
+      locales,
+      defaultLocale,
+      messagesDir,
+      lockFilePath: (0, import_node_path2.resolve)(cwd, options.lock),
+      apiKey: options.apiKey,
+      model: options.model
+    });
+    await service.sync();
+  } catch (error) {
+    console.error(import_chalk.default.red("Fatal error:"), error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import {
+  TranslationService
+} from "./chunk-IOH4K3A3.mjs";
+
+// src/cli.ts
+import { config as loadEnv } from "dotenv";
+import { Command } from "commander";
+import { resolve, join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import prompts from "prompts";
+import chalk from "chalk";
+loadEnv({ path: resolve(process.cwd(), ".env") });
+var VERSION = "0.2.3";
+var program = new Command();
+program.name("i18n-ai").description("AI-powered translation CLI").version(VERSION);
+var CONFIG_FILE = "i18n.config.json";
+async function loadConfig() {
+  try {
+    const configPath = join(process.cwd(), CONFIG_FILE);
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+program.command("init").description("Initialize i18n-ai configuration").action(async () => {
+  console.log(chalk.bold("\u{1F680} Initializing i18n-ai configuration\n"));
+  const response = await prompts([
+    {
+      type: "text",
+      name: "messagesDir",
+      message: "Where are your messages located?",
+      initial: "messages",
+      validate: (value) => value.length > 0 ? true : "Directory cannot be empty"
+    },
+    {
+      type: "text",
+      name: "defaultLocale",
+      message: "What is your default locale?",
+      initial: "en"
+    },
+    {
+      type: "list",
+      name: "locales",
+      message: "Which other locales do you support? (comma separated)",
+      initial: "es, fr",
+      separator: ","
+    }
+  ]);
+  if (!response.messagesDir || !response.defaultLocale) {
+    console.log(chalk.red("\n\u274C Initialization canceled"));
+    return;
+  }
+  const allLocales = [
+    response.defaultLocale,
+    ...response.locales.map((l) => l.trim()).filter((l) => l && l !== response.defaultLocale)
+  ];
+  const config = {
+    defaultLocale: response.defaultLocale,
+    locales: allLocales,
+    messagesDir: response.messagesDir
+  };
+  await writeFile(join(process.cwd(), CONFIG_FILE), JSON.stringify(config, null, 2));
+  console.log(chalk.green(`
+\u2705 Created ${CONFIG_FILE}`));
+  const absMessagesDir = resolve(process.cwd(), response.messagesDir);
+  await mkdir(absMessagesDir, { recursive: true });
+  const baseFilePath = join(absMessagesDir, `${response.defaultLocale}.json`);
+  try {
+    await readFile(baseFilePath);
+  } catch {
+    await writeFile(baseFilePath, JSON.stringify({ welcome: "Hello World" }, null, 2));
+    console.log(chalk.green(`\u2705 Created base file ${response.messagesDir}/${response.defaultLocale}.json`));
+  }
+  if (process.env.OPENROUTER_API_KEY) {
+    console.log(chalk.green("\u2705 OPENROUTER_API_KEY detected in .env"));
+  } else {
+    console.log(chalk.yellow("\n\u26A0\uFE0F  OPENROUTER_API_KEY not found in .env"));
+    console.log(chalk.dim("   Add it to your .env file: OPENROUTER_API_KEY=your_key"));
+    console.log(chalk.dim("   Get one at: https://openrouter.ai"));
+  }
+  console.log(chalk.blue('\n\u{1F389} Setup complete! You can now run "i18n-ai sync"'));
+});
+program.command("sync").description("Synchronize translations using AI").option("-d, --dir <path>", "Messages directory").option("-l, --locales <items>", "Comma separated list of locales").option("--default <locale>", "Default locale").option("--lock <path>", "Lock file path", "translation-lock.json").option("--api-key <key>", "OpenRouter API key (or set OPENROUTER_API_KEY)").option("--model <model>", "AI model to use", "google/gemini-2.5-flash").action(async (options) => {
+  try {
+    const cwd = process.cwd();
+    const config = await loadConfig();
+    const messagesDir = options.dir ? resolve(cwd, options.dir) : config?.messagesDir ? resolve(cwd, config.messagesDir) : resolve(cwd, "messages");
+    const locales = options.locales ? options.locales.split(",").map((l) => l.trim()).filter(Boolean) : config?.locales ?? [];
+    const defaultLocale = options.default ?? config?.defaultLocale ?? "en";
+    if (locales.length === 0) {
+      console.error(chalk.red('No locales found. Run "i18n-ai init" or specify --locales.'));
+      process.exit(1);
+    }
+    console.log(chalk.dim(`Using Config: Default=${defaultLocale}, Locales=${locales.join(",")}, Dir=${messagesDir}`));
+    const service = new TranslationService({
+      locales,
+      defaultLocale,
+      messagesDir,
+      lockFilePath: resolve(cwd, options.lock),
+      apiKey: options.apiKey,
+      model: options.model
+    });
+    await service.sync();
+  } catch (error) {
+    console.error(chalk.red("Fatal error:"), error);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+interface TranslationLock {
+    locales: Record<string, Record<string, LockEntry>>;
+}
+interface LockEntry {
+    sourceHash: string;
+    sourceText: string;
+    translation: string;
+}
+interface LocaleChanges {
+    locale: string;
+    toTranslate: Array<{
+        key: string;
+        text: string;
+        status: 'new' | 'modified';
+    }>;
+    toPreserve: Map<string, string>;
+    toRemove: Set<string>;
+    manualEdits: Map<string, string>;
+}
+declare function withLockFile<T>(path: string, fn: (lock: TranslationLock) => Promise<T>): Promise<T>;
+declare function analyzeLocale(base: Map<string, string>, target: Map<string, string>, locale: string, lock: TranslationLock): LocaleChanges;
+declare function updateLock(lock: TranslationLock, locale: string, base: Map<string, string>, final: Map<string, string>): void;
+
+interface TranslationBatch {
+    entries: Array<{
+        key: string;
+        text: string;
+    }>;
+    sourceLang: string;
+    targetLang: string;
+    apiKey?: string;
+    model?: string;
+}
+declare function translateBatch(batch: TranslationBatch): Promise<Map<string, string>>;
+
+interface SyncConfig {
+    locales: string[];
+    defaultLocale: string;
+    messagesDir: string;
+    lockFilePath: string;
+    concurrency?: number;
+    batchSize?: number;
+    apiKey?: string;
+    model?: string;
+}
+declare class TranslationService {
+    private config;
+    private queue;
+    private batchSize;
+    constructor(config: SyncConfig);
+    sync(): Promise<void>;
+    private syncLocale;
+    private translateAll;
+}
+
+export { type LocaleChanges, type LockEntry, type SyncConfig, type TranslationBatch, type TranslationLock, TranslationService, analyzeLocale, translateBatch, updateLock, withLockFile };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+interface TranslationLock {
+    locales: Record<string, Record<string, LockEntry>>;
+}
+interface LockEntry {
+    sourceHash: string;
+    sourceText: string;
+    translation: string;
+}
+interface LocaleChanges {
+    locale: string;
+    toTranslate: Array<{
+        key: string;
+        text: string;
+        status: 'new' | 'modified';
+    }>;
+    toPreserve: Map<string, string>;
+    toRemove: Set<string>;
+    manualEdits: Map<string, string>;
+}
+declare function withLockFile<T>(path: string, fn: (lock: TranslationLock) => Promise<T>): Promise<T>;
+declare function analyzeLocale(base: Map<string, string>, target: Map<string, string>, locale: string, lock: TranslationLock): LocaleChanges;
+declare function updateLock(lock: TranslationLock, locale: string, base: Map<string, string>, final: Map<string, string>): void;
+
+interface TranslationBatch {
+    entries: Array<{
+        key: string;
+        text: string;
+    }>;
+    sourceLang: string;
+    targetLang: string;
+    apiKey?: string;
+    model?: string;
+}
+declare function translateBatch(batch: TranslationBatch): Promise<Map<string, string>>;
+
+interface SyncConfig {
+    locales: string[];
+    defaultLocale: string;
+    messagesDir: string;
+    lockFilePath: string;
+    concurrency?: number;
+    batchSize?: number;
+    apiKey?: string;
+    model?: string;
+}
+declare class TranslationService {
+    private config;
+    private queue;
+    private batchSize;
+    constructor(config: SyncConfig);
+    sync(): Promise<void>;
+    private syncLocale;
+    private translateAll;
+}
+
+export { type LocaleChanges, type LockEntry, type SyncConfig, type TranslationBatch, type TranslationLock, TranslationService, analyzeLocale, translateBatch, updateLock, withLockFile };