@intlayer/docs 5.5.8

package/de/packages/express-intlayer/t.md

@@ -0,0 +1,432 @@
+# Dokumentation: `t` Funktion in `express-intlayer`
+
+Die `t`-Funktion im `express-intlayer`-Paket ist das Kernwerkzeug zur Bereitstellung lokalisierter Antworten in Ihrer Express-Anwendung. Sie vereinfacht die Internationalisierung (i18n), indem sie Inhalte dynamisch basierend auf der bevorzugten Sprache des Benutzers auswählt.
+
+---
+
+## Übersicht
+
+Die `t`-Funktion wird verwendet, um Übersetzungen für eine gegebene Menge von Sprachen zu definieren und abzurufen. Sie bestimmt automatisch die geeignete Sprache basierend auf den Anfrageeinstellungen des Clients, wie dem `Accept-Language`-Header. Wenn die bevorzugte Sprache nicht verfügbar ist, wird elegant auf die in Ihrer Konfiguration angegebene Standardsprache zurückgegriffen.
+
+---
+
+## Hauptmerkmale
+
+- **Dynamische Lokalisierung**: Wählt automatisch die passendste Übersetzung für den Client aus.
+- **Fallback auf Standardsprache**: Fällt auf eine Standardsprache zurück, wenn die bevorzugte Sprache des Clients nicht verfügbar ist, um die Benutzererfahrung zu gewährleisten.
+- **Leichtgewichtig und schnell**: Entwickelt für leistungsstarke Anwendungen mit minimalem Overhead.
+- **Unterstützung des strikten Modus**: Erzwingt strikte Einhaltung der deklarierten Sprachen für zuverlässiges Verhalten.
+
+---
+
+## Funktionssignatur
+
+```typescript
+t(translations: Record<string, string>): string;
+```
+
+### Parameter
+
+- `translations`: Ein Objekt, bei dem die Schlüssel Sprachcodes (z. B. `en`, `fr`, `es-MX`) und die Werte die entsprechenden übersetzten Zeichenketten sind.
+
+### Rückgabewert
+
+- Eine Zeichenkette, die den Inhalt in der bevorzugten Sprache des Clients darstellt.
+
+---
+
+## Laden des Internationalisierungs-Request-Handlers
+
+Um sicherzustellen, dass die von `express-intlayer` bereitgestellte Internationalisierungsfunktionalität korrekt funktioniert, **müssen** Sie die Internationalisierungs-Middleware am Anfang Ihrer Express-Anwendung laden. Dies aktiviert die `t`-Funktion und stellt sicher, dass die Erkennung und Übersetzung von Sprachen ordnungsgemäß funktioniert.
+
+Platzieren Sie die Middleware `app.use(intlayer())` **vor allen Routen** in Ihrer Anwendung, um sicherzustellen, dass alle Routen von der Internationalisierung profitieren:
+
+```typescript {7} fileName="src/index.ts" codeFormat="typescript"
+import express, { type Express } from "express";
+import { intlayer } from "express-intlayer";
+
+const app: Express = express();
+
+// Internationalisierungs-Request-Handler laden
+app.use(intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {7} fileName="src/index.mjs" codeFormat="esm"
+import express from "express";
+import { intlayer } from "express-intlayer";
+
+const app = express();
+
+// Internationalisierungs-Request-Handler laden
+app.use(intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {7} fileName="src/index.cjs" codeFormat="commonjs"
+const express = require("express");
+const { intlayer } = require("express-intlayer");
+
+const app = express();
+
+// Internationalisierungs-Request-Handler laden
+app.use(intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+### Warum dies erforderlich ist
+
+- **Spracherkennung**: Die `intlayer`-Middleware verarbeitet eingehende Anfragen, um die bevorzugte Sprache des Benutzers basierend auf Headern, Cookies oder anderen konfigurierten Methoden zu erkennen.
+- **Übersetzungskontext**: Richtet den notwendigen Kontext für die `t`-Funktion ein, um sicherzustellen, dass Übersetzungen in der richtigen Sprache zurückgegeben werden.
+- **Fehlervermeidung**: Ohne diese Middleware führt die Verwendung der `t`-Funktion zu Laufzeitfehlern, da die notwendigen Sprachinformationen nicht verfügbar sind.
+
+---
+
+## Anwendungsbeispiele
+
+### Einfaches Beispiel
+
+Lokalisierte Inhalte in verschiedenen Sprachen bereitstellen:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/", (_req, res) => {
+  res.send(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+**Client-Anfragen:**
+
+- Ein Client mit `Accept-Language: fr` erhält `Bienvenue!`.
+- Ein Client mit `Accept-Language: es` erhält `¡Bienvenido!`.
+- Ein Client mit `Accept-Language: de` erhält `Welcome!` (Standardsprache).
+
+### Fehlerbehandlung
+
+Fehlermeldungen in mehreren Sprachen bereitstellen:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/error", (_req, res) => {
+  res.status(500).send(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    })
+  );
+});
+```
+
+---
+
+### Verwendung von Sprachvarianten
+
+Übersetzungen für sprachspezifische Varianten angeben:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/greet", (_req, res) => {
+  res.send(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+---
+
+## Fortgeschrittene Themen
+
+### Fallback-Mechanismus
+
+Wenn eine bevorzugte Sprache nicht verfügbar ist, fällt die `t`-Funktion auf die in der Konfiguration definierte Standardsprache zurück:
+
+```typescript {5-6} fileName="intlayer.config.ts" codeFormat="typescript"
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+```javascript {5-6} fileName="intlayer.config.mjs" codeFormat="esm"
+import { Locales } from "intlayer";
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+```javascript {5-6} fileName="intlayer.config.cjs" codeFormat="commonjs"
+const { Locales } = require("intlayer");
+
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+module.exports = config;
+```
+
+Beispiel:
+
+- Wenn `defaultLocale` `Locales.CHINESE` ist und ein Client `Locales.DUTCH` anfordert, wird die Übersetzung auf den Wert von `Locales.CHINESE` zurückgesetzt.
+- Wenn `defaultLocale` nicht definiert ist, fällt die `t`-Funktion auf den Wert von `Locales.ENGLISH` zurück.
+
+---
+
+### Strikter Modus
+
+Konfigurieren Sie die `t`-Funktion, um die strikte Einhaltung der deklarierten Sprachen zu erzwingen:
+
+| Modus       | Verhalten                                                                               |
+| ----------- | --------------------------------------------------------------------------------------- |
+| `strict`    | Alle deklarierten Sprachen müssen Übersetzungen haben. Fehlende Sprachen werfen Fehler. |
+| `inclusive` | Deklarierte Sprachen müssen Übersetzungen haben. Fehlende Sprachen lösen Warnungen aus. |
+| `loose`     | Jede vorhandene Sprache wird akzeptiert, auch wenn sie nicht deklariert ist.            |
+
+Konfigurationsbeispiel:
+
+```typescript {7} fileName="intlayer.config.ts" codeFormat="typescript"
+import { type IntlayerConfig } from "intlayer";
+
+const config = {
+  // ... Ihre bestehende Konfiguration
+  internationalization: {
+    // ... Ihre bestehende Internationalisierungskonfiguration
+    strictMode: "strict", // Strikten Modus erzwingen
+  },
+} satisfies IntlayerConfig;
+
+export default config;
+```
+
+```javascript {7} fileName="intlayer.config.mjs" codeFormat="esm"
+import { type IntlayerConfig } from "intlayer";
+
+const config = {
+  // ... Ihre bestehende Konfiguration
+  internationalization: {
+    // ... Ihre bestehende Internationalisierungskonfiguration
+    strictMode: "strict", // Strikten Modus erzwingen
+  },
+};
+
+export default config;
+```
+
+```javascript {7} fileName="intlayer.config.cjs" codeFormat="commonjs"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  // ... Ihre bestehende Konfiguration
+  internationalization: {
+    // ... Ihre bestehende Internationalisierungskonfiguration
+    strictMode: "strict", // Strikten Modus erzwingen
+  },
+};
+
+module.exports = config;
+```
+
+---
+
+### TypeScript-Integration
+
+Die `t`-Funktion ist typsicher, wenn sie mit TypeScript verwendet wird. Definieren Sie ein typsicheres Übersetzungsobjekt:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+import { type LanguageContent } from "express-intlayer";
+
+const translations: LanguageContent<string> = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+import { type LanguageContent } from "express-intlayer";
+
+/** @type {import('express-intlayer').LanguageContent<string>} */
+const translations = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+const { type LanguageContent } = require("express-intlayer");
+
+/** @type {import('express-intlayer').LanguageContent<string>} */
+const translations = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (_req, res) => {
+  res.send(t(translations));
+});
+```
+
+---
+
+### Häufige Fehler und Fehlerbehebung
+
+| Problem                         | Ursache                                     | Lösung                                                                           |
+| ------------------------------- | ------------------------------------------- | -------------------------------------------------------------------------------- |
+| `t`-Funktion funktioniert nicht | Middleware nicht geladen                    | Stellen Sie sicher, dass `app.use(intlayer())` vor den Routen hinzugefügt wurde. |
+| Fehlende Übersetzungen-Fehler   | Strikter Modus aktiviert ohne alle Sprachen | Stellen Sie alle erforderlichen Übersetzungen bereit.                            |
+
+---
+
+## Tipps für effektive Nutzung
+
+1. **Zentralisieren Sie Übersetzungen**: Verwenden Sie ein zentrales Modul oder JSON-Dateien zur Verwaltung von Übersetzungen, um die Wartbarkeit zu verbessern.
+2. **Validieren Sie Übersetzungen**: Stellen Sie sicher, dass jede Sprachvariante eine entsprechende Übersetzung hat, um unnötiges Zurückfallen zu vermeiden.
+3. **Kombinieren Sie mit Frontend-i18n**: Synchronisieren Sie mit der Frontend-Internationalisierung für ein nahtloses Benutzererlebnis in der gesamten App.
+4. **Benchmark-Leistung**: Testen Sie die Antwortzeiten Ihrer App beim Hinzufügen von Übersetzungen, um minimale Auswirkungen sicherzustellen.
+
+---
+
+## Fazit
+
+Die `t`-Funktion ist ein leistungsstarkes Werkzeug für die Backend-Internationalisierung. Durch ihre effektive Nutzung können Sie eine inklusivere und benutzerfreundlichere Anwendung für ein globales Publikum erstellen. Für fortgeschrittene Nutzung und detaillierte Konfigurationsoptionen lesen Sie die [Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/configuration.md).

package/de/packages/intlayer/getConfiguration.md

@@ -0,0 +1,120 @@
+# Dokumentation: `getConfiguration` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getConfiguration` ruft die gesamte Konfiguration für die `intlayer`-Anwendung ab, indem sie Umgebungsvariablen extrahiert. Diese Funktion bietet die Flexibilität, dieselbe Konfiguration sowohl auf der Client- als auch auf der Serverseite zu verwenden, um Konsistenz in der gesamten Anwendung zu gewährleisten.
+
+---
+
+## Parameter
+
+Die Funktion nimmt keine Parameter entgegen. Stattdessen verwendet sie Umgebungsvariablen für die Konfiguration.
+
+### Rückgabewerte
+
+- **Typ**: `IntlayerConfig`
+- **Beschreibung**: Ein Objekt, das die vollständige Konfiguration für `intlayer` enthält. Die Konfiguration umfasst die folgenden Abschnitte:
+
+  - `internationalization`: Einstellungen zu Lokalisierungen und dem strikten Modus.
+  - `middleware`: Einstellungen zu URL- und Cookie-Management.
+  - `content`: Einstellungen zu Inhaltsdateien, Verzeichnissen und Mustern.
+  - `editor`: Editor-spezifische Konfigurationen.
+
+Siehe [Intlayer-Konfigurationsdokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/configuration.md) für weitere Details.
+
+---
+
+## Beispielverwendung
+
+### Abrufen der vollständigen Konfiguration
+
+```typescript codeFormat="typescript"
+import { getConfiguration } from "intlayer";
+
+const config = getConfiguration();
+console.log(config);
+// Ausgabe:
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+```javascript codeFormat="esm"
+import { getConfiguration } from "intlayer";
+
+const config = getConfiguration();
+console.log(config);
+// Ausgabe:
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+```javascript codeFormat="commonjs"
+const { getConfiguration } = require("intlayer");
+
+const config = getConfiguration();
+console.log(config);
+// Ausgabe:
+// {
+//   internationalization: { ... },
+//   middleware: { ... },
+//   content: { ... },
+//   editor: { ... }
+// }
+```
+
+### Extrahieren von `availableLocales` und `defaultLocale`
+
+Der Abschnitt `internationalization` der Konfiguration bietet lokalisierungsbezogene Einstellungen wie `locales` (verfügbare Lokalisierungen) und `defaultLocale` (Fallback-Sprache).
+
+```typescript codeFormat="typescript"
+import { getConfiguration } from "intlayer";
+
+const { internationalization, middleware } = getConfiguration();
+const { locales: availableLocales, defaultLocale } = internationalization;
+const { cookieName } = middleware;
+
+console.log(availableLocales); // Ausgabe Beispiel: ["en", "fr", "es"]
+console.log(defaultLocale); // Ausgabe Beispiel: "en"
+console.log(cookieName); // Ausgabe: "INTLAYER_LOCALE"
+```
+
+```javascript codeFormat="esm"
+import { getConfiguration } from "intlayer";
+
+const { internationalization, middleware } = getConfiguration();
+const { locales: availableLocales, defaultLocale } = internationalization;
+const { cookieName } = middleware;
+
+console.log(availableLocales); // Ausgabe Beispiel: ["en", "fr", "es"]
+console.log(defaultLocale); // Ausgabe Beispiel: "en"
+console.log(cookieName); // Ausgabe: "INTLAYER_LOCALE"
+```
+
+```javascript codeFormat="commonjs"
+const { getConfiguration } = require("intlayer");
+
+const { internationalization, middleware } = getConfiguration();
+const { locales: availableLocales, defaultLocale } = internationalization;
+const { cookieName } = middleware;
+
+console.log(availableLocales); // Ausgabe Beispiel: ["en", "fr", "es"]
+console.log(defaultLocale); // Ausgabe Beispiel: "en"
+console.log(cookieName); // Ausgabe: "INTLAYER_LOCALE"
+```
+
+## Hinweise
+
+- Stellen Sie sicher, dass alle erforderlichen Umgebungsvariablen korrekt gesetzt sind, bevor Sie diese Funktion aufrufen. Fehlende Variablen führen zu Fehlern während der Initialisierung.
+- Diese Funktion kann sowohl auf der Client- als auch auf der Serverseite verwendet werden, was sie zu einem vielseitigen Werkzeug für die einheitliche Verwaltung von Konfigurationen macht.
+
+## Verwendung in Anwendungen
+
+Die Funktion `getConfiguration` ist ein grundlegendes Werkzeug zur Initialisierung und Verwaltung der Konfiguration einer `intlayer`-Anwendung. Durch den Zugriff auf Einstellungen wie Lokalisierungen, Middleware und Inhaltsverzeichnisse gewährleistet sie Konsistenz und Skalierbarkeit in mehrsprachigen und inhaltsgesteuerten Anwendungen.

