@digitaldefiance/i18n-lib 1.3.12 → 1.3.13

package/dist/typed-error.js

@@ -1,251 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreTypedError = exports.PluginTypedError = exports.TypedError = exports.BaseTypedError = void 0;
-exports.createPluginTypedError = createPluginTypedError;
-exports.createCoreTypedError = createCoreTypedError;
-exports.createTranslatedError = createTranslatedError;
-// Legacy imports (for backward compatibility)
-const default_config_1 = require("./default-config");
-// New plugin architecture imports
-// CoreLanguageCode is deprecated - using string for flexibility
-const core_string_key_1 = require("./core-string-key");
-const plugin_i18n_engine_1 = require("./plugin-i18n-engine");
-/**
- * Base typed error class with common patterns
- */
-class BaseTypedError extends Error {
-    constructor(type, message, metadata) {
-        super(message);
-        this.type = type;
-        this.metadata = metadata;
-        this.name = this.constructor.name;
-    }
-    /**
-     * Create a simple typed error without engine dependency
-     */
-    static createSimple(type, message, metadata) {
-        return new this(type, message, metadata);
-    }
-    /**
-     * Create a typed error with translation support
-     */
-    static createTranslated(engine, type, reasonMap, variables, language, metadata) {
-        const key = reasonMap[type];
-        let message;
-        if (key && engine) {
-            // Try to translate the error message using the engine
-            message = engine.safeTranslate(key, variables, language);
-        }
-        else {
-            // Fallback to a basic English message
-            message = `Error: ${type}${metadata ? ` - ${JSON.stringify(metadata)}` : ''}`;
-        }
-        return new this(type, message, metadata);
-    }
-}
-exports.BaseTypedError = BaseTypedError;
-/**
- * Legacy TypedError that ensures complete enum coverage (for backward compatibility)
- */
-class TypedError extends Error {
-    constructor(engine, type, reasonMap, language, otherVars) {
-        const key = reasonMap[type];
-        if (!key)
-            throw new Error(engine.translate(default_config_1.DefaultStringKey.Error_MissingTranslationKeyTemplate, { type }, language));
-        super(engine.translate(key, otherVars, language));
-        this.type = type;
-        this.reasonMap = reasonMap;
-        this.language = language;
-        this.otherVars = otherVars;
-        this.name = this.constructor.name;
-    }
-}
-exports.TypedError = TypedError;
-/**
- * Plugin-based TypedError that works with the new component registration system
- */
-class PluginTypedError extends Error {
-    constructor(engine, componentId, type, reasonMap, language, otherVars) {
-        const key = reasonMap[type];
-        // If key is not found in the reason map, use core error message
-        if (!key) {
-            const errorMsg = engine.safeTranslate('core', core_string_key_1.CoreStringKey.Error_StringKeyNotFoundTemplate, {
-                stringKey: String(type),
-                componentId: componentId,
-            }, language);
-            throw new Error(errorMsg);
-        }
-        // Translate the error message using the component and string key
-        const translatedMessage = engine.safeTranslate(componentId, key, otherVars, language);
-        super(translatedMessage);
-        this.componentId = componentId;
-        this.type = type;
-        this.reasonMap = reasonMap;
-        this.language = language;
-        this.otherVars = otherVars;
-        this.name = this.constructor.name;
-    }
-}
-exports.PluginTypedError = PluginTypedError;
-/**
- * Core system TypedError using the core component strings
- */
-class CoreTypedError extends Error {
-    constructor(engine, type, reasonMap, language, otherVars) {
-        const key = reasonMap[type];
-        // If key is not found in the reason map, use a fallback error
-        if (!key) {
-            const errorMsg = engine.safeTranslate('core', core_string_key_1.CoreStringKey.Error_StringKeyNotFoundTemplate, {
-                stringKey: String(type),
-                componentId: 'core',
-            }, language);
-            throw new Error(errorMsg);
-        }
-        // Translate the error message using the core component
-        const translatedMessage = engine.safeTranslate('core', key, otherVars, language);
-        super(translatedMessage);
-        this.type = type;
-        this.reasonMap = reasonMap;
-        this.language = language;
-        this.otherVars = otherVars;
-        this.name = this.constructor.name;
-    }
-}
-exports.CoreTypedError = CoreTypedError;
-/**
- * Helper function to create a plugin-based TypedError with automatic engine detection
- */
-function createPluginTypedError(componentId, type, reasonMap, otherVars, language, instanceKey) {
-    const engine = plugin_i18n_engine_1.PluginI18nEngine.getInstance(instanceKey);
-    return new (class extends PluginTypedError {
-        constructor() {
-            super(engine, componentId, type, reasonMap, language, otherVars);
-        }
-    })();
-}
-/**
- * Helper function to create a core system TypedError with automatic engine detection
- */
-function createCoreTypedError(type, reasonMap, otherVars, language, instanceKey) {
-    const engine = plugin_i18n_engine_1.PluginI18nEngine.getInstance(instanceKey);
-    return new (class extends CoreTypedError {
-        constructor() {
-            super(engine, type, reasonMap, language, otherVars);
-        }
-    })();
-}
-/**
- * Create a simple error with translation support (generalized pattern from RegistryError)
- */
-function createTranslatedError(engine, componentId, type, reasonMap, variables, language, metadata, errorName) {
-    const key = reasonMap[type];
-    let message;
-    if (key && engine) {
-        try {
-            // Try to translate the error message using the engine
-            message = engine.safeTranslate(key, variables, language);
-        }
-        catch (translationError) {
-            // Fallback if translation fails
-            message = `Error: ${type}${metadata ? ` - ${JSON.stringify(metadata)}` : ''}`;
-        }
-    }
-    else {
-        // Fallback to a basic English message
-        message = `Error: ${type}${metadata ? ` - ${JSON.stringify(metadata)}` : ''}`;
-    }
-    const error = new Error(message);
-    error.name = errorName || 'TranslatedError';
-    error.type = type;
-    error.metadata = metadata;
-    return error;
-}
-/**
- * Example usage of the new plugin-based TypedError system
- */
-// Example 1: Core system error using CoreStringKey
-/*
-enum DatabaseErrorType {
-  ConnectionFailed = 'connectionFailed',
-  QueryTimeout = 'queryTimeout',
-  AccessDenied = 'accessDenied'
-}
-
-const coreErrorReasonMap: CompleteReasonMap<typeof DatabaseErrorType, CoreStringKey> = {
-  [DatabaseErrorType.ConnectionFailed]: CoreStringKey.Error_NetworkError,
-  [DatabaseErrorType.QueryTimeout]: CoreStringKey.Error_InternalServer,
-  [DatabaseErrorType.AccessDenied]: CoreStringKey.Error_AccessDenied
-};
-
-class DatabaseError extends CoreTypedError<typeof DatabaseErrorType> {
-  constructor(
-    engine: PluginI18nEngine<CoreLanguageCode>,
-    type: DatabaseErrorType,
-    otherVars?: Record<string, string | number>,
-    language?: CoreLanguage
-  ) {
-    super(engine, type, coreErrorReasonMap, language, otherVars);
-  }
-}
-
-// Usage:
-// const engine = PluginI18nEngine.getInstance<string>();
-// throw new DatabaseError(engine, DatabaseErrorType.ConnectionFailed);
-*/
-// Example 2: Custom component error with custom strings
-/*
-enum UserErrorType {
-  UserNotFound = 'userNotFound',
-  InvalidCredentials = 'invalidCredentials',
-  AccountLocked = 'accountLocked'
-}
-
-enum UserErrorStringKey {
-  UserNotFoundMessage = 'userNotFoundMessage',
-  InvalidCredentialsMessage = 'invalidCredentialsMessage',
-  AccountLockedMessage = 'accountLockedMessage'
-}
-
-const userErrorReasonMap: CompleteReasonMap<typeof UserErrorType, UserErrorStringKey> = {
-  [UserErrorType.UserNotFound]: UserErrorStringKey.UserNotFoundMessage,
-  [UserErrorType.InvalidCredentials]: UserErrorStringKey.InvalidCredentialsMessage,
-  [UserErrorType.AccountLocked]: UserErrorStringKey.AccountLockedMessage
-};
-
-class UserError extends PluginTypedError<typeof UserErrorType, UserErrorStringKey, string> {
-  constructor(
-    engine: PluginI18nEngine<string>,
-    type: UserErrorType,
-    otherVars?: Record<string, string | number>,
-    language?: string
-  ) {
-    super(engine, 'user-system', type, userErrorReasonMap, language, otherVars);
-  }
-}
-
-// Usage:
-// const engine = PluginI18nEngine.getInstance<string>();
-// throw new UserError(engine, UserErrorType.UserNotFound, { username: 'john_doe' });
-*/
-// Example 3: Using helper functions for simpler error creation
-/*
-// Define your error types and mappings
-enum ApiErrorType {
-  Timeout = 'timeout',
-  NotFound = 'notFound'
-}
-
-const apiErrorMap: CompleteReasonMap<typeof ApiErrorType, CoreStringKey> = {
-  [ApiErrorType.Timeout]: CoreStringKey.Error_NetworkError,
-  [ApiErrorType.NotFound]: CoreStringKey.Error_NotFound
-};
-
-// Create errors using helper functions
-function throwApiError(type: ApiErrorType, vars?: Record<string, string | number>) {
-  throw createCoreTypedError(type, apiErrorMap, vars);
-}
-
-// Usage:
-// throwApiError(ApiErrorType.NotFound, { resource: 'user' });
-*/
-// Export the type for external use (already exported above)

