@intlayer/docs 8.0.0 → 8.0.1-canary.1

package/docs/de/packages/adonis-intlayer/exports.md

@@ -0,0 +1,50 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: adonis-intlayer Paketdokumentation
+description: AdonisJS-Middleware für Intlayer, die Übersetzungsfunktionen und Locale-Erkennung bereitstellt.
+keywords:
+  - adonis-intlayer
+  - adonisjs
+  - middleware
+  - Internationalisierung
+  - i18n
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Initiale Dokumentation
+---
+
+# adonis-intlayer Paket
+
+Das Paket `adonis-intlayer` bietet eine Middleware für AdonisJS-Anwendungen zur Handhabung der Internationalisierung. Es erkennt die Locale des Benutzers und stellt Übersetzungsfunktionen bereit.
+
+## Installation
+
+```bash
+npm install adonis-intlayer
+```
+
+## Exporte
+
+### Middleware
+
+Das Paket bietet eine AdonisJS-Middleware zur Handhabung der Internationalisierung.
+
+| Funktion             | Beschreibung                                                                                                                                                                                                                                                                                                | Zugehörige Dokumentation                                                                                       |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `IntlayerMiddleware` | AdonisJS-Middleware, die die Locale des Benutzers erkennt und den Anfragekontext mit Intlayer-Daten füllt. Sie richtet außerdem einen CLS (Async Local Storage)-Namensraum für den Zugriff auf den Anfrage-Lebenszyklus ein, was die Verwendung globaler Funktionen wie `t`, `getIntlayer` usw. ermöglicht. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/adonis-intlayer/intlayer.md) |
+
+### Funktionen
+
+| Funktion        | Beschreibung                                                                                                                                                                                                                                     | Zugehörige Dokumentation                                                                               |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Übersetzungsfunktion, die Inhalte für die aktuelle Locale abruft. Funktioniert innerhalb des Anfrage-Lebenszyklus, der von der `intlayer`-Middleware verwaltet wird. Verwendet CLS (Async Local Storage), um auf den Anfragekontext zuzugreifen. | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md) |
+| `getIntlayer`   | Ruft ein Wörterbuch anhand seines Schlüssels aus der generierten Deklaration ab und gibt dessen Inhalt für die angegebene Locale zurück. Optimierte Version von `getDictionary`. Verwendet CLS, um auf den Anfragekontext zuzugreifen.           | -                                                                                                      |
+| `getDictionary` | Verarbeitet Wörterbuchobjekte und gibt Inhalte für die angegebene Locale zurück. Verarbeitet `t()`-Übersetzungen, Enumerationen, Markdown, HTML usw. Verwendet CLS, um auf den Anfragekontext zuzugreifen.                                       | -                                                                                                      |
+| `getLocale`     | Ruft die aktuelle Locale über CLS aus dem Anfragekontext ab.                                                                                                                                                                                     | -                                                                                                      |

package/docs/de/packages/adonis-intlayer/intlayer.md

@@ -0,0 +1,54 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: intlayer AdonisJS Middleware Dokumentation | adonis-intlayer
+description: Sehen Sie, wie Sie die intlayer-Middleware für das adonis-intlayer-Paket verwenden
+keywords:
+  - intlayer
+  - adonisjs
+  - middleware
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Initiale Dokumentation
+---
+
+# intlayer AdonisJS Middleware Dokumentation
+
+Die `intlayer`-Middleware für AdonisJS erkennt die Locale des Benutzers und stellt Übersetzungsfunktionen über den Anfragekontext bereit. Sie ermöglicht auch die Verwendung globaler Übersetzungsfunktionen innerhalb des Anfrageflusses.
+
+## Verwendung
+
+```ts fileName="start/kernel.ts"
+router.use([() => import("adonis-intlayer/middleware")]);
+```
+
+```ts fileName="start/routes.ts"
+import router from "@adonisjs/core/services/router";
+import { t } from "adonis-intlayer";
+
+router.get("/", async () => {
+  return t({
+    en: "Hello",
+    fr: "Bonjour",
+  });
+});
+```
+
+## Beschreibung
+
+Die Middleware führt die folgenden Aufgaben aus:
+
+1. **Locale-Erkennung**: Sie analysiert die Anfrage (Header, Cookies usw.), um die bevorzugte Locale des Benutzers zu bestimmen.
+2. **Kontext-Einrichtung**: Sie füllt den Anfragekontext mit Locale-Informationen.
+3. **Async Local Storage**: Sie verwendet `cls-hooked`, um einen asynchronen Kontext zu verwalten, der es globalen Intlayer-Funktionen wie `t`, `getIntlayer` und `getDictionary` ermöglicht, auf die anfragespezifische Locale zuzugreifen, ohne sie manuell übergeben zu müssen.
+
+> Hinweis: Um Cookies für die Locale-Erkennung zu verwenden, stellen Sie sicher, dass `@adonisjs/cookie` konfiguriert ist und in Ihrer Anwendung verwendet wird.

