@intlayer/docs 9.3.3 → 9.4.0

package/docs/de/packages/intlayer/getIntlayer.md

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayer Function Documentation | intlayer
+description: Siehe, wie du die getIntlayer-Funktion für das intlayer-Paket verwendest
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getIntlayer` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getIntlayer` wählt ein Wörterbuch nach seinem Schlüssel aus und gibt seinen Inhalt interpretiert für ein bestimmtes Gebietsschema zurück. Sie ist das Framework-agnostische Äquivalent des Hooks `useIntlayer`: derselbe Inhalt, dieselben Selektoren, aber überall dort einsetzbar, wo ein React Context nicht verfügbar ist — Node-Skripte, Server-Funktionen, Route Loader, Metadata-Builder, Express/Fastify-Handler, Tests.
+
+Sie liest die von Intlayer in `.intlayer/` generierten Wörterbücher, sodass das Argument `key` typisiert und automatisch aus deinen eigenen Content-Deklarationen vervollständigt wird, und das zurückgegebene Objekt ist vollständig typisiert bis auf jedes Blatt.
+
+**Hauptfunktionen:**
+
+- Typisierte Wörterbuch-Schlüssel und typisierter zurückgegebener Inhalt
+- Interpretiert jeden Content-Knoten (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- Akzeptiert ein Gebietsschema oder ein Selector-Objekt (Collections, Varianten)
+- Ergebnisse werden pro `key + locale + selector` im Speicher gespeichert
+- Fällt in der Entwicklung auf einen sicheren Proxy zurück, wenn ein Wörterbuch fehlt, anstatt zu crashen
+
+---
+
+## Funktionssignatur
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                         // Optional
+): DeepTransformContent<...>
+```
+
+---
+
+## Parameter
+
+- `key: DictionaryKeys`
+  - **Description**: Der Schlüssel des zu lesenden Wörterbuchs, wie in deinen Content-Dateien deklariert.
+  - **Type**: `DictionaryKeys` — eine Vereinigung aller deklarierten Wörterbuchschlüssel.
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: Das Locale zur Interpretation des Inhalts oder ein Selector-Objekt für [dynamische Wörterbücher](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+    - `'fr'` — ein Locale
+    - `{ item: 2 }` — ein [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md) Element (omit `item` um alle Elemente als Array zu erhalten)
+    - `{ variant: 'black-friday' }` — eine benannte [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md) (omit für die `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — eine strukturierte Variante
+    - Jeder Selector kann ein Locale enthalten: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — defaults to the configured `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Description**: Custom Node Transformer, die die Basis-Interpreter-Plugins ersetzen. Nur für fortgeschrittene Verwendung; omit it to keep the default behaviour.
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Rückgabewert
+
+- **Type**: Der interpretierte Inhalt des Wörterbuchs, typisiert aus Ihrer Deklaration.
+- **Description**: Ein einfaches Objekt, das das `content`-Feld Ihres Wörterbuchs widerspiegelt, wobei jeder Intlayer-Knoten auf seinen Endwert für das angeforderte Locale aufgelöst wurde.
+
+---
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      de: "Hallo",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "de"); // "Hallo"
+```
+
+### Ohne Locale
+
+Das Weglassen der Locale interpretiert den Inhalt mit dem `defaultLocale`, der in Ihrer [Konfiguration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/configuration.md) deklariert ist.
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Interpretiert mit der Standard-Locale
+```
+
+### Inside a server handler
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### Mit einem Selector (Collections und Varianten)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// Ein einzelnes Collection-Element
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// Alle Elemente der Collection als sortiertes Array
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// Eine benannte Variante
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## Verhaltenshinweise
+
+### Caching
+
+Ergebnisse werden in einem Cache auf Modulebene zwischengespeichert, dessen Schlüssel `key + locale + selector` ist. Das wiederholte Aufrufen von `getIntlayer("app", "fr")` interpretiert das Dictionary einmal und gibt danach immer dasselbe Objekt zurück.
+
+### Fehlende Wörterbücher
+
+Beim Anfordern eines Schlüssels, der kein generiertes Wörterbuch hat, protokolliert die Entwicklung eine Warnung einmal und gibt einen sicheren Fallback-Proxy zurück: Das Lesen von `content.title` ergibt die Zeichenkette `"app.title"` anstatt einen Fehler auszulösen. Dies hält eine Seite nutzbar, während die fehlende Deklaration behoben wird. Führen Sie den Intlayer-Build (oder den Dev-Server) aus, damit das Wörterbuch generiert wird.
+
+### Bundle-Größe
+
+`getIntlayer` liest das zusammengeführte Wörterbuch, das **jedes** Locale enthält. In Client-Bundles schreiben die [Build-Plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) den Aufruf um, sodass nur der erforderliche Inhalt ausgeliefert wird. Wenn Sie Inhalte außerhalb des Rendering lesen (Metadaten, Loaders, Server-Funktionen) und ein einzelnes Locale bei Bedarf laden möchten, verwenden Sie stattdessen [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md).
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayerAsync.md): Asynchrones Äquivalent, das einen einzelnen Locale-Chunk lädt.
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionary.md): Interpretiert ein Wörterbuch-Objekt, das Sie selbst übergeben, anstatt eines, das nach Schlüssel nachgeschlagen wird.
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/react-intlayer/useIntlayer.md): Das React-Hook-Äquivalent, das das Locale vom Provider liest.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

package/docs/de/packages/intlayer/getIntlayerAsync.md

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayerAsync Function Documentation | intlayer
+description: See how to use the getIntlayerAsync function for intlayer package
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Dokumentation: `getIntlayerAsync` Funktion in `intlayer`
+
+## Beschreibung
+
+Die Funktion `getIntlayerAsync` wählt ein Dictionary nach seinem Schlüssel aus und löst seinen Inhalt für ein bestimmtes Locale auf, **wobei nur dieses Locale geladen wird**.
+
+Es ist das asynchrone Gegenstück zu [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md), gedacht für Stellen, an denen ein Dictionary außerhalb des Rendering gelesen wird — Route `head` / Metadata Builder, Loader, Server Functions.
+
+Während `getIntlayer` das zusammengeführte Dictionary mit jedem Locale einzieht, schreiben die [Build Plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) diesen Aufruf in `getDictionaryAsync(loaderMap, key, locale)` um und verweisen auf die Locale-spezifischen Chunks in `.intlayer/dynamic_dictionaries/`. Das Bundle enthält daher nur noch das tatsächlich angeforderte Locale.
+
+Ohne diese Plugins — ein nicht optimierter Build — wird der Aufruf stattdessen durch die synchrone Dictionary Registry aufgelöst: derselbe Inhalt, aber ohne die Locale-spezifische Aufteilung.
+
+**Wichtigste Funktionen:**
+
+- Gleiche typisierte Schlüssel, Selektoren und zurückgegebener Inhalt wie `getIntlayer`
+- Lädt in optimierten Builds nur den angeforderten Locale-Chunk
+- Gleichzeitige Aufrufe für denselben Chunk teilen sich einen einzelnen Load
+- Sicher zu verwenden in `async` Metadata Buildern, Loadern und Server Functions
+
+---
+
+## Funktionssignatur
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // Erforderlich
+  localeOrSelector?: LocalesValues | DictionarySelector, // Optional
+  plugins?: Plugins[]                         // Optional
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## Parameter
+
+- `key: DictionaryKeys`
+  - **Beschreibung**: Der Schlüssel des zu lesenden Wörterbuchs, wie in deinen Content-Dateien deklariert.
+  - **Typ**: `DictionaryKeys` — eine Union aller deklarierten Wörterbuchschlüssel.
+  - **Erforderlich**: Ja
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Beschreibung**: Die Locale zur Interpretation des Inhalts oder ein Selector-Objekt für [dynamische Wörterbücher](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/index.md).
+    - `'fr'` — eine Locale
+    - `{ item: 2 }` — ein [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/collections.md)-Element (omit `item` um jedes Element als Array zu erhalten)
+    - `{ variant: 'black-friday' }` — eine benannte [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dynamic_dictionaries/variants.md) (omit für die `default`)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — eine strukturierte Variante
+    - Jeder Selector kann eine Locale tragen: `{ item: 2, locale: 'fr' }`
+  - **Typ**: `LocalesValues | DictionarySelector`
+  - **Erforderlich**: Nein (Optional) — standardmäßig auf die konfigurierte `defaultLocale`.
+
+- `plugins: Plugins[]`
+  - **Beschreibung**: Benutzerdefinierte Node-Transformer, die die Standard-Interpreter-Plugins ersetzen. Nur für fortgeschrittene Verwendung.
+  - **Typ**: `Plugins[]`
+  - **Erforderlich**: Nein (Optional)
+
+### Rückgabewert
+
+- **Type**: `Promise<Content>` — ein Promise, das sich zum interpretierten Inhalt des Wörterbuchs auflöst, typisiert aus Ihrer Deklaration.
+
+---
+
+## Beispielverwendung
+
+### Grundlegende Verwendung
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                    | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                          |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
+| Returns            | Der Inhalt                                                                                                      | Ein Promise des Inhalts                                     |
+| Dictionary loaded  | Das zusammengeführte Wörterbuch (alle Locales)                                                                  | Das Chunk der angeforderten Locale nur                      |
+| Best suited for    | Rendering, synchrone Code-Pfade                                                                                 | Metadaten, Loader, Server-Funktionen                        |
+| Requires a plugin? | Nein                                                                                                            | Nein — die Per-Locale-Aufteilung benötigt die Build-Plugins |
+
+Beide akzeptieren die gleichen Argumente und geben den gleichen Inhalt zurück: Der Wechsel von einem zum anderen ändert nur **wann** und **wie viel** geladen wird.
+
+---
+
+## Verwandte Funktionen
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getIntlayer.md): Synchrones Äquivalent, das das zusammengeführte Dictionary liest.
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getDictionaryAsync.md): Die Low-Level-Funktion, die die Build-Plugins in diesen Aufruf umschreiben.
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocale.md): Erkennt das Locale einer eingehenden Anfrage.
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

package/docs/de/packages/intlayer/getLocalizedPath.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 Die Funktion `getLocalizedPath` wandelt einen kanonischen Pfad (interner Anwendungs-Pfad) in sein lokalisiertes Äquivalent um, basierend auf der angegebenen Locale und den Rewrite-Regeln. Sie ist besonders nützlich, um SEO-freundliche URLs zu erzeugen, die je nach Sprache variieren.
 
+Es ist das relative Gegenstück zu [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocalizedUrl.md) — für eine relative Eingabe geben beide den gleichen Wert zurück. Im Gegensatz zu `getLocalizedUrl` gibt es niemals eine absolute URL zurück: die `domains`-Konfiguration wird ignoriert, daher ergibt eine Locale, die von ihrer eigenen Domain bedient wird, immer noch einen Pfad. Eine absolute Eingabe wird akzeptiert, aber ihr Ursprung wird verworfen — nur ihr Pfad, Query String und Hash werden beibehalten.
+
 **Wesentliche Merkmale:**
 
 - Unterstützt dynamische Routenparameter mithilfe der `[param]`-Syntax.
@@ -60,13 +62,17 @@ getLocalizedPath(
   - **Typ**: `string`
   - **Erforderlich**: Ja
 
-- `locale: Locales`
-  - **Beschreibung**: Die Ziel-Locale, für die der Pfad lokalisiert werden soll.
-  - **Typ**: `Locales`
-  - **Erforderlich**: Ja
-
 ### Optionale Parameter
 
+- `locale?: Locales`
+  - **Description**: The target locale for which the path should be localized.
+  - **Type**: `Locales`
+  - **Default**: The default locale of your project's configuration.
+
+- `options?: object`
+  - **Description**: Routing-Überschreibungen. Jeder Eintrag verwendet standardmäßig die Konfiguration Ihres Projekts.
+  - **Type**: `object`
+
 - `rewriteRules?: RoutingConfig['rewrite']`
   - **Beschreibung**: Ein Objekt, das benutzerdefinierte Rewrite-Regeln definiert. Wenn nicht angegeben, wird standardmäßig die Eigenschaft `routing.rewrite` aus der Konfiguration Ihres Projekts verwendet.
   - **Typ**: `RoutingConfig['rewrite']`
@@ -79,6 +85,28 @@ getLocalizedPath(
 - **Typ**: `string`
 - **Beschreibung**: Der lokalisierte Pfad für die angegebene Locale.
 
+Der Typ wird durch die in Ihrer Konfiguration deklarierten Rewrite-Regeln eingegrenzt, sodass der Editor den aufgelösten Pfad statt eines einfachen `string` anzeigt:
+
+```typescript codeFormat="typescript"
+// Konfiguration: Modus 'prefix-no-default', defaultLocale 'en',
+//                { '/about': { fr: '/a-propos' }, '/product/[id]': { fr: '/produit/[id]' } }
+const about = getLocalizedPath("/about", Locales.FRENCH);
+//    ^? '/fr/a-propos'
+const product = getLocalizedPath("/product/123", Locales.FRENCH);
+//    ^? '/fr/produit/123'
+const contact = getLocalizedPath("/contact", Locales.FRENCH);
+//    ^? '/fr/contact'  (keine Umschreiberregel passt, nur das Präfix wird angewendet)
+const home = getLocalizedPath("/", Locales.FRENCH);
+//    ^? '/fr'
+```
+
+Die gleiche Eingrenzung fließt in [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/packages/intlayer/getLocalizedUrl.md), die die Rewrite-Regeln anwendet, bevor das Locale-Präfix hinzugefügt wird.
+
+Zwei Fälle bleiben zu `string` verbreitert, da sie zur Compile-Zeit nicht aufgelöst werden können:
+
+- ein Pfad, der kein String-Literal ist (z. B. einer, der aus einer Variablen erstellt wird);
+- ein Pfad, der einer Regel mit einem Multi-Segment- oder optionalen Parameter entspricht (`[...slug]`, `[[...slug]]`, `:param?`).
+
 ---
 
 ## Beispielverwendung
@@ -126,6 +154,18 @@ getLocalizedPath("/contact", Locales.FRENCH, manualRules);
 // Ausgabe: "/contactez-nous"
 ```
 