package/dist/typed-handleable.d.ts

@@ -1,14 +0,0 @@
-import { HandleableErrorOptions } from './i-handleable-error-options';
-import { IHandleable } from './i-handleable';
-import { HandleableError } from './handleable';
-import { CompleteReasonMap, TranslationEngine } from './typed-error';
-import { CoreLanguageCode } from './core-i18n';
-export declare class TypedHandleableError<TEnum extends Record<string, string>, TStringKey extends string, TLanguage extends CoreLanguageCode = CoreLanguageCode> extends HandleableError implements IHandleable {
-    readonly type: TEnum[keyof TEnum];
-    readonly reasonMap: CompleteReasonMap<TEnum, TStringKey>;
-    readonly engine: TranslationEngine<TStringKey>;
-    readonly language?: TLanguage;
-    readonly otherVars?: Record<string, string | number>;
-    constructor(type: TEnum[keyof TEnum], reasonMap: CompleteReasonMap<TEnum, TStringKey>, engine: TranslationEngine<TStringKey>, language?: TLanguage, otherVars?: Record<string, string | number>, options?: HandleableErrorOptions);
-    toJSON(): Record<string, unknown>;
-}

package/dist/typed-handleable.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedHandleableError = void 0;
-const handleable_1 = require("./handleable");
-const plugin_i18n_engine_1 = require("./plugin-i18n-engine");
-const core_string_key_1 = require("./core-string-key");
-class TypedHandleableError extends handleable_1.HandleableError {
-    constructor(type, reasonMap, engine, language, otherVars, options) {
-        const key = reasonMap[type];
-        if (!key) {
-            const coreEngine = plugin_i18n_engine_1.PluginI18nEngine.getInstance();
-            throw new Error(coreEngine.translate('core', core_string_key_1.CoreStringKey.Error_MissingTranslationKeyTemplate, {
-                stringKey: key,
-            }));
-        }
-        let message = String(type);
-        try {
-            const keyString = key;
-            const translated = engine.translate(keyString, otherVars, language);
-            message = String(translated || type);
-        }
-        catch (error) {
-            message = String(type);
-        }
-        super(new Error(message), options);
-        this.type = type;
-        this.reasonMap = reasonMap;
-        this.language = language;
-        this.otherVars = otherVars;
-        this.engine = engine;
-    }
-    toJSON() {
-        const baseJson = super.toJSON();
-        return {
-            ...baseJson,
-            type: this.type,
-        };
-    }
-}
-exports.TypedHandleableError = TypedHandleableError;

