@digitaldefiance/i18n-lib 1.0.33 → 1.1.0

package/dist/plugin-i18n-engine.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Plugin-based internationalization engine with component and language registration
+ */
+import { ComponentDefinition } from './component-definition';
+import { ComponentRegistration } from './component-registration';
+import { ComponentRegistry } from './component-registry';
+import { EnumTranslationRegistry } from './enum-registry';
+import { LanguageDefinition } from './language-definition';
+import { LanguageRegistry } from './language-registry';
+import { RegistryConfig } from './registry-config';
+import { RegistryContext } from './registry-context';
+import { TranslationResponse } from './translation-response';
+import { EnumLanguageTranslation } from './types';
+/**
+ * Plugin-based I18n Engine with registration capabilities
+ */
+export declare class PluginI18nEngine<TLanguages extends string> {
+    private readonly languageRegistry;
+    private readonly componentRegistry;
+    private readonly enumRegistry;
+    private readonly config;
+    private context;
+    /**
+     * Static instances for semi-singleton pattern
+     */
+    private static _instances;
+    private static _defaultKey;
+    protected static readonly DefaultInstanceKey = "default";
+    constructor(initialLanguages: readonly LanguageDefinition[], config?: Partial<RegistryConfig<TLanguages>>);
+    /**
+     * Create a new instance with a specific key
+     */
+    static createInstance<TLangs extends string>(key: string, initialLanguages: readonly LanguageDefinition[], config?: Partial<RegistryConfig<TLangs>>): PluginI18nEngine<TLangs>;
+    /**
+     * Get an existing instance by key
+     */
+    static getInstance<TLangs extends string>(key?: string): PluginI18nEngine<TLangs>;
+    /**
+     * Register a new language
+     */
+    registerLanguage(language: LanguageDefinition): void;
+    /**
+     * Register multiple languages
+     */
+    registerLanguages(languages: readonly LanguageDefinition[]): void;
+    /**
+     * Register a component with its translations
+     */
+    registerComponent<TStringKeys extends string>(registration: ComponentRegistration<TStringKeys, TLanguages>): import("./validation-result").ValidationResult;
+    /**
+     * Update strings for an existing component
+     */
+    updateComponentStrings<TStringKeys extends string>(componentId: string, strings: Parameters<ComponentRegistry<TLanguages>['updateComponentStrings']>[1]): import("./validation-result").ValidationResult;
+    /**
+     * Register an enum with translations
+     */
+    registerEnum<TEnum extends string | number>(enumObj: Record<string, TEnum>, translations: EnumLanguageTranslation<TEnum, TLanguages>, enumName: string): void;
+    /**
+     * Translate a string for a component
+     */
+    translate<TStringKeys extends string>(componentId: string, stringKey: TStringKeys, variables?: Record<string, string | number>, language?: TLanguages): string;
+    /**
+     * Safe translate that returns a placeholder if translation fails
+     */
+    safeTranslate(componentId: string, stringKey: string, variables?: Record<string, string | number>, language?: TLanguages): string;
+    /**
+     * Translate an enum value
+     */
+    translateEnum<TEnum extends string | number>(enumObj: Record<string, TEnum>, value: TEnum, language?: TLanguages): string;
+    /**
+     * Get detailed translation response
+     */
+    getTranslationDetails<TStringKeys extends string>(componentId: string, stringKey: TStringKeys, variables?: Record<string, string | number>, language?: TLanguages): TranslationResponse;
+    /**
+     * Get current context
+     */
+    getContext(): RegistryContext<TLanguages>;
+    /**
+     * Update context
+     */
+    updateContext(updates: Partial<RegistryContext<TLanguages>>): void;
+    /**
+     * Set current language
+     */
+    setLanguage(language: TLanguages): void;
+    /**
+     * Get available languages
+     */
+    getLanguages(): readonly LanguageDefinition[];
+    /**
+     * Get registered components
+     */
+    getComponents(): ReadonlyArray<ComponentDefinition<any>>;
+    /**
+     * Check if a component is registered
+     */
+    hasComponent(componentId: string): boolean;
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(language: TLanguages): boolean;
+    /**
+     * Get language by code
+     */
+    getLanguageByCode(code: string): LanguageDefinition | undefined;
+    /**
+     * Get language registry for direct access
+     */
+    getLanguageRegistry(): LanguageRegistry<TLanguages>;
+    /**
+     * Get component registry for direct access
+     */
+    getComponentRegistry(): ComponentRegistry<TLanguages>;
+    /**
+     * Get enum registry for direct access
+     */
+    getEnumRegistry(): EnumTranslationRegistry<string, TLanguages>;
+    /**
+     * Validate that all components have complete translations
+     */
+    validateAllComponents(): {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+}

package/dist/plugin-i18n-engine.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Plugin-based internationalization engine with component and language registration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginI18nEngine = void 0;
+const component_registry_1 = require("./component-registry");
+const currency_code_1 = require("./currency-code");
+const enum_registry_1 = require("./enum-registry");
+const language_registry_1 = require("./language-registry");
+const registry_error_1 = require("./registry-error");
+const registry_error_type_1 = require("./registry-error-type");
+const timezone_1 = require("./timezone");
+/**
+ * Plugin-based I18n Engine with registration capabilities
+ */
+class PluginI18nEngine {
+    constructor(initialLanguages, config = {}) {
+        // Find default language from initialLanguages or use the first one
+        const defaultLang = initialLanguages.find((l) => l.isDefault) || initialLanguages[0];
+        if (!defaultLang) {
+            throw new Error('At least one language must be provided');
+        }
+        // Set up configuration with defaults
+        this.config = {
+            defaultLanguage: defaultLang.id,
+            fallbackLanguage: defaultLang.id,
+            defaultCurrencyCode: new currency_code_1.CurrencyCode('USD'),
+            timezone: new timezone_1.Timezone('UTC'),
+            adminTimezone: new timezone_1.Timezone('UTC'),
+            validation: {
+                requireCompleteStrings: false,
+                allowPartialRegistration: true,
+                fallbackLanguageId: defaultLang.id,
+            },
+            ...config,
+        };
+        // Initialize registries
+        this.languageRegistry = new language_registry_1.LanguageRegistry();
+        this.componentRegistry = new component_registry_1.ComponentRegistry(initialLanguages.map((l) => l.id), this.config.validation);
+        this.enumRegistry = new enum_registry_1.EnumTranslationRegistry(initialLanguages.map((l) => l.id), (key, vars) => this.safeTranslate('core', key, vars));
+        // Register initial languages
+        this.languageRegistry.registerLanguages(initialLanguages);
+        // Initialize context
+        this.context = {
+            currentLanguage: this.config.defaultLanguage,
+            fallbackLanguage: this.config.fallbackLanguage,
+            currencyCode: this.config.defaultCurrencyCode,
+            timezone: this.config.timezone,
+            adminTimezone: this.config.adminTimezone,
+        };
+    }
+    /**
+     * Create a new instance with a specific key
+     */
+    static createInstance(key, initialLanguages, config) {
+        if (PluginI18nEngine._instances.has(key)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.DuplicateComponent, `I18n instance with key '${key}' already exists`, { key });
+        }
+        const instance = new PluginI18nEngine(initialLanguages, config);
+        PluginI18nEngine._instances.set(key, instance);
+        if (!PluginI18nEngine._defaultKey) {
+            PluginI18nEngine._defaultKey = key;
+        }
+        return instance;
+    }
+    /**
+     * Get an existing instance by key
+     */
+    static getInstance(key) {
+        const instanceKey = key ||
+            PluginI18nEngine._defaultKey ||
+            PluginI18nEngine.DefaultInstanceKey;
+        const instance = PluginI18nEngine._instances.get(instanceKey);
+        if (!instance) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.ComponentNotFound, `I18n instance with key '${instanceKey}' not found`, { key: instanceKey });
+        }
+        return instance;
+    }
+    /**
+     * Register a new language
+     */
+    registerLanguage(language) {
+        this.languageRegistry.registerLanguage(language);
+        // Update component registry with new language
+        const newLanguages = this.languageRegistry.getLanguageIds();
+        this.componentRegistry.updateRegisteredLanguages(newLanguages);
+    }
+    /**
+     * Register multiple languages
+     */
+    registerLanguages(languages) {
+        for (const language of languages) {
+            this.registerLanguage(language);
+        }
+    }
+    /**
+     * Register a component with its translations
+     */
+    registerComponent(registration) {
+        return this.componentRegistry.registerComponent(registration);
+    }
+    /**
+     * Update strings for an existing component
+     */
+    updateComponentStrings(componentId, strings) {
+        return this.componentRegistry.updateComponentStrings(componentId, strings);
+    }
+    /**
+     * Register an enum with translations
+     */
+    registerEnum(enumObj, translations, enumName) {
+        this.enumRegistry.register(enumObj, translations, enumName);
+    }
+    /**
+     * Translate a string for a component
+     */
+    translate(componentId, stringKey, variables, language) {
+        const request = {
+            componentId,
+            stringKey,
+            language: language || this.context.currentLanguage,
+            variables,
+        };
+        const response = this.componentRegistry.getTranslation(request);
+        return response.translation;
+    }
+    /**
+     * Safe translate that returns a placeholder if translation fails
+     */
+    safeTranslate(componentId, stringKey, variables, language) {
+        try {
+            return this.translate(componentId, stringKey, variables, language);
+        }
+        catch (error) {
+            // Return a placeholder if translation fails
+            return `[${componentId}.${stringKey}]`;
+        }
+    }
+    /**
+     * Translate an enum value
+     */
+    translateEnum(enumObj, value, language) {
+        return this.enumRegistry.translate(enumObj, value, language || this.context.currentLanguage);
+    }
+    /**
+     * Get detailed translation response
+     */
+    getTranslationDetails(componentId, stringKey, variables, language) {
+        const request = {
+            componentId,
+            stringKey,
+            language: language || this.context.currentLanguage,
+            variables,
+        };
+        return this.componentRegistry.getTranslation(request);
+    }
+    /**
+     * Get current context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Update context
+     */
+    updateContext(updates) {
+        this.context = { ...this.context, ...updates };
+    }
+    /**
+     * Set current language
+     */
+    setLanguage(language) {
+        if (!this.languageRegistry.hasLanguage(language)) {
+            throw registry_error_1.RegistryError.createSimple(registry_error_type_1.RegistryErrorType.LanguageNotFound, `Language '${language}' is not registered`, { language });
+        }
+        this.context.currentLanguage = language;
+    }
+    /**
+     * Get available languages
+     */
+    getLanguages() {
+        return this.languageRegistry.getAllLanguages();
+    }
+    /**
+     * Get registered components
+     */
+    getComponents() {
+        return this.componentRegistry.getComponents();
+    }
+    /**
+     * Check if a component is registered
+     */
+    hasComponent(componentId) {
+        return this.componentRegistry.hasComponent(componentId);
+    }
+    /**
+     * Check if a language is registered
+     */
+    hasLanguage(language) {
+        return this.languageRegistry.hasLanguage(language);
+    }
+    /**
+     * Get language by code
+     */
+    getLanguageByCode(code) {
+        return this.languageRegistry.getLanguageByCode(code);
+    }
+    /**
+     * Get language registry for direct access
+     */
+    getLanguageRegistry() {
+        return this.languageRegistry;
+    }
+    /**
+     * Get component registry for direct access
+     */
+    getComponentRegistry() {
+        return this.componentRegistry;
+    }
+    /**
+     * Get enum registry for direct access
+     */
+    getEnumRegistry() {
+        return this.enumRegistry;
+    }
+    /**
+     * Validate that all components have complete translations
+     */
+    validateAllComponents() {
+        const errors = [];
+        const warnings = [];
+        let isValid = true;
+        const components = this.getComponents();
+        const languages = this.languageRegistry.getLanguageIds();
+        for (const component of components) {
+            const componentStrings = this.componentRegistry.getComponentStrings(component.id);
+            if (!componentStrings) {
+                errors.push(`Component '${component.id}' has no registered strings`);
+                isValid = false;
+                continue;
+            }
+            for (const language of languages) {
+                const languageStrings = componentStrings[language];
+                if (!languageStrings) {
+                    errors.push(`Component '${component.id}' missing strings for language '${language}'`);
+                    isValid = false;
+                    continue;
+                }
+                for (const stringKey of component.stringKeys) {
+                    if (!languageStrings[stringKey]) {
+                        warnings.push(`Component '${component.id}' missing key '${stringKey}' for language '${language}'`);
+                    }
+                }
+            }
+        }
+        return { isValid, errors, warnings };
+    }
+}
+exports.PluginI18nEngine = PluginI18nEngine;
+/**
+ * Static instances for semi-singleton pattern
+ */
+PluginI18nEngine._instances = new Map();
+PluginI18nEngine._defaultKey = null;
+PluginI18nEngine.DefaultInstanceKey = 'default';

