locai 2.6.2 → 2.7.0

package/dist/commands/review.d.ts

@@ -1,4 +1,5 @@
-interface ReviewItem {
+/** A queued translation as the review reads it: the fields of a ReviewQueueItem it uses. */
+export interface ReviewItem {
     key: string;
     language: string;
     source: string;
@@ -16,10 +17,19 @@ interface ReviewItem {
     edited?: boolean;
     editedAt?: string;
 }
-interface ReviewCommandConfig {
+export interface ReviewDecisions {
+    accepted: ReviewItem[];
+    edited: ReviewItem[];
+    rejected: ReviewItem[];
+    skipped: ReviewItem[];
+}
+export interface ReviewCommandConfig {
     localesDir: string;
     source: string;
-    [key: string]: any;
+}
+/** Nested locale file content: leaves are translations, branches are key segments. */
+export interface LocaleTree {
+    [key: string]: string | LocaleTree;
 }
 declare class ReviewCommand {
     private config;
@@ -35,6 +45,18 @@ declare class ReviewCommand {
      * @returns {boolean} - True if loaded successfully, else false.
      */
     loadReviewQueue(): boolean;
+    /**
+     * The locale file `locai translate` writes `language` to. As in
+     * FileManager.findLocaleFiles, a `<localesDir>/<source>/translation.json` source means the
+     * nested layout, anything else the flat `<localesDir>/<language>.json` one.
+     */
+    private localeFile;
+    /**
+     * Remove the reviewed items from the review queue: the rejected ones, and the accepted or
+     * edited ones whose translation is now in the locale file. Skipped items, items the session
+     * did not reach and items applyDecisions did not write stay queued.
+     */
+    private pruneReviewQueue;
     /**
      * Start interactive review session.
      */
@@ -44,7 +66,7 @@ declare class ReviewCommand {
      */
     private handleAction;
     /**
-     * Save review decisions to disk and apply them.
+     * Save review decisions to disk, apply them and remove the reviewed items from the queue.
      */
     saveDecisions(): void;
     /**
@@ -52,12 +74,15 @@ declare class ReviewCommand {
      */
     applyDecisions(): void;
     /**
-     * Set nested value in object using dot notation.
-     * @param {any} obj - Object to modify.
+     * Set nested value in object using dot notation. Missing parents are created; a parent
+     * that already holds a non-object value (e.g. a string translation) is never overwritten,
+     * and neither is a leaf that already holds nested keys.
+     * @param {LocaleTree} obj - Object to modify.
      * @param {string} path - Dot notation path.
-     * @param {any} value - Value to set.
+     * @param {string} value - Value to set.
+     * @returns {string | null} - Why the value could not be set, or null when it was set.
      */
-    setNestedValue(obj: any, path: string, value: any): void;
+    setNestedValue(obj: LocaleTree, path: string, value: string): string | null;
     /**
      * Export review queue to JSON.
      * @param {string} format - Export format (json or csv).

package/dist/commands/review.js

@@ -2,6 +2,8 @@ import fs from "fs";
 import path from "path";
 import prompts from "prompts";
 import ConfidenceScorer from "../utils/confidence-scorer.js";
+import { targetLocaleFile } from "../utils/locale-paths.js";
+import { readReviewQueue, removeFromReviewQueue } from "../utils/review-queue.js";
 class ReviewCommand {
     config;
     reviewQueue;
@@ -25,22 +27,60 @@ class ReviewCommand {
      * @returns {boolean} - True if loaded successfully, else false.
      */
     loadReviewQueue() {
-        const reviewFile = path.join(process.cwd(), ".localize-cache", "review-queue.json");
-        if (!fs.existsSync(reviewFile)) {
-            console.log("\nNo review queue found.");
-            console.log("   Run translation with confidence scoring first: localize translate --min-confidence 0.8");
-            return false;
-        }
         try {
-            const data = JSON.parse(fs.readFileSync(reviewFile, "utf8"));
-            this.reviewQueue = data.items || [];
+            const items = readReviewQueue();
+            if (!items) {
+                console.log("\nNo review queue found.");
+                console.log("   Run a translation that saves one first: locai translate --save-review-queue");
+                return false;
+            }
+            this.reviewQueue = items;
             return true;
         }
         catch (error) {
-            console.error(`Error loading review queue: ${error.message}`);
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error loading review queue: ${message}`);
             return false;
         }
     }
+    /**
+     * The locale file `locai translate` writes `language` to. As in
+     * FileManager.findLocaleFiles, a `<localesDir>/<source>/translation.json` source means the
+     * nested layout, anything else the flat `<localesDir>/<language>.json` one.
+     */
+    localeFile(language) {
+        const { localesDir, source } = this.config;
+        const nestedSource = path.join(localesDir, source, "translation.json");
+        const sourceFile = fs.existsSync(nestedSource)
+            ? nestedSource
+            : path.join(localesDir, `${source}.json`);
+        return targetLocaleFile(sourceFile, language);
+    }
+    /**
+     * Remove the reviewed items from the review queue: the rejected ones, and the accepted or
+     * edited ones whose translation is now in the locale file. Skipped items, items the session
+     * did not reach and items applyDecisions did not write stay queued.
+     */
+    pruneReviewQueue() {
+        const localeTrees = new Map();
+        const isWritten = (item) => {
+            let tree = localeTrees.get(item.language);
+            if (!tree) {
+                const localeFile = this.localeFile(item.language);
+                tree = fs.existsSync(localeFile)
+                    ? JSON.parse(fs.readFileSync(localeFile, "utf8"))
+                    : {};
+                localeTrees.set(item.language, tree);
+            }
+            let value = tree;
+            for (const segment of item.key.split(".")) {
+                value = value !== null && typeof value === "object" ? value[segment] : undefined;
+            }
+            return value === item.translation;
+        };
+        const written = [...this.decisions.accepted, ...this.decisions.edited].filter(isWritten);
+        removeFromReviewQueue([...written, ...this.decisions.rejected]);
+    }
     /**
      * Start interactive review session.
      */
@@ -108,7 +148,7 @@ class ReviewCommand {
         }
     }
     /**
-     * Save review decisions to disk and apply them.
+     * Save review decisions to disk, apply them and remove the reviewed items from the queue.
      */
     saveDecisions() {
         const cacheDir = path.join(process.cwd(), ".localize-cache");
@@ -128,8 +168,9 @@ class ReviewCommand {
         };
         fs.writeFileSync(decisionsFile, JSON.stringify(data, null, 2));
         console.log(`\nReview complete! Decisions saved to ${decisionsFile}`);
-        // Apply accepted and edited translations
+        // Apply accepted and edited translations, then drop the reviewed items from the queue
         this.applyDecisions();
+        this.pruneReviewQueue();
     }
     /**
      * Apply accepted and edited translations to locale files.
@@ -148,38 +189,64 @@ class ReviewCommand {
             }
             byLanguage[item.language].push(item);
         });
+        let skipped = 0;
         Object.entries(byLanguage).forEach(([lang, items]) => {
-            const localeFile = path.join(this.config.localesDir, `${lang}.json`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const localeFile = this.localeFile(lang);
             let localeData = {};
             if (fs.existsSync(localeFile)) {
                 localeData = JSON.parse(fs.readFileSync(localeFile, "utf8"));
             }
+            let applied = 0;
             items.forEach((item) => {
-                this.setNestedValue(localeData, item.key, item.translation);
+                const conflict = this.setNestedValue(localeData, item.key, item.translation);
+                if (conflict) {
+                    skipped++;
+                    console.warn(`   Skipped "${item.key}" for ${lang}: ${conflict}; the existing value was kept`);
+                }
+                else {
+                    applied++;
+                }
             });
+            if (applied === 0)
+                return;
+            fs.mkdirSync(path.dirname(localeFile), { recursive: true });
             fs.writeFileSync(localeFile, JSON.stringify(localeData, null, 2) + "\n");
-            console.log(`   Updated ${lang}.json (${items.length} translations)`);
+            console.log(`   Updated ${path.relative(process.cwd(), localeFile)} (${applied} translations)`);
         });
-        console.log("\nAll approved translations applied!");
+        console.log(skipped === 0
+            ? "\nAll approved translations applied!"
+            : `\nApplied ${toApply.length - skipped} approved translations; skipped ${skipped} (see warnings above).`);
     }
     /**
-     * Set nested value in object using dot notation.
-     * @param {any} obj - Object to modify.
+     * Set nested value in object using dot notation. Missing parents are created; a parent
+     * that already holds a non-object value (e.g. a string translation) is never overwritten,
+     * and neither is a leaf that already holds nested keys.
+     * @param {LocaleTree} obj - Object to modify.
      * @param {string} path - Dot notation path.
-     * @param {any} value - Value to set.
+     * @param {string} value - Value to set.
+     * @returns {string | null} - Why the value could not be set, or null when it was set.
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     setNestedValue(obj, path, value) {
         const keys = path.split(".");
         let current = obj;
         for (let i = 0; i < keys.length - 1; i++) {
-            if (!current[keys[i]]) {
+            const next = current[keys[i]];
+            if (next === undefined) {
                 current[keys[i]] = {};
             }
+            else if (next === null || typeof next !== "object" || Array.isArray(next)) {
+                const kind = next === null ? "null" : Array.isArray(next) ? "an array" : `a ${typeof next}`;
+                return `"${keys.slice(0, i + 1).join(".")}" already holds ${kind}, not nested keys`;
+            }
             current = current[keys[i]];
         }
-        current[keys[keys.length - 1]] = value;
+        const leaf = keys[keys.length - 1];
+        const existing = current[leaf];
+        if (existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+            return `"${path}" already holds nested keys, not a translation`;
+        }
+        current[leaf] = value;
+        return null;
     }
     /**
      * Export review queue to JSON.

package/dist/commands/translator.d.ts

@@ -1,4 +1,6 @@
+import { FixSummary } from "../services/translation-service.js";
 import { GlobalStats, TranslationOptions } from "../types/index.js";
+export type { FixSummary };
 /**
  * Main translator function to process source file and create translations.
  * @param {string} file - Source file path.
@@ -17,7 +19,7 @@ declare function findLocaleFiles(localesDir: string, sourceLang: string): Promis
  * Validate and fix existing translations that have length issues.
  * @param {string} file - File path to validate.
  * @param {TranslationOptions} options - Validation options.
- * @returns {Promise<void>}
+ * @returns {Promise<FixSummary>} - How many length issues were found and fixed.
  */
-declare function validateAndFixExistingTranslations(file: string, options: TranslationOptions): Promise<void>;
+declare function validateAndFixExistingTranslations(file: string, options: TranslationOptions): Promise<FixSummary>;
 export { translateFile, findLocaleFiles, validateAndFixExistingTranslations };

package/dist/commands/translator.js

@@ -21,7 +21,7 @@ async function findLocaleFiles(localesDir, sourceLang) {
  * Validate and fix existing translations that have length issues.
  * @param {string} file - File path to validate.
  * @param {TranslationOptions} options - Validation options.
- * @returns {Promise<void>}
+ * @returns {Promise<FixSummary>} - How many length issues were found and fixed.
  */
 async function validateAndFixExistingTranslations(file, options) {
     return await translationService.validateAndFixExistingTranslations(file, options);

package/dist/config/index.d.ts

@@ -1,6 +1,31 @@
-import { ConfigLayer } from "c12";
-import { OrchestratorOptions } from "../core/orchestrator.js";
-export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "context"> {
+import type { OrchestratorOptions, ProviderRetryOptions } from "../core/orchestrator.js";
+import type { ContextConfig } from "../core/context-processor.js";
+import type { ProviderConfig } from "../providers/base-provider.js";
+import type { SyncOptions } from "../types/index.js";
+import type { LoggerConfig } from "../utils/logger.js";
+/** The `context` section as written in a config file; {@link loadConfig} fills in the rest. */
+export interface ContextConfigInput extends Partial<Omit<ContextConfig, "detection" | "fallback">> {
+    detection?: Partial<ContextConfig["detection"]>;
+    fallback?: Partial<ContextConfig["fallback"]>;
+}
+/** The `fileOperations` configuration section. */
+export interface FileOperationsConfig {
+    /**
+     * File format to use (json, yaml, po, properties, etc.)
+     * @default "json"
+     */
+    format?: "json" | "yaml" | "po" | "properties" | "arb" | "auto";
+    /**
+     * File structure (flat, nested, namespaced)
+     * @default "flat"
+     */
+    fileStructure?: "flat" | "nested" | "namespaced" | "auto";
+    backupFiles?: boolean;
+    backupDir?: string;
+    atomic?: boolean;
+    createMissingDirs?: boolean;
+}
+export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "context" | "sourceCodeAnalyzer"> {
     /**
      * Source language code (e.g. 'en')
      */
@@ -10,8 +35,9 @@ export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "cont
      */
     targets?: string[];
     /**
-     * Deep Context (Source Code Analysis)
-     * Scans source code for context (component name, comments, props)
+     * Deep Context (Source Code Analysis): find where each key is used in the `.ts`/`.tsx` files
+     * under `src/`, `app/` and `components/`, and add the file, component, comments, JSX props and
+     * a code snippet of that usage to the translation prompt.
      * @default true
      */
     deepContext?: boolean;
@@ -42,16 +68,7 @@ export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "cont
     /**
      * Synchronization options
      */
-    syncOptions?: {
-        enabled?: boolean;
-        removeDeletedKeys?: boolean;
-        retranslateModified?: boolean;
-        stateTracking?: {
-            enabled?: boolean;
-            stateFileName?: string;
-            stateDir?: string;
-        };
-    };
+    syncOptions?: SyncOptions;
     /**
      * Concurrency limit for parallel translations
      * @default 5
@@ -66,22 +83,7 @@ export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "cont
      * Minimum confidence threshold (0-1)
      */
     minConfidence?: number;
-    fileOperations?: {
-        /**
-         * File format to use (json, yaml, po, properties, etc.)
-         * @default "json"
-         */
-        format?: "json" | "yaml" | "po" | "properties" | "arb" | "auto";
-        /**
-         * File structure (flat, nested, namespaced)
-         * @default "flat"
-         */
-        fileStructure?: "flat" | "nested" | "namespaced" | "auto";
-        backupFiles?: boolean;
-        backupDir?: string;
-        atomic?: boolean;
-        createMissingDirs?: boolean;
-    };
+    fileOperations?: FileOperationsConfig;
     useAi?: boolean;
     contextProvider?: string;
     contextThreshold?: number;
@@ -101,42 +103,27 @@ export interface LocalizeConfig extends Omit<Partial<OrchestratorOptions>, "cont
     force?: boolean;
     verbose?: boolean;
     version?: string;
-    rateLimiter?: {
-        enabled?: boolean;
-        queueStrategy?: string;
-        queueTimeout?: number;
-        adaptiveThrottling?: boolean;
-        providerLimits?: any;
-    };
-    context?: {
-        enabled?: boolean;
-        useAI?: boolean;
-        aiProvider?: string;
-        minTextLength?: number;
-        allowNewCategories?: boolean;
-        debug?: boolean;
-        analysisOptions?: {
-            model?: string;
-            temperature?: number;
-            maxTokens?: number;
-            cacheAnalysis?: boolean;
-        };
-        detection?: {
-            threshold?: number;
-            minConfidence?: number;
-        };
-        categories?: any;
-        fallback?: any;
-    };
-    qualityChecks?: {
-        enabled?: boolean;
-        rules?: any;
-        autoFix?: boolean;
-    };
+    logging?: LoggerConfig;
+    context?: ContextConfigInput;
     command?: string;
     fixLength?: boolean;
     showDetailedStats?: boolean;
 }
+/**
+ * The configuration returned by {@link loadConfig}: the user's settings merged over the
+ * defaults, so the defaulted settings are always present.
+ */
+export interface ResolvedLocalizeConfig extends LocalizeConfig {
+    source: string;
+    targets: string[];
+    localesDir: string;
+    concurrencyLimit: number;
+    cacheEnabled: boolean;
+    retryOptions: ProviderRetryOptions;
+    context: ContextConfig;
+    apiConfig: Record<string, ProviderConfig>;
+    fileOperations: FileOperationsConfig;
+}
 /**
  * Type-safe configuration helper
  */
@@ -145,8 +132,8 @@ export declare function defineConfig(config: LocalizeConfig): LocalizeConfig;
  * Load configuration using c12
  */
 export declare function loadConfig(cwd?: string): Promise<{
-    config: LocalizeConfig;
+    config: ResolvedLocalizeConfig;
     configFile: string | undefined;
-    layers: ConfigLayer<LocalizeConfig, import("c12").ConfigLayerMeta>[] | undefined;
+    layers: import("c12").ConfigLayer<LocalizeConfig, import("c12").ConfigLayerMeta>[] | undefined;
 }>;
-export declare const validateEnvironment: (config?: any) => void;
+export declare const validateEnvironment: (config?: LocalizeConfig) => void;

package/dist/config/index.js

@@ -45,7 +45,8 @@ export async function loadConfig(cwd = process.cwd()) {
         },
     });
     return {
-        config: config || {},
+        // c12 merges the user's config over `defaults`, so the defaulted settings are always set.
+        config: (config || {}),
         configFile,
         layers,
     };

package/dist/config/setup.d.ts

@@ -1,3 +1,4 @@
+import type { LocalizeConfig } from "./index.js";
 /**
  * Load environment variables from .env files.
  * Prioritizes .env.local over .env.
@@ -5,6 +6,6 @@
 export declare const loadEnvironmentVariables: () => Promise<void>;
 /**
  * Configure global components (logger, rate limiter, etc.).
- * @param {any} config - Configuration object.
+ * @param config - Configuration object.
  */
-export declare const configureComponents: (config: any) => void;
+export declare const configureComponents: (config: LocalizeConfig) => void;

package/dist/config/setup.js

@@ -32,8 +32,10 @@ export const loadEnvironmentVariables = async () => {
         }
         catch (error) {
             // ENOENT is expected when files don't exist - silently skip
-            if (error.code !== "ENOENT") {
-                console.warn(`Warning: Could not load ${envFile}: ${error.message}`);
+            const isMissingFile = error instanceof Error && "code" in error && error.code === "ENOENT";
+            if (!isMissingFile) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`Warning: Could not load ${envFile}: ${message}`);
             }
         }
     }
@@ -44,7 +46,7 @@ export const loadEnvironmentVariables = async () => {
 };
 /**
  * Configure global components (logger, rate limiter, etc.).
- * @param {any} config - Configuration object.
+ * @param config - Configuration object.
  */
 export const configureComponents = (config) => {
     // Configure FileManager with config settings

package/dist/core/adapters/android-adapter.d.ts

@@ -1,3 +1,4 @@
+import type { TranslationObject } from "../../utils/object-transformer.js";
 import { FileFormatAdapter } from "./base-adapter.js";
 /**
  * Adapter for Android XML resources files (strings.xml)
@@ -7,6 +8,6 @@ export declare class AndroidAdapter implements FileFormatAdapter {
     private parser;
     private builder;
     constructor();
-    parse(content: string): Promise<Record<string, any>>;
-    serialize(data: Record<string, any>): Promise<string>;
+    parse(content: string): Promise<TranslationObject>;
+    serialize(data: TranslationObject): Promise<string>;
 }

package/dist/core/adapters/android-adapter.js

@@ -51,14 +51,12 @@ export class AndroidAdapter {
             return result;
         }
         catch (error) {
-            throw new Error(`Failed to parse Android XML: ${error.message}`);
+            throw new Error(`Failed to parse Android XML: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     async serialize(data) {
-        const resources = {
-            string: [],
-            "string-array": [],
-        };
+        const stringNodes = [];
+        const stringArrayNodes = [];
         // Collect keys to handle arrays properly
         const arrays = {};
         const strings = {};
@@ -76,25 +74,26 @@ export class AndroidAdapter {
         }
         // Add strings
         for (const [key, value] of Object.entries(strings)) {
-            resources.string.push({
+            stringNodes.push({
                 "@_name": key,
                 "#text": value,
             });
         }
         // Add arrays
         for (const [key, items] of Object.entries(arrays)) {
-            resources["string-array"].push({
+            stringArrayNodes.push({
                 "@_name": key,
                 item: items.filter((i) => i !== undefined),
             });
         }
         // Sort by name for consistency
-        resources.string.sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
-        resources["string-array"].sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
-        if (resources["string-array"].length === 0)
-            delete resources["string-array"];
-        if (resources.string.length === 0)
-            delete resources.string;
+        stringNodes.sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        stringArrayNodes.sort((a, b) => a["@_name"].localeCompare(b["@_name"]));
+        const resources = {};
+        if (stringNodes.length > 0)
+            resources.string = stringNodes;
+        if (stringArrayNodes.length > 0)
+            resources["string-array"] = stringArrayNodes;
         const xmlObj = {
             "?xml": {
                 "@_version": "1.0",

package/dist/core/adapters/base-adapter.d.ts

@@ -1,3 +1,14 @@
+import type { TranslationObject } from "../../utils/object-transformer.js";
+/**
+ * Options accepted by {@link FileFormatAdapter.serialize}.
+ * Adapters ignore options that do not apply to their format.
+ */
+export interface SerializeOptions {
+    /** Indentation width (JSON, YAML) */
+    indent?: number;
+    /** Request compact output where the format supports it */
+    compact?: boolean;
+}
 /**
  * Interface for file format adapters
  */
@@ -10,11 +21,11 @@ export interface FileFormatAdapter {
      * Parse file content into a key-value object
      * @param content - Raw string content
      */
-    parse(content: string): Promise<Record<string, any>>;
+    parse(content: string): Promise<TranslationObject>;
     /**
      * Serialize data object into string format
      * @param data - Key-value object
      * @param options - Serialization options
      */
-    serialize(data: Record<string, any>, options?: any): Promise<string>;
+    serialize(data: TranslationObject, options?: SerializeOptions): Promise<string>;
 }

package/dist/core/adapters/ios-adapter.d.ts

@@ -1,3 +1,4 @@
+import type { TranslationObject } from "../../utils/object-transformer.js";
 import { FileFormatAdapter } from "./base-adapter.js";
 /**
  * Adapter for iOS .strings files
@@ -5,6 +6,6 @@ import { FileFormatAdapter } from "./base-adapter.js";
  */
 export declare class IosAdapter implements FileFormatAdapter {
     extensions: string[];
-    parse(content: string): Promise<Record<string, any>>;
-    serialize(data: Record<string, any>): Promise<string>;
+    parse(content: string): Promise<TranslationObject>;
+    serialize(data: TranslationObject): Promise<string>;
 }

package/dist/core/adapters/json-adapter.d.ts

@@ -1,9 +1,10 @@
-import { FileFormatAdapter } from "./base-adapter.js";
+import type { TranslationObject } from "../../utils/object-transformer.js";
+import { FileFormatAdapter, SerializeOptions } from "./base-adapter.js";
 /**
  * Adapter for JSON files
  */
 export declare class JsonAdapter implements FileFormatAdapter {
     extensions: string[];
-    parse(content: string): Promise<Record<string, any>>;
-    serialize(data: Record<string, any>, options?: any): Promise<string>;
+    parse(content: string): Promise<TranslationObject>;
+    serialize(data: TranslationObject, options?: SerializeOptions): Promise<string>;
 }

package/dist/core/adapters/json-adapter.js

@@ -3,16 +3,14 @@
  */
 export class JsonAdapter {
     extensions = [".json", ".arb"];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async parse(content) {
         try {
             return JSON.parse(content);
         }
         catch (error) {
-            throw new Error(`JSON parse error: ${error.message}`);
+            throw new Error(`JSON parse error: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async serialize(data, options = {}) {
         const indent = options.indent || 4;
         return JSON.stringify(data, null, indent);

package/dist/core/adapters/po-adapter.d.ts

@@ -1,9 +1,10 @@
+import type { TranslationObject } from "../../utils/object-transformer.js";
 import { FileFormatAdapter } from "./base-adapter.js";
 /**
  * Adapter for Gettext PO files
  */
 export declare class PoAdapter implements FileFormatAdapter {
     extensions: string[];
-    parse(content: string): Promise<Record<string, any>>;
-    serialize(data: Record<string, any>, options?: any): Promise<string>;
+    parse(content: string): Promise<TranslationObject>;
+    serialize(data: TranslationObject): Promise<string>;
 }