i18next-cli 0.9.0

package/types/heuristic-config.d.ts

@@ -0,0 +1,10 @@
+import type { I18nextToolkitConfig } from './types';
+/**
+ * Attempts to automatically detect the project's i18n structure by searching for
+ * common translation file locations.
+ *
+ * @returns A promise that resolves to a partial I18nextToolkitConfig if detection
+ * is successful, otherwise null.
+ */
+export declare function detectConfig(): Promise<Partial<I18nextToolkitConfig> | null>;
+//# sourceMappingURL=heuristic-config.d.ts.map

package/types/heuristic-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heuristic-config.d.ts","sourceRoot":"","sources":["../src/heuristic-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAcnD;;;;;;GAMG;AACH,wBAAsB,YAAY,IAAK,OAAO,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC,CAuCnF"}

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export type { I18nextToolkitConfig, Plugin, PluginContext, ExtractedKey } from './types';
+export { defineConfig } from './config';
+export { extract, findKeys, getTranslations } from './extractor';
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,MAAM,EACN,aAAa,EACb,YAAY,EACb,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EACL,OAAO,EACP,QAAQ,EACR,eAAe,EAChB,MAAM,aAAa,CAAA"}

package/types/init.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Interactive setup wizard for creating a new i18next-cli configuration file.
+ *
+ * This function provides a guided setup experience that:
+ * 1. Asks the user for their preferred configuration file type (TypeScript or JavaScript)
+ * 2. Collects basic project settings (locales, input patterns, output paths)
+ * 3. Detects the project module system (ESM vs CommonJS) for JavaScript files
+ * 4. Generates an appropriate configuration file with proper syntax
+ * 5. Provides helpful defaults for common use cases
+ *
+ * The generated configuration includes:
+ * - Locale specification
+ * - Input file patterns for source scanning
+ * - Output path templates with placeholders
+ * - Proper imports and exports for the detected module system
+ * - JSDoc type annotations for JavaScript files
+ *
+ * @example
+ * ```typescript
+ * // Run the interactive setup
+ * await runInit()
+ *
+ * // This will create either:
+ * // - i18next.config.ts (TypeScript)
+ * // - i18next.config.js (JavaScript ESM/CommonJS)
+ * ```
+ */
+export declare function runInit(): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/types/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,OAAO,kBAiG5B"}

package/types/linter.d.ts

@@ -0,0 +1,33 @@
+import type { I18nextToolkitConfig } from './types';
+/**
+ * Runs the i18next linter to detect hardcoded strings and other potential issues.
+ *
+ * This function performs static analysis on source files to identify:
+ * - Hardcoded text strings in JSX elements
+ * - Hardcoded strings in JSX attributes (like alt text, titles, etc.)
+ * - Text that should be extracted for translation
+ *
+ * The linter respects configuration settings:
+ * - Uses the same input patterns as the extractor
+ * - Ignores content inside configured Trans components
+ * - Skips technical content like script/style tags
+ * - Identifies numeric values and interpolation syntax to avoid false positives
+ *
+ * @param config - The toolkit configuration with input patterns and component names
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   extract: {
+ *     input: ['src/**\/*.{ts,tsx}'],
+ *     transComponents: ['Trans', 'Translation']
+ *   }
+ * }
+ *
+ * await runLinter(config)
+ * // Outputs issues found or success message
+ * // Exits with code 1 if issues found, 0 if clean
+ * ```
+ */
+export declare function runLinter(config: I18nextToolkitConfig): Promise<void>;
+//# sourceMappingURL=linter.d.ts.map

package/types/linter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linter.d.ts","sourceRoot":"","sources":["../src/linter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,iBAsC5D"}

package/types/locize.d.ts