package/dist/registry-config.d.ts

@@ -0,0 +1,14 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+import { ValidationConfig } from './validation-config';
+/**
+ * Registry configuration
+ */
+export interface RegistryConfig<TLanguages extends string> {
+    readonly defaultLanguage: TLanguages;
+    readonly fallbackLanguage: TLanguages;
+    readonly defaultCurrencyCode: CurrencyCode;
+    readonly timezone: Timezone;
+    readonly adminTimezone: Timezone;
+    readonly validation: ValidationConfig;
+}

package/dist/registry-config.js

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

package/dist/registry-context.d.ts

@@ -0,0 +1,12 @@
+import { CurrencyCode } from './currency-code';
+import { Timezone } from './timezone';
+/**
+ * Translation context similar to existing I18nContext
+ */
+export interface RegistryContext<TLanguages extends string> {
+    currentLanguage: TLanguages;
+    fallbackLanguage: TLanguages;
+    currencyCode: CurrencyCode;
+    timezone: Timezone;
+    adminTimezone: Timezone;
+}

package/dist/registry-context.js

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

package/dist/registry-error-type.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Error types for registry operations
+ */
+export declare enum RegistryErrorType {
+    ComponentNotFound = "COMPONENT_NOT_FOUND",
+    LanguageNotFound = "LANGUAGE_NOT_FOUND",
+    StringKeyNotFound = "STRING_KEY_NOT_FOUND",
+    IncompleteRegistration = "INCOMPLETE_REGISTRATION",
+    DuplicateComponent = "DUPLICATE_COMPONENT",
+    DuplicateLanguage = "DUPLICATE_LANGUAGE",
+    ValidationFailed = "VALIDATION_FAILED"
+}