package/dist/types.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultTimezone = exports.DefaultCurrencyCode = void 0;
-exports.createTranslations = createTranslations;
-/**
- * Default currency code
- */
-exports.DefaultCurrencyCode = 'USD';
-/**
- * Default timezone
- */
-exports.DefaultTimezone = 'UTC';
-/**
- * Helper function to create typed translations for an enumeration
- */
-function createTranslations(translations) {
-    return translations;
-}

package/dist/unified-translator.d.ts

@@ -1,30 +0,0 @@
-import { PluginI18nEngine } from './plugin-i18n-engine';
-import { I18nEngine } from './i18n-engine';
-/**
- * Unified translator with explicit component/engine specification
- */
-export declare class UnifiedTranslator<TLanguage extends string = string> {
-    private sources;
-    private defaultLanguage;
-    private defaultSource?;
-    constructor(defaultLanguage: TLanguage);
-    /**
-     * Register a plugin component
-     */
-    registerPlugin(id: string, engine: PluginI18nEngine<any>, componentId: string): void;
-    /**
-     * Register a legacy engine
-     */
-    registerLegacy(id: string, engine: I18nEngine<any, any, any, any>): void;
-    /**
-     * Set default source for unqualified keys
-     */
-    setDefaultSource(id: string): void;
-    /**
-     * Translate with explicit source: 'source:key' or just 'key' (uses default)
-     */
-    translate(key: string, vars?: Record<string, string | number>, language?: TLanguage): string;
-    setLanguage(language: TLanguage): void;
-    getLanguage(): TLanguage;
-    clearSources(): void;
-}

