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

package/docs/hi/compat/nuxtjs-i18n.md

@@ -0,0 +1,46 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "NuxtJS I18n से Intlayer में माइग्रेट करें"
+description: "सीखें कि अपने Nuxt.js एप्लिकेशन को @nuxtjs/i18n से Intlayer में compat adapter का उपयोग करके कैसे माइग्रेट करें।"
+keywords:
+  - nuxtjs-i18n
+  - nuxt
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - nuxtjs-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# NuxtJS I18n से Intlayer में माइग्रेट करें
+
+अपने Nuxt एप्लिकेशन को `@nuxtjs/i18n` से Intlayer में माइग्रेट करना Nuxt adapter मॉड्यूल का उपयोग करके एक सहज प्रक्रिया है।
+
+## क्या करना है
+
+प्रोजेक्ट को इनिशियलाइज़ करने के लिए, यह चलाएं:
+
+```bash
+npx intlayer init
+```
+
+यह `intlayer.config.ts` को सेट अप करेगा। फिर, अपनी `nuxt.config.ts` modules array में Intlayer Nuxt module (जैसे `@intlayer/nuxt-i18n`) जोड़ें। यह आपके application के लिए compat configuration को automatically apply करता है।
+
+## यह हुड के अंदर क्या करता है
+
+`@nuxtjs/i18n` `vue-i18n` को wrap करता है जबकि Nuxt-specific routing composables (`useLocalePath`, `useSwitchLocalePath`, `<NuxtLinkLocale>`) प्रदान करता है।
+
+हुड के अंदर:
+
+- **Translations:** सभी string translation कार्यों के लिए `@intlayer/vue-i18n` compat layer पर नेटिवली निर्भर करता है (`vue-i18n` formats, pipe plurals, और reactivity को पूरी तरह से support करता है)।
+- **Routing:** Intlayer के localized URL helpers का उपयोग करके routing composables को mirror करता है।
+- **Configuration:** आपके `intlayer.config.ts` से सीधे `availableLocales` और default settings को पढ़ता है ताकि Nuxt pages को स्वचालित रूप से coordinate किया जा सके।

package/docs/hi/compat/polyglot.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Polyglot.js से Intlayer में माइग्रेट करें"
+description: "Compat adapter का उपयोग करके Polyglot.js से Intlayer में माइग्रेट करने का तरीका जानें।"
+keywords:
+  - polyglot
+  - airbnb
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - polyglot
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Polyglot.js से Intlayer में माइग्रेट करें
+
+यदि आप Airbnb के Polyglot.js का उपयोग कर रहे हैं, तो compat layer का उपयोग करके Intlayer में माइग्रेशन बेहद सीधा है।
+
+## क्या करना है
+
+अपने प्रोजेक्ट में बस इनिशियलाइजेशन कमांड चलाएं:
+
+```bash
+npx intlayer init
+```
+
+यह `intlayer.config.ts` जनरेट करता है। फिर आप bundler plugin alias का उपयोग करके Polyglot imports को `@intlayer/polyglot` पर पारदर्शी रूप से रीडायरेक्ट कर सकते हैं।
+
+## यह हुड के तहत क्या करता है
+
+Polyglot.js syntax आमतौर पर `polyglot.t('key', {name})` पर निर्भर करता है जिसमें `%{name}` इंटरपोलेशन और `smart_count` plurals `"singular |||| plural"` से अलग होते हैं।
+
+हुड के तहत:
+
+- **Interpolation:** compat layer नेटिवली `%{var}` placeholders को हैंडल करता है।
+- **Plurals:** स्ट्रिंग को `||||` पर विभाजित किया जाता है और सक्रिय locale के अनुसार native `Intl.PluralRules` के विरुद्ध मूल्यांकन किया जाता है, जो Polyglot के स्वयं के bucket order को प्रति locale के साथ प्रतिबिंबित करता है।
+- **Dictionaries:** आप `new Polyglot()` को विशाल JSON कॉन्फ़िगरेशन प्रदान करने की आवश्यकता को दरकिनार करते हैं – Intlayer dictionaries को dynamically हैंडल करता है और उन्हें स्वचालित रूप से prune करता है।