package/de/packages/intlayer/getEnumeration.md

@@ -0,0 +1,140 @@
+# Dokumentation: `getEnumeration` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getEnumeration` ruft Inhalte ab, die einer bestimmten Menge entsprechen, basierend auf vordefinierten Bedingungen in einem Enumerationsobjekt. Die Bedingungen sind als Schlüssel definiert, und ihre Priorität wird durch ihre Reihenfolge im Objekt bestimmt.
+
+## Parameter
+
+- `enumerationContent: QuantityContent<Content>`
+
+  - **Beschreibung**: Ein Objekt, bei dem die Schlüssel Bedingungen darstellen (z. B. `<=`, `<`, `>=`, `=`) und die Werte den entsprechenden Inhalt repräsentieren. Die Reihenfolge der Schlüssel definiert ihre Priorität beim Abgleich.
+  - **Typ**: `QuantityContent<Content>`
+    - `Content` kann jeden Typ haben.
+
+- `quantity: number`
+
+  - **Beschreibung**: Der numerische Wert, der verwendet wird, um mit den Bedingungen in `enumerationContent` abzugleichen.
+  - **Typ**: `number`
+
+## Rückgabewerte
+
+- **Typ**: `Content`
+- **Beschreibung**: Der Inhalt, der der ersten übereinstimmenden Bedingung in `enumerationContent` entspricht. Wenn keine Übereinstimmung gefunden wird, erfolgt die Handhabung basierend auf der Implementierung (z. B. Fehler oder Fallback-Inhalt).
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript codeFormat="typescript"
+import { getEnumeration } from "intlayer";
+
+const content = getEnumeration(
+  {
+    "<=-2.3": "Sie haben weniger als -2.3",
+    "<1": "Sie haben weniger als eins",
+    "2": "Sie haben zwei",
+    ">=3": "Sie haben drei oder mehr",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben zwei"
+```
+
+```javascript codeFormat="esm"
+import { getEnumeration } from "intlayer";
+
+const content = getEnumeration(
+  {
+    "<1": "Sie haben weniger als eins",
+    "2": "Sie haben zwei",
+    ">=3": "Sie haben drei oder mehr",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben zwei"
+```
+
+```javascript codeFormat="commonjs"
+const { getEnumeration } = require("intlayer");
+
+const content = getEnumeration(
+  {
+    "<1": "Sie haben weniger als eins",
+    "2": "Sie haben zwei",
+    ">=3": "Sie haben drei oder mehr",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben zwei"
+```
+
+### Priorität der Bedingungen
+
+```typescript codeFormat="typescript"
+import { getEnumeration } from "intlayer";
+
+const content = getEnumeration(
+  {
+    "<4": "Sie haben weniger als vier",
+    "2": "Sie haben zwei",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben weniger als vier"
+```
+
+```javascript codeFormat="esm"
+import { getEnumeration } from "intlayer";
+
+const content = getEnumeration(
+  {
+    "<4": "Sie haben weniger als vier",
+    "2": "Sie haben zwei",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben weniger als vier"
+```
+
+```javascript codeFormat="commonjs"
+const { getEnumeration } = require("intlayer");
+
+const content = getEnumeration(
+  {
+    "<4": "Sie haben weniger als vier",
+    "2": "Sie haben zwei",
+  },
+  2
+);
+
+console.log(content); // Ausgabe: "Sie haben weniger als vier"
+```
+
+## Randfälle
+
+- **Keine übereinstimmende Bedingung:**
+
+  - Wenn keine Bedingung mit der angegebenen Menge übereinstimmt, gibt die Funktion entweder `undefined` zurück oder behandelt das Standard-/Fallback-Szenario explizit.
+
+- **Mehrdeutige Bedingungen:**
+
+  - Wenn sich Bedingungen überschneiden, hat die erste übereinstimmende Bedingung (basierend auf der Objektreihenfolge) Vorrang.
+
+- **Ungültige Schlüssel:**
+
+  - Die Funktion geht davon aus, dass alle Schlüssel in `enumerationContent` gültig und als Bedingungen interpretierbar sind. Ungültige oder falsch formatierte Schlüssel können zu unerwartetem Verhalten führen.
+
+- **TypeScript-Durchsetzung:**
+  - Die Funktion stellt sicher, dass der `Content`-Typ über alle Schlüssel hinweg konsistent ist, was Typsicherheit für den abgerufenen Inhalt ermöglicht.
+
+## Hinweise
+
+- Das Dienstprogramm `findMatchingCondition` wird verwendet, um die passende Bedingung basierend auf der angegebenen Menge zu bestimmen.
+
+[Zurück zur Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/de/**/*.md)