@digitaldefiance/i18n-lib 1.0.32 → 1.1.0

package/dist/default-config.js

@@ -40,56 +40,56 @@ const getConfig = (constants, timezone, adminTimezone) => ({
     strings: {
         [DefaultLanguage.EnglishUS]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance with key \'{key}\' already exists',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance with key \'{key}\' not found',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance with key '{key}' already exists",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance with key '{key}' not found",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Missing string collection for language: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Missing translation for key \'{key}\' in language \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Default language \'{language}\' has no string collection',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Missing translation for key '{key}' in language '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Default language '{language}' has no string collection",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Missing translation key for type: {type}',
         },
         [DefaultLanguage.EnglishUK]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance with key \'{key}\' already exists',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance with key \'{key}\' not found',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance with key '{key}' already exists",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance with key '{key}' not found",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Missing string collection for language: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Missing translation for key \'{key}\' in language \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Default language \'{language}\' has no string collection',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Missing translation for key '{key}' in language '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Default language '{language}' has no string collection",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Missing translation key for type: {type}',
         },
         [DefaultLanguage.French]: {
             [DefaultStringKey.Common_Test]: 'Test',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Instance avec clé \'{key}\' existe déjà',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instance avec clé \'{key}\' introuvable',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Instance avec clé '{key}' existe déjà",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instance avec clé '{key}' introuvable",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Collection de chaînes manquante pour la langue: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Traduction manquante pour la clé \'{key}\' dans la langue \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'La langue par défaut \'{language}\' n\'a pas de collection de chaînes',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Traduction manquante pour la clé '{key}' dans la langue '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "La langue par défaut '{language}' n'a pas de collection de chaînes",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Clé de traduction manquante pour le type: {type}',
         },
         [DefaultLanguage.MandarinChinese]: {
             [DefaultStringKey.Common_Test]: '测试',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: '键为\'{key}\'的实例已存在',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: '未找到键为\'{key}\'的实例',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "键为'{key}'的实例已存在",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "未找到键为'{key}'的实例",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: '缺少语言的字符串集合: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: '在语言\'{language}\'中缺少键\'{key}\'的翻译',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: '默认语言\'{language}\'没有字符串集合',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "在语言'{language}'中缺少键'{key}'的翻译",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "默认语言'{language}'没有字符串集合",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: '类型缺少翻译键: {type}',
         },
         [DefaultLanguage.Spanish]: {
             [DefaultStringKey.Common_Test]: 'Prueba',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'La instancia con clave \'{key}\' ya existe',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Instancia con clave \'{key}\' no encontrada',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "La instancia con clave '{key}' ya existe",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Instancia con clave '{key}' no encontrada",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Falta colección de cadenas para el idioma: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Falta traducción para la clave \'{key}\' en el idioma \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'El idioma predeterminado \'{language}\' no tiene colección de cadenas',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Falta traducción para la clave '{key}' en el idioma '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "El idioma predeterminado '{language}' no tiene colección de cadenas",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Falta clave de traducción para el tipo: {type}',
         },
         [DefaultLanguage.Ukrainian]: {
             [DefaultStringKey.Common_Test]: 'Тест',
-            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: 'Екземпляр з ключем \'{key}\' вже існує',
-            [DefaultStringKey.Error_InstanceNotFoundTemplate]: 'Екземпляр з ключем \'{key}\' не знайдено',
+            [DefaultStringKey.Error_InstanceAlreadyExistsTemplate]: "Екземпляр з ключем '{key}' вже існує",
+            [DefaultStringKey.Error_InstanceNotFoundTemplate]: "Екземпляр з ключем '{key}' не знайдено",
             [DefaultStringKey.Error_MissingStringCollectionTemplate]: 'Відсутня колекція рядків для мови: {language}',
-            [DefaultStringKey.Error_MissingTranslationTemplate]: 'Відсутній переклад для ключа \'{key}\' в мові \'{language}\'',
-            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: 'Мова за замовчуванням \'{language}\' не має колекції рядків',
+            [DefaultStringKey.Error_MissingTranslationTemplate]: "Відсутній переклад для ключа '{key}' в мові '{language}'",
+            [DefaultStringKey.Error_DefaultLanguageNoCollectionTemplate]: "Мова за замовчуванням '{language}' не має колекції рядків",
             [DefaultStringKey.Error_MissingTranslationKeyTemplate]: 'Відсутній ключ перекладу для типу: {type}',
         },
     },