package/docs/hi/compat/react-i18next.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "react-i18next से Intlayer में माइग्रेट करें"
+description: "Compat adapter का उपयोग करके अपने React एप्लिकेशन को react-i18next से Intlayer में माइग्रेट करना सीखें।"
+keywords:
+  - react-i18next
+  - i18next
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-i18next
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# react-i18next से Intlayer में माइग्रेट करें
+
+एक संपूर्ण और विस्तृत चरण-दर-चरण ट्यूटोरियल के लिए, कृपया हमारी पूर्ण [react-i18next माइग्रेशन गाइड](../migration_from_react-i18next_to_intlayer.md) देखें।
+
+Intlayer के compat adapter का उपयोग करके आप अपने स्रोत कोड आयातों में कोई बदलाव किए बिना `react-i18next` से माइग्रेट कर सकते हैं।
+
+## क्या करना है
+
+प्रोजेक्ट को शुरू करने के लिए, निम्नलिखित चलाएँ:
+
+```bash
+npx intlayer init
+```
+
+शुरुआत के दौरान, Intlayer `@intlayer/react-i18next` को इंस्टॉल करेगा और `intlayer.config.ts` बनाएगा। आपके bundler (जैसे Vite) में, Intlayer plugin लागू करें:
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { reactI18nextVitePlugin } from "@intlayer/react-i18next/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactI18nextVitePlugin()],
+});
+```
+
+## यह हुड के अंदर क्या करता है
+
+`reactI18nextVitePlugin` कोर `vite-intlayer` प्लगइन को रैप करता है और `react-i18next` और `i18next` के लिए resolve aliases को inject करता है, जिन्हें `@intlayer/react-i18next` और `@intlayer/i18next` में रीडायरेक्ट किया जाता है।
+
+हुड के अंदर:
+
+- **`useTranslation` & `withTranslation`:** Intlayer के native hooks का उपयोग करने के लिए फिर से लिखा गया है, जो आपके डिक्शनरी keys के लिए स्वचालित TypeScript completion देता है। यह namespaces को seamlessly support करता है (जैसे `t('namespace:key')`).
+- **Plurals & Context:** i18next के suffix-based pluralization (`key_one`, `key_other`) को native `Intl.PluralRules` और context suffixes (`key_male`) का उपयोग करके हैंडल करता है।
+- **`<Trans>` Component:** `components` prop, object और array forms, और numbered tags `<1>...</1>` को support करने के लिए फिर से implement किया गया है जो सीधे आपके React nodes को map करते हैं।
+- **`i18n` instance:** Intlayer से keys को सीधे resolve करता है बिना बड़ी JSON files को fetch किए, जिससे significantly lower bundle sizes प्राप्त होते हैं।

package/docs/hi/compat/react-intl.md

@@ -0,0 +1,55 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "React Intl से Intlayer में माइग्रेट करें"
+description: "सीखें कि कैसे compat adapter का उपयोग करके अपने React एप्लिकेशन को react-intl से Intlayer में माइग्रेट करें।"
+keywords:
+  - react-intl
+  - formatjs
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - react-intl
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# React Intl से Intlayer में माइग्रेट करें
+
+यदि आपकी React एप्लिकेशन `react-intl` (FormatJS) का उपयोग करती है, तो Intlayer में संक्रमण करना आसान है। हमारी compat layer निर्बाध रूप से ICU MessageFormat और सभी मौजूदा `Formatted*` घटकों को संभालता है।
+
+## क्या करें
+
+अपने प्रोजेक्ट में इनिशियलाइजेशन कमांड चलाकर शुरू करें:
+
+```bash
+npx intlayer init
+```
+
+फिर, अपने कॉन्फ़िगरेशन में Intlayer Vite या Next.js प्लगइन सेट अप करें। यह प्लगइन `react-intl` imports को `@intlayer/react-intl` में रीडायरेक्ट करने के लिए बिल्ड-टाइम aliases इंजेक्ट करता है।
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import reactIntlVitePlugin from "@intlayer/react-intl/plugin";
+
+export default defineConfig({
+  plugins: [react(), reactIntlVitePlugin()],
+});
+```
+
+## यह हुड के नीचे क्या करता है
+
+bundler plugin `react-intl` को `@intlayer/react-intl` में alias करता है। बड़ी JSON फाइलों को मैन्युअल रूप से पार्स करने और अपने ऐप को `IntlProvider` में लपेटने के बजाय, Intlayer plugin स्टैटिकली keys को निकालता है और runtime पर Intlayer dictionaries का उपयोग करता है।
+
+हुड के नीचे:
+
+- **ICU MessageFormat:** Intlayer `resolveMessage(..., 'icu')` resolver का उपयोग करता है जो ICU pluralization, selection, date/number formatting, और rich text tags को नेटिवली पूरी तरह support करता है।
+- **Method & JSX callers:** `intl.formatMessage({ id: 'a.b' })` और `<FormattedMessage id="a.b">` को Intlayer compiler plugins (`@intlayer/babel` / `@intlayer/swc`) द्वारा identify किया जाता है, flat dotted keys को convert करके ताकि पहला segment सही तरीके से Intlayer dictionary key को resolve करे।
+- **Formatters:** `<FormattedNumber>`, `<FormattedDate>`, आदि `Intl` का उपयोग करके native `core/formatters` में bridge करते हैं।

package/docs/hi/compat/svelte-i18n.md

