@intlayer/docs 9.3.3 → 9.4.0

package/docs/hi/packages/elysia-intlayer/exports.md

@@ -0,0 +1,136 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: elysia-intlayer पैकेज दस्तावेज़ीकरण
+description: Intlayer के लिए Elysia प्लगइन, जो अनुवाद फ़ंक्शन और locale का पता लगाने की सुविधाएँ प्रदान करता है।
+keywords:
+  - elysia-intlayer
+  - elysia
+  - plugin
+  - internationalization
+  - i18n
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - exports
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "सभी एक्सपोर्ट्स के लिए एकीकृत दस्तावेज़ीकरण"
+author: aymericzip
+---
+
+# elysia-intlayer पैकेज
+
+`elysia-intlayer` पैकेज Elysia एप्लिकेशनों के लिए एक प्लगइन प्रदान करता है जो internationalization को संभालता है। यह उपयोगकर्ता की locale का पता लगाता है और route context में एक `intlayer` ऑब्जेक्ट इंजेक्ट करता है।
+
+## स्थापना
+
+```bash packageManager="npm"
+npm install intlayer elysia-intlayer
+```
+
+```bash packageManager="pnpm"
+pnpm add intlayer elysia-intlayer
+```
+
+```bash packageManager="yarn"
+yarn add intlayer elysia-intlayer
+```
+
+```bash packageManager="bun"
+bun add intlayer elysia-intlayer
+```
+
+> `elysia` एक peer dependency है (`>=1.0.0`)। Elysia **Bun** रनटाइम को लक्षित करता है।
+
+## निर्यात
+
+### प्लगइन
+
+इम्पोर्ट:
+
+```ts
+import { intlayer } from "elysia-intlayer";
+```
+
+| फ़ंक्शन    | विवरण                                                                                                                                                                                                                                                                                                                                    | संबंधित दस्तावेज                                                                                               |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `intlayer` | Elysia प्लगइन जो Intlayer को आपके Elysia एप्लिकेशन में एकीकृत करता है। storage (cookies, headers) से और फिर `Accept-Language` से locale पहचान संभालता है, route context में `locale`, `t`, `getIntlayer` और `getDictionary` को उजागर करने वाला `intlayer` ऑब्जेक्ट इंजेक्ट करता है, और `AsyncLocalStorage` रिक्वेस्ट संदर्भ सेट करता है। | [intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/elysia-intlayer/intlayer.md) |
+
+### फ़ंक्शन्स
+
+इम्पोर्ट:
+
+```ts
+import { t, getIntlayer, getDictionary } from "elysia-intlayer";
+```
+
+| फ़ंक्शन         | विवरण                                                                                                                                                                                                                                                                                                       | संबंधित दस्तावेज                                                                                       |
+| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
+| `t`             | वैश्विक अनुवाद फ़ंक्शन जो Elysia में वर्तमान locale के लिए सामग्री प्राप्त करता है। `intlayer` प्लगइन द्वारा सेट किए गए रिक्वेस्ट संदर्भ तक पहुँचने के लिए `AsyncLocalStorage` का उपयोग करता है, और उसके बाहर डिफ़ॉल्ट locale पर fallback करता है। इसे `intlayer.t` के माध्यम से भी एक्सेस किया जा सकता है। | [translation](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dictionary/translation.md) |
+| `getIntlayer`   | जनरेट की गई डिक्लेरेशन से कुंजी द्वारा एक dictionary प्राप्त करता है और वर्तमान locale के लिए उसकी सामग्री लौटाता है। `getDictionary` का अनुकूलित संस्करण। रिक्वेस्ट संदर्भ तक पहुँचने के लिए `AsyncLocalStorage` का उपयोग करता है। इसे `intlayer.getIntlayer` के माध्यम से भी एक्सेस किया जा सकता है।      | -                                                                                                      |
+| `getDictionary` | dictionary ऑब्जेक्ट्स को प्रोसेस करता है और वर्तमान locale के लिए सामग्री लौटाता है। `t()` अनुवाद, enumerations, markdown, HTML आदि को प्रोसेस करता है। रिक्वेस्ट संदर्भ तक पहुँचने के लिए `AsyncLocalStorage` का उपयोग करता है। इसे `intlayer.getDictionary` के माध्यम से भी एक्सेस किया जा सकता है।       | -                                                                                                      |
+
+### प्रकार
+
+इम्पोर्ट:
+
+```ts
+import type { IntlayerContext, TranslateFunction } from "elysia-intlayer";
+```
+
+| प्रकार              | विवरण                                                                                                                                                                         |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `IntlayerContext`   | प्रत्येक route context में इंजेक्ट किए गए `intlayer` ऑब्जेक्ट की संरचना: `locale`, `locale_storage`, `locale_detected`, `defaultLocale`, `t`, `getIntlayer`, `getDictionary`। |
+| `TranslateFunction` | अनुवाद फ़ंक्शन का सिग्नेचर, जो एक locale map को वर्तमान रिक्वेस्ट locale से मेल खाने वाली सामग्री में बदलता है।                                                               |
+
+## उपयोग
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { getDictionary, getIntlayer, intlayer, t } from "elysia-intlayer";
+import dictionaryExample from "./index.content";
+
+const app = new Elysia()
+  // अंतर्राष्ट्रीयकरण plugin को लोड करें
+  .use(intlayer())
+  // Route context से locale और helpers पढ़ें
+  .get("/", ({ intlayer }) => ({
+    locale: intlayer!.locale,
+    greeting: intlayer!.t({
+      hi: "नमस्ते",
+      en: "Hello",
+      fr: "Bonjour",
+      es: "Hola",
+    }),
+    content: intlayer!.getIntlayer("index").exampleOfContent,
+  }))
+  // या मौजूदा request से बंधे standalone helpers का उपयोग करें
+  .get("/t_example", () =>
+    t({
+      hi: "अंग्रेजी में लौटाई गई सामग्री का उदाहरण",
+      en: "Example of returned content in English",
+      fr: "Exemple de contenu renvoyé en français",
+      es: "Ejemplo de contenido devuelto en español",
+    })
+  )
+  .get("/getIntlayer_example", () => getIntlayer("index").exampleOfContent)
+  .get(
+    "/getDictionary_example",
+    () => getDictionary(dictionaryExample).exampleOfContent
+  )
+  .listen(3000);
+
+console.log(
+  `🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`
+);
+```
+
+> प्लगइन अपना context एक **ग्लोबल** `derive` के माध्यम से रजिस्टर करता है, जिसे Elysia `Partial<{ intlayer: IntlayerContext }>` के रूप में टाइप करता है। `.use(intlayer())` के बाद रजिस्टर किए गए routes के लिए रनटाइम पर यह मान हमेशा मौजूद रहता है, इसलिए `strict` मोड में TypeScript को संतुष्ट करने के लिए non-null assertion (`intlayer!.locale`) — या optional chaining — का उपयोग करें।
+
+## संबंधित दस्तावेज़
+
+- [Elysia i18n - अपने ऐप्लिकेशन को अनुवाद करने के लिए संपूर्ण गाइड](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/intlayer_with_elysia.md)
+- [कॉन्फ़िगरेशन](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/configuration.md)

package/docs/hi/packages/elysia-intlayer/intlayer.md

@@ -0,0 +1,139 @@
+---
+createdAt: 2026-08-24
+updatedAt: 2026-08-24
+title: intlayer Elysia प्लगइन दस्तावेज़ | elysia-intlayer
+description: देखें कि elysia-intlayer पैकेज के intlayer प्लगइन का उपयोग कैसे करें
+keywords:
+  - intlayer
+  - elysia
+  - plugin
+  - Intlayer
+  - अंतर्राष्ट्रीयकरण
+  - दस्तावेज़ीकरण
+slugs:
+  - doc
+  - packages
+  - elysia-intlayer
+  - intlayer
+history:
+  - version: 9.4.0
+    date: 2026-08-24
+    changes: "दस्तावेज़ीकरण की शुरुआत"
+author: aymericzip
+---
+
+# intlayer Elysia प्लगइन दस्तावेज़
+
+Elysia के लिए `intlayer` प्लगइन उपयोगकर्ता की locale का पता लगाता है और route context में एक `intlayer` ऑब्जेक्ट इंजेक्ट करता है। यह अनुरोध संदर्भ के भीतर global translation फ़ंक्शनों के उपयोग को भी सक्षम बनाता है।
+
+## उपयोग
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", ({ intlayer }) =>
+  intlayer!.t({
+    hi: "नमस्ते",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+> प्लगइन अपना context एक **ग्लोबल** `derive` के माध्यम से रजिस्टर करता है, जिसे Elysia `Partial<{ intlayer: IntlayerContext }>` के रूप में टाइप करता है। `.use(intlayer())` के बाद रजिस्टर किए गए routes के लिए रनटाइम पर यह मान हमेशा मौजूद रहता है, इसलिए `strict` मोड में TypeScript को संतुष्ट करने के लिए non-null assertion (`intlayer!.t`) — या optional chaining — का उपयोग करें।
+
+वही helpers स्टैंडअलोन exports के रूप में भी उपलब्ध हैं, इसलिए आप route context को डीस्ट्रक्चर किए बिना उन्हें कॉल कर सकते हैं:
+
+```ts fileName="src/index.ts"
+import { Elysia } from "elysia";
+import { intlayer, t } from "elysia-intlayer";
+
+const app = new Elysia().use(intlayer()).get("/", () =>
+  t({
+    hi: "नमस्ते",
+    en: "Hello",
+    fr: "Bonjour",
+    es: "Hola",
+  })
+);
+```
+
+## विवरण
+
+प्लगइन निम्नलिखित कार्य करता है:
+
+1. **लोकेल पहचान**: यह क्लाइंट द्वारा स्पष्ट रूप से सेट की गई locale को storage (cookie, header) से पढ़ता है, फिर `Accept-Language` header से नेगोशिएट की गई locale पर fallback करता है।
+2. **कॉन्टेक्स्ट इंजेक्शन**: यह Elysia route context में एक `intlayer` प्रॉपर्टी जोड़ता है (नीचे दी गई Route Context तालिका देखें)।
+3. **Context Management**: यह एक असिंक्रोनस संदर्भ प्रबंधित करने के लिए `AsyncLocalStorage` का उपयोग करता है, जिससे वैश्विक Intlayer फ़ंक्शन (`t`, `getIntlayer`, `getDictionary`) संदर्भ ऑब्जेक्ट पास किए बिना रिक्वेस्ट-विशिष्ट locale तक पहुंच सकें।
+4. **Dictionaries की तैयारी**: प्लगइन बनते समय यह `prepareIntlayer` को कॉल करता है, ताकि ऐप के बूट होने पर dictionaries बन जाएँ।
+
+### Route Context
+
+| प्रॉपर्टी         | टाइप                   | विवरण                                                                                                        |
+| ----------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `locale`          | `Locale`               | इस अनुरोध के लिए उपयोग की जाने वाली locale, जिसमें `locale_storage` को `locale_detected` पर वरीयता मिलती है। |
+| `locale_storage`  | `Locale` (वैकल्पिक)    | क्लाइंट द्वारा cookie या header के माध्यम से स्पष्ट रूप से मांगी गई locale।                                  |
+| `locale_detected` | `Locale`               | अनुरोध के headers से नेगोशिएट की गई locale।                                                                  |
+| `defaultLocale`   | `Locale`               | `intlayer.config.ts` में fallback के रूप में कॉन्फ़िगर की गई locale।                                         |
+| `t`               | `TranslateFunction`    | एक अनुवाद फ़ंक्शन।                                                                                           |
+| `getIntlayer`     | `typeof getIntlayer`   | कुंजी द्वारा dictionaries प्राप्त करने वाला फ़ंक्शन।                                                         |
+| `getDictionary`   | `typeof getDictionary` | dictionary ऑब्जेक्ट्स को प्रोसेस करने वाला फ़ंक्शन।                                                          |
+
+> Node पर आधारित Intlayer प्लगइनों के विपरीत, `elysia-intlayer` `cls-hooked` के बजाय `AsyncLocalStorage` पर निर्भर करता है, क्योंकि `cls-hooked` `async_hooks.createHook` पर निर्भर है, जिसे Bun लागू नहीं करता।
+
+रिस्पॉन्स मैप होते ही रिक्वेस्ट संदर्भ मुक्त कर दिया जाता है, ताकि स्टैंडअलोन helpers कभी भी पहले से समाप्त हो चुके अनुरोध के विरुद्ध हल न हों। जब उन्हें प्लगइन द्वारा संभाले गए अनुरोध के बाहर कॉल किया जाता है, तो वे कॉन्फ़िगर की गई डिफ़ॉल्ट locale पर fallback करते हैं।
+
+## Locale हल करने का क्रम
+
+डिफ़ॉल्ट रूप से, प्लगइन locale को इस क्रम में हल करता है:
+
+1. `INTLAYER_LOCALE` कुकी।
+2. `x-intlayer-locale` हेडर।
+3. `Accept-Language` हेडर negotiation।
+4. कॉन्फ़िगर किया गया `defaultLocale`।
+
+```bash
+# `Accept-Language` से negotiate किया गया
+curl -H "Accept-Language: fr" http://localhost:3000/
+# Bonjour
+
+# कुकी `Accept-Language` पर प्राथमिकता रखती है
+curl -H "Accept-Language: fr" -H "Cookie: INTLAYER_LOCALE=es" http://localhost:3000/
+# Hola
+
+# हेडर `Accept-Language` पर प्राथमिकता रखता है
+curl -H "Accept-Language: fr" -H "x-intlayer-locale: es" http://localhost:3000/
+# Hola
+```
+
+## कॉन्फ़िगरेशन
+
+प्लगइन आपकी `intlayer.config.ts` फ़ाइल पढ़ता है। आप locale पहचान के लिए उपयोग किए जाने वाले cookie और header को कस्टमाइज़ कर सकते हैं:
+
+```typescript fileName="intlayer.config.ts" codeFormat={["typescript", "esm", "commonjs"]}
+import { Locales, type IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH, Locales.SPANISH],
+    defaultLocale: Locales.ENGLISH,
+  },
+  routing: {
+    storage: [
+      { type: "header", name: "my-locale-header" },
+      { type: "cookie", name: "my-locale-cookie" },
+    ],
+  },
+};
+
+export default config;
+```
+
+> कॉन्फ़िगरेशन के बारे में अधिक जानकारी के लिए, [कॉन्फ़िगरेशन दस्तावेज़](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/configuration.md) देखें।
+
+## संबंधित दस्तावेज़
+
+- [elysia-intlayer पैकेज दस्तावेज़ीकरण](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/elysia-intlayer/exports.md)
+- [Elysia i18n - अपने ऐप्लिकेशन को अनुवाद करने के लिए संपूर्ण गाइड](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/intlayer_with_elysia.md)

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

@@ -0,0 +1,156 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getDictionary फ़ंक्शन डॉक्यूमेंटेशन | intlayer
+description: intlayer पैकेज के लिए getDictionary फ़ंक्शन का उपयोग कैसे करें देखें
+keywords:
+  - getDictionary
+  - dictionary
+  - interpreter
+  - content
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionary
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# Documentation: `getDictionary` Function in `intlayer`
+
+## विवरण
+
+`getDictionary` फ़ंक्शन एक dictionary **object को interpret करता है जिसे आप स्वयं pass करते हैं** और दिए गए locale के लिए इसकी resolved content को return करता है। यह content को एक single pass में walk करता है और आवश्यकतानुसार प्रत्येक interpreter plugin को apply करता है, `t()` translations, enumerations, conditions, insertions, nesting, markdown, HTML और file nodes को resolve करते हुए।
+
+[`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayer.md) के विपरीत, जो generated registry में key के आधार पर dictionary को look up करता है, `getDictionary` स्वयं dictionary को लेता है। यह इसे runtime पर built content, किसी API या CMS से fetched, या test में declared inline के लिए सही tool बनाता है।
+
+**मुख्य विशेषताएँ:**
+
+- Dictionary structure (`{ key, content }`) को follow करने वाले किसी भी object के साथ काम करता है
+- Qualified dictionary group (collections, variants) को एक selector के साथ भी accept करता है
+- पूरी तरह typed: returned object आपके द्वारा pass किए गए `content` को reflect करता है
+- Custom interpreter plugins को accept करता है
+
+---
+
+## फ़ंक्शन सिग्नेचर
+
+```typescript
+getDictionary(
+  dictionary: Dictionary | QualifiedDictionaryGroup, // आवश्यक
+  localeOrSelector?: LocalesValues | DictionarySelector, // वैकल्पिक
+  plugins?: Plugins[]                                // वैकल्पिक
+): DeepTransformContent<...>
+```
+
+---
+
+## पैरामीटर
+
+- `dictionary: Dictionary | QualifiedDictionaryGroup`
+  - **विवरण**: व्याख्या करने के लिए dictionary (या qualified dictionary group)।
+  - **प्रकार**: `Dictionary | QualifiedDictionaryGroup`
+  - **आवश्यक**: हाँ
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **विवरण**: content की व्याख्या करने के लिए locale, या एक selector object (`{ item }`, `{ variant }`, वैकल्पिक रूप से `locale` के साथ)। [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/index.md) देखें।
+  - **प्रकार**: `LocalesValues | DictionarySelector`
+  - **आवश्यक**: नहीं (Optional) — configured `defaultLocale` को default करता है।
+
+- `plugins: Plugins[]`
+  - **विवरण**: node transformers की एक array जो परिभाषित करता है कि कैसे recognized nodes की व्याख्या की जाती है। यदि छोड़ दिया जाता है, तो default set of interpreter plugins का उपयोग किया जाता है।
+  - **प्रकार**: `Plugins[]`
+  - **आवश्यक**: नहीं (Optional)
+
+### रिटर्न्स
+
+- **Type**: डिक्शनरी की व्याख्या की गई सामग्री।
+- **Description**: आपके द्वारा पास की गई `content`, अनुरोधित लोकेल के लिए प्रत्येक Intlayer नोड को हल किया गया। एक संग्रह समूह के लिए जिसमें कोई `item` चयनकर्ता नहीं है, व्याख्या किए गए प्रविष्टियों का एक क्रमबद्ध array रिटर्न किया जाता है; `null` तब रिटर्न किया जाता है जब चयनकर्ता कुछ भी लक्षित नहीं करता है।
+
+---
+
+## उदाहरण उपयोग
+
+### मूल उपयोग
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionary, t } from "intlayer";
+
+const content = getDictionary(
+  {
+    key: "my_key",
+    content: {
+      greeting: t({
+        en: "Hello",
+        fr: "Bonjour",
+      }),
+    },
+  },
+  "fr"
+);
+
+console.log(content.greeting); // "Bonjour"
+```
+
+### रनटाइम पर लाई गई सामग्री की व्याख्या करना
+
+```typescript
+import { getDictionary, type Dictionary } from "intlayer";
+
+// रिमोट डिक्शनरी को फेच करें
+const remoteDictionary: Dictionary = await fetch("/api/cms/banner").then(
+  (res) => res.json()
+);
+
+// दिए गए डिक्शनरी से फ्रेंच भाषा की सामग्री प्राप्त करें
+const banner = getDictionary(remoteDictionary, "fr");
+```
+
+### एक selector के साथ
+
+```typescript
+import { getDictionary } from "intlayer";
+
+// एक qualified dictionary group एक single entry में resolve होता है…
+const secondItem = getDictionary(blogPostGroup, { item: 2, locale: "fr" });
+
+// …या एक ordered array में जब कोई `item` नहीं दिया गया हो
+const allItems = getDictionary(blogPostGroup, { locale: "fr" });
+```
+
+---
+
+## संबंधित फ़ंक्शन
+
+- [`getIntlayer`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayer.md): समान interpretation, लेकिन dictionary को generated registry में key के आधार पर देखा जाता है।
+- [`getDictionaryAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getDictionaryAsync.md): per-locale loader maps के लिए counterpart।
+- [`useDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/react-intlayer/useDictionary.md): React hook equivalent, जो provider से locale को पढ़ता है।
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionary<
+  const T extends Dictionary | QualifiedDictionaryGroup,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionary: T,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): DeepTransformContent<
+  ResolveQualifiedDictionaryContent<T, A>,
+  IInterpreterPluginState,
+  ExtractSelectorLocale<A>
+>;
+```

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

@@ -0,0 +1,166 @@
+---
+createdAt: 2026-08-23
+updatedAt: 2026-08-23
+title: getDictionaryAsync फ़ंक्शन डॉक्यूमेंटेशन | intlayer
+description: intlayer पैकेज के लिए getDictionaryAsync फ़ंक्शन का उपयोग कैसे करें, यह देखें
+keywords:
+  - getDictionaryAsync
+  - dictionary
+  - dynamic dictionaries
+  - loader map
+  - bundle optimization
+  - Intlayer
+  - intlayer
+  - Internationalization
+  - Documentation
+  - JavaScript
+  - TypeScript
+slugs:
+  - doc
+  - packages
+  - intlayer
+  - getDictionaryAsync
+history:
+  - version: 9.4.0
+    date: 2026-08-23
+    changes: "Initial documentation"
+author: aymericzip
+---
+
+# दस्तावेज़: `intlayer` में `getDictionaryAsync` फ़ंक्शन
+
+## विवरण
+
+`getDictionaryAsync` फ़ंक्शन एक **एकल locale chunk** को dictionary से लोड करता है और इसकी interpreted content को return करता है।
+
+यह `.intlayer/dynamic_dictionaries/` में emitted per-locale loader maps के लिए [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getDictionary.md) का counterpart है: हर locale को hold करने वाली dictionary प्राप्त करने के बजाय, यह loader map को प्राप्त करता है और केवल उस chunk को await करता है जिसकी requested locale को आवश्यकता है।
+
+> Application code में आप आमतौर पर [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayerAsync.md) को call करते हैं, इस फ़ंक्शन को नहीं। [build plugins](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/bundle_optimization.md) हर `getIntlayerAsync('key', locale)` call को एक `getDictionaryAsync(loaderMap, 'key', locale)` में rewrite करते हैं। `getDictionaryAsync` को custom loaders के लिए और उस tooling के लिए export किया जाता है जो अपने स्वयं के loader maps को build करता है।
+
+**मुख्य विशेषताएं:**
+
+- केवल requested locale chunk को लोड करता है
+- Plain (`locale → loader`) और qualified (`locale → qualifierId → loader`) loader maps को support करता है
+- एक ही chunk के concurrent loads को deduplicate करता है, और resolved content को cache करता है
+- Failed loads को cache से evict किया जाता है ताकि बाद की call chunk को retry कर सके
+
+---
+
+## फ़ंक्शन सिग्नेचर
+
+```typescript
+getDictionaryAsync(
+  dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap, // आवश्यक
+  key: string,                                           // आवश्यक
+  localeOrSelector?: LocalesValues | DictionarySelector, // वैकल्पिक
+  plugins?: Plugins[]                                    // वैकल्पिक
+): Promise<DeepTransformContent<...>>
+```
+
+---
+
+## पैरामीटर
+
+- `dictionaryLoaders: PlainDynamicLoaderMap | QualifiedDynamicLoaderMap`
+  - **Description**: प्रति-locale loader map। Plain maps एक locale को एक loader के साथ जोड़ते हैं; qualified maps (collections और variants द्वारा उपयोग किए जाते हैं) एक locale को एक qualifier id के साथ जोड़ते हैं, फिर एक loader के साथ। qualified map के लिए, केवल वह chunk(s) जिसे selector target करता है, लोड होते हैं।
+  - **Type**: `PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap`
+  - **Required**: Yes
+
+- `key: string`
+  - **Description**: dictionary key, chunk cache को namespace करने के लिए उपयोग किया जाता है।
+  - **Type**: `string`
+  - **Required**: Yes
+
+- `localeOrSelector: LocalesValues | DictionarySelector`
+  - **Description**: सामग्री को interpret करने के लिए locale, या एक selector object (`{ item }`, `{ variant }`, वैकल्पिक रूप से `locale` के साथ)। [dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/index.md) देखें।
+  - **Type**: `LocalesValues | DictionarySelector`
+  - **Required**: No (Optional) — configured `defaultLocale` में defaults होता है।
+
+- `plugins: Plugins[]`
+  - **Description**: Node transformers। base interpreter set में defaults होता है।
+  - **Type**: `Plugins[]`
+  - **Required**: No (Optional)
+
+### Returns
+
+- **Type**: `Promise<Content>` — a promise resolving to the interpreted content of the loaded chunk.
+- **Description**: Resolves to `null` when the map emits no chunk for the requested locale nor for any of its fallbacks, mirroring how a missing qualified coordinate resolves.
+
+---
+
+## उदाहरण उपयोग
+
+### जेनरेट किए गए लोडर मैप के साथ
+
+```typescript codeFormat={["typescript", "esm", "commonjs"]}
+import { getDictionaryAsync } from "intlayer";
+import appLoaderMap from "../.intlayer/dynamic_dictionaries/app";
+
+const { title } = await getDictionaryAsync(appLoaderMap, "app", "fr");
+```
+
+### कस्टम लोडर मैप के साथ
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const loaderMap = {
+  en: () => import("./banner.en.json").then((mod) => mod.default),
+  fr: () => import("./banner.fr.json").then((mod) => mod.default),
+};
+
+const banner = await getDictionaryAsync(loaderMap, "banner", "fr");
+```
+
+### एक योग्य मानचित्र पर एक चयनकर्ता के साथ
+
+```typescript
+import { getDictionaryAsync } from "intlayer";
+
+const promoBanner = await getDictionaryAsync(bannerLoaderMap, "banner", {
+  variant: "black-friday",
+  locale: "fr",
+});
+```
+
+---
+
+## व्यवहार नोट्स
+
+### कैशिंग और डीडुप्लिकेशन
+
+कैश प्रत्येक `key + locale + selector` ट्रिपल के **promise** को स्टोर करता है, इसलिए एक ही chunk के लिए समवर्ती कॉल एक single load की प्रतीक्षा करते हैं। एक rejected load को कैश से हटाया जाता है, इसलिए एक failing chunk को अगली कॉल पर फिर से कोशिश की जाती है, बजाय इसके कि एक ही विफलता को हमेशा के लिए दोहराया जाए।
+
+### Locale fallback
+
+एक सादा loader map को synchronous mode के समान fallback chain के अनुसार walk किया जाता है: पहले अनुरोधित locale, फिर इसके fallbacks, फिर `null` अगर कोई भी chunk emit नहीं करता है।
+
+---
+
+## संबंधित फंक्शन
+
+- [`getIntlayerAsync`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getIntlayerAsync.md): वह फंक्शन जिसे एप्लिकेशन कॉल करती हैं; बिल्ड प्लगइन इसे `getDictionaryAsync` में फिर से लिखते हैं।
+- [`getDictionary`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/packages/intlayer/getDictionary.md): सिंक्रोनस समकक्ष जो पूरी dictionary लेता है।
+- [Dynamic dictionaries](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dynamic_dictionaries/index.md): संग्रह और variants, और loader maps जो वे जेनरेट करते हैं।
+
+---
+
+## TypeScript
+
+```typescript
+function getDictionaryAsync<
+  const T extends Dictionary,
+  const A extends LocalesValues | DictionarySelector = DeclaredLocales,
+>(
+  dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap,
+  key: string,
+  localeOrSelector?: A,
+  plugins?: Plugins[]
+): Promise<
+  DeepTransformContent<
+    T["content"],
+    IInterpreterPluginState,
+    ExtractSelectorLocale<A>
+  >
+>;
+```

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

@@ -31,6 +31,8 @@ author: aymericzip
 
 `getEnumeration` फ़ंक्शन एक निर्दिष्ट मात्रा के अनुसार पूर्वनिर्धारित शर्तों के आधार पर एक एनेमरेशन ऑब्जेक्ट में संबंधित सामग्री प्राप्त करता है। शर्तें कुंजियों के रूप में परिभाषित होती हैं, और उनकी प्राथमिकता ऑब्जेक्ट में उनके क्रम द्वारा निर्धारित होती है।
 
+enumeration की घोषणा कैसे करें, इस पर अधिक विवरण के लिए, [Enumeration दस्तावेज़](https://github.com/aymericzip/intlayer/blob/main/docs/docs/hi/dictionary/enumeration.md) देखें।
+
 ## पैरामीटर
 
 - `enumerationContent: QuantityContent<Content>`