package/dist/enum-registry.d.ts

@@ -2,9 +2,12 @@ import { EnumLanguageTranslation } from './types';
 /**
  * Registry for managing enum translations across multiple languages.
  */
-export declare class EnumTranslationRegistry<TLanguage extends string> {
+export declare class EnumTranslationRegistry<TStringKey extends string, TLanguage extends string> {
     protected translations: Map<any, Partial<{ [L in TLanguage]: import("./types").EnumTranslation<any>; }>>;
     protected enumNames: WeakMap<any, string>;
+    protected availableLanguages: Set<TLanguage>;
+    protected translateFn?: (key: TStringKey, vars?: Record<string, any>) => string;
+    constructor(availableLanguages: TLanguage[], translateFn?: (key: TStringKey, vars?: Record<string, any>) => string);
     /**
      * Registers an enumeration with its translations and a name.
      * @param enumObj The enumeration object
@@ -32,4 +35,10 @@ export declare class EnumTranslationRegistry<TLanguage extends string> {
      * @returns True if translations exist, false otherwise
      */
     has(enumObj: any): boolean;
+    /**
+     * Validates that enum translations only contain available languages.
+     * @param translations The translations to validate
+     * @param enumName The name of the enumeration for error messages
+     */
+    private validateTranslations;
 }

package/dist/enum-registry.js

@@ -5,9 +5,11 @@ exports.EnumTranslationRegistry = void 0;
  * Registry for managing enum translations across multiple languages.
  */
 class EnumTranslationRegistry {
-    constructor() {
+    constructor(availableLanguages, translateFn) {
         this.translations = new Map();
         this.enumNames = new WeakMap();
+        this.availableLanguages = new Set(availableLanguages);
+        this.translateFn = translateFn;
     }
     /**
      * Registers an enumeration with its translations and a name.
@@ -16,6 +18,7 @@ class EnumTranslationRegistry {
      * @param enumName The name of the enumeration
      */
     register(enumObj, translations, enumName) {
+        this.validateTranslations(translations, enumName);
         this.translations.set(enumObj, translations);
         this.enumNames.set(enumObj, enumName);
     }
@@ -29,11 +32,17 @@ class EnumTranslationRegistry {
     translate(enumObj, value, language) {
         const translations = this.translations.get(enumObj);
         if (!translations) {
-            throw new Error(`No translations found for enum: ${this.getEnumName(enumObj)}`);
+            const message = this.translateFn
+                ? this.translateFn('Error_EnumNotFoundTemplate', { enumName: this.getEnumName(enumObj) })
+                : `No translations found for enum: ${this.getEnumName(enumObj)}`;
+            throw new Error(message);
         }
         const langTranslations = translations[language];
         if (!langTranslations) {
-            throw new Error(`No translations found for language: ${language}`);
+            const message = this.translateFn
+                ? this.translateFn('Error_EnumLanguageNotFoundTemplate', { language })
+                : `No translations found for language: ${language}`;
+            throw new Error(message);
         }
         let result = langTranslations[value];
         if (!result && typeof value === 'number') {
@@ -43,7 +52,10 @@ class EnumTranslationRegistry {
             }
         }
         if (!result) {
-            throw new Error(`No translation found for value: ${String(value)}`);
+            const message = this.translateFn
+                ? this.translateFn('Error_EnumValueNotFoundTemplate', { value: String(value) })
+                : `No translation found for value: ${String(value)}`;
+            throw new Error(message);
         }
         return result;
     }
@@ -63,5 +75,20 @@ class EnumTranslationRegistry {
     has(enumObj) {
         return this.translations.has(enumObj);
     }
+    /**
+     * Validates that enum translations only contain available languages.
+     * @param translations The translations to validate
+     * @param enumName The name of the enumeration for error messages
+     */
+    validateTranslations(translations, enumName) {
+        for (const language of Object.keys(translations)) {
+            if (!this.availableLanguages.has(language)) {
+                const message = this.translateFn
+                    ? this.translateFn('Error_EnumLanguageNotAvailableTemplate', { language, enumName })
+                    : `Language '${language}' in enum '${enumName}' is not available in this engine instance`;
+                throw new Error(message);
+            }
+        }
+    }
 }
 exports.EnumTranslationRegistry = EnumTranslationRegistry;

package/dist/i18n-config.d.ts

@@ -0,0 +1,20 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { LanguageCodeCollection, LanguageContext, MasterStringsCollection } from './types';
+/**
+ * I18n configuration interface
+ */
+export interface I18nConfig<TStringKey extends string, TLanguage extends string, TConstants extends Record<string, any> = Record<string, any>, TTranslationContext extends string = LanguageContext> {
+    stringNames: TStringKey[];
+    strings: MasterStringsCollection<TStringKey, TLanguage>;
+    defaultLanguage: TLanguage;
+    defaultTranslationContext: TTranslationContext;
+    defaultCurrencyCode: CurrencyCode;
+    languageCodes: LanguageCodeCollection<TLanguage>;
+    languages: TLanguage[];
+    constants?: TConstants;
+    enumName?: string;
+    enumObj?: Record<string, TStringKey>;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/i18n-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i18n-context.d.ts

@@ -0,0 +1,14 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { LanguageContext } from './types';
+/**
+ * I18n context interface
+ */
+export interface I18nContext<TLanguage extends string, TTranslationContext extends string = LanguageContext> {
+    language: TLanguage;
+    adminLanguage: TLanguage;
+    currencyCode: CurrencyCode;
+    currentContext: TTranslationContext;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/i18n-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/i18n-engine.d.ts

@@ -1,5 +1,7 @@
 import { EnumTranslationRegistry } from './enum-registry';
-import { EnumLanguageTranslation, I18nConfig, I18nContext } from './types';
+import { I18nConfig } from './i18n-config';
+import { I18nContext } from './i18n-context';
+import { EnumLanguageTranslation } from './types';
 /**
  * Internationalization engine class
  */
@@ -7,7 +9,7 @@ export declare class I18nEngine<TStringKey extends string, TLanguage extends str
     /**
      * Registry for enum translations
      */
-    protected enumRegistry: EnumTranslationRegistry<TLanguage>;
+    protected _enumRegistry: EnumTranslationRegistry<TStringKey, TLanguage>;
     /**
      * Configuration for the i18n engine
      */
@@ -74,6 +76,11 @@ export declare class I18nEngine<TStringKey extends string, TLanguage extends str
      * @param context The context to set
      */
     set context(context: Partial<TContext>);
+    /**
+     * Gets the enum translation registry for this engine instance
+     * @returns The enum translation registry
+     */
+    get enumRegistry(): EnumTranslationRegistry<TStringKey, TLanguage>;
     /**
      * Translates a string key into the specified language, replacing any variables as needed.
      * @param key The string key to translate

package/dist/i18n-engine.js

@@ -18,7 +18,7 @@ class I18nEngine {
     constructor(config, key, newContext = () => (0, context_1.createContext)(config.defaultLanguage, config.defaultTranslationContext, config.defaultCurrencyCode, config.timezone, config.adminTimezone)) {
         this.validateConfig(config);
         this.config = config;
-        this.enumRegistry = new enum_registry_1.EnumTranslationRegistry();
+        this._enumRegistry = new enum_registry_1.EnumTranslationRegistry(Object.keys(config.strings), (key, vars) => this.safeTranslate(key, vars));
         this._context = newContext();
         const instanceKey = key || I18nEngine.DefaultInstanceKey;
         if (I18nEngine._instances.has(instanceKey)) {
@@ -91,6 +91,13 @@ class I18nEngine {
     set context(context) {
         this._context = { ...this._context, ...context };
     }
+    /**
+     * Gets the enum translation registry for this engine instance
+     * @returns The enum translation registry
+     */
+    get enumRegistry() {
+        return this._enumRegistry;
+    }
     /**
      * Translates a string key into the specified language, replacing any variables as needed.
      * @param key The string key to translate
@@ -144,7 +151,7 @@ class I18nEngine {
      * @returns The translated enumeration value
      */
     translateEnum(enumObj, value, language) {
-        return this.enumRegistry.translate(enumObj, value, language);
+        return this._enumRegistry.translate(enumObj, value, language);
     }
     /**
      * Registers an enumeration and its translations with the engine.
@@ -153,7 +160,7 @@ class I18nEngine {
      * @param enumName The name of the enumeration (for error messages)
      */
     registerEnum(enumObj, translations, enumName) {
-        this.enumRegistry.register(enumObj, translations, enumName);
+        this._enumRegistry.register(enumObj, translations, enumName);
     }
     /**
      * Safe translation that prevents infinite recursion for error messages
@@ -274,12 +281,12 @@ class I18nEngine {
      * @throws Error if validation fails
      */
     validateConfig(config) {
-        // Check that all languages in languageCodes have string collections
-        for (const language of Object.keys(config.languageCodes)) {
-            if (!config.strings[language]) {
-                throw new Error(this.getValidationError('Error_MissingStringCollectionTemplate', { language }, config));
-            }
-            // Check that all string keys are provided for this language
+        // Check that default language exists
+        if (!config.strings[config.defaultLanguage]) {
+            throw new Error(this.getValidationError('Error_DefaultLanguageNoCollectionTemplate', { language: config.defaultLanguage }, config));
+        }
+        // Check that all string keys are provided for each language that has strings
+        for (const language of Object.keys(config.strings)) {
             const strings = config.strings[language];
             for (const stringKey of config.stringNames) {
                 if (!strings[stringKey]) {
@@ -287,10 +294,6 @@ class I18nEngine {
                 }
             }
         }
-        // Check that default language exists
-        if (!config.strings[config.defaultLanguage]) {
-            throw new Error(this.getValidationError('Error_DefaultLanguageNoCollectionTemplate', { language: config.defaultLanguage }, config));
-        }
     }
     /**
      * Gets validation error message, trying translation first, falling back to template

package/dist/index.d.ts

@@ -1,15 +1,35 @@
 export * from './active-context';
+export * from './component-definition';
+export * from './component-registration';
+export * from './component-registry';
 export * from './context';
 export * from './context-manager';
 export * from './currency';
 export * from './currency-code';
 export * from './currency-format';
-export * from './enum-registry';
 export * from './default-config';
+export * from './enum-registry';
+export * from './i18n-context';
 export * from './i18n-engine';
+export * from './language-definition';
 export * from './template';
 export * from './timezone';
 export * from './typed-error';
 export * from './types';
 export * from './utils';
+export * from './validation-config';
+export * from './validation-result';
+export * from './core-i18n';
+export * from './core-language';
+export * from './core-string-key';
+export * from './language-registry';
+export * from './plugin-i18n-engine';
+export * from './registry-config';
+export * from './registry-context';
+export * from './registry-error';
+export * from './registry-error-type';
+export * from './translation-request';
+export * from './translation-response';
+export { createCoreI18nEngine as createCoreI18n } from './core-i18n';
 export { I18nEngine as I18n } from './i18n-engine';
+export { PluginI18nEngine as PluginI18n } from './plugin-i18n-engine';

package/dist/index.js

@@ -14,21 +14,44 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.I18n = void 0;
+exports.PluginI18n = exports.I18n = exports.createCoreI18n = void 0;
+// Legacy exports (for backwards compatibility)
 __exportStar(require("./active-context"), exports);
+__exportStar(require("./component-definition"), exports);
+__exportStar(require("./component-registration"), exports);
+__exportStar(require("./component-registry"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./context-manager"), exports);
 __exportStar(require("./currency"), exports);
 __exportStar(require("./currency-code"), exports);
 __exportStar(require("./currency-format"), exports);
-__exportStar(require("./enum-registry"), exports);
 __exportStar(require("./default-config"), exports);
+__exportStar(require("./enum-registry"), exports);
+__exportStar(require("./i18n-context"), exports);
 __exportStar(require("./i18n-engine"), exports);
+__exportStar(require("./language-definition"), exports);
 __exportStar(require("./template"), exports);
 __exportStar(require("./timezone"), exports);
 __exportStar(require("./typed-error"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./validation-config"), exports);
+__exportStar(require("./validation-result"), exports);
+__exportStar(require("./core-i18n"), exports);
+__exportStar(require("./core-language"), exports);
+__exportStar(require("./core-string-key"), exports);
+__exportStar(require("./language-registry"), exports);
+__exportStar(require("./plugin-i18n-engine"), exports);
+__exportStar(require("./registry-config"), exports);
+__exportStar(require("./registry-context"), exports);
+__exportStar(require("./registry-error"), exports);
+__exportStar(require("./registry-error-type"), exports);
+__exportStar(require("./translation-request"), exports);
+__exportStar(require("./translation-response"), exports);
 // Re-export for convenience
+var core_i18n_1 = require("./core-i18n");
+Object.defineProperty(exports, "createCoreI18n", { enumerable: true, get: function () { return core_i18n_1.createCoreI18nEngine; } });
 var i18n_engine_1 = require("./i18n-engine");
 Object.defineProperty(exports, "I18n", { enumerable: true, get: function () { return i18n_engine_1.I18nEngine; } });
+var plugin_i18n_engine_1 = require("./plugin-i18n-engine");
+Object.defineProperty(exports, "PluginI18n", { enumerable: true, get: function () { return plugin_i18n_engine_1.PluginI18nEngine; } });

package/dist/language-definition.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Language definition with its properties
+ */
+export interface LanguageDefinition {
+    /** Unique identifier for the language */
+    readonly id: string;
+    /** Display name in the native language */
+    readonly name: string;
+    /** ISO language code (e.g., 'en', 'fr', 'zh-CN') */
+    readonly code: string;
+    /** Whether this is the fallback/default language */
+    readonly isDefault?: boolean;
+}

package/dist/language-definition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/language-registry.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Language registry for managing supported languages and their properties
+ */
+import { LanguageDefinition } from './language-definition';
+/**
+ * Registry for managing supported languages
+ */
+export declare class LanguageRegistry<TLanguages extends string> {
+    private readonly languages;
+    private readonly languagesByCodes;
+    private defaultLanguageId;
+    constructor();
+    /**
+     * Register a new language
+     */
+    registerLanguage(language: LanguageDefinition): void;
+    /**
+     * Register multiple languages at once
+     */
+    registerLanguages(languages: readonly LanguageDefinition[]): void;
+    /**
+     * Get a language by its ID
+     */
+    getLanguage(languageId: TLanguages): LanguageDefinition | undefined;
+    /**
+     * Get a language by its code
+     */
+    getLanguageByCode(code: string): LanguageDefinition | undefined;
+    /**
+     * Get all registered languages
+     */
+    getAllLanguages(): ReadonlyArray<LanguageDefinition>;
+    /**
+     * Get all language IDs
+     */
+    getLanguageIds(): readonly TLanguages[];
+    /**
+     * Get all language codes
+     */
+    getLanguageCodes(): readonly string[];
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(languageId: TLanguages): boolean;
+    /**
+     * Check if a language code is registered
+     */
+    hasLanguageCode(code: string): boolean;
+    /**
+     * Get the default language
+     */
+    getDefaultLanguage(): LanguageDefinition | null;
+    /**
+     * Get the default language ID
+     */
+    getDefaultLanguageId(): TLanguages | null;
+    /**
+     * Set the default language
+     */
+    setDefaultLanguage(languageId: TLanguages): void;
+    /**
+     * Get the number of registered languages
+     */
+    getLanguageCount(): number;
+    /**
+     * Validate that all required languages are present
+     */
+    validateRequiredLanguages(requiredLanguages: readonly TLanguages[]): LanguageValidationResult;
+    /**
+     * Create a mapping of language IDs to their display names
+     */
+    getLanguageDisplayNames(): Record<TLanguages, string>;
+    /**
+     * Create a mapping of language IDs to their codes
+     */
+    getLanguageCodeMapping(): Record<TLanguages, string>;
+    /**
+     * Find languages by partial name match (case-insensitive)
+     */
+    findLanguagesByName(partialName: string): readonly LanguageDefinition[];
+    /**
+     * Clear all registered languages
+     */
+    clear(): void;
+}
+/**
+ * Validation result for language operations
+ */
+export interface LanguageValidationResult {
+    readonly isValid: boolean;
+    readonly missingLanguages: readonly string[];
+    readonly errors: readonly string[];
+}
+/**
+ * Helper function to create language definitions with type safety
+ */
+export declare function createLanguageDefinition(id: string, name: string, code: string, isDefault?: boolean): LanguageDefinition;
+/**
+ * Helper function to create multiple language definitions
+ */
+export declare function createLanguageDefinitions(languages: Array<{
+    id: string;
+    name: string;
+    code: string;
+    isDefault?: boolean;
+}>): LanguageDefinition[];