package/docs/de/packages/adonis-intlayer/t.md

@@ -0,0 +1,149 @@
+---
+createdAt: 2026-01-30
+updatedAt: 2026-01-30
+title: t-Funktion Dokumentation | adonis-intlayer
+description: Sehen Sie, wie Sie die t-Funktion für das adonis-intlayer-Paket verwenden
+keywords:
+  - t
+  - Übersetzung
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+  - AdonisJS
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - adonis-intlayer
+  - t
+history:
+  - version: 8.0.0
+    date: 2026-01-30
+    changes: Initiale Dokumentation
+---
+
+# Dokumentation: `t`-Funktion in `adonis-intlayer`
+
+Die `t`-Funktion im Paket `adonis-intlayer` ist das Kernwerkzeug zur Bereitstellung lokalisierter Antworten in Ihrer AdonisJS-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 einen bestimmten Satz von Sprachen zu definieren und abzurufen. Sie bestimmt automatisch die geeignete Sprache für die Rückgabe basierend auf den Anfrageeinstellungen des Clients, wie dem `Accept-Language`-Header. Wenn die bevorzugte Sprache nicht verfügbar ist, fällt sie elegant auf die in Ihrer Konfiguration angegebene Standard-Locale zurück.
+
+---
+
+## Hauptmerkmale
+
+- **Dynamische Lokalisierung**: Wählt automatisch die am besten geeignete Übersetzung für den Client aus.
+- **Fallback auf Standard-Locale**: Fällt auf eine Standard-Locale zurück, wenn die bevorzugte Sprache des Clients nicht verfügbar ist, um die Kontinuität des Benutzererlebnisses zu gewährleisten.
+- **Asynchroner Kontext**: Arbeitet nahtlos innerhalb des AdonisJS-Anfrage-Lebenszyklus unter Verwendung von Async Local Storage.
+- **TypeScript-Unterstützung**: Erzwingen Sie Typsicherheit für Ihre Übersetzungen.
+
+---
+
+## Funktionssignatur
+
+```typescript
+t(translations: Record<string, any>): any;
+```
+
+### Parameter
+
+- `translations`: Ein Objekt, bei dem die Schlüssel Locale-Codes sind (z. B. `en`, `fr`, `es`) und die Werte die entsprechenden übersetzten Inhalte.
+
+### Rückgabewerte
+
+- Der Inhalt, der die bevorzugte Sprache des Clients repräsentiert.
+
+---
+
+## Laden der Middleware
+
+Um sicherzustellen, dass die `t`-Funktion korrekt funktioniert, **müssen** Sie die `intlayer`-Middleware in Ihrer AdonisJS-Anwendung registrieren.
+
+```typescript fileName="start/kernel.ts"
+router.use([() => import("adonis-intlayer/middleware")]);
+```
+
+---
+
+## Anwendungsbeispiele
+
+### Basispiel
+
+```typescript fileName="start/routes.ts"
+import router from "@adonisjs/core/services/router";
+import { t } from "adonis-intlayer";
+
+router.get("/", async () => {
+  return t({
+    en: "Welcome!",
+    fr: "Bienvenue !",
+    es: "¡Bienvenido!",
+  });
+});
+```
+
+### Verwendung in Controllern
+
+```typescript fileName="app/controllers/example_controller.ts"
+import type { HttpContext } from "@adonisjs/core/http";
+import { t } from "adonis-intlayer";
+
+export default class ExampleController {
+  async index({ response }: HttpContext) {
+    return response.send(
+      t({
+        en: "Hello from controller",
+        fr: "Bonjour vom Controller",
+      })
+    );
+  }
+}
+```
+
+---
+
+## Fortgeschrittene Themen
+
+### Fallback-Mechanismus
+
+Wenn eine bevorzugte Locale nicht verfügbar ist, fällt die `t`-Funktion auf die in Ihrer `intlayer.config.ts` definierte Standard-Locale zurück.
+
+```typescript
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [
+      Locales.ENGLISH,
+      Locales.RUSSIAN,
+      Locales.JAPANESE,
+      Locales.FRENCH,
+      Locales.KOREAN,
+      Locales.CHINESE,
+      Locales.SPANISH,
+      Locales.GERMAN,
+      Locales.ARABIC,
+      Locales.ITALIAN,
+      Locales.ENGLISH_UNITED_KINGDOM,
+      Locales.PORTUGUESE,
+      Locales.HINDI,
+      Locales.TURKISH,
+      Locales.POLISH,
+      Locales.INDONESIAN,
+      Locales.VIETNAMESE,
+      Locales.UKRAINIAN,
+    ],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+### TypeScript-Integration
+
+Die `t`-Funktion ist typsicher, wenn sie mit definierten Wörterbüchern verwendet wird. Weitere Details finden Sie in der [TypeScript-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md).

package/docs/de/packages/hono-intlayer/exports.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: hono-intlayer Paketdokumentation
+description: Hono-Middleware für Intlayer, die Übersetzungsfunktionen und Spracherkennung bietet.
+keywords:
+  - hono-intlayer
+  - hono
+  - middleware
+  - Internationalisierung
+  - i18n
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - exports
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Vereinheitlichte Dokumentation für alle Exporte
+---
+
+# hono-intlayer Paket
+
+Das Paket `hono-intlayer` bietet eine Middleware für Hono-Anwendungen zur Handhabung der Internationalisierung. Sie erkennt die Sprache des Benutzers und füllt das Kontextobjekt.
+
+## Installation
+
+```bash
+npm install hono-intlayer
+```
+
+## Exporte
+
+### Middleware
+
+Importieren:
+
+```tsx
+import { intlayer } from "hono-intlayer";
+```
+
+| Funktion   | Beschreibung                                                                                                                                                                                                                                                                                            | Verwandte Doc                                                                                                |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `intlayer` | Hono-Middleware, die Intlayer in Ihre Hono-Anwendung integriert. Handhabt die Spracherkennung aus dem Speicher (Cookies, Header), füllt den Kontext mit `t`, `getIntlayer` und `getDictionary` und richtet den CLS-Namespace für den programmatischen Zugriff während des Anforderungslebenszyklus ein. | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/hono-intlayer/intlayer.md) |
+
+### Funktionen
+
+Importieren:
+
+```tsx
+import { t, getIntlayer, getDictionary } from "hono-intlayer";
+```
+
+| Funktion        | Beschreibung                                                                                                                                                                                                                                                                               | Verwandte Doc                                                                                          |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
+| `t`             | Globale Übersetzungsfunktion, die Inhalte für die aktuelle Sprache in Hono abruft. Nutzt CLS (Async Local Storage) und muss innerhalb eines durch die `intlayer`-Middleware verwalteten Anforderungskontexts verwendet werden. Kann auch über den Kontext aufgerufen werden.               | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md) |
+| `getIntlayer`   | Ruft ein Wörterbuch anhand seines Schlüssels aus der generierten Deklaration ab und gibt dessen Inhalt für die angegebene Sprache zurück. Optimierte Version von `getDictionary`. Verwendet CLS für den Zugriff auf den Anforderungskontext. Kann auch über den Kontext aufgerufen werden. | -                                                                                                      |
+| `getDictionary` | Verarbeitet Wörterbuchobjekte und gibt Inhalte für die angegebene Sprache zurück. Verarbeitet `t()`-Übersetzungen, Aufzählungen, Markdown, HTML usw. Verwendet CLS für den Zugriff auf den Anforderungskontext. Kann auch über den Kontext aufgerufen werden.                              | -                                                                                                      |

package/docs/de/packages/hono-intlayer/intlayer.md

@@ -0,0 +1,59 @@
+---
+createdAt: 2026-01-29
+updatedAt: 2026-01-29
+title: intlayer Hono Middleware Dokumentation | hono-intlayer
+description: Sehen Sie, wie Sie die intlayer-Middleware für das hono-intlayer-Paket verwenden
+keywords:
+  - intlayer
+  - hono
+  - middleware
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - intlayer
+history:
+  - version: 8.0.0
+    date: 2026-01-29
+    changes: Dokumentation initialisiert
+---
+
+# intlayer Hono Middleware Dokumentation
+
+Die `intlayer`-Middleware für Hono erkennt das Locale des Benutzers und füllt das Kontextobjekt mit Intlayer-Funktionen. Sie ermöglicht auch die Verwendung globaler Übersetzungsfunktionen innerhalb des Anforderungskontexts.
+
+## Verwendung
+
+```ts
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+app.use("*", intlayer());
+
+app.get("/", async (c) => {
+  const t = c.get("t");
+  const content = t({
+    en: "Hello",
+    fr: "Bonjour",
+  });
+
+  return c.text(content);
+});
+```
+
+## Beschreibung
+
+Die Middleware führt die folgenden Aufgaben aus:
+
+1. **Locale-Erkennung**: Sie analysiert die Anfrage (Header, Cookies usw.), um das bevorzugte Locale des Benutzers zu bestimmen.
+2. **Kontext-Population**: Sie fügt Intlayer-Daten zum Hono-Kontext hinzu, auf die über `c.get()` zugegriffen werden kann. Dies beinhaltet:
+   - `locale`: Das erkannte Locale.
+   - `t`: Eine Übersetzungsfunktion.
+   - `getIntlayer`: Eine Funktion zum Abrufen von Wörterbüchern.
+   - `getDictionary`: Eine Funktion zum Verarbeiten von Wörterbuchobjekten.
+3. **Kontext-Management**: Sie verwendet `cls-hooked`, um einen asynchronen Kontext zu verwalten, der es globalen Intlayer-Funktionen (`t`, `getIntlayer`, `getDictionary`) ermöglicht, auf das anforderungsspezifische Locale zuzugreifen, ohne das Kontextobjekt zu übergeben.

package/docs/de/packages/hono-intlayer/t.md

@@ -0,0 +1,316 @@
+---
+createdAt: 2024-12-02
+updatedAt: 2025-06-29
+title: t-Funktionsdokumentation | hono-intlayer
+description: Sehen Sie, wie Sie die t-Funktion für das hono-intlayer-Paket verwenden
+keywords:
+  - t
+  - Übersetzung
+  - Intlayer
+  - Internationalisierung
+  - Dokumentation
+  - Hono
+  - JavaScript
+slugs:
+  - doc
+  - packages
+  - hono-intlayer
+  - t
+history:
+  - version: 5.5.10
+    date: 2025-06-29
+    changes: Verlauf initialisiert
+---
+
+# Dokumentation: `t`-Funktion in `hono-intlayer`
+
+Die `t`-Funktion im Paket `hono-intlayer` ist das zentrale Werkzeug zur Bereitstellung lokalisierter Antworten in Ihrer Hono-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 einen bestimmten Satz von Sprachen zu definieren und abzurufen. Sie bestimmt automatisch die passende Sprache, die zurückgegeben werden soll, basierend auf den Anfrageeinstellungen des Clients, wie dem `Accept-Language`-Header. Wenn die bevorzugte Sprache nicht verfügbar ist, fällt sie elegant auf die in Ihrer Konfiguration angegebene Standardsprache zurück.
+
+---
+
+## Hauptmerkmale
+
+- **Dynamische Lokalisierung**: Wählt automatisch die am besten geeignete Übersetzung für den Client aus.
+- **Fallback zur Standardsprache**: Fällt auf eine Standardsprache zurück, wenn die bevorzugte Sprache des Clients nicht verfügbar ist, um die Kontinuität der Benutzererfahrung zu gewährleisten.
+- **Leichtgewichtig und schnell**: Entwickelt für Hochleistungsanwendungen, um minimalen Overhead zu gewährleisten.
+- **Unterstützung des strikten Modus**: Erzwingt die strikte Einhaltung deklarierter Locales für ein zuverlässiges Verhalten.
+
+---
+
+## Funktionssignatur
+
+```typescript
+t(translations: Record<string, string>): string;
+```
+
+### Parameter
+
+- `translations`: Ein Objekt, bei dem die Schlüssel Locale-Codes (z. B. `en`, `fr`, `es-MX`) und die Werte die entsprechenden übersetzten Zeichenfolgen sind.
+
+### Rückgabewert
+
+- Eine Zeichenfolge, die den Inhalt in der bevorzugten Sprache des Clients darstellt.
+
+---
+
+## Laden des Internationalisierungs-Request-Handlers
+
+Um sicherzustellen, dass die von `hono-intlayer` bereitgestellte Internationalisierungsfunktionalität ordnungsgemäß funktioniert, **müssen** Sie die Internationalisierungs-Middleware zu Beginn Ihrer Hono-Anwendung laden. Dies aktiviert die `t`-Funktion und gewährleistet eine ordnungsgemäße Handhabung der Locale-Erkennung und Übersetzung.
+
+Platzieren Sie die `app.use("*", intlayer())`-Middleware **vor allen Routen** in Ihrer Anwendung, um sicherzustellen, dass alle Routen von der Internationalisierung profitieren:
+
+```typescript {6} fileName="src/index.ts" codeFormat="typescript"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Internationalisierungs-Request-Handler laden
+app.use("*", intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.mjs" codeFormat="esm"
+import { Hono } from "hono";
+import { intlayer } from "hono-intlayer";
+
+const app = new Hono();
+
+// Internationalisierungs-Request-Handler laden
+app.use("*", intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+```javascript {6} fileName="src/index.cjs" codeFormat="commonjs"
+const { Hono } = require("hono");
+const { intlayer, t } = require("hono-intlayer");
+
+const app = new Hono();
+
+// Internationalisierungs-Request-Handler laden
+app.use("*", intlayer());
+
+// Definieren Sie Ihre Routen nach dem Laden der Middleware
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Hello, World!",
+      fr: "Bonjour le monde!",
+      es: "¡Hola, Mundo!",
+    })
+  );
+});
+```
+
+### Warum dies erforderlich ist
+
+- **Locale-Erkennung**: Die `intlayer`-Middleware verarbeitet eingehende Anfragen, um das bevorzugte Locale des Benutzers basierend auf Headern, Cookies oder anderen konfigurierten Methoden zu erkennen.
+- **Übersetzungskontext**: Richtet den erforderlichen Kontext ein, damit die `t`-Funktion ordnungsgemäß funktioniert und sichergestellt wird, dass Übersetzungen in der richtigen Sprache zurückgegeben werden.
+- **Fehlervermeidung**: Ohne diese Middleware führt die Verwendung der `t`-Funktion zu Laufzeitfehlern, da die erforderlichen Locale-Informationen nicht verfügbar sind.
+
+---
+
+## Nutzungsbeispiele
+
+### Basispiel
+
+Lokalisierte Inhalte in verschiedenen Sprachen bereitstellen:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/", (c) => {
+  return c.text(
+    t({
+      en: "Welcome!",
+      fr: "Bienvenue!",
+      es: "¡Bienvenido!",
+    })
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/", (c) => {
+  return c.text(
+    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!` (Standard-Locale).
+
+### Fehlerbehandlung
+
+Fehlermeldungen in mehreren Sprachen bereitstellen:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+```javascript fileName="src/index.mjs" codeFormat="esm"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+```javascript fileName="src/index.cjs" codeFormat="commonjs"
+app.get("/error", (c) => {
+  return c.text(
+    t({
+      en: "An unexpected error occurred.",
+      fr: "Une erreur inattendue s'est produite.",
+      es: "Ocurrió un error inesperado.",
+    }),
+    500
+  );
+});
+```
+
+---
+
+### Verwendung von Locale-Varianten
+
+Spezifizieren Sie Übersetzungen für länderspezifische Varianten:
+
+```typescript fileName="src/index.ts" codeFormat="typescript"
+app.get("/greet", (c) => {
+  return c.text(
+    t({
+      en: "Hello!",
+      "en-GB": "Hello, mate!",
+      fr: "Bonjour!",
+      "es-MX": "¡Hola, amigo!",
+      "es-ES": "¡Hola!",
+    })
+  );
+});
+```
+
+---
+
+## Fortgeschrittene Themen
+
+### Fallback-Mechanismus
+
+Wenn ein bevorzugtes Locale nicht verfügbar ist, fällt die `t`-Funktion auf das in der Konfiguration definierte Standard-Locale 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;
+```
+
+---
+
+### Erzwingen des strikten Modus
+
+Konfigurieren Sie die `t`-Funktion so, dass die strikte Einhaltung deklarierter Locales erzwungen wird:
+
+| Modus       | Verhalten                                                                                                     |
+| ----------- | ------------------------------------------------------------------------------------------------------------- |
+| `strict`    | Alle deklarierten Locales müssen Übersetzungen bereitstellen. Fehlende Locales führen zu Fehlern.             |
+| `inclusive` | Deklarierte Locales müssen Übersetzungen haben. Fehlende Locales lösen Warnungen aus, werden aber akzeptiert. |
+| `loose`     | Jedes vorhandene Locale wird akzeptiert, auch wenn es nicht deklariert ist.                                   |
+
+---
+
+### 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 "hono-intlayer";
+
+const translations: LanguageContent<string> = {
+  en: "Good morning!",
+  fr: "Bonjour!",
+  es: "¡Buenos días!",
+};
+
+app.get("/morning", (c) => {
+  return c.text(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 wird. |
+| Fehler bei fehlenden Übersetzungen | Strikter Modus ohne alle Locales aktiviert | Stellen Sie alle erforderlichen Übersetzungen bereit.                                |
+
+---
+
+## Fazit
+
+Die `t`-Funktion ist ein leistungsstarkes Werkzeug für die Backend-Internationalisierung. Durch ihren effektiven Einsatz können Sie eine inklusivere und benutzerfreundlichere Anwendung für ein globales Publikum erstellen. Weitere Informationen zur fortgeschrittenen Nutzung und detaillierte Konfigurationsoptionen finden Sie in der [Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/en/configuration.md).