package/dist/unified-translator.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnifiedTranslator = void 0;
-/**
- * Unified translator with explicit component/engine specification
- */
-class UnifiedTranslator {
-    constructor(defaultLanguage) {
-        this.sources = new Map();
-        this.defaultLanguage = defaultLanguage;
-    }
-    /**
-     * Register a plugin component
-     */
-    registerPlugin(id, engine, componentId) {
-        this.sources.set(id, { type: 'plugin', engine, componentId });
-        if (!this.defaultSource)
-            this.defaultSource = id;
-    }
-    /**
-     * Register a legacy engine
-     */
-    registerLegacy(id, engine) {
-        this.sources.set(id, { type: 'legacy', engine });
-        if (!this.defaultSource)
-            this.defaultSource = id;
-    }
-    /**
-     * Set default source for unqualified keys
-     */
-    setDefaultSource(id) {
-        if (!this.sources.has(id)) {
-            throw new Error(`Source '${id}' not registered`);
-        }
-        this.defaultSource = id;
-    }
-    /**
-     * Translate with explicit source: 'source:key' or just 'key' (uses default)
-     */
-    translate(key, vars, language) {
-        const lang = language || this.defaultLanguage;
-        const [sourceName, actualKey] = key.includes(':')
-            ? key.split(':', 2)
-            : [this.defaultSource, key];
-        if (!sourceName)
-            return `[${key}]`;
-        const source = this.sources.get(sourceName);
-        if (!source)
-            return `[${key}]`;
-        if (source.type === 'plugin') {
-            return source.engine.safeTranslate(source.componentId, actualKey, vars, lang);
-        }
-        else {
-            return source.engine.safeTranslate(actualKey, vars, lang);
-        }
-    }
-    setLanguage(language) {
-        this.defaultLanguage = language;
-    }
-    getLanguage() {
-        return this.defaultLanguage;
-    }
-    clearSources() {
-        this.sources.clear();
-        this.defaultSource = undefined;
-    }
-}
-exports.UnifiedTranslator = UnifiedTranslator;

package/dist/utils.d.ts

