@digitaldefiance/i18n-lib 3.8.2 → 3.8.4

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

@@ -1,186 +0,0 @@
-/**
- * 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-rules.ts

@@ -1,228 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,100 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-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}',
-    };