+### Weglassen des Locales
+
+Wenn kein Locale angegeben ist, wird der Pfad für das konfigurierte Standard-Locale lokalisiert:
+
+```typescript codeFormat="typescript"
+import { getLocalizedPath } from "intlayer";
+
+// Konfiguration: defaultLocale = Locales.ENGLISH, { '/about': { en: '/about', fr: '/a-propos' } }
+getLocalizedPath("/about");
+// Ausgabe: "/about"
+```
+
 ---
 
 ## Verwandte Funktionen

package/docs/de/packages/intlayer/getLocalizedUrl.md

@@ -143,36 +143,6 @@ getLocalizedUrl(
 // Ausgabe: "/about" für das Standard-Locale (Englisch)
 ```
 
-```javascript codeFormat="esm"
-import { getLocalizedUrl, Locales } from "intlayer";
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Ausgabe: "/fr/about" für das französische Locale
-// Ausgabe: "/about" für das Standard-Locale (Englisch)
-```
-
-```javascript codeFormat="commonjs"
-const { getLocalizedUrl, Locales } = require("intlayer");
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// Ausgabe: "/fr/about" für das französische Locale
-// Ausgabe: "/about" für das Standard-Locale (Englisch)
-```
-
 ### Partielle Konfigurationsüberschreibung
 
 Sie können auch nur einige der optionalen Parameter bereitstellen. Die Funktion verwendet Ihre Projektkonfiguration für alle Parameter, die Sie nicht angeben:
@@ -249,6 +219,12 @@ getLocalizedUrl(
 - **Nicht unterstützte Locales:**
   - Für Locales, die nicht in `locales` aufgeführt sind, wird kein Präfix angewendet.
 
+- **Routing-Modi:**
+  - `'prefix-no-default'`: Standardgebietsschema hat kein Präfix, andere haben eines (z. B. `/about`, `/fr/about`)
+  - `'prefix-all'`: Alle Gebietsschemata haben Präfixe (z. B. `/en/about`, `/fr/about`)
+  - `'no-prefix'`: Keine Gebietsschema-Präfixe in URLs (Gebietsschema wird anderswo behandelt)
+  - `'search-params'`: Gebietsschema wird über Abfrageparameter angegeben (z. B. `/about?locale=fr`)
+
 ---
 
 ## Verwendung in Anwendungen

package/docs/de/packages/intlayer/getMultilingualUrls.md

@@ -138,8 +138,6 @@ getMultilingualUrls(
 // }
 ```
 
----
-
 ### Verschiedene Routing-Modi
 
 ```typescript
@@ -205,6 +203,12 @@ getMultilingualUrls("/dashboard", {
 - **Nicht unterstützte Sprachen:**
   - Es werden nur die Sprachen berücksichtigt, die im `locales`-Array angegeben sind, um die URLs zu generieren.
 
+- **Routing-Modi:**
+  - `'prefix-no-default'`: Standardlokalität hat kein Präfix, andere haben eins (z. B. `/dashboard`, `/fr/dashboard`)
+  - `'prefix-all'`: Alle Lokalitäten haben Präfixe (z. B. `/en/dashboard`, `/fr/dashboard`)
+  - `'no-prefix'`: Keine Lokalpräfixe in URLs (alle Lokalitäten geben die gleiche URL zurück)
+  - `'search-params'`: Lokalität wird über Abfrageparameter angegeben (z. B. `/dashboard?locale=fr`)
+
 ---
 
 ## Verwendung in Anwendungen

package/docs/de/packages/intlayer/getTranslation.md

@@ -31,6 +31,8 @@ author: aymericzip
 
 Die Funktion `getTranslationContent` ruft den Inhalt ab, der einer bestimmten Locale aus einem Satz anpassbarer Sprachinhalte entspricht. Wenn die angegebene Locale nicht gefunden wird, gibt sie standardmäßig den Inhalt der im Projekt konfigurierten Standard-Locale zurück.
 
+Für weitere Details zur Deklaration von Übersetzungen siehe die [Translation-Dokumentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md).
+
 ## Parameter
 
 - `languageContent: CustomizableLanguageContent<Content>`

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

@@ -158,6 +158,23 @@ In `next-intlayer` wird die aktuelle Locale über Kontext-Provider verwaltet: `I
 
 #### Beispiel:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx codeFormat={["typescript", "esm", "commonjs"]}
+import type { FC, ReactNode } from "react";
+import type { Locales } from "intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const Page: FC<{ locale: Locales; children: ReactNode }> = ({
+  locale,
+  children,
+}) => <IntlayerProvider locale={locale}>{children}</IntlayerProvider>;
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx codeFormat={["typescript", "esm", "commonjs"]}
 import type { FC } from "react";
 import type { Locales } from "intlayer";