@@ -1,64 +0,0 @@
-/**
- * Replaces variables in a string with their corresponding values from vars or constants.
- * @param str - The string containing variables to replace
- * @param vars - An object mapping variable names to their replacement values
- * @param constants - An object containing constant values for replacement
- * @returns The string with variables replaced
- */
-export declare function replaceVariables(str: string, vars?: Record<string, string | number>, constants?: any): string;
-/**
- * Checks if a given key indicates a template string.
- * @param key - The key to check
- * @returns True if the key indicates a template, false otherwise
- */
-export declare function isTemplate(key: string): boolean;
-/**
- * Checks if a given timezone string is valid.
- * @param timezone - The timezone string to validate
- * @returns
- */
-export declare function isValidTimezone(timezone: string): boolean;
-/**
- * Converts parts to a single string key, joining with underscores.
- * @param parts - The parts to join
- * @returns The joined string key
- */
-export declare function toStringKey<TStringKey extends string>(...parts: string[]): TStringKey;
-/**
- * Converts an enum value to a string key by joining parts with underscores and appending the enum value.
- * @param value - The enum value
- * @param parts - Additional parts to join
- * @returns The constructed string key
- */
-export declare function toStringKeyFromEnum<TStringKey extends string>(value: string, ...parts: string[]): TStringKey;
-/**
- * Type that constructs string keys from enum values with prefixes and optional template suffix
- */
-type BuildStringKey<TEnumValue extends string, TPrefixes extends readonly string[], TIsTemplate extends boolean = false> = TPrefixes extends readonly [] ? `${TEnumValue}${TIsTemplate extends true ? 'Template' : ''}` : TPrefixes extends readonly [infer First, ...infer Rest] ? First extends string ? Rest extends readonly string[] ? `${First}_${BuildStringKey<TEnumValue, Rest, TIsTemplate>}` : never : never : never;
-/**
- * Type that maps all enum values to their corresponding string keys
- */
-type ReasonMapFromEnum<TEnum extends Record<string, string>, TStringKey extends string, TPrefixes extends readonly string[] = [], TTemplateKeys extends Set<TEnum[keyof TEnum]> = never> = {
-    [K in TEnum[keyof TEnum]]: BuildStringKey<K, TPrefixes, TTemplateKeys extends Set<K> ? true : false> extends TStringKey ? BuildStringKey<K, TPrefixes, TTemplateKeys extends Set<K> ? true : false> : never;
-};
-/**
- * Builds a reason map from an enum object, mapping each enum value to a string key.
- * @param enumObj - The enum object
- * @param prefixes - Prefixes to prepend to each string key
- * @param templateKeys - Optional set of enum values that should have 'Template' suffix for template processing
- * @returns The constructed reason map
- */
-export declare function buildReasonMap<TEnum extends Record<string, string>, TStringKey extends string>(enumObj: TEnum, prefixes?: string[], templateKeys?: Set<TEnum[keyof TEnum]>): Record<TEnum[keyof TEnum], TStringKey>;
-/**
- * Type-safe version of buildReasonMap that ensures all enum values are mapped and all string keys exist
- */
-export declare function buildTypeSafeReasonMap<TEnum extends Record<string, string>, TStringKey extends string, TPrefixes extends readonly string[] = [], TTemplateKeys extends Set<TEnum[keyof TEnum]> = never>(enumObj: TEnum, prefixes: TPrefixes, templateKeys?: TTemplateKeys): ReasonMapFromEnum<TEnum, TStringKey, TPrefixes, TTemplateKeys>;
-/**
- * Validates that a reason map has entries for all enum values
- */
-export declare function validateReasonMap<TEnum extends Record<string, string>, TStringKey extends string>(enumObj: TEnum, reasonMap: Partial<Record<TEnum[keyof TEnum], TStringKey>>): reasonMap is Record<TEnum[keyof TEnum], TStringKey>;
-/**
- * Creates a complete reason map ensuring all enum values are covered
- */
-export declare function createCompleteReasonMap<TEnum extends Record<string, string>, TStringKey extends string>(enumObj: TEnum, prefixes?: readonly string[], templateKeys?: Set<TEnum[keyof TEnum]>): Record<TEnum[keyof TEnum], TStringKey>;
-export {};

package/dist/utils.js