package/dist/registry-error-type.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryErrorType = void 0;
+/**
+ * Error types for registry operations
+ */
+var RegistryErrorType;
+(function (RegistryErrorType) {
+    RegistryErrorType["ComponentNotFound"] = "COMPONENT_NOT_FOUND";
+    RegistryErrorType["LanguageNotFound"] = "LANGUAGE_NOT_FOUND";
+    RegistryErrorType["StringKeyNotFound"] = "STRING_KEY_NOT_FOUND";
+    RegistryErrorType["IncompleteRegistration"] = "INCOMPLETE_REGISTRATION";
+    RegistryErrorType["DuplicateComponent"] = "DUPLICATE_COMPONENT";
+    RegistryErrorType["DuplicateLanguage"] = "DUPLICATE_LANGUAGE";
+    RegistryErrorType["ValidationFailed"] = "VALIDATION_FAILED";
+})(RegistryErrorType || (exports.RegistryErrorType = RegistryErrorType = {}));

package/dist/registry-error.d.ts

@@ -0,0 +1,19 @@
+import { CoreLanguage } from './core-language';
+import { RegistryErrorType } from './registry-error-type';
+import { TranslationEngine } from './typed-error';
+/**
+ * Registry error class that can work with plugin engines
+ */
+export declare class RegistryError extends Error {
+    readonly type: RegistryErrorType;
+    readonly metadata?: Record<string, any> | undefined;
+    constructor(type: RegistryErrorType, message: string, metadata?: Record<string, any> | undefined);
+    /**
+     * Create a registry error with translation support
+     */
+    static createWithEngine(engine: TranslationEngine, type: RegistryErrorType, variables?: Record<string, string | number>, language?: CoreLanguage, metadata?: Record<string, any>): RegistryError;
+    /**
+     * Create a simple RegistryError without engine dependency
+     */
+    static createSimple(type: RegistryErrorType, message: string, metadata?: Record<string, any>): RegistryError;
+}

