@digitaldefiance/i18n-lib 3.8.0 → 3.8.2

package/src/pluralization/language-plural-map.ts

@@ -0,0 +1,186 @@
+/**
+ * Language to Plural Rule Mapping
+ */
+
+import {
+  LanguagePluralForms,
+  PluralCategory,
+  PluralRuleFunction,
+} from './plural-categories';
+import {
+  pluralRuleArabic,
+  pluralRuleBreton,
+  pluralRuleChinese,
+  pluralRuleCzech,
+  pluralRuleEnglish,
+  pluralRuleFrench,
+  pluralRuleGerman,
+  pluralRuleIrish,
+  pluralRuleJapanese,
+  pluralRuleLatvian,
+  pluralRuleLithuanian,
+  pluralRulePolish,
+  pluralRuleRomanian,
+  pluralRuleRussian,
+  pluralRuleScottishGaelic,
+  pluralRuleSlovenian,
+  pluralRuleSpanish,
+  pluralRuleUkrainian,
+  pluralRuleWelsh,
+} from './plural-rules';
+
+/**
+ * Map of language codes to plural rule functions
+ */
+export const LANGUAGE_PLURAL_RULES: Record<string, PluralRuleFunction> = {
+  en: pluralRuleEnglish,
+  'en-US': pluralRuleEnglish,
+  'en-GB': pluralRuleEnglish,
+  ru: pluralRuleRussian,
+  ar: pluralRuleArabic,
+  pl: pluralRulePolish,
+  fr: pluralRuleFrench,
+  es: pluralRuleSpanish,
+  ja: pluralRuleJapanese,
+  uk: pluralRuleUkrainian,
+  zh: pluralRuleChinese,
+  'zh-CN': pluralRuleChinese,
+  de: pluralRuleGerman,
+  gd: pluralRuleScottishGaelic,
+  cy: pluralRuleWelsh,
+  br: pluralRuleBreton,
+  sl: pluralRuleSlovenian,
+  cs: pluralRuleCzech,
+  lt: pluralRuleLithuanian,
+  lv: pluralRuleLatvian,
+  ga: pluralRuleIrish,
+  ro: pluralRuleRomanian,
+  // Common languages reusing existing rules
+  it: pluralRuleEnglish,
+  pt: pluralRuleEnglish,
+  'pt-BR': pluralRuleFrench, // Brazilian Portuguese: 0 and 1 use 'one'
+  nl: pluralRuleEnglish,
+  sv: pluralRuleEnglish,
+  no: pluralRuleEnglish,
+  da: pluralRuleEnglish,
+  fi: pluralRuleEnglish,
+  el: pluralRuleEnglish,
+  tr: pluralRuleJapanese,
+  ko: pluralRuleJapanese,
+  vi: pluralRuleJapanese,
+  th: pluralRuleJapanese,
+  id: pluralRuleJapanese,
+  ms: pluralRuleJapanese,
+  he: pluralRuleEnglish, // Simplified - full Hebrew is more complex
+  hi: pluralRuleFrench,
+};
+
+/**
+ * Map of language codes to required/optional plural forms
+ */
+export const LANGUAGE_PLURAL_FORMS: Record<string, LanguagePluralForms> = {
+  en: { required: ['one', 'other'], optional: ['zero'] },
+  'en-US': { required: ['one', 'other'], optional: ['zero'] },
+  'en-GB': { required: ['one', 'other'], optional: ['zero'] },
+  ru: { required: ['one', 'few', 'many'], optional: ['zero'] },
+  ar: {
+    required: ['zero', 'one', 'two', 'few', 'many', 'other'],
+    optional: [],
+  },
+  pl: { required: ['one', 'few', 'many'], optional: ['zero', 'other'] },
+  fr: { required: ['one', 'other'], optional: ['zero'] },
+  es: { required: ['one', 'other'], optional: ['zero'] },
+  ja: { required: ['other'], optional: [] },
+  uk: { required: ['one', 'few', 'many'], optional: ['zero'] },
+  zh: { required: ['other'], optional: [] },
+  'zh-CN': { required: ['other'], optional: [] },
+  de: { required: ['one', 'other'], optional: ['zero'] },
+  gd: { required: ['one', 'two', 'few', 'other'], optional: [] },
+  cy: {
+    required: ['zero', 'one', 'two', 'few', 'many', 'other'],
+    optional: [],
+  },
+  br: { required: ['one', 'two', 'few', 'many', 'other'], optional: [] },
+  sl: { required: ['one', 'two', 'few', 'other'], optional: [] },
+  cs: { required: ['one', 'few', 'many', 'other'], optional: [] },
+  lt: { required: ['one', 'few', 'many', 'other'], optional: [] },
+  lv: { required: ['zero', 'one', 'other'], optional: [] },
+  ga: { required: ['one', 'two', 'few', 'many', 'other'], optional: [] },
+  ro: { required: ['one', 'few', 'other'], optional: [] },
+  // Common languages
+  it: { required: ['one', 'other'], optional: ['zero'] },
+  pt: { required: ['one', 'other'], optional: ['zero'] },
+  'pt-BR': { required: ['one', 'other'], optional: ['zero'] },
+  nl: { required: ['one', 'other'], optional: ['zero'] },
+  sv: { required: ['one', 'other'], optional: ['zero'] },
+  no: { required: ['one', 'other'], optional: ['zero'] },
+  da: { required: ['one', 'other'], optional: ['zero'] },
+  fi: { required: ['one', 'other'], optional: ['zero'] },
+  el: { required: ['one', 'other'], optional: ['zero'] },
+  tr: { required: ['other'], optional: [] },
+  ko: { required: ['other'], optional: [] },
+  vi: { required: ['other'], optional: [] },
+  th: { required: ['other'], optional: [] },
+  id: { required: ['other'], optional: [] },
+  ms: { required: ['other'], optional: [] },
+  he: { required: ['one', 'other'], optional: ['zero'] },
+  hi: { required: ['one', 'other'], optional: ['zero'] },
+};
+
+/**
+ * Get plural category for a number in a specific language
+ */
+export function getPluralCategory(
+  language: string,
+  count: number,
+): PluralCategory {
+  // Handle invalid inputs
+  if (typeof count !== 'number' || !isFinite(count)) {
+    return 'other';
+  }
+
+  // Get the plural rule for the language
+  const rule = LANGUAGE_PLURAL_RULES[language] || LANGUAGE_PLURAL_RULES['en'];
+
+  // Apply the rule
+  return rule(Math.abs(count));
+}
+
+/**
+ * Get required plural forms for a language
+ */
+export function getRequiredPluralForms(language: string): string[] {
+  const forms = LANGUAGE_PLURAL_FORMS[language] || LANGUAGE_PLURAL_FORMS['en'];
+  return forms.required;
+}
+
+/**
+ * Get all plural forms (required + optional) for a language
+ */
+export function getAllPluralForms(language: string): string[] {
+  const forms = LANGUAGE_PLURAL_FORMS[language] || LANGUAGE_PLURAL_FORMS['en'];
+  return [...forms.required, ...forms.optional];
+}
+
+/**
+ * Check if a language has a specific plural form
+ */
+export function hasPluralForm(language: string, category: string): boolean {
+  const forms = LANGUAGE_PLURAL_FORMS[language] || LANGUAGE_PLURAL_FORMS['en'];
+  // Type guard to check if category is a valid PluralCategory
+  const validCategories: readonly string[] = [
+    'zero',
+    'one',
+    'two',
+    'few',
+    'many',
+    'other',
+  ];
+  if (!validCategories.includes(category)) {
+    return false;
+  }
+  return (
+    forms.required.includes(category as PluralCategory) ||
+    forms.optional.includes(category as PluralCategory)
+  );
+}

