@intlayer/docs 9.3.3 → 9.4.0

package/docs/fr/how_works_intlayer.md

@@ -67,8 +67,6 @@ Basé sur vos `dictionnaires`, Intlayer générera des types pour les rendre uti
 
 - Les types de dictionnaires sont générés à partir des `fichiers de déclaration de contenu` d'Intlayer. Par défaut, les types de dictionnaires Intlayer sont générés dans le répertoire `.intlayer/types` du projet.
 
-- L'[augmentation de module](https://www.typescriptlang.org/docs/handbook/declaration-merging.html) d'Intlayer est une fonctionnalité TypeScript qui vous permet de définir des types supplémentaires pour Intlayer. Cela rend l'expérience de développement plus facile en suggérant les arguments disponibles ou requis.
-
 Parmi les types générés, les types de dictionnaires Intlayer ou même les types de configuration de langue sont ajoutés au fichier `types/intlayer.d.ts` et utilisés par d'autres packages. Pour cela, il est nécessaire que le fichier `tsconfig.json` soit configuré pour inclure le répertoire `types` du projet.
 
 ### Étape d'interprétation des dictionnaires
@@ -100,6 +98,9 @@ Intlayer fournit également un éditeur visuel pour vous permettre d'éditer vot
 
 ![éditeur visuel](https://github.com/aymericzip/intlayer/blob/main/docs/assets/visual_editor.gif?raw=true)
 
+- Le serveur est une simple application Express qui écoute les requêtes du client et récupère le contenu de votre application, tels que les `dictionaries` et la configuration pour les rendre accessibles côté client.
+- D'autre part, le client est une application React qui est utilisée pour interagir avec votre contenu via une interface visuelle.
+
 - Le serveur est une simple application Express qui écoute les requêtes du client et récupère le contenu de votre application, tels que les `dictionaries` et la configuration pour le rendre accessible côté client.
 - D'autre part, le client est une application React utilisée pour interagir avec votre contenu via une interface visuelle.
   Lorsque vous appelez votre contenu en utilisant `useIntlayer` et que l'éditeur est activé, il enveloppe automatiquement vos chaînes avec un objet Proxy nommé `IntlayerNode`. Ce nœud utilise `window.postMessage` pour communiquer avec un iframe encapsulé contenant l'interface de l'éditeur visuel.  
@@ -110,6 +111,8 @@ Intlayer fournit également un éditeur visuel pour vous permettre d'éditer vot
 Pour optimiser la taille du bundle de votre application, Intlayer fournit deux plugins pour optimiser la construction de votre application : les plugins `@intlayer/babel` et `@intlayer/swc`.
 Les plugins Babel et SWC fonctionnent en analysant l'arbre de syntaxe abstraite (AST) de votre application pour remplacer les appels aux fonctions Intlayer par du code optimisé. Ce processus rend votre bundle final plus léger en production en s'assurant que seuls les dictionnaires réellement utilisés sont importés, optimisant ainsi le découpage des chunks et réduisant la taille du bundle.
 
+Les plugins Babel et SWC fonctionnent en analysant l'Abstract Syntax Tree (AST) de votre application pour remplacer les appels des fonctions Intlayer par du code optimisé. Ce processus rend votre bundle final plus léger en production en garantissant que seuls les dictionnaires réellement utilisés sont importés, en optimisant le chunking et en réduisant la taille du bundle.
+
 En mode développement, Intlayer utilise une importation statique centralisée pour les dictionnaires afin de simplifier l'expérience de développement.
 
 En activant l'option `importMode = "dynamic"` dans la configuration `dictionary` de la [configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md), Intlayer utilisera l'importation dynamique pour charger les dictionnaires. Cette option est désactivée par défaut pour éviter le traitement asynchrone lors du rendu de l'application.

package/docs/fr/intlayer_CMS.md

@@ -311,8 +311,6 @@ export const cmsAuthenticator = createIntlayerCMS({
 
 ### Connecter votre projet à une instance auto-hébergée
 
-Pointez votre configuration Intlayer vers votre propre backend et tableau de bord au lieu de `intlayer.org` :
-
 ```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
 import type { IntlayerConfig } from "intlayer";
 
@@ -338,21 +336,8 @@ const config: IntlayerConfig = {
 export default config;
 ```
 
-Définissez les variables d'environnement correspondantes dans votre projet :
-
-```sh
-INTLAYER_CMS_URL=http://localhost:3000
-INTLAYER_BACKEND_URL=http://localhost:3100
-INTLAYER_CLIENT_ID=<your-client-id>
-INTLAYER_CLIENT_SECRET=<your-client-secret>
-```
-
-Créez des identifiants d'accès dans votre tableau de bord auto-hébergé à `http://localhost:3000/projects`.
-
 ### SDK `@intlayer/api` : pointer vers un backend auto-hébergé
 
-Lors de l'utilisation du SDK de manière programmatique, passez `backendURL` explicitement à `createIntlayerCMS` :
-
 ```typescript fileName="cms.ts" codeFormat="typescript"
 import { createIntlayerCMS } from "@intlayer/api";
 import { dictionaryEndpoint } from "@intlayer/api/dictionary";
@@ -372,6 +357,32 @@ const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
 
 Ces fonctionnalités nécessitent des comptes externes et fonctionnent normalement même sans leurs clés dans le fichier `.env` auto-hébergé :
 
+```typescript fileName="write-dictionaries.ts" codeFormat="typescript"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cmsAuthenticator = createIntlayerCMS();
+
+// Créer un nouveau dictionnaire
+await dictionaryEndpoint(cmsAuthenticator).addDictionary({
+  key: "my-first-dictionary-key",
+  content: { title: "Hello world" },
+});
+
+// Upsert un lot de dictionnaires (les créer ou les mettre à jour en un seul appel)
+await dictionaryEndpoint(cmsAuthenticator).pushDictionaries([
+  { key: "home", content: { title: "Home" } },
+  { key: "about", content: { title: "About" } },
+]);
+
+// Mettre à jour un dictionnaire existant
+await dictionaryEndpoint(cmsAuthenticator).updateDictionary({
+  id: "<dictionary-id>",
+  key: "home",
+  content: { title: "Updated title" },
+});
+```
+
 | Fonctionnalité                      | Variable(s) d'environnement                     |
 | ----------------------------------- | ----------------------------------------------- |
 | Traduction / audit par IA           | `OPENAI_API_KEY`                                |
@@ -383,8 +394,6 @@ Ces fonctionnalités nécessitent des comptes externes et fonctionnent normaleme
 
 ### Persistance des données et mises à niveau
 
-Trois volumes Docker contiennent tout l'état persistant : `mongo-data`, `redis-data` et `minio-data`. Ils survivent aux redémarrages et aux mises à niveau des conteneurs. Relancer le programme d'installation télécharge les dernières images et effectue un `docker compose up -d` progressif.
-
 Ports exposés sur l'hôte :
 
 | Port   | Service                                                                 |
@@ -395,10 +404,6 @@ Ports exposés sur l'hôte :
 | `9000` | API S3 MinIO (requise pour le chargement des assets dans le navigateur) |
 | `9001` | Console MinIO                                                           |
 
-Pour une référence complète de toutes les variables d'environnement disponibles et des options avancées (proxy inverse, domaines personnalisés, sauvegarde/restauration), consultez le [Guide d'auto-hébergement](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/self_hosting.md).
-
----
-
 ## Synchronisation en direct
 
 La Synchronisation en direct permet à votre application de refléter les changements de contenu CMS à l'exécution — aucune reconstruction ou redéploiement requis. Lorsqu'elle est activée, les mises à jour sont diffusées vers un serveur Live Sync qui actualise les dictionnaires que votre application lit.

package/docs/fr/intlayer_visual_editor.md

@@ -85,6 +85,16 @@ pnpm add intlayer-editor --save-dev
 bun add intlayer-editor --dev
 ```
 
+Avec le flag `--with`, vous pouvez démarrer l'éditeur en parallèle avec une autre commande :
+
+```json5 fileName="package.json"
+{
+  "scripts": {
+    "start:editor": "npx intlayer-editor start --with 'next dev --turbopack'",
+  },
+}
+```
+
 ## Configuration
 
 Dans votre fichier de configuration Intlayer, vous pouvez personnaliser les paramètres de l'éditeur :
@@ -146,6 +156,8 @@ export default config;
 
    > **Notez que vous devez exécuter votre application en parallèle.** L'URL de l'application doit correspondre à celle que vous avez définie dans la configuration de l'éditeur (`applicationURL`).
 
+   > **Notez que la commande est réexportée par le package `intlayer`. Vous pouvez utiliser `npx intlayer editor start` à la place.**
+
 2. Ensuite, ouvrez l'URL fournie. Par défaut `http://localhost:8000`.
 
    Vous pouvez visualiser chaque champ indexé par Intlayer en survolant votre contenu avec votre curseur.

package/docs/fr/intlayer_with_adonisjs.md

@@ -254,9 +254,11 @@ import { Locales, type IntlayerConfig } from "intlayer";
 
 const config: IntlayerConfig = {
   // ... Autres options de configuration
-  middleware: {
-    headerName: "my-locale-header",
-    cookieName: "my-locale-cookie",
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
   },
 };
 

package/docs/fr/intlayer_with_astro.md

@@ -122,6 +122,30 @@ Voir le [Modèle d'application](https://github.com/aymericzip/intlayer-astro-tem
 
 Installez les packages nécessaires en utilisant votre gestionnaire de packages préféré :
 
+```bash packageManager="npm"
+npx intlayer init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive
+```
+
+> le flag `--interactive` est optionnel. Utilisez `intlayer-cli init` si vous êtes un agent IA.
+
+> Cette commande détectera votre environnement et installera les packages requis. Par exemple :
+
+```bash packageManager="npm"
+npm install intlayer astro-intlayer
+```
+
 ```bash packageManager="npm"
 npm install intlayer astro-intlayer
 # Optionnel : Ajoutez le support pour les îles React

package/docs/fr/intlayer_with_create_react_app.md

@@ -31,12 +31,34 @@ author: aymericzip
 
 # Traduire votre Create React App avec Intlayer | Internationalisation (i18n)
 
+<iframe
+  src="https://ide.intlayer.org/aymericzip/intlayer-react-cra-template?file=intlayer.config.ts"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Démo CodeSandbox - Comment internationaliser votre application avec Intlayer"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
 Voir [Application Template](https://github.com/aymericzip/intlayer-react-cra-template) sur GitHub.
 
 ## Qu'est-ce qu'Intlayer ?
 
+Par rapport aux principales solutions comme `react-i18next` ou `i18next`, Intlayer est une solution qui intègre des optimisations telles que :
+
+<AccordionGroup>
+
+<Accordion header="Couverture complète de React">
+
 **Intlayer** est une bibliothèque open-source innovante d'internationalisation (i18n) conçue pour simplifier la prise en charge multilingue dans les applications web modernes.
 
+</Accordion>
+
+<Accordion header="Taille du bundle">
+
+Au lieu de charger des fichiers JSON massifs dans vos pages, chargez uniquement le contenu nécessaire. Intlayer vous aide à **réduire la taille de votre bundle et de vos pages jusqu'à 50%**.
+
+</Accordion>
+
 Avec Intlayer, vous pouvez :
 
 - **Gérer facilement les traductions** en utilisant des dictionnaires déclaratifs au niveau des composants.
@@ -44,6 +66,35 @@ Avec Intlayer, vous pouvez :
 - **Assurer la prise en charge de TypeScript** avec des types générés automatiquement, améliorant l'autocomplétion et la détection des erreurs.
 - **Bénéficier de fonctionnalités avancées**, comme la détection et le changement dynamiques de locale.
 
+</Accordion>
+
+<Accordion header="Agent IA">
+
+La co-localisation du contenu **réduit le contexte nécessaire** aux Large Language Models (LLMs). Intlayer est également fourni avec une suite d'outils, tels qu'une **CLI** pour tester les traductions manquantes, **[LSP](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/lsp.md)**, **[MCP](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/mcp_server.md)**, et **[agent skills](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/agent_skills.md)**, pour rendre l'expérience développeur (DX) encore plus fluide pour les agents IA.
+
+</Accordion>
+
+<Accordion header="Automatisation">
+
+Utilisez l'automatisation pour traduire dans votre pipeline CI/CD en utilisant l'LLM de votre choix au coût de votre fournisseur IA. Intlayer offre également un **compilateur** pour automatiser l'extraction de contenu, ainsi qu'une [plateforme web](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md) pour vous aider à **traduire en arrière-plan**.
+
+</Accordion>
+
+<Accordion header="Performance">
+
+La connexion de fichiers JSON massifs aux composants peut entraîner des problèmes de performance et de réactivité. Intlayer optimise le chargement de votre contenu au moment de la construction.
+
+</Accordion>
+
+<Accordion header="Scaling avec none-dev">
+
+Plus qu'une simple solution i18n, Intlayer fournit un **[éditeur visuel](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_visual_editor.md) auto-hébergé** et un **[CMS complet](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md)** pour vous aider à gérer votre contenu multilingue en **temps réel**, rendant la collaboration avec les traducteurs, rédacteurs et autres membres de l'équipe transparente. Le contenu peut être stocké localement et/ou à distance.
+
+</Accordion>
+</AccordionGroup>
+
+---
+
 ## Guide étape par étape pour configurer Intlayer dans une application React
 
 <Steps>
@@ -243,6 +294,8 @@ export default App;
 >
 > Pour en savoir plus sur le hook `useIntlayer`, consultez la [documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useIntlayer.md).
 
+> Pour en savoir plus sur le hook `useIntlayer`, consultez la [documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/useIntlayer.md).
+
 </Step>
 
 <Step number={6} title="Changer la langue de votre contenu" isOptional={true}>
@@ -603,6 +656,8 @@ Pour ce faire, vous pouvez ajouter les instructions suivantes à votre fichier `
 
 ### Extension VS Code
 
+Pour améliorer votre expérience de développement avec Intlayer, vous pouvez installer l'extension officielle **Intlayer VS Code Extension**.
+
 Pour améliorer votre expérience de développement avec Intlayer, vous pouvez installer l’**extension officielle Intlayer pour VS Code**.
 [Installer depuis le Marketplace VS Code](https://marketplace.visualstudio.com/items?itemName=intlayer.intlayer-vs-code-extension)
 

package/docs/fr/intlayer_with_elysia.md

@@ -0,0 +1,339 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-24
+title: "Elysia i18n - Guide complet pour traduire votre application"
+description: "Fini i18next. Le guide 2026 pour construire une application Elysia multilingue (i18n). Traduisez avec des agents IA et optimisez la taille du bundle, le SEO et les performances."
+keywords:
+  - Internationalization
+  - Documentation
+  - Intlayer
+  - Elysia
+  - JavaScript
+  - Backend
+slugs:
+  - doc
+  - environment
+  - elysia
+applicationTemplate: https://github.com/aymericzip/intlayer-elysia-template
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "Aligne le guide sur le template Elysia (typage du contexte, setup Bun, scripts)"
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "init Elysia plugin"
+author: aymericzip
+---
+
+# Traduisez votre site backend Elysia à l'aide d'Intlayer | Internationalization (i18n)
+
+`elysia-intlayer` est un puissant plugin d'internationalization (i18n) pour les applications Elysia, conçu pour rendre vos services backend mondialement accessibles en fournissant des réponses localisées en fonction des préférences du client.
+
+> Voir l'implémentation du package sur GitHub : https://github.com/aymericzip/intlayer/tree/main/packages/elysia-intlayer
+
+### Cas d'usage pratiques
+
+- **Affichage des erreurs backend dans la langue de l'utilisateur** : Quand une erreur se produit, afficher les messages dans la langue maternelle de l'utilisateur améliore la compréhension et réduit la frustration. Cela est particulièrement utile pour les messages d'erreur dynamiques qui pourraient être affichés dans des composants front-end comme des toasts ou des modales.
+- **Récupération de contenu multilingue** : Pour les applications qui extraient du contenu d'une base de données, l'internationalisation garantit que vous pouvez servir ce contenu dans plusieurs langues. Cela est crucial pour les plateformes comme les sites e-commerce ou les systèmes de gestion de contenu qui ont besoin d'afficher des descriptions de produits, des articles et d'autres contenus dans la langue préférée par l'utilisateur.
+- **Envoi d'e-mails multilingues** : Qu'il s'agisse d'e-mails transactionnels, de campagnes marketing ou de notifications, envoyer des e-mails dans la langue du destinataire peut augmenter significativement l'engagement et l'efficacité.
+- **Notifications push multilingues** : Pour les applications mobiles, envoyer des notifications push dans la langue préférée d'un utilisateur peut améliorer l'interaction et la rétention. Cette touche personnelle peut rendre les notifications plus pertinentes et exploitables.
+- **Autres communications** : Toute forme de communication du backend, comme les messages SMS, les alertes système ou les mises à jour de l'interface utilisateur, bénéficie d'être dans la langue de l'utilisateur, assurant la clarté et améliorant l'expérience utilisateur globale.
+
+En internationalisant le backend, votre application non seulement respecte les différences culturelles mais s'aligne également mieux avec les besoins du marché mondial, ce qui en fait une étape clé dans la mise à l'échelle de vos services dans le monde entier.
+
+## Commencer
+
+<iframe
+  src="https://ide.intlayer.org/aymericzip/intlayer-elysia-template?file=intlayer.config.ts"
+  className="m-auto overflow-hidden rounded-lg border-0 max-md:size-full max-md:h-[700px] md:aspect-16/9 md:w-full"
+  title="Demo CodeSandbox - How to Internationalize your application using Intlayer"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+  loading="lazy"
+/>
+
+Voir [Modèle d'application](https://github.com/aymericzip/intlayer-elysia-template) sur GitHub.
+
+### Installation
+
+Pour commencer à utiliser `elysia-intlayer`, installez le package en utilisant npm :
+
+```bash packageManager="npm"
+npx intlayer init --interactive
+```
+
+```bash packageManager="pnpm"
+pnpm dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="yarn"
+yarn dlx intlayer@canary init --interactive
+```
+
+```bash packageManager="bun"
+bunx intlayer@canary init --interactive
+```
+
+> le flag `--interactive` est optionnel. Utilisez `intlayer-cli init` si vous êtes un agent IA.
+
+> Cette commande détectera votre environnement et installera les packages requis. Par exemple :
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> Elysia cible le runtime **Bun**. `elysia-intlayer` s'appuie sur `AsyncLocalStorage` (au lieu de la librairie `cls-hooked` utilisée par les plugins Intlayer basés sur Node) précisément parce que Bun n'implémente pas `async_hooks.createHook`.
+
+### Configuration
+
+Configurez les paramètres d'internationalisation en créant un fichier `intlayer.config.ts` à la racine de votre projet :
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    /**
+     * Locale par défaut utilisée en fallback si la locale demandée n'est pas trouvée.
+     */
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+### Déclarez Votre Contenu
+
+Créez et gérez vos déclarations de contenu pour stocker les traductions :
+
+```typescript fileName="src/index.content.ts" contentDeclarationFormat={["typescript", "esm", "commonjs"]}
+import { t, type Dictionary } from "intlayer";
+
+const indexContent = {
+  key: "index",
+  content: {
+    exampleOfContent: t({
+      fr: "Exemple de contenu renvoyé en français",
+      en: "Example of returned content in English",
+      es: "Ejemplo de contenido devuelto en español",
+    }),
+  },
+} satisfies Dictionary;
+
+export default indexContent;
+```
+
+```json fileName="src/index.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "index",
+  "content": {
+    "exampleOfContent": {
+      "nodeType": "translation",
+      "translation": {
+        "fr": "Exemple de contenu renvoyé en français",
+        "en": "Example of returned content in English",
+        "es": "Ejemplo de contenido devuelto en español"
+      }
+    }
+  }
+}
+```
+
+> Vos déclarations de contenu peuvent être définies n'importe où dans votre application tant qu'elles sont incluses dans le répertoire `contentDir` (par défaut, `./src`). Et correspondent à l'extension de fichier de déclaration de contenu (par défaut, `.content.{json,ts,tsx,js,jsx,mjs,cjs,md,mdx,yaml,yml}`).
+
+> Pour plus de détails, consultez la [documentation de déclaration de contenu](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/dictionary/content_file.md).
+
+### Configuration de l'application Elysia
+
+Configurez votre application Elysia pour utiliser `elysia-intlayer`:
+
+```typescript fileName="src/index.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia()
+  // Charger le plugin d'internationalisation
+  .use(intlayer())
+  // Routes
+  .get("/", ({ intlayer }) => ({
+    // Locale utilisée pour cette requête, négociée via `Accept-Language` ou lue depuis le stockage
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> Le plugin enregistre son contexte via un `derive` **global**, que Elysia type comme `Partial<{ intlayer: IntlayerContext }>`. La valeur est toujours présente à l'exécution pour les routes enregistrées après `.use(intlayer())`, utilisez donc l'assertion non-nulle (`intlayer!.locale`) — ou l'optional chaining — pour satisfaire TypeScript en mode `strict`.
+
+Le contexte de la route expose :
+
+| Propriété         | Description                                                                                        |
+| ----------------- | -------------------------------------------------------------------------------------------------- |
+| `locale`          | La locale à utiliser pour cette requête, `locale_storage` étant prioritaire sur `locale_detected`. |
+| `locale_storage`  | La locale explicitement demandée par le client via un cookie ou un header.                         |
+| `locale_detected` | La locale négociée à partir des headers de la requête.                                             |
+| `defaultLocale`   | La locale configurée comme fallback dans `intlayer.config.ts`.                                     |
+| `t`               | Une fonction de traduction.                                                                        |
+| `getIntlayer`     | Une fonction pour récupérer les dictionnaires par clé.                                             |
+| `getDictionary`   | Une fonction pour traiter les objets dictionnaire.                                                 |
+
+Les mêmes helpers sont aussi exportés en standalone. Ils résolvent la requête courante via `AsyncLocalStorage`, vous pouvez donc les appeler sans déstructurer le contexte :
+
+```typescript fileName="src/index.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Elysia } from "elysia";
+import { intlayer, t, getDictionary, getIntlayer } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  .use(intlayer())
+  .get("/t_example", () =>
+    t({
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+```
+
+> Le contexte de requête est libéré une fois la réponse mappée, afin que les helpers autonomes ne se résolvent jamais sur une requête déjà terminée. Lorsqu'ils sont appelés en dehors d'une requête gérée par le plugin, ils se rabattent sur la locale par défaut configurée.
+
+### Lancer votre application
+
+Ajoutez les scripts Intlayer à votre `package.json`. `intlayer build` compile vos déclarations de contenu dans le répertoire `.intlayer` et génère les types TypeScript :
+
+```json fileName="package.json"
+{
+  "scripts": {
+    "dev": "intlayer build && bun run --watch src/index.ts",
+    "build": "intlayer build",
+    "start": "bun run src/index.ts",
+    "i18n:fill": "intlayer fill",
+    "i18n:test": "intlayer test"
+  }
+}
+```
+
+Démarrez ensuite le serveur :
+
+```bash
+bun run dev
+```
+
+Testez la négociation de locale avec `Accept-Language` :
+
+```bash
+curl -H "Accept-Language: fr" http://localhost:3000/
+# {"locale":"fr","greeting":"Bonjour","content":"Exemple de contenu renvoyé en français"}
+
+curl -H "Accept-Language: es" http://localhost:3000/
+# {"locale":"es","greeting":"Hola","content":"Ejemplo de contenido devuelto en español"}
+```
+
+> `intlayer build` n'est pas strictement nécessaire avant `bun run src/index.ts` : le plugin prépare aussi les dictionnaires au démarrage de l'application Elysia. Le lancer en amont garde les types générés à jour pour votre éditeur et évite le coût du build à la première requête.
+
+### Compatibilité
+
+`elysia-intlayer` est entièrement compatible avec :
+
+- [`react-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/react-intlayer/index.md) pour les applications React
+- [`next-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/next-intlayer/index.md) pour les applications Next.js
+- [`vite-intlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/packages/vite-intlayer/index.md) pour les applications Vite
+
+Elle fonctionne également de manière transparente avec n'importe quelle solution d'internationalisation dans divers environnements, y compris les navigateurs et les requêtes API.
+
+Par défaut, le plugin résout la locale dans cet ordre :
+
+1. Le cookie `INTLAYER_LOCALE`.
+2. Le header `x-intlayer-locale`.
+3. La négociation du header `Accept-Language`.
+
+Vous pouvez personnaliser le cookie et le header utilisés pour la détection de la locale :
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  // ... Autres options de configuration
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> Pour plus d'informations sur la configuration et les sujets avancés, consultez notre [documentation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md).
+
+### Configurer TypeScript
+
+`elysia-intlayer` exploite les capacités robustes de TypeScript pour améliorer le processus d'internationalisation. Le typage statique de TypeScript garantit que chaque clé de traduction est prise en compte, réduisant le risque de traductions manquantes et améliorant la maintenabilité.
+
+Assurez-vous que les types générés automatiquement (par défaut à ./types/intlayer.d.ts) sont inclus dans votre fichier tsconfig.json.
+
+```json5 fileName="tsconfig.json"
+{
+  // ... Vos configurations TypeScript existantes
+  "include": [
+    // ... Vos configurations TypeScript existantes
+    ".intlayer/**/*.ts", // Inclure les types générés automatiquement
+  ],
+}
+```
+
+### Extension VS Code
+
+Pour améliorer votre expérience de développement avec Intlayer, vous pouvez installer l'**extension Intlayer VS Code** officielle.
+
+[Installer depuis le VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=intlayer.intlayer-vs-code-extension)
+
+Cette extension fournit :
+
+- **Autocomplétion** pour les clés de traduction.
+- **Détection d'erreurs en temps réel** pour les traductions manquantes.
+- **Aperçus intégrés** du contenu traduit.
+- **Actions rapides** pour créer et mettre à jour facilement les traductions.
+
+Pour plus de détails sur la façon d'utiliser l'extension, reportez-vous à la [documentation de l'extension Intlayer VS Code](https://intlayer.org/doc/vs-code-extension).
+
+### Configuration Git
+
+Il est recommandé d'ignorer les fichiers générés par Intlayer. Cela vous permet d'éviter de les valider dans votre référentiel Git.
+
+Pour ce faire, vous pouvez ajouter les instructions suivantes à votre fichier `.gitignore` :
+
+```plaintext fileName=".gitignore"
+# Ignorer les fichiers générés par Intlayer
+.intlayer
+```