@intlayer/docs 8.12.5-canary.0 → 9.0.0-canary.11

package/docs/fr/self_hosting.md

@@ -0,0 +1,349 @@
+---
+createdAt: 2026-06-30
+updatedAt: 2026-06-30
+title: Auto-hébergement d'Intlayer
+description: Exécutez une instance complète d'Intlayer sur votre propre infrastructure avec une seule commande. Aucun compte Intlayer Cloud n'est requis.
+keywords:
+  - Auto-hébergement
+  - Docker
+  - Docker Compose
+  - Intlayer
+  - CMS
+  - Installation
+  - Infrastructure
+slugs:
+  - doc
+  - self-hosting
+author: aymericzip
+---
+
+# Auto-hébergement d'Intlayer
+
+Intlayer peut fonctionner entièrement sur votre propre infrastructure — aucun compte Intlayer Cloud n'est requis. Une seule commande démarre une stack prête pour la production :
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+L'installateur télécharge un fichier `docker-compose.yml` et un fichier `.env`, génère automatiquement les secrets requis et démarre tous les conteneurs avec `docker compose up -d`.
+
+## Table des matières
+
+<TOC/>
+
+---
+
+## Architecture
+
+```
+                ┌─────────────────────────────┐
+ browser ──────▶ │  app  (TanStack Start)  :3000│ ──┐
+                └─────────────────────────────┘   │ VITE_BACKEND_URL
+                ┌─────────────────────────────┐   │
+                │  backend (Fastify/Bun)  :3100│ ◀─┘
+                └──────────────┬──────────────┘
+          ┌──────────┬─────────┼──────────┬───────────┐
+          ▼          ▼         ▼          ▼           ▼
+     mongo:27017  redis:6379  minio:9000  mailpit:1025  Chromium
+     (1-node RS)             (S3 API)     (SMTP)        (in-image)
+                             minio:9001   mailpit:8025
+                             (console)    (web UI)
+```
+
+Chromium (utilisé pour la génération de captures d'écran Puppeteer) est intégré à l'image du backend — aucun conteneur séparé n'est nécessaire.
+
+---
+
+## Prérequis
+
+- **Docker** ≥ 24 et **Docker Compose** ≥ v2. Si l'un des deux est manquant, l'installateur affiche le lien d'installation et quitte.
+- Ports `3000`, `3100`, `8025`, `9000` et `9001` disponibles sur l'hôte.
+- Un hôte Linux ou macOS (ou WSL2 sur Windows).
+
+---
+
+## Démarrage rapide
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Ce que fait l'installateur :
+
+1.  Vérifie que `docker` et `docker compose` sont présents.
+2.  Télécharge `docker-compose.yml` et `.env.example` dans `./intlayer/`.
+3.  S'il n'existe pas de fichier `.env`, copie l'exemple et génère des secrets aléatoires pour `BETTER_AUTH_SECRET`, `S3_ACCESS_KEY_ID` et `S3_SECRET_ACCESS_KEY` via `openssl rand`.
+4.  Exécute `docker compose pull` + `docker compose up -d`.
+5.  Affiche les URL : tableau de bord `:3000`, API `:3100`, UI e-mail `:8025`, console MinIO `:9001`.
+
+Une fois la stack démarrée, ouvrez **http://localhost:3000** et créez votre premier compte.
+
+---
+
+## Services
+
+| Service     | Image                                           | Port(s) hôte                   | Objectif                                                                 |
+| ----------- | ----------------------------------------------- | ------------------------------ | ------------------------------------------------------------------------ |
+| **app**     | construit à partir de `apps/app/Dockerfile`     | `3000`                         | Tableau de bord TanStack Start (UI du CMS)                               |
+| **backend** | construit à partir de `apps/backend/Dockerfile` | `3100`                         | API REST Fastify (endpoint `/health`)                                    |
+| **mongo**   | `mongo:7`                                       | interne                        | Réplica set à nœud unique (`rs0`)                                        |
+| **redis**   | `redis:7-alpine`                                | interne                        | Files d'attente de jobs (BullMQ) et mise en cache (ioredis)              |
+| **minio**   | `minio/minio`                                   | `9000` (S3), `9001` (console)  | Stockage d'objets compatible S3 pour les avatars et les captures d'écran |
+| **mailpit** | `axllent/mailpit`                               | `1025` (SMTP), `8025` (web UI) | Réceptacle local d'e-mails transactionnels                               |
+
+Les ports internes (mongo, redis) ne sont pas exposés à l'hôte par défaut.
+
+> Le port `9000` de MinIO doit être accessible par le navigateur car les assets téléchargés (avatars, captures d'écran) sont chargés directement depuis `S3_PUBLIC_URL=http://localhost:9000/intlayer`.
+
+---
+
+## Variables d'environnement
+
+L'installateur génère un fichier `.env` prêt à l'emploi. Le tableau ci-dessous décrit chaque variable.
+
+### Requis (auto-généré ou demandé)
+
+| Variable               | Exemple                                         | Description                                                        |
+| ---------------------- | ----------------------------------------------- | ------------------------------------------------------------------ |
+| `NODE_ENV`             | `production`                                    | Environnement d'exécution                                          |
+| `PORT`                 | `3100`                                          | Port d'écoute du backend                                           |
+| `BACKEND_URL`          | `http://localhost:3100`                         | URL publique de l'API backend                                      |
+| `APP_URL`              | `http://localhost:3000`                         | URL publique du tableau de bord                                    |
+| `DOMAIN`               | `localhost`                                     | Domaine du cookie                                                  |
+| `MONGODB_URI`          | `mongodb://mongo:27017/intlayer?replicaSet=rs0` | URI de connexion complète à MongoDB                                |
+| `REDIS_URL`            | `redis://redis:6379`                            | URL de connexion Redis                                             |
+| `BETTER_AUTH_SECRET`   | _(généré)_                                      | Secret de 32 octets pour la signature de session                   |
+| `MAIL_PROVIDER`        | `smtp`                                          | Transport de courrier : `smtp` ou `resend`                         |
+| `MAIL_SMTP_HOST`       | `mailpit`                                       | Nom d'hôte SMTP (nom du conteneur Mailpit)                         |
+| `MAIL_SMTP_PORT`       | `1025`                                          | Port SMTP                                                          |
+| `MAIL_FROM`            | `Intlayer <no-reply@localhost>`                 | Adresse de l'expéditeur                                            |
+| `S3_ENDPOINT`          | `http://minio:9000`                             | Endpoint compatible S3                                             |
+| `S3_PUBLIC_URL`        | `http://localhost:9000/intlayer`                | URL publique pour le chargement des assets par le navigateur       |
+| `S3_BUCKET_NAME`       | `intlayer`                                      | Nom du bucket                                                      |
+| `S3_ACCESS_KEY_ID`     | _(généré)_                                      | Clé d'accès MinIO                                                  |
+| `S3_SECRET_ACCESS_KEY` | _(généré)_                                      | Clé secrète MinIO                                                  |
+| `VITE_BACKEND_URL`     | `http://localhost:3100`                         | URL du backend intégrée au tableau de bord lors de la construction |
+| `VITE_DOMAIN`          | `localhost`                                     | Domaine intégré au tableau de bord lors de la construction         |
+
+### Facultatif (les fonctionnalités se dégradent gracieusement en leur absence)
+
+| Variable                                                 | Fonctionnalité                                                  |
+| -------------------------------------------------------- | --------------------------------------------------------------- |
+| `OPENAI_API_KEY`                                         | Traduction assistée par IA et audit de contenu                  |
+| `STRIPE_SECRET_KEY`, `STRIPE_WEBHOOK_SECRET`, `STRIPE_*` | Gestion de la facturation et des abonnements                    |
+| `RESEND_API_KEY`                                         | E-mail transactionnel via Resend (outrepasse Mailpit si défini) |
+| `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`               | Connexion OAuth GitHub                                          |
+| `GOOGLE_CLIENT_ID`, `GOOGLE_CLIENT_SECRET`               | Connexion OAuth Google                                          |
+| `GITLAB_CLIENT_ID`, `GITLAB_CLIENT_SECRET`               | Connexion OAuth GitLab                                          |
+| `MICROSOFT_CLIENT_ID`, `MICROSOFT_CLIENT_SECRET`         | Connexion OAuth Microsoft                                       |
+| `LINKEDIN_CLIENT_ID`, `LINKEDIN_CLIENT_SECRET`           | Connexion OAuth LinkedIn                                        |
+| `ATLASSIAN_CLIENT_ID`, `ATLASSIAN_CLIENT_SECRET`         | Connexion OAuth Atlassian                                       |
+
+---
+
+## Connexion de votre projet Intlayer
+
+Une fois la stack en cours d'exécution, pointez votre projet vers le backend et le tableau de bord auto-hébergés au lieu de `intlayer.org`.
+
+### Configuration du projet
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+
+    /**
+     * URL du tableau de bord CMS auto-hébergé.
+     * Par défaut : https://app.intlayer.org
+     */
+    cmsURL: process.env.INTLAYER_CMS_URL, // ex. http://localhost:3000
+
+    /**
+     * URL de l'API backend auto-hébergée.
+     * Par défaut : https://back.intlayer.org
+     */
+    backendURL: process.env.INTLAYER_BACKEND_URL, // ex. http://localhost:3100
+  },
+};
+
+export default config;
+```
+
+Définissez les variables d'environnement dans le fichier `.env` de 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é sous **Projets → Clés d'accès** à l'adresse `http://localhost:3000/projects`.
+
+### SDK `@intlayer/api`
+
+Lorsque vous utilisez le SDK `@intlayer/api` de manière programmatique, passez `backendURL` explicitement :
+
+```typescript fileName="cms.ts" codeFormat="typescript"
+import { createIntlayerCMS } from "@intlayer/api";
+import { dictionaryEndpoint } from "@intlayer/api/dictionary";
+
+const cms = createIntlayerCMS({
+  editor: {
+    clientId: process.env.INTLAYER_CLIENT_ID,
+    clientSecret: process.env.INTLAYER_CLIENT_SECRET,
+    backendURL: process.env.INTLAYER_BACKEND_URL, // http://localhost:3100
+  },
+});
+
+const { data: dictionaries } = await dictionaryEndpoint(cms).getDictionaries();
+```
+
+---
+
+## Mise à niveau
+
+Exécuter à nouveau l'installateur sur un déploiement existant effectue une mise à niveau progressive :
+
+```sh
+curl -fsSL https://intlayer.org/install.sh | sh
+```
+
+Ceci télécharge les dernières images et redémarre les conteneurs avec `docker compose pull && docker compose up -d`. Les volumes existants (`mongo-data`, `redis-data`, `minio-data`) sont préservés — aucune perte de données.
+
+Pour effectuer une mise à niveau manuellement depuis le répertoire `./intlayer/` :
+
+```sh
+docker compose pull
+docker compose up -d
+```
+
+---
+
+## Sauvegarde et restauration
+
+Toutes les données persistantes résident dans trois volumes Docker nommés.
+
+### Sauvegarde
+
+```sh
+docker run --rm \
+  -v intlayer_mongo-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/mongo-data.tar.gz /data
+
+docker run --rm \
+  -v intlayer_redis-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/redis-data.tar.gz /data
+
+docker run --rm \
+  -v intlayer_minio-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar czf /backup/minio-data.tar.gz /data
+```
+
+### Restauration
+
+```sh
+docker run --rm \
+  -v intlayer_mongo-data:/data \
+  -v "$(pwd)":/backup \
+  busybox tar xzf /backup/mongo-data.tar.gz -C /
+
+# Répétez pour redis-data et minio-data
+```
+
+---
+
+## Utilisation d'un proxy inverse (Nginx / Caddy)
+
+Pour les déploiements de production, placez un proxy inverse devant les conteneurs de l'application et du backend au lieu de les exposer directement.
+
+### Exemple Nginx
+
+```nginx
+server {
+    listen 80;
+    server_name cms.example.com;
+
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+
+server {
+    listen 80;
+    server_name api.example.com;
+
+    location / {
+        proxy_pass http://localhost:3100;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+Mettez à jour les variables `.env` suivantes pour qu'elles correspondent à vos domaines publics :
+
+```sh
+BACKEND_URL=https://api.example.com
+APP_URL=https://cms.example.com
+DOMAIN=example.com
+VITE_BACKEND_URL=https://api.example.com
+VITE_DOMAIN=example.com
+```
+
+> Les variables `VITE_*` sont intégrées à l'image du tableau de bord lors de la construction. Si vous les modifiez après la construction de l'image, vous devez reconstruire l'image `app` (`docker compose build app`) ou utiliser l'injection de configuration au moment de l'exécution.
+
+---
+
+## Dépannage
+
+### Le backend redémarre en boucle au premier démarrage
+
+MongoDB et Redis doivent être sains avant le démarrage du backend. Le fichier compose utilise `depends_on` avec `condition: service_healthy`. Si vous voyez des redémarrages répétés du backend, vérifiez que les contrôles de santé de `mongo` et `redis` sont réussis :
+
+```sh
+docker compose ps
+docker compose logs mongo
+docker compose logs redis
+```
+
+### Le tableau de bord ne peut pas atteindre l'API
+
+Vérifiez que `VITE_BACKEND_URL` correspond à l'URL où le backend est accessible depuis le **navigateur** (pas le réseau Docker). Si vous avez modifié le port du backend ou ajouté un proxy inverse, reconstruisez l'image du tableau de bord :
+
+```sh
+docker compose build app
+docker compose up -d app
+```
+
+### Les e-mails ne sont pas envoyés
+
+Par défaut, tous les e-mails sortants sont capturés par Mailpit. Ouvrez `http://localhost:8025` pour voir les messages envoyés. Pour envoyer de vrais e-mails, définissez `MAIL_PROVIDER=resend` et `RESEND_API_KEY=<your-key>` dans `.env`, puis redémarrez le backend :
+
+```sh
+docker compose restart backend
+```
+
+### Bucket MinIO manquant
+
+Si le service ponctuel `minio-init` n'a pas fonctionné (ou a fonctionné avant que MinIO ne soit prêt), créez le bucket manuellement :
+
+```sh
+docker compose run --rm minio-init
+```
+
+---
+
+## Liens utiles
+
+- [Documentation du CMS Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md)
+- [Référence de configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/configuration.md)
+- [SDK CMS — `@intlayer/api`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/fr/intlayer_CMS.md#programmatic-access-with-the-intlayerapi-sdk)

package/docs/hi/CI_CD.md

@@ -26,6 +26,10 @@ author: aymericzip
 
 Intlayer आपके सामग्री घोषणा फ़ाइलों के लिए अनुवादों का स्वचालित उत्पादन करने की अनुमति देता है। आपके कार्यप्रवाह के आधार पर इसे प्राप्त करने के कई तरीके हैं।
 
+## विषय सूची
+
+<TOC/>
+
 ## CMS का उपयोग करना
 
 Intlayer के साथ, आप एक ऐसा कार्यप्रवाह अपना सकते हैं जहाँ केवल एक ही स्थानीय भाषा स्थानीय रूप से घोषित की जाती है, जबकि सभी अनुवाद CMS के माध्यम से दूरस्थ रूप से प्रबंधित किए जाते हैं। यह सामग्री और अनुवादों को कोडबेस से पूरी तरह से अलग करने की अनुमति देता है, जिससे सामग्री संपादकों के लिए अधिक लचीलापन मिलता है और हॉट कंटेंट रीलोडिंग सक्षम होती है (परिवर्तन लागू करने के लिए एप्लिकेशन को पुनः निर्माण करने की आवश्यकता नहीं होती)।

package/docs/hi/autoFill.md

@@ -28,6 +28,53 @@ history:
 author: aymericzip
 ---
 
+# कंटेंट डिक्लेरेशन फ़ाइल अनुवाद भरें
+
+**अपने CI में कंटेंट डिक्लेरेशन फ़ाइलों को ऑटोफिल करना** आपके विकास वर्कफ़्लो को तेज़ करने का एक तरीका है।
+
+## व्यवहार को समझना
+
+`fill` कमांड में दो मोड शामिल हैं:
+
+- **Complete**: प्रत्येक locale के लिए सभी missing content को स्वचालित रूप से भरें और वर्तमान फ़ाइल को संपादित करें, या यदि निर्दिष्ट हो तो दूसरी फ़ाइल को संपादित करें। यानी, complete मोड पहले से से अनुवादित मौजूदा content को छोड़ देगा।
+- **Review**: प्रत्येक locale के लिए **सभी** content को स्वचालित रूप से भरें और एक विशिष्ट फ़ाइल के लिए generate करें, या यदि निर्दिष्ट हो तो दूसरी फ़ाइल के लिए generate करें।
+
+`fill` कमांड आपकी सभी locale content declaration files को process करेगा। यानी, यह CMS से आपकी remote content को process नहीं करेगा। CMS के पास अपना स्वयं का translations management है।
+यदि आप `@intlayer/sync-json-plugin` जैसे plugins का उपयोग करते हैं, तो Intlayer JSON files को locale content declaration files में transform करेगा। यानी, वे `fill` कमांड द्वारा process किए जाएंगे।
+
+नई generated files में एक `filled` instruction को dictionary metadata के रूप में शामिल है। यह instruction Intlayer को यह जानने के लिए उपयोग किया जाएगा कि फ़ाइल को autofilled किया गया है या नहीं, और यदि मौजूद है तो इस फ़ाइल को फिर से translate किए जाने से छोड़ दें।
+
+Intlayer autofill के लिए निम्नलिखित instruction पर भी विचार करेगा:
+
+- आपकी `.content.{ts|js|json}` → `fill` instruction से
+- आपकी configuration file `.intlayer.config.ts` → `dictionary.fill` instruction से
+- अन्यथा `true` पर set किया जाएगा
+
+Per-locale content declaration files के लिए, `true` instruction को `./{{fileName}}.fill.content.json` से replace किया जाएगा। यह इसलिए है क्योंकि एक per-locale content declaration file अतिरिक्त localized content प्राप्त नहीं कर सकता है। इसलिए यह मौजूदा फ़ाइल को overwrite न करने के लिए एक नई फ़ाइल generate करेगा।
+
+## डिफ़ॉल्ट व्यवहार
+
+डिफ़ॉल्ट रूप से, `fill` को globally `true` पर सेट किया गया है, जिसका अर्थ है कि Intlayer automatically सभी content files को fill करेगा और फ़ाइल को स्वयं edit करेगा। इस व्यवहार को कई तरीकों से customize किया जा सकता है:
+
+### वैश्विक कॉन्फ़िगरेशन विकल्प
+
+1. **`fill: true` (डिफ़ॉल्ट)** - सभी locales को स्वचालित रूप से भरें और वर्तमान फ़ाइल को संपादित करें
+2. **`fill: false`** - इस सामग्री फ़ाइल के लिए स्वचालित भरण अक्षम करें
+3. **`fill: "./relative/path/to/file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, वर्तमान फ़ाइल के स्थान के आधार पर हल किए गए सापेक्ष पथ की ओर इशारा करके
+4. **`fill: "/absolute/path/to/file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, कॉन्फ़िगरेशन फ़ाइल `.intlayer.config.ts` में बेस डायरेक्टरी (फ़ील्ड `baseDir`) के आधार पर हल किए गए सापेक्ष पथ की ओर इशारा करके
+5. **`fill: "C:\\absolute\path\to\file"`** - वर्तमान फ़ाइल को संपादित किए बिना निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें, आपके ऑपरेटिंग सिस्टम के आधार पर हल किए गए निरपेक्ष पथ की ओर इशारा करके
+6. **`fill: { [key in Locales]?: string }`** - प्रत्येक locale के लिए निर्दिष्ट फ़ाइल को बनाएं/अपडेट करें
+
+### v7 व्यवहार परिवर्तन
+
+v7 में, `fill` कमांड का व्यवहार अपडेट किया गया है:
+
+- **`fill: true`** - वर्तमान फ़ाइल को सभी locales के लिए भरी गई सामग्री के साथ फिर से लिखता है
+- **`fill: "path/to/file"`** - निर्दिष्ट फ़ाइल को भरता है बिना वर्तमान फ़ाइल को संशोधित किए
+- **`fill: false`** - auto-fill को पूरी तरह अक्षम करता है
+
+जब किसी दूसरी फ़ाइल में लिखने के लिए path विकल्प का उपयोग करते हैं, तो fill तंत्र सामग्री घोषणा फ़ाइलों के बीच एक _master-slave_ संबंध के माध्यम से काम करता है। मुख्य (master) फ़ाइल सत्य का स्रोत है, और जब इसे अपडेट किया जाता है, तो Intlayer स्वचालित रूप से उन परिवर्तनों को path द्वारा निर्दिष्ट व्युत्पन्न (भरी गई) घोषणा फ़ाइलों पर लागू करता है।
+
 # ऑटोफिल सामग्री घोषणा फ़ाइल अनुवाद
 
 **ऑटोफिल सामग्री घोषणा फ़ाइलें** आपके विकास कार्यप्रवाह को तेज़ करने का एक तरीका हैं।
@@ -88,6 +135,40 @@ Intlayer स्वचालित रूप से व्युत्पन्
 
 इसके बाद, दोनों घोषणा फ़ाइलों को एकल शब्दकोश में मर्ज किया जाएगा, जिसे मानक `useIntlayer("example")` हुक (react) / कॉम्पोज़ेबल (vue) का उपयोग करके एक्सेस किया जा सकता है।
 
+## Global Configuration
+
+आप `intlayer.config.ts` फ़ाइल में global auto fill configuration को कॉन्फ़िगर कर सकते हैं।
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig, Locales } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+    requiredLocales: [Locales.ENGLISH, Locales.FRENCH],
+  },
+  dictionary: {
+    // सभी dictionaries के लिए लापता translations को auto-generate करें
+    fill: "./{{fileName}}Filled.content.ts",
+    //
+    // fill: "/messages/{{locale}}/{{key}}/{{fileName}}.content.json",
+    //
+    // fill: true, // सभी dictionaries के लिए लापता translations को auto-generate करें जैसे "./{{fileName}}.content.json" का उपयोग करना
+    //
+    // fill: {
+    //   en: "./{{fileName}}.en.content.json",
+    //   fr: "./{{fileName}}.fr.content.json",
+    //   es: "./{{fileName}}.es.content.json",
+    // },
+  },
+};
+
+export default config;
+```
+
+आप content files में `fill` field का उपयोग करके प्रति dictionary को fine-tune कर सकते हैं। Intlayer पहले per dictionary configuration पर विचार करेगा और फिर global configuration पर fallback करेगा।
+
 ## ऑटोफिल की गई फ़ाइल प्रारूप
 
 सिफारिश की गई स्वरूप ऑटोफिल की गई घोषणा फ़ाइलों के लिए **JSON** है, जो स्वरूपण प्रतिबंधों से बचने में मदद करता है। हालांकि, Intlayer `.ts`, `.js`, `.mjs`, `.cjs`, और अन्य स्वरूपों का भी समर्थन करता है।

package/docs/hi/benchmark/solid.md

@@ -118,6 +118,28 @@ i18n लीकेज समस्याओं को तुरंत पहच
 - **Scoped static**: जटिल अतिरिक्त नेटवर्क अनुरोधों के बिना कोड को व्यवस्थित रखता है (तार्किक पृथक्करण)।
 - **Scoped dynamic**: _कोड स्प्लिटिंग_ और प्रदर्शन के लिए सर्वोत्तम दृष्टिकोण। केवल वर्तमान दृश्य और सक्रिय लोकेल के लिए आवश्यक सामग्री लोड करके मेमोरी को कम करता है।
 
+### मैंने क्या मापा:
+
+मैंने हर स्टैक के लिए एक वास्तविक ब्राउज़र में एक ही बहुभाषी ऐप चलाया, फिर लिखा कि वास्तव में क्या तार पर दिखाई दिया और कितने समय लगे। आकार सामान्य वेब संपीड़न के **बाद** रिपोर्ट किए जाते हैं, क्योंकि यह कच्चे स्रोत गणना की तुलना में लोग जो डाउनलोड करते हैं उसके करीब है।
+
+- **Internationalization लाइब्रेरी आकार**: बंडलिंग, ट्री-शेकिंग और मिनिफिकेशन के बाद, i18n लाइब्रेरी का आकार providers + hooks/primitives कोड एक खाली कंपोनेंट में है। इसमें ट्रांसलेशन फाइलों को लोड करना शामिल नहीं है। यह जवाब देता है कि लाइब्रेरी आपकी सामग्री तस्वीर में आने से पहले कितनी महंगी है।
+
+- **प्रति पृष्ठ JavaScript**: प्रत्येक बेंचमार्क रूट के लिए, ब्राउज़र उस विज़िट के लिए कितनी स्क्रिप्ट खींचता है, सूट में पृष्ठों में औसत (और locales में जहां रिपोर्ट उन्हें रोल करती है)। भारी पृष्ठ धीमे पृष्ठ हैं।
+
+- **अन्य locales से रिसाव**: यह एक ही पृष्ठ की सामग्री है लेकिन एक अन्य भाषा में जो ऑडिट किए गए पृष्ठ में गलती से लोड हो सकती है। यह सामग्री अनावश्यक है और इससे बचा जाना चाहिए। (उदाहरण के लिए `/fr/about` पृष्ठ की सामग्री `/en/about` पृष्ठ बंडल में)
+
+- **अन्य routes से रिसाव**: **अन्य स्क्रीन** के लिए भी यही विचार: कि क्या उनकी कॉपी तब चल रही है जब आपने केवल एक पृष्ठ खोला है। (उदाहरण के लिए `/en/about` पृष्ठ की सामग्री `/en/contact` पृष्ठ बंडल में)। उच्च स्कोर कमजोर splitting या over-broad बंडल का संकेत देता है।
+
+- **औसत कंपोनेंट बंडल आकार**: सामान्य UI टुकड़ों को **एक समय में एक** मापा जाता है एक विशाल ऐप नंबर के अंदर छिपने के बजाय। यह दिखाता है कि क्या internationalization चुपचाप रोज़मर्रा के कंपोनेंट को बढ़ाता है। उदाहरण के लिए, यदि आपका कंपोनेंट पुनः रेंडर करता है, तो यह मेमोरी से सभी डेटा लोड करेगा। किसी कंपोनेंट से एक विशाल JSON को जोड़ना अप्रयुक्त डेटा के एक बड़े स्टोर को जोड़ने जैसा है जो आपके कंपोनेंट के प्रदर्शन को धीमा कर देगा।
+
+- **भाषा स्विच प्रतिक्रिया**: मैं ऐप के अपने नियंत्रण का उपयोग करके भाषा को फ्लिप करता हूं और समय करता हूं कि पृष्ठ स्पष्ट रूप से स्विच होने तक कितना समय लगता है, एक आगंतुक को क्या ध्यान देगा, lab micro-step नहीं।
+
+- **भाषा परिवर्तन के बाद रेंडरिंग कार्य**: एक संकीर्ण अनुवर्ती: एक बार स्विच उड़ान में आने के बाद नई भाषा के लिए इंटरफेस को पुनः पेंट करने में कितना प्रयास लगा। उपयोगी जब "महसूस" किया गया समय और framework cost भिन्न हों।
+
+- **प्रारंभिक पृष्ठ लोड समय**: navigation से ब्राउज़र तक उन परिदृश्यों के लिए पृष्ठ को पूरी तरह से लोड माना जाता है जिनका मैंने परीक्षण किया। cold starts की तुलना के लिए अच्छा।
+
+- **Hydration समय**: जब ऐप इसे उजागर करता है, तो क्लाइंट कितने समय तक server HTML को उन चीजों में बदलने में खर्च करता है जिन पर आप वास्तव में क्लिक कर सकते हैं। तालिकाओं में एक dash का मतलब है कि इस बेंचमार्क में कार्यान्वयन ने एक विश्वसनीय hydration आंकड़ा प्रदान नहीं किया।
+
 ## GitHub सितारे
 
 GitHub सितारे किसी प्रोजेक्ट की लोकप्रियता, सामुदायिक विश्वास और दीर्घकालिक प्रासंगिकता का एक मजबूत संकेतक हैं। हालांकि यह तकनीकी गुणवत्ता का प्रत्यक्ष माप नहीं है, वे दर्शाते हैं कि कितने डेवलपर्स प्रोजेक्ट को उपयोगी पाते हैं, इसकी प्रगति का पालन करते हैं, और इसे अपनाने की संभावना रखते हैं। किसी प्रोजेक्ट के मूल्य का अनुमान लगाने के लिए, सितारे विकल्पों के बीच कर्षण की तुलना करने में मदद करते हैं और पारिस्थितिकी तंत्र के विकास में अंतर्दृष्टि प्रदान करते हैं।

package/docs/hi/benchmark/svelte.md

@@ -116,6 +116,28 @@ i18n लीकेज समस्याओं को तुरंत पहच
 - **Scoped static**: जटिल अतिरिक्त नेटवर्क अनुरोधों के बिना कोड को व्यवस्थित रखता है (तार्किक पृथक्करण)।
 - **Scoped dynamic**: _कोड स्प्लिटिंग_ और प्रदर्शन के लिए सर्वोत्तम दृष्टिकोण। केवल वर्तमान दृश्य और सक्रिय लोकेल के लिए आवश्यक सामग्री लोड करके मेमोरी को कम करता है।
 
+### मैंने क्या मापा:
+
+मैंने प्रत्येक stack के लिए एक ही बहुभाषी ऐप्लिकेशन को एक वास्तविक ब्राउज़र में चलाया, फिर नोट किया कि वास्तव में तार पर क्या दिखाई दिया और चीजें कितनी देर लीं। आकार **सामान्य वेब संपीड़न के बाद** रिपोर्ट किए जाते हैं, क्योंकि यह कच्चे स्रोत गणना की तुलना में लोगों द्वारा डाउनलोड किए जाने वाले से करीब है।
+
+- **Internationalization library size**: bundling, tree-shaking और minification के बाद, i18n library का आकार providers + stores code का आकार एक खाली component में है। इसमें translation files को लोड करना शामिल नहीं है। यह इस बात का उत्तर देता है कि आपकी content से पहले library कितनी महंगी है।
+
+- **JavaScript per page**: प्रत्येक benchmark route के लिए, browser उस visit के लिए कितनी script खींचता है, suite में pages के औसत पर (और locales के पार जहां report उन्हें roll करता है)। Heavy pages slow pages हैं।
+
+- **Leakage from other locales**: यह एक ही page की content है लेकिन दूसरी language में जो audited page में गलती से load हो जाती है। यह content अनावश्यक है और इससे बचा जाना चाहिए। (उदाहरण के लिए `/fr/about` page content `/en/about` page bundle में)
+
+- **Leakage from other routes**: **अन्य screens** के लिए भी यही विचार: क्या उनकी copy तब भी साथ आती है जब आपने केवल एक page खोला हो। (उदाहरण के लिए `/en/about` page content `/en/contact` page bundle में)। एक high score weak splitting या over-broad bundles का संकेत देता है।
+
+- **Average component bundle size**: Common UI pieces को **एक बार में** measure किया जाता है बजाय एक giant app number के अंदर छिपने के। यह दिखाता है कि internationalization आम components को quietly inflate करता है या नहीं। उदाहरण के लिए, यदि आपका component rerender करता है, तो यह memory से सभी उस data को load करेगा। किसी भी component के साथ एक giant JSON को attach करना एक बड़े unused data store को जोड़ने जैसा है जो आपके components के performance को slow down करेगा।
+
+- **Language switch responsiveness**: मैं ऐप के अपने control का उपयोग करके language को flip करता हूं और time करता हूं कि page clearly switch होने में कितना समय लगता है, जो एक visitor को notice होगा, न कि एक lab micro-step।
+
+- **Rendering work after a language change**: एक narrower follow-up: interface को नई language के लिए repaint करने में कितनी effort लगी एक बार switch in flight हो। उपयोगी जब "felt" समय और framework cost में divergence हो।
+
+- **Initial page load time**: navigation से browser तक जब page को उन scenarios के लिए fully loaded माना जाए जिन्हें मैंने test किया। Cold starts की तुलना के लिए अच्छा।
+
+- **Hydration time**: जब app इसे expose करता है, तो client कितना समय server HTML को कुछ ऐसे में बदलने में खर्च करता है जिसे आप actually click कर सकते हैं। Tables में एक dash का मतलब है कि implementation ने इस benchmark में एक reliable hydration figure provide नहीं किया।
+
 ## GitHub सितारे
 
 GitHub सितारे किसी प्रोजेक्ट की लोकप्रियता, सामुदायिक विश्वास और दीर्घकालिक प्रासंगिकता का एक मजबूत संकेतक हैं। हालांकि यह तकनीकी गुणवत्ता का प्रत्यक्ष माप नहीं है, वे दर्शाते हैं कि कितने डेवलपर्स प्रोजेक्ट को उपयोगी पाते हैं, इसकी प्रगति का पालन करते हैं, और इसे अपनाने की संभावना रखते हैं। किसी प्रोजेक्ट के मूल्य का अनुमान लगाने के लिए, सितारे विकल्पों के बीच कर्षण की तुलना करने में मदद करते हैं और पारिस्थितिकी तंत्र के विकास में अंतर्दृष्टि प्रदान करते हैं।

package/docs/hi/benchmark/tanstack.md

@@ -124,6 +124,28 @@ i18n लीकेज के मुद्दों को तेज़ी से
 - **Scoped static**: अतिरिक्त जटिल नेटवर्क अनुरोधों के बिना कोड को व्यवस्थित (लॉजिकल सेपरेशन) रखता है।
 - **Scoped dynamic**: कोड स्प्लिटिंग और परफॉरमेंस के लिए सबसे अच्छा दृष्टिकोण। वर्तमान व्यू और सक्रिय लोकेल की आवश्यकता वाली चीज़ों को लोड करके मेमोरी को कम करता है।
 
+### मैंने क्या मापा:
+
+मैंने हर स्टैक के लिए एक वास्तविक ब्राउज़र में एक ही बहुभाषी ऐप चलाया, फिर लिखा कि वास्तव में तार पर क्या दिखाई दिया और चीजों में कितना समय लगा। आकार **सामान्य वेब कंप्रेशन के बाद** रिपोर्ट किए जाते हैं, क्योंकि यह कच्चे स्रोत गणना की तुलना में लोग जो डाउनलोड करते हैं उसके करीब है।
+
+- **Internationalization लाइब्रेरी का आकार**: bundling, tree-shaking और minification के बाद, i18n लाइब्रेरी का आकार providers (जैसे `NextIntlClientProvider`) + hooks (जैसे `useTranslations`) कोड का आकार एक खाली component में है। इसमें translation फाइलों का लोडिंग शामिल नहीं है। यह इस बात का उत्तर देता है कि आपकी content के picture में आने से पहले लाइब्रेरी कितनी महंगी है।
+
+- **प्रति पृष्ठ JavaScript**: प्रत्येक benchmark route के लिए, ब्राउज़र उस visit के लिए कितनी script खींचता है, suite के pages में averaged (और locales में जहां report उन्हें roll करता है)। भारी pages धीमे pages हैं।
+
+- **अन्य locales से Leakage**: यह एक ही page की content है लेकिन एक अलग language में जो audited page में गलती से लोड हो सकती है। यह content अनावश्यक है और इसे avoid किया जाना चाहिए। (उदाहरण के लिए `/fr/about` page content `/en/about` page bundle में)
+
+- **अन्य routes से Leakage**: **अन्य screens** के लिए भी यही विचार है: क्या जब आप केवल एक page खोलते हैं तो उनकी copy साथ चल रही है। (उदाहरण के लिए `/en/about` page content `/en/contact` page bundle में)। एक high score कमजोर splitting या over-broad bundles का संकेत देता है।
+
+- **औसत component bundle का आकार**: Common UI pieces को **एक बार में एक** मापा जाता है, एक विशाल app संख्या के अंदर छिपने के बजाय। यह दिखाता है कि क्या internationalization quietly रोज़मर्रा के components को inflate करती है। उदाहरण के लिए, यदि आपका component rerenders, तो यह memory से सभी data को load करेगा। किसी component को एक विशाल JSON को attach करना अप्रयुक्त data के एक बड़े store को जोड़ने जैसा है जो आपके components के performance को धीमा कर देगा।
+
+- **Language switch responsiveness**: मैं ऐप के अपने control का उपयोग करके language को flip करता हूं और time करता हूं कि page clearly switch होने में कितना समय लगता है, जो एक visitor को notice होगा, एक lab micro-step नहीं।
+
+- **Language change के बाद Rendering work**: एक narrower follow-up: interface को repaint करने में कितना effort लगा नई language के लिए एक बार switch flight में है। उपयोगी जब "felt" time और framework cost diverge हों।
+
+- **Initial page load time**: Navigation से browser तक यह मानते हुए कि मैंने जिन scenarios को test किया उनके लिए page पूरी तरह से loaded है। Cold starts की तुलना करने के लिए अच्छा है।
+
+- **Hydration time**: जब ऐप इसे expose करता है, तो client कितना समय server HTML को ऐसी चीज़ में बदलने में खर्च करता है जिस पर आप actually क्लिक कर सकते हैं। Tables में एक dash का मतलब है कि implementation ने इस benchmark में एक reliable hydration figure प्रदान नहीं किया।
+
 ## GitHub सितारे
 
 GitHub सितारे किसी प्रोजेक्ट की लोकप्रियता, सामुदायिक विश्वास और दीर्घकालिक प्रासंगिकता का एक मजबूत संकेतक हैं। हालांकि यह तकनीकी गुणवत्ता का प्रत्यक्ष माप नहीं है, वे दर्शाते हैं कि कितने डेवलपर्स प्रोजेक्ट को उपयोगी पाते हैं, इसकी प्रगति का पालन करते हैं, और इसे अपनाने की संभावना रखते हैं। किसी प्रोजेक्ट के मूल्य का अनुमान लगाने के लिए, सितारे विकल्पों के बीच कर्षण की तुलना करने में मदद करते हैं और पारिस्थितिकी तंत्र के विकास में अंतर्दृष्टि प्रदान करते हैं।

package/docs/hi/cli/ci.md

@@ -140,6 +140,28 @@ steps:
     run: npx intlayer ci fill
 ```
 