@@ -1,130 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceVariables = replaceVariables;
-exports.isTemplate = isTemplate;
-exports.isValidTimezone = isValidTimezone;
-exports.toStringKey = toStringKey;
-exports.toStringKeyFromEnum = toStringKeyFromEnum;
-exports.buildReasonMap = buildReasonMap;
-exports.buildTypeSafeReasonMap = buildTypeSafeReasonMap;
-exports.validateReasonMap = validateReasonMap;
-exports.createCompleteReasonMap = createCompleteReasonMap;
-const moment_timezone_1 = __importDefault(require("moment-timezone"));
-/**
- * Replaces variables in a string with their corresponding values from vars or constants.
- * @param str - The string containing variables to replace
- * @param vars - An object mapping variable names to their replacement values
- * @param constants - An object containing constant values for replacement
- * @returns The string with variables replaced
- */
-function replaceVariables(str, vars, constants) {
-    // Ensure input is a string
-    if (typeof str !== 'string') {
-        str = String(str);
-    }
-    const variables = str.match(/\{(.+?)\}/g);
-    if (!variables)
-        return str;
-    let result = str;
-    for (const variable of variables) {
-        const varName = variable.slice(1, -1);
-        let replacement = '';
-        if (vars && varName in vars) {
-            replacement = String(vars[varName]);
-        }
-        else if (constants && varName in constants) {
-            replacement = String(constants[varName]);
-        }
-        if (replacement) {
-            result = result.replace(variable, replacement);
-        }
-    }
-    return result;
-}
-/**
- * Checks if a given key indicates a template string.
- * @param key - The key to check
- * @returns True if the key indicates a template, false otherwise
- */
-function isTemplate(key) {
-    return key.trim().toLowerCase().endsWith('template');
-}
-/**
- * Checks if a given timezone string is valid.
- * @param timezone - The timezone string to validate
- * @returns
- */
-function isValidTimezone(timezone) {
-    return moment_timezone_1.default.tz.zone(timezone) !== null;
-}
-/**
- * Converts parts to a single string key, joining with underscores.
- * @param parts - The parts to join
- * @returns The joined string key
- */
-function toStringKey(...parts) {
-    return parts.join('_');
-}
-/**
- * Converts an enum value to a string key by joining parts with underscores and appending the enum value.
- * @param value - The enum value
- * @param parts - Additional parts to join
- * @returns The constructed string key
- */
-function toStringKeyFromEnum(value, ...parts) {
-    const allParts = [...parts, value];
-    return allParts.join('_');
-}
-/**
- * Builds a reason map from an enum object, mapping each enum value to a string key.
- * @param enumObj - The enum object
- * @param prefixes - Prefixes to prepend to each string key
- * @param templateKeys - Optional set of enum values that should have 'Template' suffix for template processing
- * @returns The constructed reason map
- */
-function buildReasonMap(enumObj, prefixes = [], templateKeys) {
-    const map = {};
-    Object.values(enumObj).forEach((value) => {
-        const baseKey = [...prefixes, value].join('_');
-        const finalKey = templateKeys?.has(value)
-            ? baseKey + 'Template'
-            : baseKey;
-        map[value] = finalKey;
-    });
-    return map;
-}
-/**
- * Type-safe version of buildReasonMap that ensures all enum values are mapped and all string keys exist
- */
-function buildTypeSafeReasonMap(enumObj, prefixes, templateKeys) {
-    const map = {};
-    Object.values(enumObj).forEach((value) => {
-        const baseKey = [...prefixes, value].join('_');
-        const finalKey = templateKeys?.has(value)
-            ? baseKey + 'Template'
-            : baseKey;
-        map[value] = finalKey;
-    });
-    return map;
-}
-/**
- * Validates that a reason map has entries for all enum values
- */
-function validateReasonMap(enumObj, reasonMap) {
-    return Object.values(enumObj).every((value) => value in reasonMap &&
-        reasonMap[value] !== undefined);
-}
-/**
- * Creates a complete reason map ensuring all enum values are covered
- */
-function createCompleteReasonMap(enumObj, prefixes = [], templateKeys) {
-    const map = buildReasonMap(enumObj, [...prefixes], templateKeys);
-    if (!validateReasonMap(enumObj, map)) {
-        const missing = Object.values(enumObj).filter((value) => !(value in map));
-        throw new Error(`Missing reason map entries for: ${missing.join(', ')}`);
-    }
-    return map;
-}

package/dist/validation-config.d.ts

@@ -1,11 +0,0 @@
-/**
- * Configuration for component registration validation
- */
-export interface ValidationConfig {
-    /** Whether to require all languages to have all strings */
-    readonly requireCompleteStrings: boolean;
-    /** Whether to allow registration with missing strings (will use fallbacks) */
-    readonly allowPartialRegistration: boolean;
-    /** Default language to fall back to for missing strings */
-    readonly fallbackLanguageId: string;
-}

package/dist/validation-config.js

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

package/dist/validation-result.d.ts

@@ -1,12 +0,0 @@
-/**
- * Validation result for component registration
- */
-export interface ValidationResult {
-    readonly isValid: boolean;
-    readonly missingKeys: ReadonlyArray<{
-        readonly languageId: string;
-        readonly componentId: string;
-        readonly stringKey: string;
-    }>;
-    readonly errors: readonly string[];
-}

package/dist/validation-result.js

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