@@ -0,0 +1,5 @@
+import type { I18nextToolkitConfig } from './types';
+export declare const runLocizeSync: (config: I18nextToolkitConfig, cliOptions?: any) => Promise<void>;
+export declare const runLocizeDownload: (config: I18nextToolkitConfig, cliOptions?: any) => Promise<void>;
+export declare const runLocizeMigrate: (config: I18nextToolkitConfig, cliOptions?: any) => Promise<void>;
+//# sourceMappingURL=locize.d.ts.map

package/types/locize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locize.d.ts","sourceRoot":"","sources":["../src/locize.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAmPnD,eAAO,MAAM,aAAa,GAAI,QAAQ,oBAAoB,EAAE,aAAa,GAAG,kBAAiD,CAAA;AAC7H,eAAO,MAAM,iBAAiB,GAAI,QAAQ,oBAAoB,EAAE,aAAa,GAAG,kBAAqD,CAAA;AACrI,eAAO,MAAM,gBAAgB,GAAI,QAAQ,oBAAoB,EAAE,aAAa,GAAG,kBAAoD,CAAA"}

package/types/migrator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Migrates a legacy i18next-parser.config.js configuration file to the new
+ * i18next-cli configuration format.
+ *
+ * This function:
+ * 1. Checks if a legacy config file exists
+ * 2. Prevents migration if any new config file already exists
+ * 3. Dynamically imports the old configuration
+ * 4. Maps old configuration properties to new format:
+ *    - `$LOCALE` → `{{language}}`
+ *    - `$NAMESPACE` → `{{namespace}}`
+ *    - Maps lexer functions and components
+ *    - Creates sensible defaults for new features
+ * 5. Generates a new TypeScript configuration file
+ * 6. Provides warnings for deprecated features
+ *
+ * @example
+ * ```typescript
+ * // Legacy config (i18next-parser.config.js):
+ * module.exports = {
+ *   locales: ['en', 'de'],
+ *   output: 'locales/$LOCALE/$NAMESPACE.json',
+ *   input: ['src/**\/*.js']
+ * }
+ *
+ * // After migration (i18next.config.ts):
+ * export default defineConfig({
+ *   locales: ['en', 'de'],
+ *   extract: {
+ *     input: ['src/**\/*.js'],
+ *     output: 'locales/{{language}}/{{namespace}}.json'
+ *   }
+ * })
+ * ```
+ */
+export declare function runMigrator(): Promise<void>;
+//# sourceMappingURL=migrator.d.ts.map

package/types/migrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrator.d.ts","sourceRoot":"","sources":["../src/migrator.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,WAAW,kBA+EhC"}

package/types/status.d.ts

@@ -0,0 +1,20 @@
+import type { I18nextToolkitConfig } from './types';
+interface StatusOptions {
+    detail?: string;
+}
+/**
+ * Runs a health check on the project's i18next translations and displays a status report.
+ *
+ * This command provides a high-level overview of the localization status by:
+ * 1. Extracting all keys from the source code using the core extractor.
+ * 2. Reading all existing translation files for each locale.
+ * 3. Calculating the translation completeness for each secondary language against the primary.
+ * 4. Displaying a formatted report with key counts, locales, and progress bars.
+ * 5. Serving as a value-driven funnel to introduce the locize commercial service.
+ *
+ * @param config - The i18next toolkit configuration object.
+ * @param options Options object, may contain a `detail` property with a locale string.
+ */
+export declare function runStatus(config: I18nextToolkitConfig, options?: StatusOptions): Promise<void>;
+export {};
+//# sourceMappingURL=status.d.ts.map

package/types/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAgB,MAAM,SAAS,CAAA;AAGjE,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,EAAE,OAAO,GAAE,aAAkB,iBAYzF"}

package/types/syncer.d.ts

