@intlayer/docs 9.3.3 → 9.4.0

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

@@ -0,0 +1,197 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayer फंक्शन डॉक्यूमेंटेशन | intlayer
+description: intlayer पैकेज के लिए getIntlayer फंक्शन का उपयोग कैसे करें देखें
+keywords:
+  - getIntlayer
+  - dictionary
+  - content
+  - selector
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "प्रारंभिक डॉक्यूमेंटेशन"
+author: aymericzip
+---
+
+# दस्तावेज़: `intlayer` में `getIntlayer` फ़ंक्शन
+
+## विवरण
+
+`getIntlayer` फ़ंक्शन अपनी key द्वारा एक डिक्शनरी चुनता है और दिए गए locale के लिए इसकी content को return करता है। यह `useIntlayer` hook का framework-agnostic समकक्ष है: समान content, समान selectors, लेकिन कहीं भी usable जहाँ React context उपलब्ध नहीं है — Node scripts, server functions, route loaders, metadata builders, Express/Fastify handlers, tests.
+
+यह Intlayer द्वारा `.intlayer/` में जनरेट की गई डिक्शनरीज़ को पढ़ता है, इसलिए `key` argument typed है और आपकी अपनी content declarations से autocompleted है, और returned object प्रत्येक leaf तक पूरी तरह typed है।
+
+**मुख्य विशेषताएं:**
+
+- Typed dictionary keys और typed returned content
+- प्रत्येक content node को interpret करता है (`t()`, `enu()`, `cond()`, `insert()`, `nest()`, `md()`, `html()`, `file()`, `gender()`)
+- locale या selector object (collections, variants) स्वीकार करता है
+- Results `key + locale + selector` के अनुसार memoized हैं
+- Development में एक safe proxy में fallback करता है जब dictionary missing हो, crash करने के बजाय
+
+---
+
+## फ़ंक्शन सिग्नेचर
+
+```typescript
+getIntlayer(
+  key: DictionaryKeys,                        // आवश्यक
+  localeOrSelector?: LocalesValues | DictionarySelector, // वैकल्पिक
+  plugins?: Plugins[]                         // वैकल्पिक
+): DeepTransformContent<...>
+```
+
+---
+
+## पैरामीटर
+
+- `key: DictionaryKeys`
+  - **Description**: डिक्शनरी की कुंजी जिसे पढ़ना है, जैसा कि आपकी कंटेंट फाइलों में घोषित किया गया है।
+  - **Type**: `DictionaryKeys` — हर घोषित डिक्शनरी कुंजी का एक union।
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: कंटेंट को interpret करने के लिए locale, या [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/index.md) के लिए एक selector object।
+    - `'fr'` — एक locale
+    - `{ item: 2 }` — एक [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/collections.md) item (सभी items को array के रूप में प्राप्त करने के लिए `item` को omit करें)
+    - `{ variant: 'black-friday' }` — एक named [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/variants.md) (`default` के लिए omit करें)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — एक structured variant
+    - कोई भी selector एक locale ले सकता है: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — configured `defaultLocale` को default करता है।
+
+- `plugins: Plugins[]`
+  - **Description**: Custom node transformers जो base interpreter plugins को replace करते हैं। Advanced use only; default behaviour रखने के लिए इसे omit करें।
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### रिटर्न्स
+
+- **Type**: शब्दकोश की व्याख्या की गई सामग्री, आपकी घोषणा से टाइप की गई।
+- **Description**: आपके शब्दकोश के `content` फील्ड को दर्शाने वाली एक सादी object, जहां प्रत्येक Intlayer नोड को अनुरोधित locale के लिए अंतिम मान में resolve किया गया है।
+
+---
+
+## उदाहरण उपयोग
+
+### बुनियादी उपयोग
+
+```typescript fileName="src/app.content.ts" codeFormat="typescript"
+import { t, type Dictionary } from "intlayer";
+
+const appContent = {
+  key: "app",
+  content: {
+    title: t({
+      hi: "नमस्ते",
+      en: "Hello",
+      fr: "Bonjour",
+    }),
+  },
+} satisfies Dictionary;
+
+export default appContent;
+```
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app", "fr"); // "Bonjour"
+```
+
+### बिना locale के
+
+Locale को छोड़ देने से content को आपके [configuration](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/configuration.md) में घोषित `defaultLocale` के साथ interpret किया जाता है।
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+const { title } = getIntlayer("app"); // Default locale के साथ interpret किया गया
+```
+
+### एक सर्वर हैंडलर के अंदर
+
+```typescript fileName="src/routes/greeting.ts" codeFormat="typescript"
+import { getIntlayer, getLocale } from "intlayer";
+
+export const greetingHandler = async (request: Request) => {
+  const locale = await getLocale({
+    getHeader: (name) => request.headers.get(name) ?? undefined,
+  });
+
+  const { title } = getIntlayer("app", locale);
+
+  return Response.json({ title });
+};
+```
+
+### एक सिलेक्टर के साथ (collections और variants)
+
+```typescript
+import { getIntlayer } from "intlayer";
+
+// एक एकल collection item
+const secondPost = getIntlayer("blog-post", { item: 2, locale: "fr" });
+
+// collection का प्रत्येक item, एक क्रमबद्ध array के रूप में
+const allPosts = getIntlayer("blog-post", { locale: "fr" });
+
+// एक नाम वाला variant
+const banner = getIntlayer("banner", { variant: "black-friday", locale: "fr" });
+```
+
+---
+
+## व्यवहार नोट्स
+
+### कैशिंग
+
+परिणाम एक मॉड्यूल-स्तरीय कैश में `key + locale + selector` के आधार पर संग्रहीत होते हैं। `getIntlayer("app", "fr")` को बार-बार कॉल करने से शब्दकोश की व्याख्या एक बार होती है और उसके बाद वही ऑब्जेक्ट वापस किया जाता है।
+
+### अनुपलब्ध शब्दकोश
+
+विकास में, एक ऐसी कुंजी का अनुरोध करना जिसके पास कोई जनित शब्दकोश नहीं है, एक बार एक चेतावनी लॉग करता है और एक सुरक्षित फॉलबैक प्रॉक्सी लौटाता है: `content.title` को पढ़ने से `"app.title"` स्ट्रिंग उत्पन्न होती है। यह एक पृष्ठ को उपयोग योग्य रखता है जबकि अनुपलब्ध घोषणा को ठीक किया जाता है। Intlayer बिल्ड चलाएं (या dev सर्वर) ताकि शब्दकोश जनित हो सके।
+
+### Bundle size
+
+`getIntlayer` merged dictionary को पढ़ता है, जो **हर** locale को hold करता है। Client bundles में, [build plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/bundle_optimization.md) call को rewrite करते हैं ताकि केवल required content ship हो। जब आप rendering के बाहर content को पढ़ते हैं (metadata, loaders, server functions) और single locale को on demand load करना चाहते हैं, तो इसके बजाय [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayerAsync.md) का उपयोग करें।
+
+---
+
+## संबंधित फ़ंक्शन
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayerAsync.md): एक single locale chunk को लोड करने वाला Async counterpart।
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getDictionary.md): एक dictionary object को interpret करता है जो आप स्वयं पास करते हैं, key द्वारा देखे गए object के बजाय।
+- [`useIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/react-intlayer/useIntlayer.md): React hook का समतुल्य, provider से locale को पढ़ता है।
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayer<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  DictionaryRegistryResult<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

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

@@ -0,0 +1,141 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getIntlayerAsync Function Documentation | intlayer
+description: getIntlayerAsync फ़ंक्शन को intlayer पैकेज के लिए कैसे उपयोग करें यह देखें
+keywords:
+  - getIntlayerAsync
+  - dictionary
+  - dynamic import
+  - metadata
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getIntlayerAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# दस्तावेज़: `intlayer` में `getIntlayerAsync` फ़ंक्शन
+
+## विवरण
+
+`getIntlayerAsync` फ़ंक्शन अपनी key के आधार पर एक डिक्शनरी चुनता है और दिए गए locale के लिए उसकी content को resolve करता है, **केवल उस locale को लोड करते हुए**।
+
+यह [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayer.md) का asynchronous counterpart है, जिसका उपयोग उन जगहों पर किया जाता है जहां डिक्शनरी rendering के बाहर पढ़ी जाती है — route `head` / metadata builders, loaders, server functions।
+
+जहां `getIntlayer` merged डिक्शनरी को pull करता है जिसमें हर locale है, वहीं [build plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/bundle_optimization.md) (`@intlayer/babel`, `@intlayer/swc`) इस call को `getDictionaryAsync(loaderMap, key, locale)` में rewrite करते हैं, जो `.intlayer/dynamic_dictionaries/` में per-locale chunks की ओर इशारा करते हैं। इसलिए bundle केवल वास्तव में अनुरोधित locale को ही carry करता है।
+
+इन plugins के बिना — एक unoptimized build — call synchronous dictionary registry के माध्यम से resolve होती है: वही content, per-locale split के बिना।
+
+**मुख्य विशेषताएं:**
+
+- `getIntlayer` के समान typed keys, selectors और returned content
+- Optimized builds में केवल अनुरोधित locale chunk को load करता है
+- एक ही chunk के लिए Concurrent calls एक single load share करती हैं
+- `async` metadata builders, loaders और server functions में उपयोग के लिए सुरक्षित
+
+---
+
+## Function Signature
+
+```typescript
+getIntlayerAsync(
+  key: DictionaryKeys,                        // आवश्यक
+  localeOrSelector?: LocalesValues | DictionarySelector, // वैकल्पिक
+  plugins?: Plugins[]                         // वैकल्पिक
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## पैरामीटर
+
+- `key: DictionaryKeys`
+  - **विवरण**: डिक्शनरी की कुंजी जिसे पढ़ना है, जैसा कि आपकी content files में घोषित किया गया है।
+  - **Type**: `DictionaryKeys` — हर घोषित डिक्शनरी कुंजी का एक union।
+  - **आवश्यक**: हाँ
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **विवरण**: content को interpret करने के लिए locale, या [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/index.md) के लिए एक selector object।
+    - `'fr'` — एक locale
+    - `{ item: 2 }` — एक [collection](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/collections.md) item (हर item को array के रूप में पाने के लिए `item` को omit करें)
+    - `{ variant: 'black-friday' }` — एक नाम दिया गया [variant](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/variants.md) (`default` के लिए omit करें)
+    - `{ variant: { id: 'prod_abc', userId: '123' } }` — एक structured variant
+    - कोई भी selector एक locale ले सकता है: `{ item: 2, locale: 'fr' }`
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **आवश्यक**: नहीं (Optional) — configured `defaultLocale` को default करता है।
+
+- `plugins: Plugins[]`
+  - **विवरण**: Custom node transformers जो base interpreter plugins को replace करते हैं। Advanced use only।
+  - **Type**: `Plugins[]`
+  - **आवश्यक**: नहीं (Optional)
+
+### Returns
+
+- **Type**: `Promise<Content>` — एक promise जो आपकी घोषणा से टाइप किए गए dictionary की interpreted content को resolve करता है।
+
+---
+
+## उदाहरण उपयोग
+
+### बुनियादी उपयोग
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getIntlayerAsync } from "intlayer";
+
+const { title } = await getIntlayerAsync("app", "fr"); // "Bonjour"
+```
+
+---
+
+## `getIntlayer` vs `getIntlayerAsync`
+
+|                    | [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayer.md) | `getIntlayerAsync`                                      |
+| ------------------ | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
+| Returns            | सामग्री                                                                                                         | सामग्री का एक promise                                   |
+| Dictionary loaded  | मर्ज किया गया शब्दकोश (सभी locales)                                                                             | केवल अनुरोधित locale का chunk                           |
+| Best suited for    | Rendering, synchronous code paths                                                                               | Metadata, loaders, server functions                     |
+| Requires a plugin? | नहीं                                                                                                            | नहीं — per-locale split को build plugins की आवश्यकता है |
+
+दोनों एक ही arguments स्वीकार करते हैं और एक ही सामग्री return करते हैं: एक से दूसरे में स्विच करने से केवल **कब** और **कितना** load होता है, यह बदलता है।
+
+---
+
+## संबंधित Functions
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayer.md): Synchronous equivalent जो merged dictionary को पढ़ता है।
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getDictionaryAsync.md): The lower-level function जिसे build plugins इस call को rewrite करते हैं।
+- [`getLocale`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getLocale.md): Incoming request की locale को detect करता है।
+
+---
+
+## TypeScript
+
+```typescript
+function getIntlayerAsync<
+  const T extends DictionaryKeys,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  key: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    DictionaryRegistryResult<T, A>,
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 The `getLocalizedPath` फ़ंक्शन एक कैनोनिकल पाथ (आंतरिक एप्लिकेशन पाथ) को दिए गए locale और rewrite नियमों के आधार पर उसके लोकलाइज़्ड समतुल्य में resolve करता है। यह विशेष रूप से उन SEO-friendly URLs को जनरेट करने के लिए उपयोगी है जो भाषा के अनुसार बदलते हैं।
 
+यह [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getLocalizedUrl.md) का सापेक्ष समकक्ष है — एक सापेक्ष इनपुट के लिए दोनों समान मान लौटाते हैं। `getLocalizedUrl` के विपरीत, यह कभी भी एक निरपेक्ष URL नहीं लौटाता है: `domains` कॉन्फ़िगरेशन को अनदेखा किया जाता है, इसलिए एक लोकेल जो अपने स्वयं के डोमेन से परोसा जाता है फिर भी एक पथ प्राप्त करता है। एक निरपेक्ष इनपुट स्वीकार किया जाता है, लेकिन इसकी उत्पत्ति को छोड़ दिया जाता है — केवल इसका पथ, क्वेरी स्ट्रिंग और हैश रखे जाते हैं।
+
 **मुख्य विशेषताएँ:**
 
 - `[param]` सिंटैक्स का उपयोग करके डायनामिक रूट पैरामीटर का समर्थन करता है।
@@ -60,13 +62,17 @@ getLocalizedPath(
   - **प्रकार**: `string`
   - **आवश्यक**: हाँ
 
-- `locale: Locales`
-  - **विवरण**: वह लक्षित locale जिसके लिए पथ स्थानीयकृत किया जाना चाहिए।
-  - **प्रकार**: `Locales`
-  - **आवश्यक**: हाँ
-
 ### वैकल्पिक पैरामीटर
 
+- `locale?: Locales`
+  - **Description**: वह target locale जिसके लिए path को localize किया जाना चाहिए।
+  - **Type**: `Locales`
+  - **Default**: आपकी project के configuration का default locale।
+
+- `options?: object`
+  - **Description**: Routing ओवरराइड्स। प्रत्येक entry आपके project के configuration पर default होता है।
+  - **Type**: `object`
+
 - `rewriteRules?: RoutingConfig['rewrite']`
   - **विवरण**: कस्टम rewrite नियमों को परिभाषित करने वाला एक ऑब्जेक्ट। यदि प्रदान नहीं किया गया है, तो यह आपके प्रोजेक्ट कॉन्फ़िगरेशन की `routing.rewrite` प्रॉपर्टी पर डिफॉल्ट होगा।
   - **प्रकार**: `RoutingConfig['rewrite']`
@@ -79,6 +85,28 @@ getLocalizedPath(
 - **प्रकार**: `string`
 - **विवरण**: निर्दिष्ट locale के लिए स्थानीयकृत पथ।
 
+प्रकार आपके कॉन्फ़िगरेशन में घोषित rewrite rules से narrow किया जाता है, इसलिए editor एक bare `string` के बजाय resolved path दिखाता है:
+
+```typescript codeFormat="typescript"
+// कॉन्फ़िगरेशन: मोड 'prefix-no-default', defaultLocale 'en',
+//                { '/about': { fr: '/a-propos' }, '/product/[id]': { fr: '/produit/[id]' } }
+const about = getLocalizedPath("/about", Locales.FRENCH);
+//    ^? '/fr/a-propos'
+const product = getLocalizedPath("/product/123", Locales.FRENCH);
+//    ^? '/fr/produit/123'
+const contact = getLocalizedPath("/contact", Locales.FRENCH);
+//    ^? '/fr/contact'  (कोई रीराइट नियम मेल नहीं खाता, केवल प्रीफिक्स लागू किया जाता है)
+const home = getLocalizedPath("/", Locales.FRENCH);
+//    ^? '/fr'
+```
+
+यही संकीर्णन [`getLocalizedUrl`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getLocalizedUrl.md) में बहता है, जो locale को prefix करने से पहले rewrite rules को लागू करता है।
+
+दो मामले `string` तक विस्तृत रहते हैं, क्योंकि उन्हें compile time पर resolve नहीं किया जा सकता:
+
+- एक path जो string literal नहीं है (उदाहरण के लिए, एक variable से बनाई गई);
+- एक path जो multi-segment या optional parameter का उपयोग करते हुए एक rule से मेल खाती है (`[...slug]`, `[[...slug]]`, `:param?`)।
+
 ---
 
 ## उदाहरण उपयोग
@@ -126,6 +154,18 @@ getLocalizedPath("/contact", Locales.FRENCH, manualRules);
 // Output: "/contactez-nous"
 ```
 
+### Locale को छोड़ना
+
+जब कोई locale नहीं दिया जाता है, तो पथ को कॉन्फ़िगर किए गए डिफ़ॉल्ट locale के लिए स्थानीयकृत किया जाता है:
+
+```typescript codeFormat="typescript"
+import { getLocalizedPath } from "intlayer";
+
+// Configuration: defaultLocale = Locales.ENGLISH, { '/about': { en: '/about', fr: '/a-propos' } }
+getLocalizedPath("/about");
+// Output: "/about"
+```
+
 ---
 
 ## संबंधित फ़ंक्शन

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

@@ -169,21 +169,6 @@ getLocalizedUrl(
 // आउटपुट: डिफ़ॉल्ट (अंग्रेज़ी) लोकल के लिए "/about"
 ```
 
-```javascript codeFormat="commonjs"
-const { getLocalizedUrl, Locales } = require("intlayer");
-
-getLocalizedUrl(
-  "/about",
-  Locales.FRENCH,
-  [Locales.ENGLISH, Locales.FRENCH],
-  Locales.ENGLISH,
-  false
-);
-
-// आउटपुट: फ्रेंच लोकल के लिए "/fr/about"
-// आउटपुट: डिफ़ॉल्ट (अंग्रेज़ी) लोकल के लिए "/about"
-```
-
 ### पूर्ण URL
 
 ```typescript
@@ -236,6 +221,12 @@ getLocalizedUrl(
 - **असमर्थित लोकल:**
   - `locales` में सूचीबद्ध नहीं किए गए लोकल के लिए, फ़ंक्शन कोई प्रीफिक्स लागू नहीं करता।
 
+- **राउटिंग मोड्स:**
+  - `'prefix-no-default'`: डिफ़ॉल्ट लोकेल के पास कोई उपसर्ग नहीं है, अन्य के पास हैं (उदाहरण के लिए, `/about`, `/fr/about`)
+  - `'prefix-all'`: सभी लोकेल्स के पास उपसर्ग हैं (उदाहरण के लिए, `/en/about`, `/fr/about`)
+  - `'no-prefix'`: URLs में कोई लोकेल उपसर्ग नहीं (लोकेल कहीं और संभाला जाता है)
+  - `'search-params'`: क्वेरी पैरामीटर के माध्यम से निर्दिष्ट लोकेल (उदाहरण के लिए, `/about?locale=fr`)
+
 ---
 
 ## अनुप्रयोगों में उपयोग

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

@@ -138,8 +138,6 @@ getMultilingualUrls(
 // }
 ```
 
----
-
 ### विभिन्न रूटिंग मोड्स
 
 ```typescript
@@ -205,6 +203,12 @@ getMultilingualUrls("/dashboard", {
 - **असमर्थित लोकेल:**
   - केवल `locales` एरे में दिए गए लोकेल को ही URL बनाने के लिए माना जाता है।
 
+- **राउटिंग मोड्स:**
+  - `'prefix-no-default'`: डिफ़ॉल्ट लोकेल के पास कोई उपसर्ग नहीं है, अन्य के पास है (उदा., `/dashboard`, `/fr/dashboard`)
+  - `'prefix-all'`: सभी लोकेल के पास उपसर्ग हैं (उदा., `/en/dashboard`, `/fr/dashboard`)
+  - `'no-prefix'`: URLs में कोई लोकेल उपसर्ग नहीं है (सभी लोकेल एक ही URL लौटाते हैं)
+  - `'search-params'`: क्वेरी पैरामीटर के माध्यम से निर्दिष्ट लोकेल (उदा., `/dashboard?locale=fr`)
+
 ---
 
 ## अनुप्रयोगों में उपयोग

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 `getTranslationContent` फ़ंक्शन एक सेट से एक विशिष्ट लोकल के अनुरूप सामग्री प्राप्त करता है जिसे अनुकूलित भाषा सामग्री कहा जाता है। यदि निर्दिष्ट लोकल नहीं मिलता है, तो यह परियोजना में कॉन्फ़िगर किए गए डिफ़ॉल्ट लोकल की सामग्री लौटाता है।
 
+अनुवाद घोषित करने के तरीके के बारे में अधिक विवरण के लिए, [अनुवाद दस्तावेज़](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dictionary/translation.md) देखें।
+
 ## पैरामीटर
 
 - `languageContent: CustomizableLanguageContent<Content>`

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

@@ -102,37 +102,6 @@ export const ServerComponentExample: FC = () => (
 );
 ```
 
-###एट्रिब्यूट्स में इनलाइन अनुवाद
-
-`t` फ़ंक्शन JSX एट्रिब्यूट्स में इनलाइन अनुवाद के लिए विशेष रूप से उपयोगी है।
-जब आप `alt`, `title`, `href`, या `aria-label` जैसे एट्रिब्यूट्स का स्थानीयकरण कर रहे हों, तो आप सीधे एट्रिब्यूट के भीतर `t` का उपयोग कर सकते हैं।
-
-```jsx
-<button
-  aria-label={t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
->
-  {t({
-    en: "Submit",
-    fr: "Soumettre",
-    es: "Enviar",
-  })}
-  <img
-    src="/path/to/image"
-    alt={t({
-      en: "A beautiful scenery",
-      fr: "Un beau paysage",
-      es: "Un hermoso paisaje",
-    })}
-  />
-</button>
-```
-
----
-
 ### विशेषताओं में इनलाइन अनुवाद
 
 `t` फ़ंक्शन JSX विशेषताओं में इनलाइन अनुवादों के लिए विशेष रूप से उपयोगी है।
@@ -192,6 +161,23 @@ const greeting = t(translations);
 
 #### उदाहरण:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx codeFormat={["typescript", "esm", "commonjs"]}
+import type { FC, ReactNode } from "react";
+import type { Locales } from "intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const Page: FC<{ locale: Locales; children: ReactNode }> = ({
+  locale,
+  children,
+}) => <IntlayerProvider locale={locale}>{children}</IntlayerProvider>;
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx codeFormat={["typescript", "esm", "commonjs"]}
 import type { FC } from "react";
 import type { Locales } from "intlayer";
@@ -207,6 +193,9 @@ const Page: FC<{ locale: Locales }> = ({ locale }) => (
 );
 ```
 
+</Tab>
+</Tabs>
+
 ---
 
 ## सामान्य त्रुटियाँ और समस्या निवारण

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

@@ -79,6 +79,36 @@ author: aymericzip
 
 यहाँ बताया गया है कि आप `useIntlayer` हुक को Next.js पेज के भीतर कैसे लागू कर सकते हैं ताकि एप्लिकेशन की वर्तमान स्थानीय भाषा के आधार पर स्थानीयकृत सामग्री को गतिशील रूप से लोड किया जा सके:
 
+<Tabs>
+ <Tab label='Intlayer >=9.4' value='>=9.4'>
+
+```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
+import { ClientComponentExample } from "@components/ClientComponentExample";
+import { ServerComponentExample } from "@components/ServerComponentExample";
+import { type NextPageIntlayer } from "next-intlayer";
+import { useIntlayer } from "next-intlayer";
+import { IntlayerProvider } from "next-intlayer/server";
+
+const HomePage: NextPageIntlayer = async ({ params }) => {
+  // पैरामीटर से locale को निकालें
+  const { locale } = await params;
+
+  // होमपेज की सामग्री प्राप्त करें
+  const content = useIntlayer("homepage", locale);
+
+  return (
+    <IntlayerProvider locale={locale}>
+      <p>{content.introduction}</p>
+      <ClientComponentExample />
+      <ServerComponentExample />
+    </IntlayerProvider>
+  );
+};
+```
+
+ </Tab>
+ <Tab label='Intlayer <9.4' value='<9.4'>
+
 ```tsx fileName="src/pages/[locale]/index.tsx" codeFormat={["typescript", "esm"]}
 import { ClientComponentExample } from "@components/ClientComponentExample";
 import { ServerComponentExample } from "@components/ServerComponentExample";
@@ -104,6 +134,9 @@ const HomePage: NextPageIntlayer = async ({ params }) => {
 };
 ```
 
+ </Tab>
+</Tabs>
+
 ```tsx fileName="src/components/ClientComponentExample.tsx" codeFormat={["typescript", "esm"]}
 "use-client";
 

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

@@ -104,6 +104,8 @@ const LocaleSwitcher: FC = () => {
 
 ## रिटर्न मान
 
+जब आप `useLocale` hook को invoke करते हैं, तो यह निम्नलिखित properties वाली एक object return करता है:
+
 - **`locale`**: वर्तमान स्थानीय जो React संदर्भ में सेट किया गया है।
 - **`defaultLocale`**: कॉन्फ़िगरेशन में परिभाषित प्राथमिक स्थानीय।
 - **`availableLocales`**: कॉन्फ़िगरेशन में परिभाषित सभी उपलब्ध स्थानीययों की सूची।

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

@@ -30,8 +30,6 @@ author: aymericzip
 
 ## React में उदाहरण उपयोग
 
-नीचे एक उदाहरण दिया गया है कि कैसे `useDictionary` हुक को एक React कंपोनेंट में उपयोग किया जाए:
-
 ```tsx fileName="./ComponentExample.tsx" codeFormat={["typescript", "esm"]}
 import type { FC } from "react";
 import { useDictionary } from "react-intlayer";