package/dist/registry-error.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryError = void 0;
+const core_string_key_1 = require("./core-string-key");
+const registry_error_type_1 = require("./registry-error-type");
+const typed_error_1 = require("./typed-error");
+/**
+ * Reason map for registry errors
+ */
+const REGISTRY_ERROR_REASON_MAP = {
+    [registry_error_type_1.RegistryErrorType.ComponentNotFound]: core_string_key_1.CoreStringKey.Error_ComponentNotFoundTemplate,
+    [registry_error_type_1.RegistryErrorType.DuplicateComponent]: core_string_key_1.CoreStringKey.Error_DuplicateComponentTemplate,
+    [registry_error_type_1.RegistryErrorType.DuplicateLanguage]: core_string_key_1.CoreStringKey.Error_DuplicateLanguageTemplate,
+    [registry_error_type_1.RegistryErrorType.IncompleteRegistration]: core_string_key_1.CoreStringKey.Error_IncompleteRegistrationTemplate,
+    [registry_error_type_1.RegistryErrorType.LanguageNotFound]: core_string_key_1.CoreStringKey.Error_LanguageNotFoundTemplate,
+    [registry_error_type_1.RegistryErrorType.StringKeyNotFound]: core_string_key_1.CoreStringKey.Error_StringKeyNotFoundTemplate,
+    [registry_error_type_1.RegistryErrorType.ValidationFailed]: core_string_key_1.CoreStringKey.Error_ValidationFailedTemplate,
+};
+/**
+ * Registry error class that can work with plugin engines
+ */
+class RegistryError extends Error {
+    constructor(type, message, metadata) {
+        super(message);
+        this.type = type;
+        this.metadata = metadata;
+        this.name = 'RegistryError';
+    }
+    /**
+     * Create a registry error with translation support
+     */
+    static createWithEngine(engine, type, variables, language, metadata) {
+        const error = (0, typed_error_1.createTranslatedError)(engine, 'core', type, REGISTRY_ERROR_REASON_MAP, variables, language, metadata, 'RegistryError');
+        // Convert to RegistryError instance
+        return new RegistryError(type, error.message, metadata);
+    }
+    /**
+     * Create a simple RegistryError without engine dependency
+     */
+    static createSimple(type, message, metadata) {
+        return new RegistryError(type, message, metadata);
+    }
+}
+exports.RegistryError = RegistryError;