package/src/pluralization/{plural-categories.d.ts → plural-categories.ts}

@@ -3,20 +3,22 @@
  * Based on Unicode CLDR plural rules
  * @see https://cldr.unicode.org/index/cldr-spec/plural-rules
  */
+
 /**
  * Standard CLDR plural categories
  */
 export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+
 /**
  * Plural rule function type
  * Takes a number and returns the appropriate plural category
  */
 export type PluralRuleFunction = (n: number) => PluralCategory;
+
 /**
  * Language-specific plural forms required
  */
 export interface LanguagePluralForms {
-    required: PluralCategory[];
-    optional: PluralCategory[];
+  required: PluralCategory[];
+  optional: PluralCategory[];
 }
-//# sourceMappingURL=plural-categories.d.ts.map

package/src/pluralization/plural-rules.ts

@@ -0,0 +1,228 @@
+/**
+ * CLDR Plural Rules Implementation
+ * Based on Unicode CLDR plural rules for cardinal numbers
+ */
+
+import { PluralCategory, PluralRuleFunction } from './plural-categories';
+
+/**
+ * English plural rule (en-US, en-GB)
+ * Forms: one, other
+ */
+export const pluralRuleEnglish: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1) return 'one';
+  return 'other';
+};
+
+/**
+ * Russian plural rule (ru)
+ * Forms: one, few, many
+ */
+export const pluralRuleRussian: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod10 = n % 10;
+  const mod100 = n % 100;
+  
+  if (mod10 === 1 && mod100 !== 11) return 'one';
+  if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return 'few';
+  return 'many';
+};
+
+/**
+ * Arabic plural rule (ar)
+ * Forms: zero, one, two, few, many, other
+ */
+export const pluralRuleArabic: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 0) return 'zero';
+  if (n === 1) return 'one';
+  if (n === 2) return 'two';
+  
+  const mod100 = n % 100;
+  if (mod100 >= 3 && mod100 <= 10) return 'few';
+  if (mod100 >= 11) return 'many';
+  return 'other';
+};
+
+/**
+ * Polish plural rule (pl)
+ * Forms: one, few, many, other
+ */
+export const pluralRulePolish: PluralRuleFunction = (n: number): PluralCategory => {
+  // Fractional numbers use "other"
+  if (n !== Math.floor(n)) return 'other';
+  
+  if (n === 1) return 'one';
+  
+  const mod10 = n % 10;
+  const mod100 = n % 100;
+  
+  if (mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)) return 'few';
+  if (n !== 1 && (mod10 === 0 || mod10 === 1 || (mod10 >= 5 && mod10 <= 9) || (mod100 >= 12 && mod100 <= 14))) return 'many';
+  return 'other';
+};
+
+/**
+ * French plural rule (fr)
+ * Forms: one, other
+ */
+export const pluralRuleFrench: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 0 || n === 1) return 'one';
+  return 'other';
+};
+
+/**
+ * Spanish plural rule (es)
+ * Forms: one, other
+ */
+export const pluralRuleSpanish: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1) return 'one';
+  return 'other';
+};
+
+/**
+ * Japanese plural rule (ja)
+ * Forms: other (no plural distinction)
+ */
+export const pluralRuleJapanese: PluralRuleFunction = (n: number): PluralCategory => {
+  return 'other';
+};
+
+/**
+ * Ukrainian plural rule (uk)
+ * Forms: one, few, many (same as Russian)
+ */
+export const pluralRuleUkrainian: PluralRuleFunction = pluralRuleRussian;
+
+/**
+ * Chinese plural rule (zh-CN)
+ * Forms: other (no plural distinction)
+ */
+export const pluralRuleChinese: PluralRuleFunction = (n: number): PluralCategory => {
+  return 'other';
+};
+
+/**
+ * German plural rule (de)
+ * Forms: one, other
+ */
+export const pluralRuleGerman: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1) return 'one';
+  return 'other';
+};
+
+/**
+ * Scottish Gaelic plural rule (gd)
+ * Forms: one, two, few, other
+ * One of the most complex plural systems
+ */
+export const pluralRuleScottishGaelic: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1 || n === 11) return 'one';
+  if (n === 2 || n === 12) return 'two';
+  if ((n >= 3 && n <= 10) || (n >= 13 && n <= 19)) return 'few';
+  return 'other';
+};
+
+/**
+ * Welsh plural rule (cy)
+ * Forms: zero, one, two, few, many, other
+ */
+export const pluralRuleWelsh: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 0) return 'zero';
+  if (n === 1) return 'one';
+  if (n === 2) return 'two';
+  if (n === 3) return 'few';
+  if (n === 6) return 'many';
+  return 'other';
+};
+
+/**
+ * Breton plural rule (br)
+ * Forms: one, two, few, many, other
+ */
+export const pluralRuleBreton: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod10 = n % 10;
+  const mod100 = n % 100;
+  
+  if (mod10 === 1 && mod100 !== 11 && mod100 !== 71 && mod100 !== 91) return 'one';
+  if (mod10 === 2 && mod100 !== 12 && mod100 !== 72 && mod100 !== 92) return 'two';
+  if ((mod10 === 3 || mod10 === 4 || mod10 === 9) && 
+      (mod100 < 10 || mod100 > 19) && 
+      (mod100 < 70 || mod100 > 79) && 
+      (mod100 < 90 || mod100 > 99)) return 'few';
+  if (n !== 0 && n % 1000000 === 0) return 'many';
+  return 'other';
+};
+
+/**
+ * Slovenian plural rule (sl)
+ * Forms: one, two, few, other
+ */
+export const pluralRuleSlovenian: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod100 = n % 100;
+  
+  if (mod100 === 1) return 'one';
+  if (mod100 === 2) return 'two';
+  if (mod100 === 3 || mod100 === 4) return 'few';
+  return 'other';
+};
+
+/**
+ * Czech plural rule (cs)
+ * Forms: one, few, many, other
+ */
+export const pluralRuleCzech: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1) return 'one';
+  if (n >= 2 && n <= 4) return 'few';
+  if (n !== Math.floor(n)) return 'many';
+  return 'other';
+};
+
+/**
+ * Lithuanian plural rule (lt)
+ * Forms: one, few, many, other
+ */
+export const pluralRuleLithuanian: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod10 = n % 10;
+  const mod100 = n % 100;
+  
+  if (mod10 === 1 && (mod100 < 11 || mod100 > 19)) return 'one';
+  if (mod10 >= 2 && mod10 <= 9 && (mod100 < 11 || mod100 > 19)) return 'few';
+  if (n !== Math.floor(n)) return 'many';
+  return 'other';
+};
+
+/**
+ * Latvian plural rule (lv)
+ * Forms: zero, one, other
+ */
+export const pluralRuleLatvian: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod10 = n % 10;
+  const mod100 = n % 100;
+  
+  if (n === 0) return 'zero';
+  if (mod10 === 1 && mod100 !== 11) return 'one';
+  return 'other';
+};
+
+/**
+ * Irish plural rule (ga)
+ * Forms: one, two, few, many, other
+ */
+export const pluralRuleIrish: PluralRuleFunction = (n: number): PluralCategory => {
+  if (n === 1) return 'one';
+  if (n === 2) return 'two';
+  if (n >= 3 && n <= 6) return 'few';
+  if (n >= 7 && n <= 10) return 'many';
+  return 'other';
+};
+
+/**
+ * Romanian plural rule (ro)
+ * Forms: one, few, other
+ */
+export const pluralRuleRomanian: PluralRuleFunction = (n: number): PluralCategory => {
+  const mod100 = n % 100;
+  
+  if (n === 1) return 'one';
+  if (n === 0 || (mod100 >= 1 && mod100 <= 19)) return 'few';
+  return 'other';
+}