@@ -0,0 +1,47 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Svelte I18n से Intlayer में माइग्रेट करें"
+description: "compat adapter का उपयोग करके अपने Svelte एप्लिकेशन को svelte-i18n से Intlayer में माइग्रेट करना सीखें।"
+keywords:
+  - svelte-i18n
+  - svelte
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - svelte-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Svelte I18n से Intlayer में माइग्रेट करें
+
+अपने Svelte एप्लिकेशन को `svelte-i18n` से Intlayer में माइग्रेट करना compat adapter का उपयोग करके बस एक पल में संभव है।
+
+## क्या करें
+
+अपने प्रोजेक्ट में बस निम्नलिखित initialization कमांड चलाएं:
+
+```bash
+npx intlayer init
+```
+
+यह `intlayer.config.ts` generate करता है। सुनिश्चित करें कि आपके SvelteKit / Vite plugins को Intlayer के alias plugin से wrap किया गया है ताकि `svelte-i18n` को `@intlayer/svelte-i18n` में seamlessly map किया जा सके।
+
+## यह हुड के तहत क्या करता है
+
+Svelte-i18n भारी उपयोग किए जाने वाले stores (`$_`, `$t`, `$format`, आदि) और ICU MessageFormat पर निर्भर करता है।
+
+हुड के तहत:
+
+- **Stores:** Intlayer, `svelte-i18n` stores को proxy करता है। `$_` वर्तमान locale का एक derived store बन जाता है जो एक Intlayer resolver लौटाता है।
+- **Keys:** आपकी flat keys (जैसे `$_('home.title')`) का मूल्यांकन इस तरह किया जाता है कि पहला path segment Intlayer dictionary का प्रतिनिधित्व करता है।
+- **ICU Syntax:** पूरी तरह shared ICU resolver (`intl-messageformat` समतुल्य parsing) द्वारा संभाला जाता है।
+- **Formatters:** `$date`, `$time`, `$number` कॉल Intlayer के native core formatters को सुरक्षित रूप से रीडायरेक्ट करते हैं।
+- **Babel/SWC Analysis:** Intlayer analyzer आपकी `.svelte` source files में Svelte store callers (`$_`) को compilation से पहले पढ़ता है ताकि स्वचालित रूप से प्रासंगिक dictionary chunks बनाए जा सकें।

package/docs/hi/compat/transloco.md

@@ -0,0 +1,45 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Transloco से Intlayer में माइग्रेट करें"
+description: "सीखें कि compat adapter का उपयोग करके अपने Angular एप्लिकेशन को Transloco से Intlayer में कैसे माइग्रेट करें।"
+keywords:
+  - transloco
+  - angular
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - transloco
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Transloco से Intlayer में माइग्रेट करें
+
+यदि आपकी Angular एप्लिकेशन वर्तमान में `@jsverse/transloco` का उपयोग करती है, तो आप हमारे compat adapter का उपयोग करके Intlayer में माइग्रेट कर सकते हैं। यह संक्रमण आपको अपने मौजूदा template syntax को बनाए रखते हुए Intlayer की शक्तिशाली dictionary संरचना का उपयोग करने की अनुमति देता है।
+
+## क्या करें
+
+अपने प्रोजेक्ट में बस initialization command चलाएं:
+
+```bash
+npx intlayer init
+```
+
+यह आवश्यक `intlayer.config.ts` configuration generate करेगा। फिर आप अपने Transloco imports को `@intlayer/transloco` modules के साथ replace कर सकते हैं या build aliases पर निर्भर रह सकते हैं।
+
+## यह हुड के नीचे क्या करता है
+
+Transloco scopes और एक `TranslocoService` (`translate`, `selectTranslate`) का उपयोग करता है, साथ ही structural directives (`*transloco="let t"`) और pipes (`| transloco`)।
+
+हुड के नीचे:
+
+- **Scopes:** Intlayer dictionary keys के लिए स्वाभाविक रूप से मैप करते हैं, bundle optimization के लिए एक बेहतरीन pruning story प्रदान करते हैं।
+- **Service & Directives:** Intlayer का Angular adapter seamlessly providers को बदलता है, जिससे आपके मौजूदा template pipes और directives Intlayer dictionaries के विरुद्ध strings को resolve कर सकते हैं।
+- **Build time parsing:** TypeScript analyzer `instant/get` calls को पहचानता है, और fallback pruning सुनिश्चित करता है कि सही है यहां तक कि जब template usage statically trackable न हो।

package/docs/hi/compat/vue-i18n.md