package/dist/translation-request.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Translation request interface
+ */
+export interface TranslationRequest<TStringKeys extends string, TLanguages extends string> {
+    readonly componentId: string;
+    readonly stringKey: TStringKeys;
+    readonly language?: TLanguages;
+    readonly variables?: Record<string, string | number>;
+}

package/dist/translation-request.js

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

package/dist/translation-response.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Translation response interface
+ */
+export interface TranslationResponse {
+    readonly translation: string;
+    readonly actualLanguage: string;
+    readonly wasFallback: boolean;
+}

package/dist/translation-response.js

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

package/dist/typed-error.d.ts

@@ -1,11 +1,36 @@
 import { Language, StringKey } from './default-config';
 import { I18nEngine } from './i18n-engine';
+import { CoreLanguage } from './core-language';
+import { CoreStringKey } from './core-string-key';
+import { PluginI18nEngine } from './plugin-i18n-engine';
+/**
+ * Interface for engines that can translate strings (unified interface)
+ */
+export interface TranslationEngine {
+    safeTranslate(componentId: string, stringKey: string, variables?: Record<string, string | number>, language?: string): string;
+}
 /**
  * Type constraint to ensure reasonMap has entries for all enum values
  */
-type CompleteReasonMap<TEnum extends Record<string, string | number>, TStringKey extends string> = Record<TEnum[keyof TEnum], TStringKey>;
+export type CompleteReasonMap<TEnum extends Record<string, string | number>, TStringKey extends string> = Record<TEnum[keyof TEnum], TStringKey>;
+/**
+ * Base typed error class with common patterns
+ */
+export declare abstract class BaseTypedError<TEnum extends Record<string, string>, TStringKey extends string> extends Error {
+    readonly type: TEnum[keyof TEnum];
+    readonly metadata?: Record<string, any> | undefined;
+    constructor(type: TEnum[keyof TEnum], message: string, metadata?: Record<string, any> | undefined);
+    /**
+     * Create a simple typed error without engine dependency
+     */
+    static createSimple<TEnum extends Record<string, string>, TStringKey extends string, TError extends BaseTypedError<TEnum, TStringKey>>(this: new (type: TEnum[keyof TEnum], message: string, metadata?: Record<string, any>) => TError, type: TEnum[keyof TEnum], message: string, metadata?: Record<string, any>): TError;
+    /**
+     * Create a typed error with translation support
+     */
+    static createTranslated<TEnum extends Record<string, string>, TStringKey extends string, TError extends BaseTypedError<TEnum, TStringKey>>(this: new (type: TEnum[keyof TEnum], message: string, metadata?: Record<string, any>) => TError, engine: TranslationEngine, componentId: string, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, variables?: Record<string, string | number>, language?: string, metadata?: Record<string, any>): TError;
+}
 /**
- * Type-safe TypedError that ensures complete enum coverage
+ * Legacy TypedError that ensures complete enum coverage (for backward compatibility)
  */
 export declare abstract class TypedError<TEnum extends Record<string, string>, TStringKey extends string = StringKey> extends Error {
     readonly type: TEnum[keyof TEnum];
@@ -14,4 +39,39 @@ export declare abstract class TypedError<TEnum extends Record<string, string>, T
     readonly otherVars?: Record<string, string | number> | undefined;
     constructor(engine: I18nEngine<TStringKey, Language, Record<string, any>, string>, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, language?: Language | undefined, otherVars?: Record<string, string | number> | undefined);
 }