@@ -0,0 +1,33 @@
+import type { I18nextToolkitConfig } from './types';
+/**
+ * Synchronizes translation files across different locales by ensuring all secondary
+ * language files contain the same keys as the primary language file.
+ *
+ * This function:
+ * 1. Reads the primary language translation file
+ * 2. Extracts all translation keys from the primary file
+ * 3. For each secondary language:
+ *    - Preserves existing translations
+ *    - Adds missing keys with empty values or configured default
+ *    - Removes keys that no longer exist in primary
+ * 4. Only writes files that have changes
+ *
+ * @param config - The i18next toolkit configuration object
+ *
+ * @example
+ * ```typescript
+ * // Configuration
+ * const config = {
+ *   locales: ['en', 'de', 'fr'],
+ *   extract: {
+ *     output: 'locales/{{language}}/{{namespace}}.json',
+ *     defaultNS: 'translation'
+ *     defaultValue: '[MISSING]'
+ *   }
+ * }
+ *
+ * await runSyncer(config)
+ * ```
+ */
+export declare function runSyncer(config: I18nextToolkitConfig): Promise<void>;
+//# sourceMappingURL=syncer.d.ts.map

package/types/syncer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"syncer.d.ts","sourceRoot":"","sources":["../src/syncer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAInD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,SAAS,CAAE,MAAM,EAAE,oBAAoB,iBA2E5D"}

package/types/types-generator.d.ts

@@ -0,0 +1,29 @@
+import type { I18nextToolkitConfig } from './types';
+/**
+ * Generates TypeScript type definitions for i18next translations.
+ *
+ * This function:
+ * 1. Reads translation files based on the input glob patterns
+ * 2. Generates TypeScript interfaces using i18next-resources-for-ts
+ * 3. Creates separate resources.d.ts and main i18next.d.ts files
+ * 4. Handles namespace detection from filenames
+ * 5. Supports type-safe selector API when enabled
+ *
+ * @param config - The i18next toolkit configuration object
+ *
+ * @example
+ * ```typescript
+ * // Configuration
+ * const config = {
+ *   types: {
+ *     input: ['locales/en/*.json'],
+ *     output: 'src/types/i18next.d.ts',
+ *     enableSelector: true
+ *   }
+ * }
+ *
+ * await runTypesGenerator(config)
+ * ```
+ */
+export declare function runTypesGenerator(config: I18nextToolkitConfig): Promise<void>;
+//# sourceMappingURL=types-generator.d.ts.map

package/types/types-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-generator.d.ts","sourceRoot":"","sources":["../src/types-generator.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAYnD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,iBAAiB,CAAE,MAAM,EAAE,oBAAoB,iBAuEpE"}

package/types/types.d.ts