@@ -0,0 +1,58 @@
+---
+createdAt: 2026-06-13
+updatedAt: 2026-06-13
+title: "Vue I18n से Intlayer में माइग्रेट करें"
+description: "सीखें कि compat adapter का उपयोग करके अपने Vue एप्लिकेशन को vue-i18n से Intlayer में कैसे माइग्रेट करें।"
+keywords:
+  - vue-i18n
+  - vue
+  - intlayer
+  - migration
+  - compat
+slugs:
+  - doc
+  - compatibility
+  - vue-i18n
+history:
+  - version: 9.0.0
+    date: 2026-06-13
+    changes: "Init history"
+author: aymericzip
+---
+
+# Vue I18n से Intlayer में माइग्रेट करें
+
+यदि आपका Vue एप्लिकेशन वर्तमान में `vue-i18n` का उपयोग करता है, तो आप अपने components को फिर से लिखे बिना या translating hooks के बिना Intlayer में माइग्रेट कर सकते हैं। Intlayer एक compat adapter प्रदान करता है जो `vue-i18n` के API को perfectly mirror करता है जबकि hood के तहत Intlayer की शक्तिशाली features का लाभ उठाता है।
+
+## क्या करें
+
+शुरुआत करने के लिए, बस अपने प्रोजेक्ट में initialization command चलाएं:
+
+```bash
+npx intlayer init
+```
+
+Initialization के दौरान, Intlayer आपकी configuration file (`intlayer.config.ts`) को सेट अप करेगा और आपके प्रोजेक्ट को migration के लिए तैयार करेगा। आपको बस Intlayer plugin को अपनी Vite configuration में जोड़ना होगा ताकि `vue-i18n` imports को स्वचालित रूप से alias किया जा सके।
+
+```typescript fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+## यह हुड के नीचे क्या करता है
+
+`vueI18nVitePlugin` आपके bundler में एक मॉड्यूल alias को inject करता है। आपके codebase में `vue-i18n` का कोई भी import पारदर्शी रूप से `@intlayer/vue-i18n` पर रीडायरेक्ट किया जाएगा।
+
+**हुड के नीचे, adapter जटिल `vue-i18n` syntax को natively संभालता है:**
+
+- **Interpolation & Plurals:** `{name}` और list `{0}` interpolations को resolve करता है। Pipe plurals (`"car | cars"`) को positional semantics के आधार पर Intlayer enumeration/plural nodes में परिवर्तित किया जाता है।
+- **Formats:** `d()` और `n()` जैसे functions हुड के नीचे `Intl` को wrap करते हैं, आपके options में परिभाषित `datetimeFormats` और `numberFormats` को honor करते हुए।
+- **Global & Local State:** `global.locale` को एक `WritableComputedRef` पर मैप किया जाता है जो Intlayer client द्वारा समर्थित है, इसलिए reactivity बिल्कुल अपेक्षित रूप से व्यवहार करता है (उदाहरण के लिए `locale.value = 'fr'`)।
+- **Directives:** `v-t` directive को register किया जाता है और सामान्य रूप से कार्य करता है।
+
+आपका application पहले की तरह ही बिल्कुल rendering करता रहता है, लेकिन content आपके Intlayer dictionaries द्वारा powered होता है, जो आपको type safety, बेहतर bundle optimization, और seamless CMS integration देता है।

package/docs/hi/compiler.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-09-09
-updatedAt: 2026-03-12
+updatedAt: 2026-06-23
 title: Intlayer Compiler | i18n के लिए स्वचालित सामग्री निष्कर्षण
 description: Intlayer Compiler के साथ अपने अंतरराष्ट्रीयकरण प्रक्रिया को स्वचालित करें। Vite, Next.js, और अन्य में तेज़, अधिक कुशल i18n के लिए सीधे अपने कंपोनेंट्स से सामग्री निकालें।
 keywords:
@@ -60,6 +60,8 @@ author: aymericzip
 
 ## उपयोग
 
+> The quickest way to wire the compiler in is the interactive setup: run `npx intlayer init --interactive` and select **Compiler**. On Vite there is nothing to configure — the compiler is plugged in directly through the `intlayerCompiler()` plugin. On Next.js the command scaffolds the `babel.config.js` shown below. The non-interactive `intlayer init` leaves the compiler setup untouched.
+
 <Tabs>
  <Tab value='vite'>
 
@@ -79,12 +81,15 @@ npm install vite-intlayer
 
 ```ts fileName="vite.config.ts"
 import { defineConfig } from "vite";