-export type { CompleteReasonMap };
+/**
+ * Plugin-based TypedError that works with the new component registration system
+ */
+export declare abstract class PluginTypedError<TEnum extends Record<string, string>, TStringKey extends string, TLanguages extends string = CoreLanguage> extends Error {
+    readonly componentId: string;
+    readonly type: TEnum[keyof TEnum];
+    readonly reasonMap: CompleteReasonMap<TEnum, TStringKey>;
+    readonly language?: TLanguages | undefined;
+    readonly otherVars?: Record<string, string | number> | undefined;
+    constructor(engine: PluginI18nEngine<TLanguages>, componentId: string, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, language?: TLanguages | undefined, otherVars?: Record<string, string | number> | undefined);
+}
+/**
+ * Core system TypedError using the core component strings
+ */
+export declare abstract class CoreTypedError<TEnum extends Record<string, string>> extends Error {
+    readonly type: TEnum[keyof TEnum];
+    readonly reasonMap: CompleteReasonMap<TEnum, CoreStringKey>;
+    readonly language?: CoreLanguage | undefined;
+    readonly otherVars?: Record<string, string | number> | undefined;
+    constructor(engine: PluginI18nEngine<CoreLanguage>, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, CoreStringKey>, language?: CoreLanguage | undefined, otherVars?: Record<string, string | number> | undefined);
+}
+/**
+ * Helper function to create a plugin-based TypedError with automatic engine detection
+ */
+export declare function createPluginTypedError<TEnum extends Record<string, string>, TStringKey extends string, TLanguages extends string = CoreLanguage>(componentId: string, type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, otherVars?: Record<string, string | number>, language?: TLanguages, instanceKey?: string): Error;
+/**
+ * Helper function to create a core system TypedError with automatic engine detection
+ */
+export declare function createCoreTypedError<TEnum extends Record<string, string>>(type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, CoreStringKey>, otherVars?: Record<string, string | number>, language?: CoreLanguage, instanceKey?: string): Error;
+/**
+ * Create a simple error with translation support (generalized pattern from RegistryError)
+ */
+export declare function createTranslatedError<TEnum extends Record<string, string>, TStringKey extends string>(engine: TranslationEngine, componentId: string, type: TEnum[keyof TEnum], reasonMap: Record<TEnum[keyof TEnum], TStringKey>, variables?: Record<string, string | number>, language?: string, metadata?: Record<string, any>, errorName?: string): Error;
+/**
+ * Example usage of the new plugin-based TypedError system
+ */