package/src/registry-config.ts

@@ -0,0 +1,16 @@
+import { CurrencyCode } from './utils/currency';
+import { Timezone } from './utils/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;
+  readonly constants?: Record<string, any>;
+}

package/src/registry-error-type.ts

@@ -0,0 +1,19 @@
+/**
+ * Error types for registry operations
+ */
+export enum RegistryErrorType {
+  /** Error when a requested component is not found in the registry */
+  ComponentNotFound = 'COMPONENT_NOT_FOUND',
+  /** Error when a requested language is not found in the registry */
+  LanguageNotFound = 'LANGUAGE_NOT_FOUND',
+  /** Error when a requested string key is not found in a component */
+  StringKeyNotFound = 'STRING_KEY_NOT_FOUND',
+  /** Error when component registration is incomplete (missing strings) */
+  IncompleteRegistration = 'INCOMPLETE_REGISTRATION',
+  /** Error when attempting to register a component that already exists */
+  DuplicateComponent = 'DUPLICATE_COMPONENT',
+  /** Error when attempting to register a language that already exists */
+  DuplicateLanguage = 'DUPLICATE_LANGUAGE',
+  /** Error when component validation fails */
+  ValidationFailed = 'VALIDATION_FAILED',
+}

package/src/registry-error.ts

@@ -0,0 +1,100 @@
+// CoreLanguageCode is deprecated - using string
+import { CoreI18nComponentId } from './core-component-id';
+import { CoreStringKey } from './core-string-key';
+import { RegistryErrorType } from './registry-error-type';
+
+/**
+ * Minimal translation engine interface to avoid circular dependencies
+ */
+export interface RegistryTranslationEngine {
+  safeTranslate(
+    componentId: string,
+    key: string,
+    variables?: Record<string, string | number>,
+    language?: string,
+  ): string;
+}
+
+/**
+ * Reason map for registry errors
+ */
+const REGISTRY_ERROR_REASON_MAP = {
+  [RegistryErrorType.ComponentNotFound]:
+    CoreStringKey.Error_ComponentNotFoundTemplate,
+  [RegistryErrorType.DuplicateComponent]:
+    CoreStringKey.Error_DuplicateComponentTemplate,
+  [RegistryErrorType.DuplicateLanguage]:
+    CoreStringKey.Error_DuplicateLanguageTemplate,
+  [RegistryErrorType.IncompleteRegistration]:
+    CoreStringKey.Error_IncompleteRegistrationTemplate,
+  [RegistryErrorType.LanguageNotFound]:
+    CoreStringKey.Error_LanguageNotFoundTemplate,
+  [RegistryErrorType.StringKeyNotFound]:
+    CoreStringKey.Error_StringKeyNotFoundTemplate,
+  [RegistryErrorType.ValidationFailed]:
+    CoreStringKey.Error_ValidationFailedTemplate,
+} as const;
+
+/**
+ * Registry error class that can work with plugin engines
+ */
+export class RegistryError extends Error {
+  constructor(
+    public override readonly type: RegistryErrorType,
+    message: string,
+    public override readonly metadata?: Record<string, any>,
+  ) {
+    super(message);
+    this.name = 'RegistryError';
+  }
+
+  /**
+   * Create a registry error with translation support
+   * Uses lazy initialization to avoid circular dependencies
+   */
+  static createWithEngine(
+    engine: RegistryTranslationEngine,
+    type: RegistryErrorType,
+    variables?: Record<string, string | number>,
+    language?: string,
+    metadata?: Record<string, any>,
+  ): RegistryError {
+    const key = REGISTRY_ERROR_REASON_MAP[type];
+    let message: string;
+
+    if (key && engine) {
+      try {
+        // Try to translate the error message using the engine
+        message = engine.safeTranslate(
+          CoreI18nComponentId,
+          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)}` : ''
+      }`;
+    }
+
+    return new RegistryError(type, message, metadata);
+  }
+
+  /**
+   * Create a simple RegistryError without engine dependency
+   */
+  static createSimple(
+    type: RegistryErrorType,
+    message: string,
+    metadata?: Record<string, any>,
+  ): RegistryError {
+    return new RegistryError(type, message, metadata);
+  }
+}