-import { intlayer, intlayerCompiler } from "vite-intlayer";
+import { intlayer } from "vite-intlayer";
 
 export default defineConfig({
   plugins: [
-    intlayer(),
-    intlayerCompiler(), // कंपाइलर प्लगइन जोड़ता है
+    intlayer({
+      proxy: {
+        ignore: (req) => req.url?.startsWith("/api"),
+      },
+    }),
   ],
 });
 ```

package/docs/hi/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-05-12
+updatedAt: 2026-06-23
 title: कॉन्फ़िगरेशन (Configuration)
 description: जानें कि अपने एप्लिकेशन के लिए Intlayer को कैसे कॉन्फ़िगर करें। Intlayer को अपनी आवश्यकताओं के अनुसार अनुकूलित करने के लिए उपलब्ध विभिन्न सेटिंग्स और विकल्पों को समझें।
 keywords:
@@ -14,6 +14,12 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 9.0.0
+    date: 2026-06-24
+    changes: "Add `enableProxy` option to the routing configuration"
+  - version: 8.10.0
+    date: 2026-06-17
+    changes: "शब्दकोश कॉन्फ़िगरेशन में `format` विकल्प जोड़ा गया"
   - version: 8.9.4
     date: 2026-05-12
     changes: "LM Studio प्रदाता के लिए समर्थन जोड़ें"
@@ -135,6 +141,7 @@ Intlayer JSON, JS, MJS और TS कॉन्फ़िगरेशन फ़ा
 ````typescript fileName="intlayer.config.ts" codeFormat="typescript"
 import { Locales, type IntlayerConfig } from "intlayer";
 import { nextjsRewrite } from "intlayer/routing";
+import { syncJSON } from "@intlayer/sync-json-plugin";
 import { z } from "zod";
 
 /**
@@ -575,10 +582,38 @@ const config: IntlayerConfig = {
     }),
   },
 
+  /**
+   * शब्दकोश कॉन्फ़िगरेशन।
+   */
+  dictionary: {
+    /**
+     * यह नियंत्रित करता है कि शब्दकोश कैसे आयात किए जाते हैं।
+     * - "static": निर्माण के समय स्थिर रूप से आयातित।
+     * - "dynamic": सस्पेंस का उपयोग करके गतिशील रूप से आयातित।
+     * - "fetch": लाइव सिंक एपीआई के माध्यम से गतिशील रूप से प्राप्त किया गया।
+     */
+    importMode: "static",
+
+    /**
+     * प्रोजेक्ट में सभी शब्दकोशों के लिए डिफ़ॉल्ट संदेश प्रारूप।
+     * - 'intlayer': मूल intlayer प्रारूप (डिफ़ॉल्ट)।
+     * - 'icu': ICU संदेश प्रारूप।
+     * - 'i18next': i18next प्रारूप।
+     * - 'vue-i18n': Vue I18n प्रारूप।
+     * - 'po': GNU Gettext PO प्रारूप।
+     */
+    format: "icu",
+  },
+
   /**
    * प्लगइन्स कॉन्फ़िगरेशन।
    */
-  plugins: [],
+  plugins: [
+    syncJSON({
+      format: "icu",
+      source: ({ locale }) => `./messages/${locale}.json`,
+    }),
+  ],
 };
 
 export default config;
@@ -843,24 +878,40 @@ export default config;
 
 ---
 
+### System Configuration
+
+Intlayer के आंतरिक पथ और आउटपुट परिणामों से संबंधित सेटिंग्स। ये सेटिंग्स आम तौर पर आंतरिक हैं और उपयोगकर्ता द्वारा संशोधित करने की आवश्यकता नहीं होनी चाहिए।
+
+| Field                     | Description                                                                                 | Type     | Default                           | Example              | Note                                                                       |
+| ------------------------- | ------------------------------------------------------------------------------------------- | -------- | --------------------------------- | -------------------- | -------------------------------------------------------------------------- |
+| `baseDir`                 | प्रोजेक्ट के लिए बेस डायरेक्टरी।                                                            | `string` | `process.cwd()`                   | `'/path/to/project'` | सभी Intlayer-संबंधित डायरेक्टरी को resolve करने के लिए उपयोग किया जाता है। |
+| `dictionariesDir`         | लोकलाइजेशन डिक्शनरी को स्टोर करने के लिए डायरेक्टरी पथ।                                     | `string` | `'.intlayer/dictionary'`          |                      |                                                                            |
+| `moduleAugmentationDir`   | Module augmentation के लिए डायरेक्टरी, जो बेहतर IDE सुझाव और टाइप चेकिंग की अनुमति देती है। | `string` | `'.intlayer/types'`               | `'intlayer-types'`   | सुनिश्चित करें कि यह `tsconfig.json` में शामिल है।                         |
+| `unmergedDictionariesDir` | अनमर्ज्ड डिक्शनरी को स्टोर करने के लिए डायरेक्टरी।                                          | `string` | `'.intlayer/unmerged_dictionary'` |                      |                                                                            |
+| `typesDir`                | डिक्शनरी प्रकार को स्टोर करने के लिए डायरेक्टरी।                                            | `string` | `'.intlayer/types'`               |                      |                                                                            |
+| `mainDir`                 | डायरेक्टरी जहां मुख्य एप्लिकेशन फाइलें स्टोर की जाती हैं।                                   | `string` | `'.intlayer/main'`                |                      |                                                                            |
+| `configDir`               | डायरेक्टरी जहां कॉन्फ़िगरेशन फाइलें स्टोर की जाती हैं।                                      | `string` | `'.intlayer/config'`              |                      |                                                                            |
+| `cacheDir`                | डायरेक्टरी जहां कैश फाइलें स्टोर की जाती हैं।                                               | `string` | `'.intlayer/cache'`               |                      |                                                                            |
+
 ### डिक्शनरी कॉन्फ़िगरेशन (Dictionary)
 
 डिक्शनरी संचालन को नियंत्रित करने वाले मापदंड, जिसमें ऑटो-फिल व्यवहार और कंटेंट जनरेशन शामिल है।
 
-| फ़ील्ड                      | विवरण                                                                                                                                                             | टाइप                                                                                                            | डिफ़ॉल्ट    | उदाहरण                                                                                      | टिप्पणी                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `fill`                      | नियंत्रित करता है कि ऑटो-फिल (AI अनुवाद) आउटपुट फ़ाइलें कैसे उत्पन्न होती हैं।                                                                                    | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`      | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: डिफ़ॉल्ट पाथ (स्रोत के समान फ़ाइल)।<br/>• `false`: अक्षम करें।<br/>• टेम्पलेट स्ट्रिंग/फ़ंक्शन प्रति लोकेल फ़ाइलें उत्पन्न करता है।<br/>• प्रति लोकेल ऑब्जेक्ट: प्रत्येक लोकेल अपने टेम्पलेट से मेल खाता है; `false` उस लोकेल को अनदेखा करता है।<br/>• `{{locale}}` का समावेश प्रति लोकेल जनरेशन को सक्रिय करता है।<br/>• डिक्शनरी स्तर पर `fill` हमेशा इस वैश्विक सेटिंग पर प्राथमिकता लेता है।                       |
-| `description`               | एडिटर और CMS को डिक्शनरी के उद्देश्य को समझने में मदद करता है। AI का उपयोग करके अनुवाद उत्पन्न करने के लिए संदर्भ के रूप में भी उपयोग किया जाता है।               | `string`                                                                                                        | `undefined` | `'User profile section'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `locale`                    | डिक्शनरी को किसी विशिष्ट लोकेल के प्रारूप में बदल देता है। प्रत्येक घोषित फ़ील्ड एक अनुवाद नोड बन जाता है। यदि अनुपस्थित है, तो डिक्शनरी को बहुभाषी माना जाता है। | `LocalesValues`                                                                                                 | `undefined` | `'en'`                                                                                      | यदि डिक्शनरी कई अनुवादों के बजाय एक विशिष्ट लोकेल के लिए है, तो इसका उपयोग करें।                                                                                                                                                                                                                                                                                                                                                 |
-| `contentAutoTransformation` | कंटेंट स्ट्रिंग्स को स्वचालित रूप से टाइप किए गए नोड्स (मार्कडाउन, HTML या सम्मिलन) में रूपांतरित करता है।                                                        | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`     | `true`                                                                                      | • मार्कडाउन : `### Title` → `md('### Title')` ।<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')` ।<br/>• सम्मिलन : `Hello {{name}}` → `insert('Hello {{name}}')` ।                                                                                                                                                                                                                                                   |
-| `location`                  | इंगित करता है कि डिक्शनरी फ़ाइलें कहाँ संग्रहीत हैं और वे CMS के साथ कैसे सिंक की जाती हैं।                                                                       | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`   | `'hybrid'`                                                                                  | • `'local'`: केवल स्थानीय प्रबंधन।<br/>• `'remote'`: केवल दूरस्थ प्रबंधन (CMS)।<br/>• `'hybrid'`: स्थानीय और दूरस्थ प्रबंधन दोनों।<br/>• `'plugin'` या कस्टम स्ट्रिंग: प्लगइन या कस्टम स्रोत द्वारा प्रबंधन।                                                                                                                                                                                                                     |
-| `importMode`                | डिक्शनरी कैसे आयात की जाती है, इसे नियंत्रित करता है।                                                                                                             | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`  | `'dynamic'`                                                                                 | • `'static'`: स्थिर आयात।<br/>• `'dynamic'`: Suspense के माध्यम से गतिशील आयात।<br/>• `'fetch'`: लाइव सिंक API के माध्यम से फ़ेच; विफल होने पर `'dynamic'` पर वापस जाना।<br/>• `@intlayer/babel` और `@intlayer/swc` प्लगइन्स की आवश्यकता होती है।<br/>• की (keys) को स्थिर रूप से घोषित किया जाना चाहिए।<br/>• यदि `optimize` बंद है, तो अनदेखा किया जाता है।<br/>• `getIntlayer`, `getDictionary` आदि को प्रभावित नहीं करता है। |
-| `priority`                  | डिक्शनरी प्राथमिकता। डिक्शनरी के बीच संघर्षों को सुलझाने के दौरान उच्च मान निम्न मानों पर जीतते हैं।                                                              | `number`                                                                                                        | `undefined` | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `live`                      | अप्रचलित - `importMode: 'fetch'` का उपयोग करें। इंगित किया गया कि डिक्शनरी कंटेंट को लाइव सिंक API के माध्यम से गतिशील रूप से फ़ेच किया जाना चाहिए या नहीं।       | `boolean`                                                                                                       | `undefined` |                                                                                             | v8.0.0 में नाम बदलकर `importMode: 'fetch'` कर दिया गया।                                                                                                                                                                                                                                                                                                                                                                          |
-| `schema`                    | JSON स्कीमा सत्यापन के लिए Intlayer द्वारा स्वचालित रूप से जेनरेट किया गया।                                                                                       | `'https://intlayer.org/schema.json'`                                                                            | ऑटो-जनरेशन  |                                                                                             | मैन्युअल रूप से संपादित न करें।                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `title`                     | एडिटर और CMS में डिक्शनरी की पहचान करने में मदद करता है।                                                                                                          | `string`                                                                                                        | `undefined` | `'User Profile'`                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `tags`                      | डिक्शनरी को श्रेणीबद्ध करता है और एडिटर और AI के लिए संदर्भ या निर्देश प्रदान करता है।                                                                            | `string[]`                                                                                                      | `undefined` | `['user', 'profile']`                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `version`                   | दूरस्थ डिक्शनरी का संस्करण; वर्तमान में उपयोग किए जा रहे संस्करण को ट्रैक करने में मदद करता है।                                                                   | `string`                                                                                                        | `undefined` | `'1.0.0'`                                                                                   | • CMS में प्रबंधित।<br/>• स्थानीय रूप से संपादित न करें।                                                                                                                                                                                                                                                                                                                                                                         |
+| फ़ील्ड                      | विवरण                                                                                                                                                             | टाइप                                                                                                            | डिफ़ॉल्ट     | उदाहरण                                                                                      | टिप्पणी                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `fill`                      | नियंत्रित करता है कि ऑटो-फिल (AI अनुवाद) आउटपुट फ़ाइलें कैसे उत्पन्न होती हैं।                                                                                    | `boolean` &#124; <br/> `FilePathPattern` &#124; <br/> `Partial<Record<Locale, boolean &#124; FilePathPattern>>` | `true`       | `{ en: '/locales/en/{{key}}.json', fr: ({ key }) => '/locales/fr/${key}.json', es: false }` | • `true`: डिफ़ॉल्ट पाथ (स्रोत के समान फ़ाइल)।<br/>• `false`: अक्षम करें।<br/>• टेम्पलेट स्ट्रिंग/फ़ंक्शन प्रति लोकेल फ़ाइलें उत्पन्न करता है।<br/>• प्रति लोकेल ऑब्जेक्ट: प्रत्येक लोकेल अपने टेम्पलेट से मेल खाता है; `false` उस लोकेल को अनदेखा करता है।<br/>• `{{locale}}` का समावेश प्रति लोकेल जनरेशन को सक्रिय करता है।<br/>• डिक्शनरी स्तर पर `fill` हमेशा इस वैश्विक सेटिंग पर प्राथमिकता लेता है।                       |
+| `description`               | एडिटर और CMS को डिक्शनरी के उद्देश्य को समझने में मदद करता है। AI का उपयोग करके अनुवाद उत्पन्न करने के लिए संदर्भ के रूप में भी उपयोग किया जाता है।               | `string`                                                                                                        | `undefined`  | `'User profile section'`                                                                    |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `locale`                    | डिक्शनरी को किसी विशिष्ट लोकेल के प्रारूप में बदल देता है। प्रत्येक घोषित फ़ील्ड एक अनुवाद नोड बन जाता है। यदि अनुपस्थित है, तो डिक्शनरी को बहुभाषी माना जाता है। | `LocalesValues`                                                                                                 | `undefined`  | `'en'`                                                                                      | यदि डिक्शनरी कई अनुवादों के बजाय एक विशिष्ट लोकेल के लिए है, तो इसका उपयोग करें।                                                                                                                                                                                                                                                                                                                                                 |
+| `contentAutoTransformation` | कंटेंट स्ट्रिंग्स को स्वचालित रूप से टाइप किए गए नोड्स (मार्कडाउन, HTML या सम्मिलन) में रूपांतरित करता है।                                                        | `boolean` &#124; <br/> `{ markdown?: boolean; html?: boolean; insertion?: boolean }`                            | `false`      | `true`                                                                                      | • मार्कडाउन : `### Title` → `md('### Title')` ।<br/>• HTML : `<div>Title</div>` → `html('<div>Title</div>')` ।<br/>• सम्मिलन : `Hello {{name}}` → `insert('Hello {{name}}')` ।                                                                                                                                                                                                                                                   |
+| `location`                  | इंगित करता है कि डिक्शनरी फ़ाइलें कहाँ संग्रहीत हैं और वे CMS के साथ कैसे सिंक की जाती हैं।                                                                       | `'local'` &#124; <br/> `'remote'` &#124; <br/> `'hybrid'` &#124; <br/> `'plugin'` &#124; <br/> `string`         | `'local'`    | `'hybrid'`                                                                                  | • `'local'`: केवल स्थानीय प्रबंधन।<br/>• `'remote'`: केवल दूरस्थ प्रबंधन (CMS)।<br/>• `'hybrid'`: स्थानीय और दूरस्थ प्रबंधन दोनों।<br/>• `'plugin'` या कस्टम स्ट्रिंग: प्लगइन या कस्टम स्रोत द्वारा प्रबंधन।                                                                                                                                                                                                                     |
+| `importMode`                | डिक्शनरी कैसे आयात की जाती है, इसे नियंत्रित करता है।                                                                                                             | `'static'` &#124; <br/> `'dynamic'` &#124; <br/> `'fetch'`                                                      | `'static'`   | `'dynamic'`                                                                                 | • `'static'`: स्थिर आयात।<br/>• `'dynamic'`: Suspense के माध्यम से गतिशील आयात।<br/>• `'fetch'`: लाइव सिंक API के माध्यम से फ़ेच; विफल होने पर `'dynamic'` पर वापस जाना।<br/>• `@intlayer/babel` और `@intlayer/swc` प्लगइन्स की आवश्यकता होती है।<br/>• की (keys) को स्थिर रूप से घोषित किया जाना चाहिए।<br/>• यदि `optimize` बंद है, तो अनदेखा किया जाता है।<br/>• `getIntlayer`, `getDictionary` आदि को प्रभावित नहीं करता है। |
+| `format`                    | प्रोजेक्ट में सभी शब्दकोशों के लिए डिफ़ॉल्ट संदेश प्रारूप।                                                                                                        | `'intlayer'` &#124; <br/> `'icu'` &#124; <br/> `'i18next'` &#124; <br/> `'vue-i18n'` &#124; <br/> `'po'`        | `'intlayer'` | `'icu'`                                                                                     | • `'intlayer'`: मूल intlayer प्रारूप।<br/>• `'icu'`: ICU संदेश प्रारूप।<br/>• `'i18next'`: i18next प्रारूप।<br/>• `'vue-i18n'`: Vue I18n प्रारूप।<br/>• `'po'`: GNU Gettext PO प्रारूप।                                                                                                                                                                                                                                          |
+| `priority`                  | डिक्शनरी प्राथमिकता। डिक्शनरी के बीच संघर्षों को सुलझाने के दौरान उच्च मान निम्न मानों पर जीतते हैं।                                                              | `number`                                                                                                        | `undefined`  | `1`                                                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `live`                      | अप्रचलित - `importMode: 'fetch'` का उपयोग करें। इंगित किया गया कि डिक्शनरी कंटेंट को लाइव सिंक API के माध्यम से गतिशील रूप से फ़ेच किया जाना चाहिए या नहीं।       | `boolean`                                                                                                       | `undefined`  |                                                                                             | v8.0.0 में नाम बदलकर `importMode: 'fetch'` कर दिया गया।                                                                                                                                                                                                                                                                                                                                                                          |
+| `schema`                    | JSON स्कीमा सत्यापन के लिए Intlayer द्वारा स्वचालित रूप से जेनरेट किया गया।                                                                                       | `'https://intlayer.org/schema.json'`                                                                            | ऑटो-जनरेशन   |                                                                                             | मैन्युअल रूप से संपादित न करें।                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `title`                     | एडिटर और CMS में डिक्शनरी की पहचान करने में मदद करता है।                                                                                                          | `string`                                                                                                        | `undefined`  | `'User Profile'`                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `tags`                      | डिक्शनरी को श्रेणीबद्ध करता है और एडिटर और AI के लिए संदर्भ या निर्देश प्रदान करता है।                                                                            | `string[]`                                                                                                      | `undefined`  | `['user', 'profile']`                                                                       |                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `version`                   | दूरस्थ डिक्शनरी का संस्करण; वर्तमान में उपयोग किए जा रहे संस्करण को ट्रैक करने में मदद करता है।                                                                   | `string`                                                                                                        | `undefined`  | `'1.0.0'`                                                                                   | • CMS में प्रबंधित।<br/>• स्थानीय रूप से संपादित न करें।                                                                                                                                                                                                                                                                                                                                                                         |
 
 **`fill` उदाहरण**:
 