+## Scaffolded GitHub Actions
+
+जब आप `intlayer init` चलाते हैं, तो Intlayer आपके package manager (npm, yarn, pnpm, या bun) को detect करता है और `.github/workflows/` के अंतर्गत दो GitHub Actions workflows को scaffold करता है, जिनमें उस package manager से मेल खाने वाली commands होती हैं:
+
+- **`intlayer-fill.yml`** — हर pull request पर, dictionaries को build करता है और `intlayer fill --git-diff --mode complete` चलाता है ताकि बदली हुई dictionaries के लिए missing translations generate हो सकें, फिर परिणाम को PR branch में commit करता है।
+- **`intlayer-test.yml`** — हर pull request पर, dictionaries को build करता है और `intlayer test` चलाता है, जब required locales में translations missing हों तो check को fail करता है।
+
+Existing workflow files को कभी overwrite नहीं किया जाता है। Scaffolding को पूरी तरह skip करने के लिए, यह चलाएँ:
+
+```bash
+npx intlayer init --no-github-actions
+```
+
+### Fill workflow को AI access प्रदान करना
+
+Scaffolded `intlayer-fill.yml` को AI access की आवश्यकता है। दो विकल्प उपलब्ध हैं (workflow के `env` block में कॉन्फ़िगर किए गए):
+
+1. **आपकी अपनी AI provider key** — अपनी repository settings में एक `AI_API_KEY` secret जोड़ें (Settings → Secrets and variables → Actions)। Workflow इसे `--provider`, `--model`, और `--api-key` के माध्यम से forward करता है।
+2. **Intlayer CMS access keys** — `INTLAYER_CLIENT_ID` और `INTLAYER_CLIENT_SECRET` secrets जोड़ें और उन्हें अपने `intlayer.config` `editor` section में wire करें। CMS access keys Intlayer backend के माध्यम से AI access प्रदान करती हैं।
+
+`intlayer-test.yml` workflow को किसी भी AI access की आवश्यकता नहीं है।
+
 ## Error Handling
 
 - यदि `INTLAYER_PROJECT_CREDENTIALS` सेट नहीं है, तो कमांड error के साथ exit होगा।