@@ -0,0 +1,268 @@
+import type { Node } from '@swc/core';
+/**
+ * Main configuration interface for the i18next toolkit.
+ * Defines all available options for extraction, type generation, synchronization, and integrations.
+ *
+ * @example
+ * ```typescript
+ * const config: I18nextToolkitConfig = {
+ *   locales: ['en', 'de', 'fr'],
+ *   extract: {
+ *     input: ['src/**\/*.{ts,tsx}'],
+ *     output: 'locales/{{language}}/{{namespace}}.json',
+ *     functions: ['t', 'i18n.t'],
+ *     transComponents: ['Trans', 'Translation']
+ *   },
+ *   types: {
+ *     input: ['locales/en/*.json'],
+ *     output: 'src/types/i18next.d.ts'
+ *   }
+ * }
+ * ```
+ */
+export interface I18nextToolkitConfig {
+    /** Array of supported locale codes (e.g., ['en', 'de', 'fr']) */
+    locales: string[];
+    /** Configuration options for translation key extraction */
+    extract: {
+        /** Glob pattern(s) for source files to scan for translation keys */
+        input: string | string[];
+        /** Output path template with placeholders: {{language}} for locale, {{namespace}} for namespace */
+        output: string;
+        /** Default namespace when none is specified (default: 'translation') */
+        defaultNS?: string;
+        /** Separator for nested keys, or false for flat keys (default: '.') */
+        keySeparator?: string | false | null;
+        /** Separator between namespace and key, or false to disable (default: ':') */
+        nsSeparator?: string | false | null;
+        /** Separator for context variants (default: '_') */
+        contextSeparator?: string;
+        /** Separator for plural variants (default: '_') */
+        pluralSeparator?: string;
+        /** Function names to extract translation calls from (default: ['t']) */
+        functions?: string[];
+        /** JSX component names to extract translations from (default: ['Trans']) */
+        transComponents?: string[];
+        /** Hook function names that return translation functions (default: ['useTranslation']) */
+        useTranslationNames?: string[];
+        /** A list of JSX attribute names to ignore when linting for hardcoded strings. */
+        ignoredAttributes?: string[];
+        /** HTML tags to preserve in Trans component serialization (default: ['br', 'strong', 'i']) */
+        transKeepBasicHtmlNodesFor?: string[];
+        /** Glob patterns for keys to preserve even if not found in source (for dynamic keys) */
+        preservePatterns?: string[];
+        /** Whether to sort keys alphabetically in output files (default: true) */
+        sort?: boolean;
+        /** Number of spaces for JSON indentation (default: 2) */
+        indentation?: number;
+        /** Default value to use for missing translations in secondary languages */
+        defaultValue?: string;
+        /** Primary language that provides default values (default: first locale) */
+        primaryLanguage?: string;
+        /** Secondary languages that get empty values initially */
+        secondaryLanguages?: string[];
+    };
+    /** Configuration options for TypeScript type generation */
+    types?: {
+        /** Glob pattern(s) for translation files to generate types from */
+        input: string | string[];
+        /** Output path for the main TypeScript definition file */
+        output: string;
+        /** Enable type-safe selector API (boolean or 'optimize' for smaller types) */
+        enableSelector?: boolean | 'optimize';
+        /** Path for the separate resources interface file */
+        resourcesFile?: string;
+    };
+    /** Array of plugins to extend functionality */
+    plugins?: Plugin[];
+    /** Configuration for Locize integration */
+    locize?: {
+        /** Locize project ID */
+        projectId?: string;
+        /** Locize API key (recommended to use environment variables) */
+        apiKey?: string;
+        /** Version to sync with (default: 'latest') */
+        version?: string;
+        /** Whether to update existing translation values on Locize */
+        updateValues?: boolean;
+        /** Only sync the source language to Locize */
+        sourceLanguageOnly?: boolean;
+        /** Compare modification times when syncing */
+        compareModificationTime?: boolean;
+        /** Preview changes without making them */
+        dryRun?: boolean;
+    };
+}
+/**
+ * Plugin interface for extending the i18next toolkit functionality.
+ * Plugins can hook into various stages of the extraction process.
+ *
+ * @example
+ * ```typescript
+ * const myPlugin = (): Plugin => ({
+ *   name: 'my-custom-plugin',
+ *
+ *   setup: async () => {
+ *     console.log('Plugin initialized')
+ *   },
+ *
+ *   onLoad: (code, filePath) => {
+ *     // Transform code before parsing
+ *     return code.replace(/OLD_PATTERN/g, 'NEW_PATTERN')
+ *   },
+ *
+ *   onVisitNode: (node, context) => {
+ *     if (node.type === 'CallExpression') {
+ *       // Custom extraction logic
+ *       context.addKey({ key: 'custom.key', defaultValue: 'Custom Value' })
+ *     }
+ *   },
+ *
+ *   onEnd: async (allKeys) => {
+ *     console.log(`Found ${allKeys.size} total keys`)
+ *   }
+ * })
+ * ```
+ */
+export interface Plugin {
+    /** Unique name for the plugin */
+    name: string;
+    /**
+     * Hook called once at the beginning of the extraction process.
+     * Use for initialization tasks like setting up resources or validating configuration.
+     */
+    setup?: () => void | Promise<void>;
+    /**
+     * Hook called for each source file before it's parsed.
+     * Allows transformation of source code before AST generation.
+     *
+     * @param code - The source code content
+     * @param path - The file path being processed
+     * @returns The transformed code (or undefined to keep original)
+     */
+    onLoad?: (code: string, path: string) => string | Promise<string>;
+    /**
+     * Hook called for each AST node during traversal.
+     * Enables custom extraction logic by examining syntax nodes.
+     *
+     * @param node - The current AST node being visited
+     * @param context - Context object with helper methods
+     */
+    onVisitNode?: (node: Node, context: PluginContext) => void;
+    /**
+     * Hook called after all files have been processed.
+     * Useful for post-processing, validation, or reporting.
+     *
+     * @param keys - Final map of all extracted keys
+     */
+    onEnd?: (keys: Map<string, {
+        key: string;
+        defaultValue?: string;
+    }>) => void | Promise<void>;
+}
+/**
+ * Represents an extracted translation key with its metadata.
+ * Contains all information needed to generate translation files.
+ *
+ * @example
+ * ```typescript
+ * const extractedKey: ExtractedKey = {
+ *   key: 'user.profile.name',
+ *   defaultValue: 'Full Name',
+ *   ns: 'common',
+ *   hasCount: false
+ * }
+ * ```
+ */
+export interface ExtractedKey {
+    /** The translation key (may be nested with separators) */
+    key: string;
+    /** Default value to use in the primary language */
+    defaultValue?: string;
+    /** Namespace this key belongs to */
+    ns?: string;
+    /** Whether this key is used with pluralization (count parameter) */
+    hasCount?: boolean;
+}
+/**
+ * Result of processing translation files for a specific locale and namespace.
+ * Contains the generated translations and metadata about changes.
+ *
+ * @example
+ * ```typescript
+ * const result: TranslationResult = {
+ *   path: '/project/locales/en/common.json',
+ *   updated: true,
+ *   newTranslations: { button: { save: 'Save', cancel: 'Cancel' } },
+ *   existingTranslations: { button: { save: 'Save' } }
+ * }
+ * ```
+ */
+export interface TranslationResult {
+    /** Full file system path where the translation file will be written */
+    path: string;
+    /** Whether the file content changed and needs to be written */
+    updated: boolean;
+    /** The new translation object to be written to the file */
+    newTranslations: Record<string, any>;
+    /** The existing translation object that was read from the file */
+    existingTranslations: Record<string, any>;
+}
+/**
+ * Logger interface for consistent output formatting across the toolkit.
+ * Implementations can customize how messages are displayed or stored.
+ *
+ * @example
+ * ```typescript
+ * class FileLogger implements Logger {
+ *   info(message: string) { fs.appendFileSync('info.log', message) }
+ *   warn(message: string) { fs.appendFileSync('warn.log', message) }
+ *   error(message: string) { fs.appendFileSync('error.log', message) }
+ * }
+ * ```
+ */
+export interface Logger {
+    /**
+     * Logs an informational message.
+     * @param message - The message to log
+     */
+    info(message: string): void;
+    /**
+     * Logs a warning message.
+     * @param message - The warning message to log
+     */
+    warn(message: string): void;
+    /**
+     * Logs an error message.
+     * @param message - The error message to log
+     */
+    error(message: string): void;
+}
+/**
+ * Context object provided to plugins during AST traversal.
+ * Provides helper methods for plugins to interact with the extraction process.
+ *
+ * @example
+ * ```typescript
+ * // Inside a plugin's onVisitNode hook:
+ * onVisitNode(node, context) {
+ *   if (isCustomTranslationCall(node)) {
+ *     context.addKey({
+ *       key: extractKeyFromNode(node),
+ *       defaultValue: extractDefaultFromNode(node),
+ *       ns: 'custom'
+ *     })
+ *   }
+ * }
+ * ```
+ */
+export interface PluginContext {
+    /**
+     * Adds a translation key to the extraction results.
+     * Keys are automatically deduplicated by their namespace:key combination.
+     *
+     * @param keyInfo - The extracted key information
+     */
+    addKey: (keyInfo: ExtractedKey) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/types/utils/file-utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Ensures that the directory for a given file path exists.
+ * Creates all necessary parent directories recursively if they don't exist.
+ *
+ * @param filePath - The file path for which to ensure the directory exists
+ *
+ * @example
+ * ```typescript
+ * await ensureDirectoryExists('/path/to/nested/file.json')
+ * // Creates /path/to/nested/ directory if it doesn't exist
+ * ```
+ */
+export declare function ensureDirectoryExists(filePath: string): Promise<void>;
+/**
+ * Reads a file asynchronously and returns its content as a UTF-8 string.
+ *
+ * @param filePath - The path to the file to read
+ * @returns Promise resolving to the file content as a string
+ *
+ * @example
+ * ```typescript
+ * const content = await readFileAsync('./config.json')
+ * const config = JSON.parse(content)
+ * ```
+ */
+export declare function readFileAsync(filePath: string): Promise<string>;
+/**
+ * Writes data to a file asynchronously.
+ *
+ * @param filePath - The path where to write the file
+ * @param data - The string data to write to the file
+ *
+ * @example
+ * ```typescript
+ * const jsonData = JSON.stringify({ key: 'value' }, null, 2)
+ * await writeFileAsync('./output.json', jsonData)
+ * ```
+ */
+export declare function writeFileAsync(filePath: string, data: string): Promise<void>;
+/**
+ * Generates a file path by replacing template placeholders with actual values.
+ * Supports both legacy and modern placeholder formats for language and namespace.
+ *
+ * @param template - The template string containing placeholders
+ * @param locale - The locale/language code to substitute
+ * @param namespace - The namespace to substitute
+ * @returns The resolved file path with placeholders replaced
+ *
+ * @example
+ * ```typescript
+ * // Modern format
+ * getOutputPath('locales/{{language}}/{{namespace}}.json', 'de', 'validation')
+ * // Returns: 'locales/de/validation.json'
+ *
+ * // Legacy format (also supported)
+ * getOutputPath('locales/{{lng}}/{{ns}}.json', 'en', 'common')
+ * // Returns: 'locales/en/common.json'
+ * ```
+ */
+export declare function getOutputPath(template: string, locale: string, namespace: string): string;
+//# sourceMappingURL=file-utils.d.ts.map

package/types/utils/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/utils/file-utils.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wBAAsB,qBAAqB,CAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,MAAM,CAIR"}

package/types/utils/logger.d.ts

@@ -0,0 +1,34 @@
+import type { Logger } from '../types';
+/**
+ * Default console-based logger implementation for the i18next toolkit.
+ * Provides basic logging functionality with different severity levels.
+ *
+ * @example
+ * ```typescript
+ * const logger = new ConsoleLogger()
+ * logger.info('Extraction started')
+ * logger.warn('Deprecated configuration option used')
+ * logger.error('Failed to parse file')
+ * ```
+ */
+export declare class ConsoleLogger implements Logger {
+    /**
+     * Logs an informational message to the console.
+     *
+     * @param message - The message to log
+     */
+    info(message: string): void;
+    /**
+     * Logs a warning message to the console.
+     *
+     * @param message - The warning message to log
+     */
+    warn(message: string): void;
+    /**
+     * Logs an error message to the console.
+     *
+     * @param message - The error message to log
+     */
+    error(message: string): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/types/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,YAAW,MAAM;IAC1C;;;;OAIG;IACH,IAAI,CAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAE5B;;;;OAIG;IACH,IAAI,CAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAE5B;;;;OAIG;IACH,KAAK,CAAE,OAAO,EAAE,MAAM,GAAG,IAAI;CAC9B"}