@@ -950,22 +1001,6 @@ Intlayer आपके एप्लिकेशन के अंतर्रा
 
 ---
 
-### सिस्टम कॉन्फ़िगरेशन (System)
-
-ये सेटिंग्स उन्नत उपयोग के मामलों और Intlayer के आंतरिक कॉन्फ़िगरेशन के लिए अभिप्रेत हैं।
-
-| फ़ील्ड                    | विवरण                                                      | टाइप     | डिफ़ॉल्ट                          | उदाहरण | टिप्पणी |
-| ------------------------- | ---------------------------------------------------------- | -------- | --------------------------------- | ------ | ------- |
-| `dictionariesDir`         | संकलित डिक्शनरी के लिए निर्देशिका।                         | `string` | `'.intlayer/dictionary'`          |        |         |
-| `moduleAugmentationDir`   | TypeScript मॉड्यूल ऑगमेंटेशन के लिए निर्देशिका।            | `string` | `'.intlayer/types'`               |        |         |
-| `unmergedDictionariesDir` | बिना मर्ज किए गए डिक्शनरी संग्रहीत करने के लिए निर्देशिका। | `string` | `'.intlayer/unmerged_dictionary'` |        |         |
-| `typesDir`                | जेनरेट किए गए टाइप्स के लिए निर्देशिका।                    | `string` | `'.intlayer/types'`               |        |         |
-| `mainDir`                 | Intlayer की मुख्य फ़ाइल की निर्देशिका।                     | `string` | `'.intlayer/main'`                |        |         |
-| `configDir`               | संकलित कॉन्फ़िगरेशन फ़ाइलों की निर्देशिका।                 | `string` | `'.intlayer/config'`              |        |         |
-| `cacheDir`                | कैश फ़ाइलों के लिए निर्देशिका।                             | `string` | `'.intlayer/cache'`               |        |         |
-
----
-
 ### कंपाइलर कॉन्फ़िगरेशन (Compiler)
 
 Intlayer कंपाइलर को नियंत्रित करने वाली सेटिंग्स, जो आपके घटकों से सीधे डिक्शनरी निकालती है।