@@ -173,6 +190,9 @@ const Page: FC<{ locale: Locales }> = ({ locale }) => (
 );
 ```
 
+</Tab>
+</Tabs>
+
 ---
 
 ## Häufige Fehler und Problemlösungen

package/docs/de/packages/next-intlayer/useIntlayer.md

@@ -79,6 +79,34 @@ Anleitungen zum Einrichten von Inhaltsdeklarationsdateien finden Sie [hier](http
 
 So können Sie den `useIntlayer`-Hook in einer Next.js-Seite implementieren, um lokalisierten Inhalt dynamisch basierend auf der aktuellen Anwendungslocale zu laden:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
+import { ClientComponentExample } from "@components/ClientComponentExample";
+import { ServerComponentExample } from "@components/ServerComponentExample";
+import { type NextPageIntlayer } from "next-intlayer";
+import { useIntlayer } from "next-intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const HomePage: NextPageIntlayer = async ({ params }) => {
+  const { locale } = await params;
+
+  const content = useIntlayer("homepage", locale);
+
+  return (
+    <IntlayerProvider locale={locale}>
+      <p>{content.introduction}</p>
+      <ClientComponentExample />
+      <ServerComponentExample />
+    </IntlayerProvider>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
 import { ClientComponentExample } from "@components/ClientComponentExample";
 import { ServerComponentExample } from "@components/ServerComponentExample";
@@ -104,6 +132,9 @@ const HomePage: NextPageIntlayer = async ({ params }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ClientComponentExample.tsx" codeFormat={["typescript", "esm"]}
 "use-client";
 

package/docs/de/packages/next-intlayer/useLocale.md

@@ -104,6 +104,8 @@ Der `useLocale` Hook akzeptiert die folgenden Parameter:
 
 ## Rückgabewerte
 
+Wenn Sie den Hook `useLocale` aufrufen, gibt dieser ein Objekt mit den folgenden Eigenschaften zurück:
+
 - **`locale`**: Die aktuelle Sprache, wie im React-Kontext gesetzt.
 - **`defaultLocale`**: Die primäre Sprache, die in der Konfiguration definiert ist.
 - **`availableLocales`**: Eine Liste aller verfügbaren Sprachen, wie in der Konfiguration definiert.

package/docs/de/packages/react-intlayer/useDictionary.md

@@ -30,8 +30,6 @@ Der `useDictionary` Hook ermöglicht es dir, ein Objekt zu verarbeiten, das wie
 
 ## Beispiel für die Verwendung in React
 
-Nachfolgend ein Beispiel, wie der `useDictionary` Hook in einer React-Komponente verwendet wird:
-
 ```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 tsx fileName="./ComponentExample.tsx" codeFormat="typescript"

package/docs/de/packages/react-intlayer/useI18n.md

@@ -77,6 +77,34 @@ Alle Wörterbuchschlüssel müssen in Inhaltsdeklarationsdateien deklariert werd
 
 Beispiele für die Verwendung des `useI18n` Hooks innerhalb von React-Komponenten:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/App.tsx" codeFormat={["typescript", "esm"]}
+import type { FC } from "react";
+import { ClientComponentExample, ServerComponentExample } from "@components";
+import { IntlayerProvider } from "react-intlayer";
+import { useI18n } from "react-intlayer/server";
+import { Locales } from "intlayer";
+
+const App: FC<{ locale: Locales }> = ({ locale }) => {
+  const t = useI18n("home-page", locale);
+
+  return (
+    <>
+      <p>{t("introduction")}</p>
+      <IntlayerProvider locale={locale}>
+        <ClientComponentExample />
+      </IntlayerProvider>
+      <ServerComponentExample />
+    </>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/App.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { ClientComponentExample, ServerComponentExample } from "@components";
@@ -101,6 +129,9 @@ const App: FC<{ locale: Locales }> = ({ locale }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useI18n } from "react-intlayer";