package/src/strict-types.ts

@@ -0,0 +1,35 @@
+/**
+ * Enforces that for each language L, all string keys K are present.
+ */
+export type CompleteLanguageStrings<TStringKey extends string> = {
+  [K in TStringKey]: string;
+};
+
+export type CompleteComponentLanguageStrings<
+  TStringKey extends string,
+  TLanguages extends string,
+> = {
+  [L in TLanguages]: CompleteLanguageStrings<TStringKey>;
+};
+
+/**
+ * Helper to assert at compile-time that an object is a complete component language map.
+ * Returns the object unchanged at runtime.
+ */
+export function createCompleteComponentStrings<
+  TStringKey extends string,
+  TLanguages extends string,
+>(
+  obj: CompleteComponentLanguageStrings<TStringKey, TLanguages>,
+): CompleteComponentLanguageStrings<TStringKey, TLanguages> {
+  return obj;
+}
+
+/**
+ * Utility to extract missing keys at compile time (identity, purely for readability)
+ */
+export function defineLanguageStrings<TStringKey extends string>(
+  strings: CompleteLanguageStrings<TStringKey>,
+): CompleteLanguageStrings<TStringKey> {
+  return strings;
+}

package/src/strings/de.ts

@@ -0,0 +1,75 @@
+import { CoreStringKey } from '../core-string-key';
+
+export const germanStrings: Record<CoreStringKey, string> = {
+      // Common/General
+      [CoreStringKey.Common_Yes]: 'Ja',
+      [CoreStringKey.Common_No]: 'Nein',
+      [CoreStringKey.Common_Cancel]: 'Abbrechen',
+      [CoreStringKey.Common_OK]: 'OK',
+      [CoreStringKey.Common_Save]: 'Speichern',
+      [CoreStringKey.Common_Delete]: 'Löschen',
+      [CoreStringKey.Common_Edit]: 'Bearbeiten',
+      [CoreStringKey.Common_Create]: 'Erstellen',
+      [CoreStringKey.Common_Update]: 'Aktualisieren',
+      [CoreStringKey.Common_Loading]: 'Lädt...',
+      [CoreStringKey.Common_Error]: 'Fehler',
+      [CoreStringKey.Common_Success]: 'Erfolg',
+      [CoreStringKey.Common_Warning]: 'Warnung',
+      [CoreStringKey.Common_Info]: 'Information',
+      [CoreStringKey.Common_Disposed]: 'Objekt wurde freigegeben',
+      [CoreStringKey.Common_Test]: 'Test',
+
+      // Error Messages
+      [CoreStringKey.Error_InvalidInput]: 'Ungültige Eingabe bereitgestellt',
+      [CoreStringKey.Error_NetworkError]: 'Netzwerkverbindungsfehler',
+      [CoreStringKey.Error_NotFound]: 'Ressource nicht gefunden',
+      [CoreStringKey.Error_AccessDenied]: 'Zugriff verweigert',
+      [CoreStringKey.Error_InternalServer]: 'Interner Serverfehler',
+      [CoreStringKey.Error_ValidationFailed]: 'Validierung fehlgeschlagen',
+      [CoreStringKey.Error_RequiredField]: 'Dieses Feld ist erforderlich',
+      [CoreStringKey.Error_InvalidContext]: 'Ungültiger Kontext',
+      [CoreStringKey.Error_InvalidContextTemplate]:
+        'Ungültiger Kontext: {contextKey}',
+      [CoreStringKey.Error_MissingTranslationKeyTemplate]:
+        'Fehlender Übersetzungsschlüssel: {stringKey}',
+      [CoreStringKey.Error_InvalidCurrencyCodeTemplate]: 'Ungültiger Währungscode: {value}',
+
+      // Registry Error Templates
+      [CoreStringKey.Error_ComponentNotFoundTemplate]:
+        'Komponente "{componentId}" nicht gefunden',
+      [CoreStringKey.Error_LanguageNotFoundTemplate]:
+        'Sprache "{language}" nicht gefunden',
+      [CoreStringKey.Error_StringKeyNotFoundTemplate]:
+        'String-Schlüssel "{stringKey}" für Komponente "{componentId}" nicht gefunden',
+      [CoreStringKey.Error_IncompleteRegistrationTemplate]:
+        'Unvollständige Registrierung für Komponente "{componentId}": {missingCount} Strings fehlen',
+      [CoreStringKey.Error_DuplicateComponentTemplate]:
+        'Komponente "{componentId}" ist bereits registriert',
+      [CoreStringKey.Error_DuplicateLanguageTemplate]:
+        'Sprache "{languageId}" ist bereits registriert',
+      [CoreStringKey.Error_ValidationFailedTemplate]:
+        'Validierung für Komponente "{componentId}" fehlgeschlagen: {errorCount} Fehler',
+
+      // System Messages
+      [CoreStringKey.System_Welcome]: 'Willkommen',
+      [CoreStringKey.System_Goodbye]: 'Auf Wiedersehen',
+      [CoreStringKey.System_PleaseWait]: 'Bitte warten...',
+      [CoreStringKey.System_ProcessingRequest]:
+        'Ihre Anfrage wird bearbeitet...',
+      [CoreStringKey.System_OperationComplete]:
+        'Vorgang erfolgreich abgeschlossen',
+      [CoreStringKey.System_NoDataAvailable]: 'Keine Daten verfügbar',
+
+      [CoreStringKey.Error_InstanceAlreadyExistsTemplate]:
+        "Instanz mit Schlüssel '{key}' existiert bereits",
+      [CoreStringKey.Error_InstanceNotFoundTemplate]:
+        "Instanz mit Schlüssel '{key}' nicht gefunden",
+      [CoreStringKey.Error_MissingStringCollectionTemplate]:
+        'Fehlende String-Sammlung für Sprache: {language}',
+      [CoreStringKey.Error_MissingTranslationTemplate]:
+        "Fehlende Übersetzung für Schlüssel '{key}' in Sprache '{language}'",
+      [CoreStringKey.Error_DefaultLanguageNoCollectionTemplate]:
+        "Standardsprache '{language}' hat keine String-Sammlung",
+      [CoreStringKey.Error_MissingTranslationKeyForTypeTemplate]:
+        'Fehlender Übersetzungsschlüssel für Typ: {type}',
+    };