@{{ user.login }}
Questions replied: {{ user.count }}
+
+## पहले से परिभाषित responses और custom responses को मिलाएँ { #combine-predefined-responses-and-custom-ones }
+
+आप कुछ पहले से परिभाषित responses रखना चाह सकते हैं जो कई *path operations* पर लागू होते हैं, लेकिन आप उन्हें प्रत्येक *path operation* के लिए ज़रूरी custom responses के साथ मिलाना चाहते हैं।
+
+ऐसे मामलों के लिए, आप `**dict_to_unpack` के साथ `dict` को "unpacking" करने की Python technique का उपयोग कर सकते हैं:
+
+```Python
+old_dict = {
+ "old key": "old value",
+ "second old key": "second old value",
+}
+new_dict = {**old_dict, "new key": "new value"}
+```
+
+यहाँ, `new_dict` में `old_dict` के सभी key-value pairs के साथ नया key-value pair भी होगा:
+
+```Python
+{
+ "old key": "old value",
+ "second old key": "second old value",
+ "new key": "new value",
+}
+```
+
+आप इस technique का उपयोग अपने *path operations* में कुछ पहले से परिभाषित responses को reuse करने और उन्हें अतिरिक्त custom responses के साथ मिलाने के लिए कर सकते हैं।
+
+उदाहरण के लिए:
+
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
+
+## OpenAPI responses के बारे में अधिक जानकारी { #more-information-about-openapi-responses }
+
+Responses में आप ठीक-ठीक क्या शामिल कर सकते हैं, यह देखने के लिए आप OpenAPI specification में ये sections देख सकते हैं:
+
+* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), इसमें `Response Object` शामिल है।
+* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), आप इसमें से कुछ भी सीधे अपने `responses` parameter के अंदर प्रत्येक response में शामिल कर सकते हैं। जिसमें `description`, `headers`, `content` (इसी के अंदर आप अलग-अलग media types और JSON Schemas घोषित करते हैं), और `links` शामिल हैं।
diff --git a/docs/hi/docs/advanced/additional-status-codes.md b/docs/hi/docs/advanced/additional-status-codes.md
new file mode 100644
index 000000000..bec6e4eae
--- /dev/null
+++ b/docs/hi/docs/advanced/additional-status-codes.md
@@ -0,0 +1,41 @@
+# अतिरिक्त Status Codes { #additional-status-codes }
+
+default रूप से, **FastAPI** responses को `JSONResponse` का उपयोग करके return करेगा, जिसमें आपके *path operation* से return किया गया content उस `JSONResponse` के अंदर रखा जाएगा।
+
+यह default status code या वह status code उपयोग करेगा जो आपने अपने *path operation* में set किया है।
+
+## अतिरिक्त status codes { #additional-status-codes_1 }
+
+अगर आप मुख्य status code के अलावा अतिरिक्त status codes return करना चाहते हैं, तो आप सीधे `Response`, जैसे `JSONResponse`, return करके और अतिरिक्त status code को सीधे set करके ऐसा कर सकते हैं।
+
+उदाहरण के लिए, मान लीजिए कि आप एक ऐसा *path operation* रखना चाहते हैं जो items को update करने की अनुमति देता है, और सफल होने पर HTTP status code 200 "OK" return करता है।
+
+लेकिन आप यह भी चाहते हैं कि यह नए items को स्वीकार करे। और जब items पहले मौजूद नहीं थे, तो यह उन्हें बनाता है, और HTTP status code 201 "Created" return करता है।
+
+ऐसा करने के लिए, `JSONResponse` import करें, और अपना content वहीं सीधे return करें, साथ में अपनी पसंद का `status_code` set करें:
+
+{* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
+
+/// warning | चेतावनी
+
+जब आप सीधे `Response` return करते हैं, जैसे ऊपर के उदाहरण में, तो वह सीधे return किया जाएगा।
+
+इसे किसी model आदि के साथ serialize नहीं किया जाएगा।
+
+सुनिश्चित करें कि इसमें वही data है जो आप चाहते हैं, और values valid JSON हैं (अगर आप `JSONResponse` उपयोग कर रहे हैं)।
+
+///
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import JSONResponse` भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` `fastapi.responses` के रूप में प्रदान करता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं। `status` के साथ भी यही है।
+
+///
+
+## OpenAPI और API docs { #openapi-and-api-docs }
+
+अगर आप अतिरिक्त status codes और responses सीधे return करते हैं, तो वे OpenAPI schema (API docs) में शामिल नहीं होंगे, क्योंकि FastAPI के पास पहले से यह जानने का तरीका नहीं है कि आप क्या return करने वाले हैं।
+
+लेकिन आप इसे अपने code में document कर सकते हैं, उपयोग करके: [अतिरिक्त Responses](additional-responses.md)।
diff --git a/docs/hi/docs/advanced/advanced-dependencies.md b/docs/hi/docs/advanced/advanced-dependencies.md
new file mode 100644
index 000000000..4c6648b95
--- /dev/null
+++ b/docs/hi/docs/advanced/advanced-dependencies.md
@@ -0,0 +1,163 @@
+# Advanced Dependencies { #advanced-dependencies }
+
+## Parameterized dependencies { #parameterized-dependencies }
+
+अब तक हमने जो भी dependencies देखी हैं, वे एक निश्चित function या class हैं।
+
+लेकिन ऐसे मामले हो सकते हैं जहाँ आप dependency पर parameters सेट कर पाना चाहें, बिना कई अलग-अलग functions या classes declare किए।
+
+कल्पना करें कि हम एक ऐसी dependency रखना चाहते हैं जो जाँचती है कि query parameter `q` में कुछ निश्चित content है या नहीं।
+
+लेकिन हम उस निश्चित content को parameterize कर पाना चाहते हैं।
+
+## एक "callable" instance { #a-callable-instance }
+
+Python में किसी class के instance को "callable" बनाने का एक तरीका है।
+
+खुद class को नहीं (जो पहले से ही callable होती है), बल्कि उस class के एक instance को।
+
+ऐसा करने के लिए, हम एक method `__call__` declare करते हैं:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[12] *}
+
+इस मामले में, यही `__call__` है जिसे **FastAPI** अतिरिक्त parameters और sub-dependencies की जाँच के लिए उपयोग करेगा, और बाद में आपकी *path operation function* में parameter को value पास करने के लिए यही call किया जाएगा।
+
+## Instance को parameterize करें { #parameterize-the-instance }
+
+और अब, हम `__init__` का उपयोग करके instance के parameters declare कर सकते हैं जिन्हें हम dependency को "parameterize" करने के लिए उपयोग कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[9] *}
+
+इस मामले में, **FastAPI** कभी भी `__init__` को छुएगा या उसकी परवाह नहीं करेगा, हम इसे सीधे अपने code में उपयोग करेंगे।
+
+## एक instance बनाएँ { #create-an-instance }
+
+हम इस class का एक instance इस तरह बना सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[18] *}
+
+और इस तरह हम अपनी dependency को "parameterize" कर पाते हैं, जिसमें अब `"bar"` उसके अंदर है, attribute `checker.fixed_content` के रूप में।
+
+## Instance को dependency के रूप में उपयोग करें { #use-the-instance-as-a-dependency }
+
+फिर, हम `Depends(FixedContentQueryChecker)` के बजाय इस `checker` को `Depends(checker)` में उपयोग कर सकते हैं, क्योंकि dependency class खुद नहीं, बल्कि instance `checker` है।
+
+और dependency को solve करते समय, **FastAPI** इस `checker` को इस तरह call करेगा:
+
+```Python
+checker(q="somequery")
+```
+
+...और जो भी यह return करेगा उसे हमारी *path operation function* में dependency की value के रूप में parameter `fixed_content_included` में पास करेगा:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[22] *}
+
+/// tip | सुझाव
+
+यह सब थोड़ा बनावटी लग सकता है। और अभी यह बहुत स्पष्ट नहीं हो सकता कि यह कैसे उपयोगी है।
+
+ये उदाहरण जानबूझकर सरल रखे गए हैं, लेकिन दिखाते हैं कि यह सब कैसे काम करता है।
+
+Security वाले chapters में utility functions हैं जिन्हें इसी तरीके से implement किया गया है।
+
+अगर आपने यह सब समझ लिया है, तो आप पहले से जानते हैं कि security के लिए वे utility tools अंदर से कैसे काम करते हैं।
+
+///
+
+## `yield`, `HTTPException`, `except` और Background Tasks वाली Dependencies { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+/// warning | चेतावनी
+
+सबसे अधिक संभावना है कि आपको इन तकनीकी विवरणों की आवश्यकता नहीं है।
+
+ये विवरण मुख्य रूप से तब उपयोगी हैं जब आपके पास 0.121.0 से पुरानी FastAPI application थी और आपको `yield` वाली dependencies के साथ समस्याएँ आ रही हैं।
+
+///
+
+`yield` वाली dependencies समय के साथ अलग-अलग use cases को संभालने और कुछ समस्याएँ ठीक करने के लिए विकसित हुई हैं, यहाँ बदले हुए व्यवहार का सारांश है।
+
+### `yield` और `scope` वाली Dependencies { #dependencies-with-yield-and-scope }
+
+Version 0.121.0 में, FastAPI ने `yield` वाली dependencies के लिए `Depends(scope="function")` का support जोड़ा।
+
+`Depends(scope="function")` का उपयोग करने पर, `yield` के बाद का exit code *path operation function* के समाप्त होते ही, response client को वापस भेजे जाने से पहले execute होता है।
+
+और `Depends(scope="request")` (default) का उपयोग करने पर, `yield` के बाद का exit code response भेजे जाने के बाद execute होता है।
+
+आप इसके बारे में docs में [Dependencies with `yield` - Early exit and `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope) में अधिक पढ़ सकते हैं।
+
+### `yield` और `StreamingResponse` वाली Dependencies, तकनीकी विवरण { #dependencies-with-yield-and-streamingresponse-technical-details }
+
+FastAPI 0.118.0 से पहले, यदि आप `yield` वाली dependency उपयोग करते थे, तो यह *path operation function* के return करने के बाद लेकिन response भेजने से ठीक पहले exit code run करती थी।
+
+इरादा यह था कि आवश्यक से अधिक समय तक resources को पकड़े रखने से बचा जाए, response के network से गुजरने की प्रतीक्षा करते हुए।
+
+इस बदलाव का अर्थ यह भी था कि यदि आपने `StreamingResponse` return किया, तो `yield` वाली dependency का exit code पहले ही run हो चुका होता।
+
+उदाहरण के लिए, यदि आपके पास `yield` वाली dependency में database session था, तो `StreamingResponse` data stream करते समय उस session का उपयोग नहीं कर पाता क्योंकि `yield` के बाद वाले exit code में session पहले ही बंद हो चुका होता।
+
+यह व्यवहार 0.118.0 में revert कर दिया गया, ताकि `yield` के बाद का exit code response भेजे जाने के बाद execute हो।
+
+/// note | ध्यान दें
+
+जैसा कि आप नीचे देखेंगे, यह version 0.106.0 से पहले के व्यवहार से बहुत मिलता-जुलता है, लेकिन कई सुधारों और corner cases के लिए bug fixes के साथ।
+
+///
+
+#### Early Exit Code वाले Use Cases { #use-cases-with-early-exit-code }
+
+कुछ specific conditions वाले use cases हैं जिन्हें response भेजने से पहले `yield` वाली dependencies का exit code run करने के पुराने व्यवहार से लाभ हो सकता है।
+
+उदाहरण के लिए, कल्पना करें कि आपके पास ऐसा code है जो `yield` वाली dependency में database session का उपयोग केवल user verify करने के लिए करता है, लेकिन database session फिर *path operation function* में कभी उपयोग नहीं होता, केवल dependency में उपयोग होता है, **और** response भेजे जाने में लंबा समय लेता है, जैसे `StreamingResponse` जो data धीरे-धीरे भेजता है, लेकिन किसी कारण से database का उपयोग नहीं करता।
+
+इस मामले में, database session तब तक पकड़ा रहेगा जब तक response भेजना समाप्त नहीं हो जाता, लेकिन यदि आप इसका उपयोग नहीं करते हैं, तो इसे पकड़े रखना आवश्यक नहीं होगा।
+
+यह इस तरह दिख सकता है:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py *}
+
+Exit code, यानी `Session` का automatic closing, यहाँ:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
+
+...response द्वारा slow data भेजना समाप्त करने के बाद run होगा:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
+
+लेकिन क्योंकि `generate_stream()` database session का उपयोग नहीं करता, response भेजते समय session को खुला रखना वास्तव में आवश्यक नहीं है।
+
+यदि आपके पास SQLModel (या SQLAlchemy) का उपयोग करते हुए यह specific use case है, तो आप session को तब explicit रूप से बंद कर सकते हैं जब आपको इसकी आगे आवश्यकता न हो:
+
+{* ../../docs_src/dependencies/tutorial014_an_py310.py ln[24:28] hl[28] *}
+
+इस तरह session database connection release कर देगा, ताकि अन्य requests उसका उपयोग कर सकें।
+
+यदि आपके पास कोई अलग use case है जिसे `yield` वाली dependency से early exit करने की आवश्यकता है, तो कृपया अपने specific use case और dependencies with `yield` के लिए early closing से आपको क्यों लाभ होगा, इसके साथ एक [GitHub Discussion Question](https://github.com/fastapi/fastapi/discussions/new?category=questions) बनाएँ।
+
+यदि dependencies with `yield` में early closing के लिए compelling use cases होते हैं, तो मैं early closing में opt in करने का नया तरीका जोड़ने पर विचार करूँगा।
+
+### `yield` और `except` वाली Dependencies, तकनीकी विवरण { #dependencies-with-yield-and-except-technical-details }
+
+FastAPI 0.110.0 से पहले, यदि आप `yield` वाली dependency उपयोग करते थे, और फिर उस dependency में `except` के साथ exception capture करते थे, और exception को फिर से raise नहीं करते थे, तो exception automatic रूप से किसी भी exception handlers या internal server error handler को raise/forward कर दिया जाता था।
+
+यह version 0.110.0 में बदला गया ताकि handler के बिना forwarded exceptions (internal server errors) से होने वाली unhandled memory consumption ठीक की जा सके, और इसे regular Python code के व्यवहार के साथ consistent बनाया जा सके।
+
+### Background Tasks और `yield` वाली Dependencies, तकनीकी विवरण { #background-tasks-and-dependencies-with-yield-technical-details }
+
+FastAPI 0.106.0 से पहले, `yield` के बाद exceptions raise करना संभव नहीं था, `yield` वाली dependencies में exit code response भेजे जाने के *बाद* execute होता था, इसलिए [Exception Handlers](../tutorial/handling-errors.md#install-custom-exception-handlers) पहले ही run हो चुके होते।
+
+इसे मुख्य रूप से इस तरह design किया गया था ताकि dependencies द्वारा "yielded" किए गए उन्हीं objects को background tasks के अंदर उपयोग किया जा सके, क्योंकि exit code background tasks के समाप्त होने के बाद execute होता था।
+
+यह FastAPI 0.106.0 में बदला गया, इस इरादे से कि response के network से गुजरने की प्रतीक्षा करते समय resources को पकड़े न रखा जाए।
+
+/// tip | सुझाव
+
+इसके अतिरिक्त, background task सामान्यतः logic का एक independent set होता है जिसे अलग से संभाला जाना चाहिए, अपने स्वयं के resources के साथ (जैसे उसका अपना database connection)।
+
+इसलिए, इस तरह आपके पास शायद अधिक साफ़ code होगा।
+
+///
+
+यदि आप इस व्यवहार पर निर्भर थे, तो अब आपको background tasks के लिए resources background task के अंदर ही बनाने चाहिए, और internally केवल ऐसा data उपयोग करना चाहिए जो `yield` वाली dependencies के resources पर निर्भर न हो।
+
+उदाहरण के लिए, उसी database session का उपयोग करने के बजाय, आप background task के अंदर एक नया database session बनाएँगे, और इस नए session का उपयोग करके database से objects प्राप्त करेंगे। और फिर database से object को background task function में parameter के रूप में पास करने के बजाय, आप उस object की ID पास करेंगे और फिर background task function के अंदर object को फिर से प्राप्त करेंगे।
diff --git a/docs/hi/docs/advanced/advanced-python-types.md b/docs/hi/docs/advanced/advanced-python-types.md
new file mode 100644
index 000000000..d73a95fd8
--- /dev/null
+++ b/docs/hi/docs/advanced/advanced-python-types.md
@@ -0,0 +1,61 @@
+# उन्नत Python Types { #advanced-python-types }
+
+Python types के साथ काम करते समय यहाँ कुछ अतिरिक्त विचार हैं जो उपयोगी हो सकते हैं।
+
+## `Union` या `Optional` का उपयोग { #using-union-or-optional }
+
+अगर आपका code किसी कारण से `|` का उपयोग नहीं कर सकता, उदाहरण के लिए अगर यह type annotation में नहीं बल्कि `response_model=` जैसी किसी चीज़ में है, तो vertical bar (`|`) का उपयोग करने के बजाय आप `typing` से `Union` का उपयोग कर सकते हैं।
+
+उदाहरण के लिए, आप declare कर सकते हैं कि कोई चीज़ `str` या `None` हो सकती है:
+
+```python
+from typing import Union
+
+
+def say_hi(name: Union[str, None]):
+ print(f"Hi {name}!")
+```
+
+`typing` में `Optional` के साथ यह declare करने का एक shortcut भी है कि कोई चीज़ `None` हो सकती है।
+
+मेरे बहुत **subjective** दृष्टिकोण से एक tip यहाँ है:
+
+* 🚨 `Optional[SomeType]` का उपयोग करने से बचें
+* इसके बजाय ✨ **`Union[SomeType, None]` का उपयोग करें** ✨।
+
+दोनों equivalent हैं और अंदर से वे समान हैं, लेकिन मैं `Optional` के बजाय `Union` की सलाह दूँगा क्योंकि "**optional**" शब्द से ऐसा लग सकता है कि value optional है, जबकि इसका वास्तविक अर्थ है "यह `None` हो सकता है", भले ही यह optional न हो और अभी भी required हो।
+
+मुझे लगता है कि `Union[SomeType, None]` अपने अर्थ के बारे में अधिक explicit है।
+
+यह बस शब्दों और नामों की बात है। लेकिन ये शब्द इस बात को प्रभावित कर सकते हैं कि आप और आपके teammates code के बारे में कैसे सोचते हैं।
+
+एक उदाहरण के रूप में, इस function को लेते हैं:
+
+```python
+from typing import Optional
+
+
+def say_hi(name: Optional[str]):
+ print(f"Hey {name}!")
+```
+
+parameter `name` को `Optional[str]` के रूप में define किया गया है, लेकिन यह **optional नहीं है**, आप function को parameter के बिना call नहीं कर सकते:
+
+```Python
+say_hi() # अरे नहीं, यह error throw करता है! 😱
+```
+
+`name` parameter **अभी भी required** है (*optional* नहीं) क्योंकि इसमें default value नहीं है। फिर भी, `name` value के रूप में `None` स्वीकार करता है:
+
+```Python
+say_hi(name=None) # यह काम करता है, None valid है 🎉
+```
+
+अच्छी खबर यह है कि अधिकतर मामलों में, आप types के unions को define करने के लिए बस `|` का उपयोग कर पाएँगे:
+
+```python
+def say_hi(name: str | None):
+ print(f"Hey {name}!")
+```
+
+इसलिए, सामान्यतः आपको `Optional` और `Union` जैसे नामों के बारे में चिंता करने की ज़रूरत नहीं होती। 😎
diff --git a/docs/hi/docs/advanced/async-tests.md b/docs/hi/docs/advanced/async-tests.md
new file mode 100644
index 000000000..8981d552b
--- /dev/null
+++ b/docs/hi/docs/advanced/async-tests.md
@@ -0,0 +1,99 @@
+# Async Tests { #async-tests }
+
+आपने पहले ही देखा है कि दिए गए `TestClient` का उपयोग करके अपनी **FastAPI** applications को कैसे test किया जाता है। अब तक, आपने केवल synchronous tests लिखना देखा है, `async` functions का उपयोग किए बिना।
+
+अपने tests में asynchronous functions का उपयोग कर पाना उपयोगी हो सकता है, उदाहरण के लिए, जब आप अपने database को asynchronously query कर रहे हों। कल्पना करें कि आप अपनी FastAPI application को requests भेजना test करना चाहते हैं और फिर verify करना चाहते हैं कि आपके backend ने async database library का उपयोग करते हुए database में सही data सफलतापूर्वक लिखा है।
+
+आइए देखें कि हम इसे कैसे काम करवा सकते हैं।
+
+## pytest.mark.anyio { #pytest-mark-anyio }
+
+अगर हम अपने tests में asynchronous functions call करना चाहते हैं, तो हमारे test functions asynchronous होने चाहिए। AnyIO इसके लिए एक अच्छा plugin प्रदान करता है, जो हमें specify करने देता है कि कुछ test functions को asynchronously call किया जाना है।
+
+## HTTPX { #httpx }
+
+भले ही आपकी **FastAPI** application `async def` के बजाय सामान्य `def` functions का उपयोग करती हो, यह अंदर से फिर भी एक `async` application होती है।
+
+`TestClient` अंदर कुछ magic करता है ताकि standard pytest का उपयोग करते हुए आपकी सामान्य `def` test functions में asynchronous FastAPI application को call किया जा सके। लेकिन जब हम इसे asynchronous functions के अंदर उपयोग करते हैं, तो वह magic अब काम नहीं करता। अपने tests को asynchronously चलाने पर, हम अपने test functions के अंदर `TestClient` का उपयोग नहीं कर सकते।
+
+`TestClient` [HTTPX](https://www.python-httpx.org) पर आधारित है, और सौभाग्य से, हम API को test करने के लिए इसे सीधे उपयोग कर सकते हैं।
+
+## उदाहरण { #example }
+
+एक सरल उदाहरण के लिए, आइए [बड़ी Applications](../tutorial/bigger-applications.md) और [Testing](../tutorial/testing.md) में वर्णित file structure जैसी एक structure पर विचार करें:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+│ └── test_main.py
+```
+
+file `main.py` में यह होगा:
+
+{* ../../docs_src/async_tests/app_a_py310/main.py *}
+
+file `test_main.py` में `main.py` के लिए tests होंगे, यह अब कुछ ऐसा दिख सकता है:
+
+{* ../../docs_src/async_tests/app_a_py310/test_main.py *}
+
+## इसे चलाएँ { #run-it }
+
+आप अपने tests को हमेशा की तरह इस तरह चला सकते हैं:
+
+
+
+लेकिन अगर हम port `9999` वाले proxy का उपयोग करके "official" URL पर, `/api/v1/docs` पर docs UI access करते हैं, तो यह सही तरीके से काम करता है! 🎉
+
+आप इसे [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) पर देख सकते हैं:
+
+
+
+बिल्कुल जैसा हम चाहते थे। ✔️
+
+ऐसा इसलिए है क्योंकि FastAPI इस `root_path` का उपयोग OpenAPI में default `server` बनाने के लिए करता है, जिसमें `root_path` द्वारा दिया गया URL होता है।
+
+## अतिरिक्त servers { #additional-servers }
+
+/// warning | चेतावनी
+
+यह एक अधिक advanced use case है। चाहें तो इसे skip कर सकते हैं।
+
+///
+
+Default रूप से, **FastAPI** OpenAPI schema में `root_path` के URL वाला एक `server` बनाएगा।
+
+लेकिन आप अन्य alternative `servers` भी प्रदान कर सकते हैं, उदाहरण के लिए अगर आप चाहते हैं कि *वही* docs UI staging और production environment दोनों के साथ interact करे।
+
+अगर आप `servers` की custom list पास करते हैं और कोई `root_path` है (क्योंकि आपकी API proxy के पीछे रहती है), तो **FastAPI** list की शुरुआत में इस `root_path` के साथ एक "server" insert करेगा।
+
+उदाहरण के लिए:
+
+{* ../../docs_src/behind_a_proxy/tutorial003_py310.py hl[4:7] *}
+
+यह इस तरह का OpenAPI schema generate करेगा:
+
+```JSON hl_lines="5-7"
+{
+ "openapi": "3.1.0",
+ // यहाँ और चीज़ें
+ "servers": [
+ {
+ "url": "/api/v1"
+ },
+ {
+ "url": "https://stag.example.com",
+ "description": "Staging environment"
+ },
+ {
+ "url": "https://prod.example.com",
+ "description": "Production environment"
+ }
+ ],
+ "paths": {
+ // यहाँ और चीज़ें
+ }
+}
+```
+
+/// tip | सुझाव
+
+ध्यान दें कि `/api/v1` के `url` value वाला auto-generated server `root_path` से लिया गया है।
+
+///
+
+[http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) पर docs UI में यह ऐसा दिखेगा:
+
+
+
+/// tip | सुझाव
+
+Docs UI आपके द्वारा चुने गए server के साथ interact करेगा।
+
+///
+
+/// note | तकनीकी विवरण
+
+OpenAPI specification में `servers` property optional है।
+
+अगर आप `servers` parameter specify नहीं करते और `root_path` `/` के बराबर है, तो generated OpenAPI schema में `servers` property default रूप से पूरी तरह omit कर दी जाएगी, जो `/` के `url` value वाले single server के equivalent है।
+
+///
+
+### `root_path` से automatic server disable करें { #disable-automatic-server-from-root-path }
+
+अगर आप नहीं चाहते कि **FastAPI** `root_path` का उपयोग करके automatic server शामिल करे, तो आप parameter `root_path_in_servers=False` उपयोग कर सकते हैं:
+
+{* ../../docs_src/behind_a_proxy/tutorial004_py310.py hl[9] *}
+
+और फिर यह उसे OpenAPI schema में शामिल नहीं करेगा।
+
+## Sub-application mount करना { #mounting-a-sub-application }
+
+अगर आपको `root_path` वाले proxy का उपयोग करते हुए भी sub-application mount करनी है (जैसा कि [Sub Applications - Mounts](sub-applications.md) में बताया गया है), तो आप इसे सामान्य रूप से कर सकते हैं, जैसा कि आप अपेक्षा करेंगे।
+
+FastAPI internally `root_path` का smart तरीके से उपयोग करेगा, इसलिए यह बस काम करेगा। ✨
diff --git a/docs/hi/docs/advanced/custom-response.md b/docs/hi/docs/advanced/custom-response.md
new file mode 100644
index 000000000..8655618f2
--- /dev/null
+++ b/docs/hi/docs/advanced/custom-response.md
@@ -0,0 +1,273 @@
+# कस्टम Response - HTML, Stream, File, अन्य { #custom-response-html-stream-file-others }
+
+Default रूप से, **FastAPI** JSON responses लौटाएगा।
+
+आप [सीधे Response लौटाएँ](response-directly.md) में दिखाए गए अनुसार सीधे `Response` लौटाकर इसे override कर सकते हैं।
+
+लेकिन अगर आप सीधे `Response` लौटाते हैं (या कोई subclass, जैसे `JSONResponse`), तो data अपने आप convert नहीं होगा (भले ही आप `response_model` declare करें), और documentation अपने आप generate नहीं होगी (उदाहरण के लिए, generated OpenAPI के हिस्से के रूप में HTTP header `Content-Type` में specific "media type" शामिल करना)।
+
+लेकिन आप *path operation decorator* में `response_class` parameter का उपयोग करके वह `Response` भी declare कर सकते हैं जिसे आप उपयोग करना चाहते हैं (जैसे कोई भी `Response` subclass)।
+
+आप अपनी *path operation function* से जो contents लौटाते हैं, उन्हें उस `Response` के अंदर रख दिया जाएगा।
+
+/// note | नोट
+
+यदि आप बिना media type वाली response class का उपयोग करते हैं, तो FastAPI अपेक्षा करेगा कि आपके response में कोई content न हो, इसलिए यह अपने generated OpenAPI docs में response format को document नहीं करेगा।
+
+///
+
+## JSON Responses { #json-responses }
+
+Default रूप से FastAPI JSON responses लौटाता है।
+
+यदि आप [Response Model](../tutorial/response-model.md) declare करते हैं तो FastAPI Pydantic का उपयोग करके data को JSON में serialize करने के लिए उसका उपयोग करेगा।
+
+यदि आप response model declare नहीं करते हैं, तो FastAPI [JSON Compatible Encoder](../tutorial/encoder.md) में समझाए गए `jsonable_encoder` का उपयोग करेगा और उसे `JSONResponse` में रखेगा।
+
+यदि आप JSON media type (`application/json`) के साथ `response_class` declare करते हैं, जैसा कि `JSONResponse` के साथ होता है, तो आपके द्वारा लौटाया गया data आपकी *path operation decorator* में declare किए गए किसी भी Pydantic `response_model` के साथ अपने आप convert (और filter) हो जाएगा। लेकिन data Pydantic के साथ JSON bytes में serialize नहीं होगा, इसके बजाय इसे `jsonable_encoder` के साथ convert किया जाएगा और फिर `JSONResponse` class को pass किया जाएगा, जो Python की standard JSON library का उपयोग करके इसे bytes में serialize करेगी।
+
+### JSON Performance { #json-performance }
+
+संक्षेप में, यदि आप maximum performance चाहते हैं, तो [Response Model](../tutorial/response-model.md) का उपयोग करें और *path operation decorator* में `response_class` declare न करें।
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py ln[15:17] hl[16] *}
+
+## HTML Response { #html-response }
+
+**FastAPI** से सीधे HTML के साथ response लौटाने के लिए, `HTMLResponse` का उपयोग करें।
+
+* `HTMLResponse` import करें।
+* अपने *path operation decorator* के parameter `response_class` के रूप में `HTMLResponse` pass करें।
+
+{* ../../docs_src/custom_response/tutorial002_py310.py hl[2,7] *}
+
+/// note | नोट
+
+Parameter `response_class` का उपयोग response के "media type" को define करने के लिए भी किया जाएगा।
+
+इस मामले में, HTTP header `Content-Type` को `text/html` पर set किया जाएगा।
+
+और इसे OpenAPI में इसी तरह document किया जाएगा।
+
+///
+
+### `Response` लौटाएँ { #return-a-response }
+
+जैसा कि [सीधे Response लौटाएँ](response-directly.md) में देखा गया है, आप अपनी *path operation* में response को सीधे लौटाकर भी override कर सकते हैं।
+
+ऊपर वाला वही उदाहरण, जो `HTMLResponse` लौटाता है, इस तरह दिख सकता है:
+
+{* ../../docs_src/custom_response/tutorial003_py310.py hl[2,7,19] *}
+
+/// warning | चेतावनी
+
+आपकी *path operation function* द्वारा सीधे लौटाया गया `Response` OpenAPI में document नहीं होगा (उदाहरण के लिए, `Content-Type` document नहीं होगा) और automatic interactive docs में visible नहीं होगा।
+
+///
+
+/// note | नोट
+
+बेशक, वास्तविक `Content-Type` header, status code, आदि, आपके द्वारा लौटाए गए `Response` object से आएँगे।
+
+///
+
+### OpenAPI में document करें और `Response` override करें { #document-in-openapi-and-override-response }
+
+यदि आप function के अंदर से response को override करना चाहते हैं लेकिन साथ ही OpenAPI में "media type" document करना चाहते हैं, तो आप `response_class` parameter का उपयोग कर सकते हैं और `Response` object भी लौटा सकते हैं।
+
+तब `response_class` का उपयोग केवल OpenAPI *path operation* को document करने के लिए किया जाएगा, लेकिन आपका `Response` जैसा है वैसा ही उपयोग किया जाएगा।
+
+#### सीधे `HTMLResponse` लौटाएँ { #return-an-htmlresponse-directly }
+
+उदाहरण के लिए, यह कुछ ऐसा हो सकता है:
+
+{* ../../docs_src/custom_response/tutorial004_py310.py hl[7,21,23] *}
+
+इस उदाहरण में, function `generate_html_response()` पहले से ही HTML को `str` में लौटाने के बजाय `Response` generate करके लौटाता है।
+
+`generate_html_response()` को call करने का result लौटाकर, आप पहले से ही एक `Response` लौटा रहे हैं जो default **FastAPI** behavior को override करेगा।
+
+लेकिन क्योंकि आपने `response_class` में भी `HTMLResponse` pass किया है, **FastAPI** को पता होगा कि इसे OpenAPI और interactive docs में `text/html` के साथ HTML के रूप में कैसे document करना है:
+
+
+
+## उपलब्ध responses { #available-responses }
+
+यहाँ कुछ उपलब्ध responses दिए गए हैं।
+
+ध्यान रखें कि आप कुछ और लौटाने के लिए `Response` का उपयोग कर सकते हैं, या custom sub-class भी बना सकते हैं।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import HTMLResponse` भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` `fastapi.responses` के रूप में प्रदान करता है। लेकिन अधिकांश उपलब्ध responses सीधे Starlette से आते हैं।
+
+///
+
+### `Response` { #response }
+
+मुख्य `Response` class, बाकी सभी responses इससे inherit करते हैं।
+
+आप इसे सीधे लौटा सकते हैं।
+
+यह निम्नलिखित parameters accept करता है:
+
+* `content` - एक `str` या `bytes`।
+* `status_code` - एक `int` HTTP status code।
+* `headers` - strings का एक `dict`।
+* `media_type` - media type बताने वाला एक `str`। उदाहरण के लिए `"text/html"`।
+
+FastAPI (असल में Starlette) अपने आप एक Content-Length header शामिल करेगा। यह `media_type` के आधार पर Content-Type header भी शामिल करेगा और text types के लिए charset append करेगा।
+
+{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+
+### `HTMLResponse` { #htmlresponse }
+
+कुछ text या bytes लेता है और HTML response लौटाता है, जैसा आपने ऊपर पढ़ा।
+
+### `PlainTextResponse` { #plaintextresponse }
+
+कुछ text या bytes लेता है और plain text response लौटाता है।
+
+{* ../../docs_src/custom_response/tutorial005_py310.py hl[2,7,9] *}
+
+### `JSONResponse` { #jsonresponse }
+
+कुछ data लेता है और `application/json` encoded response लौटाता है।
+
+जैसा आपने ऊपर पढ़ा, यह **FastAPI** में उपयोग किया जाने वाला default response है।
+
+/// note | तकनीकी विवरण
+
+लेकिन यदि आप response model या return type declare करते हैं, तो उसका उपयोग सीधे data को JSON में serialize करने के लिए किया जाएगा, और JSON के लिए सही media type वाला response सीधे लौटाया जाएगा, `JSONResponse` class का उपयोग किए बिना।
+
+यह best performance पाने का ideal तरीका है।
+
+///
+
+### `RedirectResponse` { #redirectresponse }
+
+HTTP redirect लौटाता है। Default रूप से 307 status code (Temporary Redirect) का उपयोग करता है।
+
+आप सीधे `RedirectResponse` लौटा सकते हैं:
+
+{* ../../docs_src/custom_response/tutorial006_py310.py hl[2,9] *}
+
+---
+
+या आप इसे `response_class` parameter में उपयोग कर सकते हैं:
+
+
+{* ../../docs_src/custom_response/tutorial006b_py310.py hl[2,7,9] *}
+
+यदि आप ऐसा करते हैं, तो आप अपनी *path operation* function से URL सीधे लौटा सकते हैं।
+
+इस मामले में, उपयोग किया गया `status_code` `RedirectResponse` के लिए default वाला होगा, जो `307` है।
+
+---
+
+आप `status_code` parameter को `response_class` parameter के साथ combine करके भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/custom_response/tutorial006c_py310.py hl[2,7,9] *}
+
+### `StreamingResponse` { #streamingresponse }
+
+एक async generator या सामान्य generator/iterator (`yield` वाली function) लेता है और response body को stream करता है।
+
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
+
+/// note | तकनीकी विवरण
+
+एक `async` task केवल तब cancel किया जा सकता है जब वह किसी `await` तक पहुँचता है। यदि कोई `await` नहीं है, तो generator (`yield` वाली function) ठीक से cancel नहीं हो सकता और cancellation request किए जाने के बाद भी चलना जारी रख सकता है।
+
+चूँकि इस छोटे उदाहरण को किसी `await` statement की आवश्यकता नहीं है, हम event loop को cancellation handle करने का अवसर देने के लिए `await anyio.sleep(0)` जोड़ते हैं।
+
+यह बड़े या infinite streams के साथ और भी अधिक महत्वपूर्ण होगा।
+
+///
+
+/// tip | टिप
+
+सीधे `StreamingResponse` लौटाने के बजाय, आपको शायद [Stream Data](./stream-data.md) में दिए गए style का पालन करना चाहिए, यह कहीं अधिक सुविधाजनक है और आपके लिए पर्दे के पीछे cancellation handle करता है।
+
+यदि आप JSON Lines stream कर रहे हैं, तो [Stream JSON Lines](../tutorial/stream-json-lines.md) tutorial का पालन करें।
+
+///
+
+### `FileResponse` { #fileresponse }
+
+एक file को response के रूप में asynchronously stream करता है।
+
+Instantiate करने के लिए अन्य response types की तुलना में अलग set of arguments लेता है:
+
+* `path` - stream की जाने वाली file का file path।
+* `headers` - dictionary के रूप में शामिल किए जाने वाले कोई भी custom headers।
+* `media_type` - media type बताने वाली string। यदि unset है, तो media type infer करने के लिए filename या path का उपयोग किया जाएगा।
+* `filename` - यदि set है, तो इसे response `Content-Disposition` में शामिल किया जाएगा।
+
+File responses में उपयुक्त `Content-Length`, `Last-Modified` और `ETag` headers शामिल होंगे।
+
+{* ../../docs_src/custom_response/tutorial009_py310.py hl[2,10] *}
+
+आप `response_class` parameter का उपयोग भी कर सकते हैं:
+
+{* ../../docs_src/custom_response/tutorial009b_py310.py hl[2,8,10] *}
+
+इस मामले में, आप अपनी *path operation* function से file path सीधे लौटा सकते हैं।
+
+## Custom response class { #custom-response-class }
+
+आप `Response` से inherit करके और उसका उपयोग करके अपनी खुद की custom response class बना सकते हैं।
+
+उदाहरण के लिए, मान लें कि आप कुछ settings के साथ [`orjson`](https://github.com/ijl/orjson) का उपयोग करना चाहते हैं।
+
+मान लें आप चाहते हैं कि यह indented और formatted JSON लौटाए, इसलिए आप orjson option `orjson.OPT_INDENT_2` का उपयोग करना चाहते हैं।
+
+आप `CustomORJSONResponse` बना सकते हैं। आपको मुख्य रूप से `Response.render(content)` method बनाना है जो content को `bytes` के रूप में लौटाता है:
+
+{* ../../docs_src/custom_response/tutorial009c_py310.py hl[9:14,17] *}
+
+अब यह लौटाने के बजाय:
+
+```json
+{"message": "Hello World"}
+```
+
+...यह response लौटाएगा:
+
+```json
+{
+ "message": "Hello World"
+}
+```
+
+बेशक, JSON formatting की तुलना में इसका लाभ उठाने के लिए आपको शायद कहीं बेहतर तरीके मिलेंगे। 😉
+
+### `orjson` या Response Model { #orjson-or-response-model }
+
+यदि आप performance खोज रहे हैं, तो शायद `orjson` response की तुलना में [Response Model](../tutorial/response-model.md) का उपयोग करना आपके लिए बेहतर होगा।
+
+Response model के साथ, FastAPI data को JSON में serialize करने के लिए Pydantic का उपयोग करेगा, intermediate steps के बिना, जैसे `jsonable_encoder` के साथ convert करना, जो किसी भी अन्य मामले में होता।
+
+और अंदर से, Pydantic JSON में serialize करने के लिए `orjson` जैसे ही underlying Rust mechanisms का उपयोग करता है, इसलिए response model के साथ आपको पहले से ही best performance मिल जाएगी।
+
+## Default response class { #default-response-class }
+
+**FastAPI** class instance या `APIRouter` बनाते समय आप specify कर सकते हैं कि default रूप से कौन-सी response class उपयोग करनी है।
+
+इसे define करने वाला parameter `default_response_class` है।
+
+नीचे दिए गए उदाहरण में, **FastAPI** सभी *path operations* में JSON के बजाय default रूप से `HTMLResponse` का उपयोग करेगा।
+
+{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
+
+/// tip | टिप
+
+आप पहले की तरह *path operations* में अब भी `response_class` override कर सकते हैं।
+
+///
+
+## अतिरिक्त documentation { #additional-documentation }
+
+आप `responses` का उपयोग करके OpenAPI में media type और कई अन्य details भी declare कर सकते हैं: [OpenAPI में अतिरिक्त Responses](additional-responses.md)।
diff --git a/docs/hi/docs/advanced/dataclasses.md b/docs/hi/docs/advanced/dataclasses.md
new file mode 100644
index 000000000..55e487691
--- /dev/null
+++ b/docs/hi/docs/advanced/dataclasses.md
@@ -0,0 +1,95 @@
+# Dataclasses का उपयोग { #using-dataclasses }
+
+FastAPI **Pydantic** के ऊपर बनाया गया है, और मैंने आपको दिखाया है कि requests और responses घोषित करने के लिए Pydantic models का उपयोग कैसे करें।
+
+लेकिन FastAPI उसी तरह [`dataclasses`](https://docs.python.org/3/library/dataclasses.html) का उपयोग भी support करता है:
+
+{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
+
+यह अभी भी **Pydantic** की वजह से support किया जाता है, क्योंकि इसमें [`dataclasses` के लिए internal support](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel) है।
+
+इसलिए, ऊपर दिए गए code में भी, जो Pydantic का स्पष्ट रूप से उपयोग नहीं करता, FastAPI उन standard dataclasses को Pydantic की अपनी तरह की dataclasses में बदलने के लिए Pydantic का उपयोग कर रहा है।
+
+और निश्चित रूप से, यह इन्हें भी support करता है:
+
+* data validation
+* data serialization
+* data documentation, आदि।
+
+यह Pydantic models की तरह ही काम करता है। और अंदर से यह वास्तव में उसी तरह, Pydantic का उपयोग करके हासिल किया जाता है।
+
+/// note | नोट
+
+ध्यान रखें कि dataclasses वह सब कुछ नहीं कर सकतीं जो Pydantic models कर सकते हैं।
+
+इसलिए, आपको अभी भी Pydantic models का उपयोग करना पड़ सकता है।
+
+लेकिन अगर आपके पास बहुत सारी dataclasses पहले से मौजूद हैं, तो FastAPI का उपयोग करके web API को power देने के लिए उनका उपयोग करने की यह एक अच्छी तरकीब है। 🤓
+
+///
+
+## `response_model` में Dataclasses { #dataclasses-in-response-model }
+
+आप `response_model` parameter में भी `dataclasses` का उपयोग कर सकते हैं:
+
+{* ../../docs_src/dataclasses_/tutorial002_py310.py hl[1,6:12,18] *}
+
+dataclass अपने आप Pydantic dataclass में बदल जाएगी।
+
+इस तरह, उसका schema API docs के user interface में दिखाई देगा:
+
+
+
+## Nested Data Structures में Dataclasses { #dataclasses-in-nested-data-structures }
+
+आप nested data structures बनाने के लिए `dataclasses` को अन्य type annotations के साथ भी जोड़ सकते हैं।
+
+कुछ मामलों में, आपको अभी भी Pydantic के `dataclasses` वाले version का उपयोग करना पड़ सकता है। उदाहरण के लिए, अगर automatically generated API documentation में errors हों।
+
+उस स्थिति में, आप standard `dataclasses` को बस `pydantic.dataclasses` से बदल सकते हैं, जो एक drop-in replacement है:
+
+{* ../../docs_src/dataclasses_/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
+
+1. हम अभी भी standard `dataclasses` से `field` import करते हैं।
+
+2. `pydantic.dataclasses`, `dataclasses` के लिए एक drop-in replacement है।
+
+3. `Author` dataclass में `Item` dataclasses की एक list शामिल है।
+
+4. `Author` dataclass को `response_model` parameter के रूप में उपयोग किया गया है।
+
+5. आप request body के रूप में dataclasses के साथ अन्य standard type annotations का उपयोग कर सकते हैं।
+
+ इस मामले में, यह `Item` dataclasses की एक list है।
+
+6. यहाँ हम एक dictionary return कर रहे हैं जिसमें `items` है, जो dataclasses की एक list है।
+
+ FastAPI अभी भी data को JSON में serialize करने में सक्षम है।
+
+7. यहाँ `response_model`, `Author` dataclasses की list के type annotation का उपयोग कर रहा है।
+
+ फिर से, आप `dataclasses` को standard type annotations के साथ जोड़ सकते हैं।
+
+8. ध्यान दें कि यह *path operation function* `async def` की बजाय सामान्य `def` का उपयोग करता है।
+
+ हमेशा की तरह, FastAPI में आप आवश्यकता के अनुसार `def` और `async def` को जोड़ सकते हैं।
+
+ अगर आपको यह याद दिलाने की आवश्यकता है कि किसे कब उपयोग करना है, तो [`async` और `await`](../async.md#in-a-hurry) के docs में _"जल्दी में हैं?"_ section देखें।
+
+9. यह *path operation function* dataclasses return नहीं कर रहा है (हालाँकि कर सकता था), बल्कि internal data वाली dictionaries की list return कर रहा है।
+
+ FastAPI response को बदलने के लिए `response_model` parameter (जिसमें dataclasses शामिल हैं) का उपयोग करेगा।
+
+आप जटिल data structures बनाने के लिए `dataclasses` को कई अलग-अलग combinations में अन्य type annotations के साथ जोड़ सकते हैं।
+
+अधिक विशिष्ट विवरण देखने के लिए ऊपर दिए गए in-code annotation tips देखें।
+
+## और जानें { #learn-more }
+
+आप `dataclasses` को अन्य Pydantic models के साथ भी जोड़ सकते हैं, उनसे inherit कर सकते हैं, उन्हें अपने models में शामिल कर सकते हैं, आदि।
+
+अधिक जानने के लिए, [dataclasses के बारे में Pydantic docs](https://docs.pydantic.dev/latest/concepts/dataclasses/) देखें।
+
+## Version { #version }
+
+यह FastAPI version `0.67.0` से उपलब्ध है। 🔖
diff --git a/docs/hi/docs/advanced/events.md b/docs/hi/docs/advanced/events.md
new file mode 100644
index 000000000..05afd4e1c
--- /dev/null
+++ b/docs/hi/docs/advanced/events.md
@@ -0,0 +1,165 @@
+# Lifespan Events { #lifespan-events }
+
+आप ऐसी logic (code) define कर सकते हैं जिसे application के **starts up** होने से पहले execute किया जाना चाहिए। इसका मतलब है कि यह code application के **requests receive करना शुरू करने से पहले**, **एक बार** execute होगा।
+
+उसी तरह, आप ऐसी logic (code) define कर सकते हैं जिसे application के **shutting down** होने पर execute किया जाना चाहिए। इस मामले में, यह code संभवतः **कई requests** handle करने के **बाद**, **एक बार** execute होगा।
+
+क्योंकि यह code application के requests लेना **शुरू** करने से पहले, और requests handle करना **पूरा** करने के तुरंत बाद execute होता है, यह पूरी application **lifespan** को cover करता है (शब्द "lifespan" थोड़ी देर में महत्वपूर्ण होगा 😉)।
+
+यह उन **resources** को setup करने के लिए बहुत उपयोगी हो सकता है जिनकी आपको पूरी app में जरूरत होती है, और जो requests के बीच **shared** होते हैं, और/या जिन्हें आपको बाद में **clean up** करना होता है। उदाहरण के लिए, database connection pool, या कोई shared machine learning model load करना।
+
+## Use Case { #use-case }
+
+आइए एक उदाहरण **use case** से शुरू करते हैं और फिर देखते हैं कि इसे इससे कैसे solve किया जाए।
+
+मान लीजिए कि आपके पास कुछ **machine learning models** हैं जिन्हें आप requests handle करने के लिए use करना चाहते हैं। 🤖
+
+वही models requests के बीच shared हैं, इसलिए, यह हर request के लिए एक model, या हर user के लिए एक model या ऐसा कुछ नहीं है।
+
+मान लीजिए कि model load करने में **काफी समय लग सकता है**, क्योंकि उसे disk से बहुत सारा **data** read करना होता है। इसलिए आप इसे हर request के लिए नहीं करना चाहते।
+
+आप इसे module/file के top level पर load कर सकते हैं, लेकिन इसका मतलब यह भी होगा कि अगर आप सिर्फ एक simple automated test run कर रहे हैं, तब भी यह **model load** करेगा, और फिर वह test **slow** होगा क्योंकि code के किसी independent part को run कर पाने से पहले उसे model load होने का इंतजार करना पड़ेगा।
+
+यही हम solve करेंगे, चलिए model को requests handle होने से पहले load करते हैं, लेकिन केवल application के requests receive करना शुरू करने से ठीक पहले, code load होते समय नहीं।
+
+## Lifespan { #lifespan }
+
+आप `FastAPI` app के `lifespan` parameter और एक "context manager" (मैं अभी दिखाऊंगा कि यह क्या है) का use करके यह *startup* और *shutdown* logic define कर सकते हैं।
+
+आइए एक उदाहरण से शुरू करते हैं और फिर इसे detail में देखते हैं।
+
+हम `yield` के साथ एक async function `lifespan()` इस तरह create करते हैं:
+
+{* ../../docs_src/events/tutorial003_py310.py hl[16,19] *}
+
+यहां हम `yield` से पहले machine learning models वाली dictionary में (fake) model function रखकर model load करने वाली महंगी *startup* operation को simulate कर रहे हैं। यह code application के **requests लेना शुरू करने से पहले**, *startup* के दौरान execute होगा।
+
+और फिर, `yield` के तुरंत बाद, हम model unload करते हैं। यह code application के **requests handle करना पूरा करने के बाद**, *shutdown* से ठीक पहले execute होगा। उदाहरण के लिए, यह memory या GPU जैसे resources release कर सकता है।
+
+/// tip | सुझाव
+
+`shutdown` तब होगा जब आप application को **stop** कर रहे होंगे।
+
+शायद आपको कोई नया version start करना हो, या आप इसे चलाते-चलाते बस थक गए हों। 🤷
+
+///
+
+### Lifespan function { #lifespan-function }
+
+ध्यान देने वाली पहली चीज यह है कि हम `yield` के साथ एक async function define कर रहे हैं। यह `yield` वाली Dependencies से बहुत मिलता-जुलता है।
+
+{* ../../docs_src/events/tutorial003_py310.py hl[14:19] *}
+
+function का पहला हिस्सा, `yield` से पहले वाला, application start होने से **पहले** execute होगा।
+
+और `yield` के बाद वाला हिस्सा application के finish हो जाने के **बाद** execute होगा।
+
+### Async Context Manager { #async-context-manager }
+
+अगर आप check करें, तो function को `@asynccontextmanager` से decorate किया गया है।
+
+यह function को "**async context manager**" नाम की चीज में convert करता है।
+
+{* ../../docs_src/events/tutorial003_py310.py hl[1,13] *}
+
+Python में एक **context manager** ऐसी चीज है जिसे आप `with` statement में use कर सकते हैं, उदाहरण के लिए, `open()` को context manager की तरह use किया जा सकता है:
+
+```Python
+with open("file.txt") as file:
+ file.read()
+```
+
+Python के नए versions में, एक **async context manager** भी है। आप इसे `async with` के साथ use करेंगे:
+
+```Python
+async with lifespan(app):
+ await do_stuff()
+```
+
+जब आप ऊपर की तरह कोई context manager या async context manager create करते हैं, तो यह क्या करता है कि `with` block में enter करने से पहले, यह `yield` से पहले वाला code execute करेगा, और `with` block से exit करने के बाद, यह `yield` के बाद वाला code execute करेगा।
+
+ऊपर हमारे code example में, हम इसे सीधे use नहीं करते, बल्कि FastAPI को pass करते हैं ताकि वह इसे use कर सके।
+
+`FastAPI` app का `lifespan` parameter एक **async context manager** लेता है, इसलिए हम अपना नया `lifespan` async context manager उसे pass कर सकते हैं।
+
+{* ../../docs_src/events/tutorial003_py310.py hl[22] *}
+
+## Alternative Events (deprecated) { #alternative-events-deprecated }
+
+/// warning | चेतावनी
+
+*startup* और *shutdown* को handle करने का recommended तरीका ऊपर बताए गए अनुसार `FastAPI` app के `lifespan` parameter का use करना है। अगर आप `lifespan` parameter provide करते हैं, तो `startup` और `shutdown` event handlers अब call नहीं किए जाएंगे। यह पूरा `lifespan` होगा या पूरे events, दोनों नहीं।
+
+आप शायद यह हिस्सा skip कर सकते हैं।
+
+///
+
+इस logic को *startup* के दौरान और *shutdown* के दौरान execute करने के लिए define करने का एक alternative तरीका है।
+
+आप event handlers (functions) define कर सकते हैं जिन्हें application के starts up होने से पहले, या application के shutting down होने पर execute किया जाना चाहिए।
+
+इन functions को `async def` या normal `def` के साथ declare किया जा सकता है।
+
+### `startup` event { #startup-event }
+
+application start होने से पहले run होने वाला function add करने के लिए, इसे event `"startup"` के साथ declare करें:
+
+{* ../../docs_src/events/tutorial001_py310.py hl[8] *}
+
+इस मामले में, `startup` event handler function items "database" (बस एक `dict`) को कुछ values के साथ initialize करेगा।
+
+आप एक से अधिक event handler function add कर सकते हैं।
+
+और आपकी application requests receive करना तब तक शुरू नहीं करेगी जब तक सभी `startup` event handlers complete नहीं हो जाते।
+
+### `shutdown` event { #shutdown-event }
+
+application के shutting down होने पर run होने वाला function add करने के लिए, इसे event `"shutdown"` के साथ declare करें:
+
+{* ../../docs_src/events/tutorial002_py310.py hl[6] *}
+
+यहां, `shutdown` event handler function एक text line `"Application shutdown"` को `log.txt` file में write करेगा।
+
+/// note | नोट
+
+`open()` function में, `mode="a"` का मतलब "append" होता है, इसलिए, line उस file में जो भी है उसके बाद add की जाएगी, पिछले contents को overwrite किए बिना।
+
+///
+
+/// tip | सुझाव
+
+ध्यान दें कि इस मामले में हम एक standard Python `open()` function use कर रहे हैं जो एक file के साथ interact करता है।
+
+इसलिए, इसमें I/O (input/output) शामिल है, जिसके लिए चीजों के disk पर write होने का "waiting" करना पड़ता है।
+
+लेकिन `open()` `async` और `await` use नहीं करता।
+
+इसलिए, हम event handler function को `async def` के बजाय standard `def` के साथ declare करते हैं।
+
+///
+
+### `startup` और `shutdown` साथ में { #startup-and-shutdown-together }
+
+इस बात की काफी संभावना है कि आपके *startup* और *shutdown* की logic connected हो, आप शायद कुछ start करना और फिर उसे finish करना, कोई resource acquire करना और फिर उसे release करना, आदि चाहें।
+
+इसे अलग-अलग functions में करना, जो logic या variables को साथ में share नहीं करते, अधिक कठिन है क्योंकि आपको values को global variables या इसी तरह की tricks में store करना पड़ेगा।
+
+इसी वजह से, अब इसके बजाय ऊपर explain किए गए `lifespan` को use करने की recommendation है।
+
+## Technical Details { #technical-details }
+
+जिज्ञासु nerds के लिए बस एक technical detail। 🤓
+
+अंदर से, ASGI technical specification में, यह [Lifespan Protocol](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) का हिस्सा है, और यह `startup` और `shutdown` नाम के events define करता है।
+
+/// note | नोट
+
+आप Starlette `lifespan` handlers के बारे में [Starlette की Lifespan docs](https://www.starlette.dev/lifespan/) में और पढ़ सकते हैं।
+
+इसमें यह भी शामिल है कि lifespan state को कैसे handle किया जाए जिसे आपके code के अन्य areas में use किया जा सकता है।
+
+///
+
+## Sub Applications { #sub-applications }
+
+🚨 ध्यान रखें कि ये lifespan events (startup और shutdown) केवल main application के लिए execute होंगे, [Sub Applications - Mounts](sub-applications.md) के लिए नहीं।
diff --git a/docs/hi/docs/advanced/generate-clients.md b/docs/hi/docs/advanced/generate-clients.md
new file mode 100644
index 000000000..fa4b8f496
--- /dev/null
+++ b/docs/hi/docs/advanced/generate-clients.md
@@ -0,0 +1,192 @@
+# SDKs जेनरेट करना { #generating-sdks }
+
+क्योंकि **FastAPI** **OpenAPI** specification पर आधारित है, इसकी APIs को एक standard format में वर्णित किया जा सकता है जिसे कई tools समझते हैं।
+
+इससे up-to-date **documentation**, कई भाषाओं में client libraries (**SDKs**), और **testing** या **automation workflows** जेनरेट करना आसान हो जाता है, जो आपके code के साथ sync में रहते हैं।
+
+इस guide में, आप सीखेंगे कि अपने FastAPI backend के लिए **TypeScript SDK** कैसे जेनरेट करें।
+
+## Open Source SDK Generators { #open-source-sdk-generators }
+
+एक versatile विकल्प [OpenAPI Generator](https://openapi-generator.tech/) है, जो **कई programming languages** को support करता है और आपकी OpenAPI specification से SDKs जेनरेट कर सकता है।
+
+**TypeScript clients** के लिए, [Hey API](https://heyapi.dev/) एक purpose-built solution है, जो TypeScript ecosystem के लिए optimized experience प्रदान करता है।
+
+आप [OpenAPI.Tools](https://openapi.tools/#sdk) पर और SDK generators खोज सकते हैं।
+
+/// tip | सुझाव
+
+FastAPI अपने-आप **OpenAPI 3.1** specifications जेनरेट करता है, इसलिए आपके द्वारा उपयोग किया जाने वाला कोई भी tool इस version को support करना चाहिए।
+
+///
+
+## TypeScript SDK बनाएँ { #create-a-typescript-sdk }
+
+आइए एक सरल FastAPI application से शुरू करें:
+
+{* ../../docs_src/generate_clients/tutorial001_py310.py hl[7:9,12:13,16:17,21] *}
+
+ध्यान दें कि *path operations* उन models को define करते हैं जिनका उपयोग वे request payload और response payload के लिए करते हैं, `Item` और `ResponseMessage` models का उपयोग करके।
+
+### API Docs { #api-docs }
+
+यदि आप `/docs` पर जाते हैं, तो आप देखेंगे कि इसमें requests में भेजे जाने और responses में प्राप्त होने वाले data के लिए **schemas** हैं:
+
+
+
+आप वे schemas देख सकते हैं क्योंकि उन्हें app में models के साथ declare किया गया था।
+
+वह जानकारी app के **OpenAPI schema** में उपलब्ध होती है, और फिर API docs में दिखाई जाती है।
+
+Models से वही जानकारी जो OpenAPI में शामिल होती है, **client code जेनरेट करने** के लिए उपयोग की जा सकती है।
+
+### Hey API { #hey-api }
+
+जब हमारे पास models के साथ एक FastAPI app हो, तो हम Hey API का उपयोग करके TypeScript client जेनरेट कर सकते हैं। ऐसा करने का सबसे तेज़ तरीका npx के माध्यम से है।
+
+```sh
+npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
+```
+
+यह `./src/client` में TypeScript SDK जेनरेट करेगा।
+
+आप उनकी website पर [`@hey-api/openapi-ts` install करना](https://heyapi.dev/openapi-ts/get-started) सीख सकते हैं और [generated output](https://heyapi.dev/openapi-ts/output) के बारे में पढ़ सकते हैं।
+
+### SDK का उपयोग करना { #using-the-sdk }
+
+अब आप client code को import करके उपयोग कर सकते हैं। यह कुछ ऐसा दिख सकता है, ध्यान दें कि आपको methods के लिए autocompletion मिलता है:
+
+
+
+आपको भेजने के लिए payload के लिए भी autocompletion मिलेगा:
+
+
+
+/// tip | सुझाव
+
+`name` और `price` के लिए autocompletion पर ध्यान दें, जिसे FastAPI application में, `Item` model में define किया गया था।
+
+///
+
+आपके द्वारा भेजे जाने वाले data के लिए inline errors होंगे:
+
+
+
+Response object में भी autocompletion होगा:
+
+
+
+## Tags के साथ FastAPI App { #fastapi-app-with-tags }
+
+कई मामलों में, आपका FastAPI app बड़ा होगा, और आप शायद *path operations* के अलग-अलग groups को separate करने के लिए tags का उपयोग करेंगे।
+
+उदाहरण के लिए, आपके पास **items** के लिए एक section और **users** के लिए दूसरा section हो सकता है, और उन्हें tags द्वारा separate किया जा सकता है:
+
+{* ../../docs_src/generate_clients/tutorial002_py310.py hl[21,26,34] *}
+
+### Tags के साथ TypeScript Client जेनरेट करें { #generate-a-typescript-client-with-tags }
+
+यदि आप tags का उपयोग करने वाले FastAPI app के लिए client जेनरेट करते हैं, तो यह सामान्यतः client code को भी tags के आधार पर separate करेगा।
+
+इस तरह, आप client code के लिए चीज़ों को सही तरह से ordered और grouped रख पाएँगे:
+
+
+
+इस मामले में, आपके पास हैं:
+
+* `ItemsService`
+* `UsersService`
+
+### Client Method Names { #client-method-names }
+
+अभी, जेनरेट किए गए method names जैसे `createItemItemsPost` बहुत साफ़ नहीं दिखते:
+
+```TypeScript
+ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
+```
+
+...ऐसा इसलिए है क्योंकि client generator प्रत्येक *path operation* के लिए OpenAPI internal **operation ID** का उपयोग करता है।
+
+OpenAPI required करता है कि प्रत्येक operation ID सभी *path operations* में unique हो, इसलिए FastAPI उस operation ID को जेनरेट करने के लिए **function name**, **path**, और **HTTP method/operation** का उपयोग करता है, क्योंकि इस तरह यह सुनिश्चित कर सकता है कि operation IDs unique हैं।
+
+लेकिन मैं आगे आपको दिखाऊँगा कि इसे कैसे बेहतर बनाया जाए। 🤓
+
+## Custom Operation IDs और बेहतर Method Names { #custom-operation-ids-and-better-method-names }
+
+आप इन operation IDs को **जेनरेट** करने के तरीके को **modify** कर सकते हैं ताकि वे clients में सरल हों और **सरल method names** हों।
+
+इस मामले में, आपको किसी दूसरे तरीके से सुनिश्चित करना होगा कि प्रत्येक operation ID **unique** हो।
+
+उदाहरण के लिए, आप सुनिश्चित कर सकते हैं कि प्रत्येक *path operation* में एक tag हो, और फिर **tag** और *path operation* **name** (function name) के आधार पर operation ID जेनरेट करें।
+
+### Custom Generate Unique ID Function { #custom-generate-unique-id-function }
+
+FastAPI प्रत्येक *path operation* के लिए एक **unique ID** का उपयोग करता है, जिसका उपयोग **operation ID** के लिए और requests या responses के लिए आवश्यक किसी भी custom models के names के लिए भी किया जाता है।
+
+आप उस function को customize कर सकते हैं। यह एक `APIRoute` लेता है और एक string output करता है।
+
+उदाहरण के लिए, यहाँ यह पहले tag (आपके पास शायद केवल एक tag होगा) और *path operation* name (function name) का उपयोग कर रहा है।
+
+फिर आप उस custom function को `generate_unique_id_function` parameter के रूप में **FastAPI** को pass कर सकते हैं:
+
+{* ../../docs_src/generate_clients/tutorial003_py310.py hl[6:7,10] *}
+
+### Custom Operation IDs के साथ TypeScript Client जेनरेट करें { #generate-a-typescript-client-with-custom-operation-ids }
+
+अब, यदि आप client को फिर से जेनरेट करते हैं, तो आप देखेंगे कि इसमें बेहतर method names हैं:
+
+
+
+जैसा कि आप देखते हैं, method names में अब tag और फिर function name है, अब वे URL path और HTTP operation की जानकारी शामिल नहीं करते।
+
+### Client Generator के लिए OpenAPI Specification को Preprocess करें { #preprocess-the-openapi-specification-for-the-client-generator }
+
+जेनरेट किए गए code में अभी भी कुछ **duplicated information** है।
+
+हम पहले से जानते हैं कि यह method **items** से संबंधित है क्योंकि वह शब्द `ItemsService` (tag से लिया गया) में है, लेकिन method name में भी tag name prefixed है। 😕
+
+हम शायद इसे सामान्य रूप से OpenAPI के लिए रखना चाहेंगे, क्योंकि यह सुनिश्चित करेगा कि operation IDs **unique** हैं।
+
+लेकिन generated client के लिए, हम clients जेनरेट करने से ठीक पहले OpenAPI operation IDs को **modify** कर सकते हैं, ताकि उन method names को अधिक अच्छे और **cleaner** बनाया जा सके।
+
+हम OpenAPI JSON को `openapi.json` file में download कर सकते हैं और फिर इस तरह के script से **उस prefixed tag को remove** कर सकते हैं:
+
+{* ../../docs_src/generate_clients/tutorial004_py310.py *}
+
+//// tab | Node.js
+
+```Javascript
+{!> ../../docs_src/generate_clients/tutorial004.js!}
+```
+
+////
+
+इसके साथ, operation IDs को `items-get_items` जैसी चीज़ों से बदलकर सिर्फ़ `get_items` कर दिया जाएगा, इस तरह client generator सरल method names जेनरेट कर सकता है।
+
+### Preprocessed OpenAPI के साथ TypeScript Client जेनरेट करें { #generate-a-typescript-client-with-the-preprocessed-openapi }
+
+क्योंकि अंतिम परिणाम अब `openapi.json` file में है, आपको अपनी input location update करनी होगी:
+
+```sh
+npx @hey-api/openapi-ts -i ./openapi.json -o src/client
+```
+
+नया client जेनरेट करने के बाद, अब आपके पास **clean method names** होंगे, सभी **autocompletion**, **inline errors**, आदि के साथ:
+
+
+
+## लाभ { #benefits }
+
+Automatically generated clients का उपयोग करते समय, आपको इन चीज़ों के लिए **autocompletion** मिलेगा:
+
+* Methods.
+* body में request payloads, query parameters, आदि।
+* Response payloads.
+
+आपके पास हर चीज़ के लिए **inline errors** भी होंगे।
+
+और जब भी आप backend code update करते हैं, और frontend को **regenerate** करते हैं, तो इसमें methods के रूप में कोई भी नए *path operations* उपलब्ध होंगे, पुराने remove हो जाएँगे, और कोई भी अन्य change generated code में reflect होगा। 🤓
+
+इसका मतलब यह भी है कि यदि कुछ बदलता है, तो वह client code में अपने-आप **reflect** होगा। और यदि आप client को **build** करते हैं, तो यदि उपयोग किए गए data में कोई **mismatch** है, तो यह error देगा।
+
+इसलिए, आप development cycle में बहुत जल्दी **कई errors detect** कर लेंगे, बजाय इसके कि errors के production में आपके अंतिम users को दिखने का इंतज़ार करना पड़े और फिर यह debug करने की कोशिश करनी पड़े कि समस्या कहाँ है। ✨
diff --git a/docs/hi/docs/advanced/index.md b/docs/hi/docs/advanced/index.md
new file mode 100644
index 000000000..d2ecb69dc
--- /dev/null
+++ b/docs/hi/docs/advanced/index.md
@@ -0,0 +1,21 @@
+# उन्नत उपयोगकर्ता गाइड { #advanced-user-guide }
+
+## अतिरिक्त feature { #additional-features }
+
+मुख्य [ट्यूटोरियल - उपयोगकर्ता गाइड](../tutorial/index.md) आपको **FastAPI** के सभी मुख्य feature का अवलोकन देने के लिए पर्याप्त होना चाहिए।
+
+अगले sections में आप अन्य विकल्प, configurations, और अतिरिक्त feature देखेंगे।
+
+/// tip | सुझाव
+
+अगले sections **ज़रूरी नहीं कि "उन्नत"** हों।
+
+और संभव है कि आपके उपयोग के मामले के लिए समाधान उनमें से किसी एक में हो।
+
+///
+
+## पहले ट्यूटोरियल पढ़ें { #read-the-tutorial-first }
+
+आप मुख्य [ट्यूटोरियल - उपयोगकर्ता गाइड](../tutorial/index.md) से मिली जानकारी के साथ भी **FastAPI** के ज़्यादातर feature का उपयोग कर सकते हैं।
+
+और अगले sections मानते हैं कि आपने इसे पहले ही पढ़ लिया है, और यह भी मानते हैं कि आप उन मुख्य विचारों को जानते हैं।
diff --git a/docs/hi/docs/advanced/json-base64-bytes.md b/docs/hi/docs/advanced/json-base64-bytes.md
new file mode 100644
index 000000000..c99ffbc7f
--- /dev/null
+++ b/docs/hi/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# Base64 के रूप में Bytes वाला JSON { #json-with-bytes-as-base64 }
+
+अगर आपके app को JSON data receive और send करना है, लेकिन आपको उसमें binary data शामिल करना है, तो आप उसे base64 के रूप में encode कर सकते हैं।
+
+## Base64 बनाम Files { #base64-vs-files }
+
+पहले यह विचार करें कि क्या आप binary data upload करने के लिए [Request Files](../tutorial/request-files.md) और binary data भेजने के लिए [कस्टम Response - FileResponse](./custom-response.md#fileresponse) का उपयोग कर सकते हैं, बजाय इसके कि उसे JSON में encode किया जाए।
+
+JSON में केवल UTF-8 encoded strings हो सकती हैं, इसलिए उसमें raw bytes नहीं हो सकते।
+
+Base64 binary data को strings में encode कर सकता है, लेकिन ऐसा करने के लिए उसे मूल binary data की तुलना में अधिक characters का उपयोग करना पड़ता है, इसलिए यह सामान्य files की तुलना में आमतौर पर कम efficient होगा।
+
+Base64 का उपयोग केवल तभी करें जब आपको निश्चित रूप से JSON में binary data शामिल करना हो, और आप उसके लिए files का उपयोग नहीं कर सकते।
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+आप `bytes` fields वाला एक Pydantic model declare कर सकते हैं, और फिर model config में `val_json_bytes` का उपयोग करके उसे बता सकते हैं कि input JSON data को *validate* करने के लिए base64 का उपयोग करे; उस validation के हिस्से के रूप में यह base64 string को bytes में decode करेगा।
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+अगर आप `/docs` देखें, तो वे दिखाएँगे कि field `data` base64 encoded bytes की अपेक्षा करता है:
+
+
+
diff --git a/docs/hi/docs/advanced/openapi-webhooks.md b/docs/hi/docs/advanced/openapi-webhooks.md
new file mode 100644
index 000000000..65cafd0d6
--- /dev/null
+++ b/docs/hi/docs/advanced/openapi-webhooks.md
@@ -0,0 +1,55 @@
+# OpenAPI Webhooks { #openapi-webhooks }
+
+ऐसे मामले होते हैं जहाँ आप अपने API **users** को बताना चाहते हैं कि आपकी app कुछ data के साथ (एक request भेजते हुए) *उनकी* app को कॉल कर सकती है, सामान्यतः किसी प्रकार के **event** की **सूचना** देने के लिए।
+
+इसका मतलब है कि आपके users द्वारा आपकी API को requests भेजने की सामान्य प्रक्रिया के बजाय, **आपकी API** (या आपकी app) **उनके system को requests भेज** सकती है (उनकी API, उनकी app को)।
+
+इसे सामान्यतः **webhook** कहा जाता है।
+
+## Webhooks के चरण { #webhooks-steps }
+
+सामान्यतः प्रक्रिया यह होती है कि **आप अपने code में define करते हैं** कि आप कौन-सा message भेजेंगे, यानी **request का body**।
+
+आप यह भी किसी तरीके से define करते हैं कि आपकी app किन **क्षणों** पर वे requests या events भेजेगी।
+
+और **आपके users** किसी तरीके से (उदाहरण के लिए कहीं किसी web dashboard में) वह **URL** define करते हैं जहाँ आपकी app को वे requests भेजनी चाहिए।
+
+Webhooks के लिए URLs को register करने की सारी **logic** और वास्तव में उन requests को भेजने का code आपके ऊपर है। आप इसे **अपने खुद के code** में जैसे चाहें वैसे लिखते हैं।
+
+## **FastAPI** और OpenAPI के साथ webhooks का दस्तावेज़ीकरण { #documenting-webhooks-with-fastapi-and-openapi }
+
+**FastAPI** के साथ, OpenAPI का उपयोग करते हुए, आप इन webhooks के नाम, आपकी app द्वारा भेजे जा सकने वाले HTTP operations के प्रकार (जैसे `POST`, `PUT`, आदि) और आपकी app द्वारा भेजे जाने वाले request **bodies** define कर सकते हैं।
+
+इससे आपके users के लिए आपकी **webhook** requests प्राप्त करने के लिए **अपनी APIs implement करना** बहुत आसान हो सकता है, वे शायद अपने कुछ API code को autogenerate भी कर सकें।
+
+/// note | नोट
+
+Webhooks OpenAPI 3.1.0 और उससे ऊपर में उपलब्ध हैं, और FastAPI `0.99.0` और उससे ऊपर द्वारा समर्थित हैं।
+
+///
+
+## Webhooks वाली app { #an-app-with-webhooks }
+
+जब आप एक **FastAPI** application बनाते हैं, तो एक `webhooks` attribute होता है जिसका उपयोग आप *webhooks* define करने के लिए कर सकते हैं, उसी तरह जैसे आप *path operations* define करते हैं, उदाहरण के लिए `@app.webhooks.post()` के साथ।
+
+{* ../../docs_src/openapi_webhooks/tutorial001_py310.py hl[9:12,15:20] *}
+
+आप जिन webhooks को define करते हैं वे **OpenAPI** schema और automatic **docs UI** में आ जाएँगे।
+
+/// note | नोट
+
+`app.webhooks` object वास्तव में सिर्फ़ एक `APIRouter` है, वही type जिसका उपयोग आप अपनी app को multiple files के साथ structure करते समय करेंगे।
+
+///
+
+ध्यान दें कि webhooks के साथ आप वास्तव में कोई *path* declare नहीं कर रहे हैं (जैसे `/items/`), वहाँ आप जो text pass करते हैं वह केवल webhook का एक **identifier** है (event का नाम), उदाहरण के लिए `@app.webhooks.post("new-subscription")` में, webhook का नाम `new-subscription` है।
+
+ऐसा इसलिए है क्योंकि उम्मीद की जाती है कि **आपके users** उस वास्तविक **URL path** को किसी और तरीके से define करेंगे जहाँ वे webhook request प्राप्त करना चाहते हैं (जैसे कोई web dashboard)।
+
+### Docs देखें { #check-the-docs }
+
+अब आप अपनी app start कर सकते हैं और [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) पर जा सकते हैं।
+
+आप देखेंगे कि आपके docs में सामान्य *path operations* हैं और अब कुछ **webhooks** भी हैं:
+
+
diff --git a/docs/hi/docs/advanced/path-operation-advanced-configuration.md b/docs/hi/docs/advanced/path-operation-advanced-configuration.md
new file mode 100644
index 000000000..1636b4f0e
--- /dev/null
+++ b/docs/hi/docs/advanced/path-operation-advanced-configuration.md
@@ -0,0 +1,166 @@
+# Path Operation की उन्नत Configuration { #path-operation-advanced-configuration }
+
+## OpenAPI operationId { #openapi-operationid }
+
+/// warning | चेतावनी
+
+अगर आप OpenAPI में "expert" नहीं हैं, तो शायद आपको इसकी ज़रूरत नहीं है।
+
+///
+
+आप अपने *path operation* में उपयोग किए जाने वाले OpenAPI `operationId` को parameter `operation_id` के साथ सेट कर सकते हैं।
+
+आपको यह सुनिश्चित करना होगा कि यह प्रत्येक operation के लिए unique हो।
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial001_py310.py hl[6] *}
+
+### *path operation function* के नाम को operationId के रूप में उपयोग करना { #using-the-path-operation-function-name-as-the-operationid }
+
+अगर आप अपने APIs के function नामों को `operationId`s के रूप में उपयोग करना चाहते हैं, तो आप `FastAPI` को एक custom `generate_unique_id_function` पास कर सकते हैं।
+
+यह function प्रत्येक `APIRoute` प्राप्त करता है और उस path operation के लिए उपयोग करने वाला `operationId` return करता है।
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py310.py hl[2,5:6,9] *}
+
+/// warning | चेतावनी
+
+अगर आप ऐसा करते हैं, तो आपको यह सुनिश्चित करना होगा कि आपके प्रत्येक *path operation functions* का नाम unique हो।
+
+भले ही वे अलग-अलग modules (Python files) में हों।
+
+///
+
+## OpenAPI से बाहर रखना { #exclude-from-openapi }
+
+किसी *path operation* को generated OpenAPI schema से बाहर रखने के लिए (और इस प्रकार, automatic documentation systems से भी), parameter `include_in_schema` का उपयोग करें और इसे `False` पर सेट करें:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py310.py hl[6] *}
+
+## Docstring से उन्नत description { #advanced-description-from-docstring }
+
+आप OpenAPI के लिए किसी *path operation function* की docstring से उपयोग की जाने वाली lines को सीमित कर सकते हैं।
+
+एक `\f` (एक escaped "form feed" character) जोड़ने से **FastAPI** इस बिंदु पर OpenAPI के लिए उपयोग किए जाने वाले output को truncate कर देता है।
+
+यह documentation में नहीं दिखेगा, लेकिन अन्य tools (जैसे Sphinx) बाकी हिस्से का उपयोग कर सकेंगे।
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
+
+## अतिरिक्त Responses { #additional-responses }
+
+आपने शायद देखा होगा कि किसी *path operation* के लिए `response_model` और `status_code` कैसे declare किए जाते हैं।
+
+यह किसी *path operation* के मुख्य response के बारे में metadata define करता है।
+
+आप उनके models, status codes आदि के साथ अतिरिक्त responses भी declare कर सकते हैं।
+
+इसके बारे में documentation में यहाँ एक पूरा chapter है, आप इसे [OpenAPI में अतिरिक्त Responses](additional-responses.md) पर पढ़ सकते हैं।
+
+## OpenAPI Extra { #openapi-extra }
+
+जब आप अपने application में कोई *path operation* declare करते हैं, तो **FastAPI** उस *path operation* के बारे में relevant metadata को automatically generate करता है, जिसे OpenAPI schema में शामिल किया जाता है।
+
+/// note | तकनीकी विवरण
+
+OpenAPI specification में इसे [Operation Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object) कहा जाता है।
+
+///
+
+इसमें *path operation* के बारे में सारी जानकारी होती है और इसका उपयोग automatic documentation generate करने के लिए किया जाता है।
+
+इसमें `tags`, `parameters`, `requestBody`, `responses` आदि शामिल होते हैं।
+
+यह *path operation*-specific OpenAPI schema सामान्यतः **FastAPI** द्वारा automatically generate किया जाता है, लेकिन आप इसे extend भी कर सकते हैं।
+
+/// tip | सुझाव
+
+यह एक low level extension point है।
+
+अगर आपको केवल अतिरिक्त responses declare करने की ज़रूरत है, तो ऐसा करने का एक अधिक सुविधाजनक तरीका [OpenAPI में अतिरिक्त Responses](additional-responses.md) के साथ है।
+
+///
+
+आप parameter `openapi_extra` का उपयोग करके किसी *path operation* के लिए OpenAPI schema को extend कर सकते हैं।
+
+### OpenAPI Extensions { #openapi-extensions }
+
+यह `openapi_extra` उपयोगी हो सकता है, उदाहरण के लिए, [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) declare करने के लिए:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial005_py310.py hl[6] *}
+
+अगर आप automatic API docs खोलते हैं, तो आपका extension specific *path operation* के नीचे दिखाई देगा।
+
+
+
+और अगर आप resulting OpenAPI (आपकी API में `/openapi.json` पर) देखते हैं, तो आपको अपना extension specific *path operation* के हिस्से के रूप में भी दिखाई देगा:
+
+```JSON hl_lines="22"
+{
+ "openapi": "3.1.0",
+ "info": {
+ "title": "FastAPI",
+ "version": "0.1.0"
+ },
+ "paths": {
+ "/items/": {
+ "get": {
+ "summary": "Read Items",
+ "operationId": "read_items_items__get",
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {}
+ }
+ }
+ }
+ },
+ "x-aperture-labs-portal": "blue"
+ }
+ }
+ }
+}
+```
+
+### Custom OpenAPI *path operation* schema { #custom-openapi-path-operation-schema }
+
+`openapi_extra` में मौजूद dictionary को *path operation* के लिए automatically generated OpenAPI schema के साथ deeply merge किया जाएगा।
+
+तो, आप automatically generated schema में अतिरिक्त data जोड़ सकते हैं।
+
+उदाहरण के लिए, आप FastAPI की Pydantic के साथ automatic features का उपयोग किए बिना, अपने code से request को read और validate करने का निर्णय ले सकते हैं, लेकिन फिर भी आप OpenAPI schema में request को define करना चाह सकते हैं।
+
+आप यह `openapi_extra` के साथ कर सकते हैं:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py310.py hl[19:36, 39:40] *}
+
+इस उदाहरण में, हमने कोई Pydantic model declare नहीं किया। वास्तव में, request body को JSON के रूप में parsed भी नहीं किया गया है, इसे सीधे `bytes` के रूप में read किया गया है, और function `magic_data_reader()` किसी तरीके से इसे parse करने का ज़िम्मेदार होगा।
+
+फिर भी, हम request body के लिए expected schema declare कर सकते हैं।
+
+### Custom OpenAPI content type { #custom-openapi-content-type }
+
+इसी trick का उपयोग करके, आप JSON Schema define करने के लिए Pydantic model का उपयोग कर सकते हैं, जिसे फिर *path operation* के लिए custom OpenAPI schema section में शामिल किया जाता है।
+
+और आप ऐसा तब भी कर सकते हैं जब request में data type JSON न हो।
+
+उदाहरण के लिए, इस application में हम Pydantic models से JSON Schema निकालने के लिए FastAPI की integrated functionality या JSON के लिए automatic validation का उपयोग नहीं करते हैं। वास्तव में, हम request content type को JSON नहीं, बल्कि YAML के रूप में declare कर रहे हैं:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py310.py hl[15:20, 22] *}
+
+फिर भी, हालांकि हम default integrated functionality का उपयोग नहीं कर रहे हैं, हम अभी भी उस data के लिए JSON Schema manually generate करने के लिए Pydantic model का उपयोग कर रहे हैं जिसे हम YAML में receive करना चाहते हैं।
+
+फिर हम request को सीधे उपयोग करते हैं, और body को `bytes` के रूप में extract करते हैं। इसका मतलब है कि FastAPI request payload को JSON के रूप में parse करने की कोशिश भी नहीं करेगा।
+
+और फिर अपने code में, हम उस YAML content को सीधे parse करते हैं, और फिर हम YAML content को validate करने के लिए फिर से उसी Pydantic model का उपयोग कर रहे हैं:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py310.py hl[24:31] *}
+
+/// tip | सुझाव
+
+यहाँ हम उसी Pydantic model को reuse करते हैं।
+
+लेकिन इसी तरह, हम इसे किसी और तरीके से भी validate कर सकते थे।
+
+///
diff --git a/docs/hi/docs/advanced/response-change-status-code.md b/docs/hi/docs/advanced/response-change-status-code.md
new file mode 100644
index 000000000..3ef2f1b3f
--- /dev/null
+++ b/docs/hi/docs/advanced/response-change-status-code.md
@@ -0,0 +1,31 @@
+# Response - Status Code बदलें { #response-change-status-code }
+
+आपने शायद पहले पढ़ा होगा कि आप एक default [Response Status Code](../tutorial/response-status-code.md) सेट कर सकते हैं।
+
+लेकिन कुछ मामलों में आपको default से अलग status code लौटाना पड़ता है।
+
+## उपयोग का मामला { #use-case }
+
+उदाहरण के लिए, कल्पना करें कि आप default रूप से "OK" `200` का HTTP status code लौटाना चाहते हैं।
+
+लेकिन अगर data मौजूद नहीं था, तो आप उसे बनाना चाहते हैं, और "CREATED" `201` का HTTP status code लौटाना चाहते हैं।
+
+लेकिन फिर भी आप `response_model` के साथ लौटाए गए data को filter और convert कर पाने में सक्षम रहना चाहते हैं।
+
+ऐसे मामलों के लिए, आप `Response` parameter का उपयोग कर सकते हैं।
+
+## `Response` parameter का उपयोग करें { #use-a-response-parameter }
+
+आप अपनी *path operation function* में `Response` type का parameter घोषित कर सकते हैं (जैसा कि आप cookies और headers के लिए कर सकते हैं)।
+
+और फिर आप उस *temporary* response object में `status_code` सेट कर सकते हैं।
+
+{* ../../docs_src/response_change_status_code/tutorial001_py310.py hl[1,9,12] *}
+
+और फिर आप अपनी ज़रूरत का कोई भी object लौटा सकते हैं, जैसा कि आप सामान्य रूप से करते हैं (एक `dict`, एक database model, आदि)।
+
+और अगर आपने `response_model` घोषित किया है, तो यह आपके लौटाए गए object को filter और convert करने के लिए अभी भी उपयोग किया जाएगा।
+
+**FastAPI** उस *temporary* response का उपयोग status code (साथ ही cookies और headers) निकालने के लिए करेगा, और उन्हें अंतिम response में डाल देगा जिसमें आपके द्वारा लौटाया गया value होगा, जिसे किसी भी `response_model` द्वारा filter किया गया होगा।
+
+आप dependencies में भी `Response` parameter घोषित कर सकते हैं, और उनमें status code सेट कर सकते हैं। लेकिन ध्यान रखें कि आख़िरी बार जो सेट किया जाएगा, वही प्रभावी होगा।
diff --git a/docs/hi/docs/advanced/response-cookies.md b/docs/hi/docs/advanced/response-cookies.md
new file mode 100644
index 000000000..ccd65dc0f
--- /dev/null
+++ b/docs/hi/docs/advanced/response-cookies.md
@@ -0,0 +1,51 @@
+# Response Cookies { #response-cookies }
+
+## `Response` parameter का उपयोग करें { #use-a-response-parameter }
+
+आप अपने *path operation function* में `Response` प्रकार का parameter घोषित कर सकते हैं।
+
+और फिर आप उस *temporary* response object में cookies set कर सकते हैं।
+
+{* ../../docs_src/response_cookies/tutorial002_py310.py hl[1, 8:9] *}
+
+और फिर आप अपनी ज़रूरत का कोई भी object return कर सकते हैं, जैसा कि आप सामान्य रूप से करते हैं (एक `dict`, database model, आदि)।
+
+और अगर आपने `response_model` घोषित किया है, तो आपके द्वारा return किए गए object को filter और convert करने के लिए उसका अभी भी उपयोग किया जाएगा।
+
+**FastAPI** उस *temporary* response का उपयोग cookies (साथ ही headers और status code) निकालने के लिए करेगा, और उन्हें final response में डाल देगा जिसमें आपके द्वारा return किया गया value होगा, किसी भी `response_model` द्वारा filter किया हुआ।
+
+आप dependencies में भी `Response` parameter घोषित कर सकते हैं, और उनमें cookies (और headers) set कर सकते हैं।
+
+## सीधे `Response` return करें { #return-a-response-directly }
+
+आप अपने code में सीधे `Response` return करते समय भी cookies बना सकते हैं।
+
+ऐसा करने के लिए, आप [सीधे Response Return करें](response-directly.md) में बताए अनुसार एक response बना सकते हैं।
+
+फिर उसमें Cookies set करें, और फिर उसे return करें:
+
+{* ../../docs_src/response_cookies/tutorial001_py310.py hl[10:12] *}
+
+/// tip | सुझाव
+
+ध्यान रखें कि अगर आप `Response` parameter का उपयोग करने के बजाय सीधे response return करते हैं, तो FastAPI उसे सीधे return करेगा।
+
+इसलिए, आपको यह सुनिश्चित करना होगा कि आपका data सही प्रकार का है। उदाहरण के लिए, अगर आप `JSONResponse` return कर रहे हैं, तो वह JSON के साथ compatible हो।
+
+और यह भी कि आप कोई ऐसा data नहीं भेज रहे हैं जिसे `response_model` द्वारा filter किया जाना चाहिए था।
+
+///
+
+### अधिक जानकारी { #more-info }
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import Response` या `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` `fastapi.responses` के रूप में प्रदान करता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+और क्योंकि `Response` का उपयोग अक्सर headers और cookies set करने के लिए किया जा सकता है, **FastAPI** इसे `fastapi.Response` पर भी प्रदान करता है।
+
+///
+
+सभी उपलब्ध parameters और options देखने के लिए, [Starlette में documentation](https://www.starlette.dev/responses/#set-cookie) देखें।
diff --git a/docs/hi/docs/advanced/response-directly.md b/docs/hi/docs/advanced/response-directly.md
new file mode 100644
index 000000000..1f91a875e
--- /dev/null
+++ b/docs/hi/docs/advanced/response-directly.md
@@ -0,0 +1,83 @@
+# सीधे एक Response लौटाएँ { #return-a-response-directly }
+
+जब आप **FastAPI** *path operation* बनाते हैं, तो सामान्यतः आप उससे कोई भी data लौटा सकते हैं: एक `dict`, एक `list`, एक Pydantic model, एक database model, आदि।
+
+अगर आप [Response Model](../tutorial/response-model.md) declare करते हैं, तो FastAPI Pydantic का उपयोग करके data को JSON में serialize करने के लिए उसका उपयोग करेगा।
+
+अगर आप response model declare नहीं करते, तो FastAPI [JSON Compatible Encoder](../tutorial/encoder.md) में समझाए गए `jsonable_encoder` का उपयोग करेगा और उसे एक `JSONResponse` में रखेगा।
+
+आप सीधे एक `JSONResponse` भी बना सकते हैं और उसे लौटा सकते हैं।
+
+/// tip | सुझाव
+
+आम तौर पर सीधे `JSONResponse` लौटाने की तुलना में [Response Model](../tutorial/response-model.md) का उपयोग करने पर performance काफी बेहतर होगी, क्योंकि उस तरीके से यह Rust में Pydantic का उपयोग करके data serialize करता है।
+
+///
+
+## एक `Response` लौटाएँ { #return-a-response }
+
+आप एक `Response` या उसकी कोई भी sub-class लौटा सकते हैं।
+
+/// note | नोट
+
+`JSONResponse` खुद `Response` की एक sub-class है।
+
+///
+
+और जब आप एक `Response` लौटाते हैं, तो **FastAPI** उसे सीधे pass कर देगा।
+
+यह Pydantic models के साथ कोई data conversion नहीं करेगा, contents को किसी भी type में convert नहीं करेगा, आदि।
+
+यह आपको बहुत अधिक **flexibility** देता है। आप कोई भी data type लौटा सकते हैं, किसी भी data declaration या validation को override कर सकते हैं, आदि।
+
+यह आपको बहुत अधिक **responsibility** भी देता है। आपको यह सुनिश्चित करना होगा कि आप जो data लौटा रहे हैं वह सही है, सही format में है, वह serialize किया जा सकता है, आदि।
+
+## `Response` में `jsonable_encoder` का उपयोग करना { #using-the-jsonable-encoder-in-a-response }
+
+क्योंकि **FastAPI** आपके लौटाए गए `Response` में कोई बदलाव नहीं करता, आपको सुनिश्चित करना होगा कि उसके contents इसके लिए तैयार हैं।
+
+उदाहरण के लिए, आप किसी Pydantic model को पहले `dict` में convert किए बिना `JSONResponse` में नहीं रख सकते, जिसमें सभी data types (जैसे `datetime`, `UUID`, आदि) JSON-compatible types में convert किए गए हों।
+
+ऐसे मामलों के लिए, response को pass करने से पहले आप अपने data को convert करने के लिए `jsonable_encoder` का उपयोग कर सकते हैं:
+
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` `fastapi.responses` के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+///
+
+## custom `Response` लौटाना { #returning-a-custom-response }
+
+ऊपर दिया गया उदाहरण वे सभी हिस्से दिखाता है जिनकी आपको जरूरत है, लेकिन यह अभी बहुत उपयोगी नहीं है, क्योंकि आप सीधे `item` लौटा सकते थे, और **FastAPI** उसे आपके लिए `JSONResponse` में रख देता, उसे `dict` में convert करता, आदि। यह सब default रूप से होता है।
+
+अब, देखते हैं कि आप इसका उपयोग custom response लौटाने के लिए कैसे कर सकते हैं।
+
+मान लें कि आप एक [XML](https://en.wikipedia.org/wiki/XML) response लौटाना चाहते हैं।
+
+आप अपना XML content एक string में रख सकते हैं, उसे `Response` में रख सकते हैं, और उसे लौटा सकते हैं:
+
+{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+
+## Response Model कैसे काम करता है { #how-a-response-model-works }
+
+जब आप किसी path operation में [Response Model - Return Type](../tutorial/response-model.md) declare करते हैं, तो **FastAPI** Pydantic का उपयोग करके data को JSON में serialize करने के लिए उसका उपयोग करेगा।
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+क्योंकि यह Rust side पर होगा, performance regular Python और `JSONResponse` class के साथ किए जाने की तुलना में काफी बेहतर होगी।
+
+`response_model` या return type का उपयोग करते समय, FastAPI data को convert करने के लिए `jsonable_encoder` का उपयोग नहीं करेगा (जो धीमा होता), और न ही `JSONResponse` class का उपयोग करेगा।
+
+इसके बजाय यह response model (या return type) का उपयोग करके Pydantic के साथ generate किए गए JSON bytes लेता है और JSON के लिए सही media type (`application/json`) के साथ सीधे एक `Response` लौटाता है।
+
+## नोट्स { #notes }
+
+जब आप सीधे एक `Response` लौटाते हैं, तो उसका data अपने-आप validate, convert (serialize), या document नहीं किया जाता।
+
+लेकिन आप फिर भी उसे [OpenAPI में अतिरिक्त Responses](additional-responses.md) में बताए अनुसार document कर सकते हैं।
+
+बाद के sections में आप देख सकते हैं कि automatic data conversion, documentation, आदि रखते हुए इन custom `Response`s का उपयोग/declare कैसे करें।
diff --git a/docs/hi/docs/advanced/response-headers.md b/docs/hi/docs/advanced/response-headers.md
new file mode 100644
index 000000000..9d62e2f47
--- /dev/null
+++ b/docs/hi/docs/advanced/response-headers.md
@@ -0,0 +1,41 @@
+# Response Headers { #response-headers }
+
+## `Response` parameter का उपयोग करें { #use-a-response-parameter }
+
+आप अपने *path operation function* में `Response` प्रकार का parameter घोषित कर सकते हैं (जैसा कि आप cookies के लिए कर सकते हैं)।
+
+और फिर आप उस *अस्थायी* response object में headers सेट कर सकते हैं।
+
+{* ../../docs_src/response_headers/tutorial002_py310.py hl[1, 7:8] *}
+
+और फिर आप अपनी ज़रूरत का कोई भी object return कर सकते हैं, जैसा कि आप सामान्य रूप से करते हैं (एक `dict`, database model, आदि)।
+
+और अगर आपने `response_model` घोषित किया है, तो वह अब भी आपके return किए गए object को filter और convert करने के लिए उपयोग किया जाएगा।
+
+**FastAPI** headers (साथ ही cookies और status code) निकालने के लिए उस *अस्थायी* response का उपयोग करेगा, और उन्हें अंतिम response में डाल देगा जिसमें आपके द्वारा return किया गया value होता है, जिसे किसी भी `response_model` द्वारा filter किया गया होता है।
+
+आप dependencies में भी `Response` parameter घोषित कर सकते हैं, और उनमें headers (और cookies) सेट कर सकते हैं।
+
+## सीधे `Response` return करें { #return-a-response-directly }
+
+जब आप सीधे `Response` return करते हैं, तब भी आप headers जोड़ सकते हैं।
+
+[सीधे Response Return करें](response-directly.md) में वर्णित तरीके से response बनाएँ और headers को एक अतिरिक्त parameter के रूप में पास करें:
+
+{* ../../docs_src/response_headers/tutorial001_py310.py hl[10:12] *}
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import Response` या `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए वही `starlette.responses` `fastapi.responses` के रूप में प्रदान करता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+और क्योंकि `Response` का उपयोग अक्सर headers और cookies सेट करने के लिए किया जा सकता है, **FastAPI** इसे `fastapi.Response` पर भी प्रदान करता है।
+
+///
+
+## Custom Headers { #custom-headers }
+
+ध्यान रखें कि custom proprietary headers को [`X-` prefix का उपयोग करके](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) जोड़ा जा सकता है।
+
+लेकिन अगर आपके पास custom headers हैं जिन्हें आप चाहते हैं कि browser में कोई client देख सके, तो आपको उन्हें अपनी CORS configurations में जोड़ना होगा ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) में और पढ़ें), इसके लिए [Starlette के CORS docs](https://www.starlette.dev/middleware/#corsmiddleware) में documented parameter `expose_headers` का उपयोग करें।
diff --git a/docs/hi/docs/advanced/security/http-basic-auth.md b/docs/hi/docs/advanced/security/http-basic-auth.md
new file mode 100644
index 000000000..172694ef9
--- /dev/null
+++ b/docs/hi/docs/advanced/security/http-basic-auth.md
@@ -0,0 +1,107 @@
+# HTTP Basic Auth { #http-basic-auth }
+
+सबसे सरल मामलों के लिए, आप HTTP Basic Auth का उपयोग कर सकते हैं।
+
+HTTP Basic Auth में, application एक header की अपेक्षा करता है जिसमें username और password होता है।
+
+अगर उसे यह नहीं मिलता, तो यह HTTP 401 "Unauthorized" error लौटाता है।
+
+और `WWW-Authenticate` header लौटाता है जिसका value `Basic` होता है, और एक optional `realm` parameter होता है।
+
+यह browser को username और password के लिए integrated prompt दिखाने को कहता है।
+
+फिर, जब आप वह username और password टाइप करते हैं, तो browser उन्हें header में अपने-आप भेज देता है।
+
+## Simple HTTP Basic Auth { #simple-http-basic-auth }
+
+* `HTTPBasic` और `HTTPBasicCredentials` import करें।
+* `HTTPBasic` का उपयोग करके एक "`security` scheme" बनाएँ।
+* अपने *path operation* में dependency के साथ उस `security` का उपयोग करें।
+* यह `HTTPBasicCredentials` type का एक object लौटाता है:
+ * इसमें भेजे गए `username` और `password` होते हैं।
+
+{* ../../docs_src/security/tutorial006_an_py310.py hl[4,8,12] *}
+
+जब आप पहली बार URL खोलने की कोशिश करते हैं (या docs में "Execute" button पर क्लिक करते हैं), तो browser आपसे आपका username और password पूछेगा:
+
+
+
+## Username जाँचें { #check-the-username }
+
+यहाँ एक अधिक complete example है।
+
+यह जाँचने के लिए dependency का उपयोग करें कि username और password सही हैं या नहीं।
+
+इसके लिए, username और password जाँचने के लिए Python standard module [`secrets`](https://docs.python.org/3/library/secrets.html) का उपयोग करें।
+
+`secrets.compare_digest()` को `bytes` या ऐसा `str` लेना होता है जिसमें केवल ASCII characters (English वाले) हों, इसका मतलब है कि यह `á` जैसे characters के साथ काम नहीं करेगा, जैसे `Sebastián` में।
+
+इसे handle करने के लिए, हम पहले `username` और `password` को UTF-8 से encode करके `bytes` में convert करते हैं।
+
+फिर हम `secrets.compare_digest()` का उपयोग करके यह सुनिश्चित कर सकते हैं कि `credentials.username` `"stanleyjobson"` है, और `credentials.password` `"swordfish"` है।
+
+{* ../../docs_src/security/tutorial007_an_py310.py hl[1,12:24] *}
+
+यह इसके समान होगा:
+
+```Python
+if not (credentials.username == "stanleyjobson") or not (credentials.password == "swordfish"):
+ # कोई error लौटाएँ
+ ...
+```
+
+लेकिन `secrets.compare_digest()` का उपयोग करने से यह "timing attacks" नाम के attacks के एक type के विरुद्ध सुरक्षित रहेगा।
+
+### Timing Attacks { #timing-attacks }
+
+लेकिन "timing attack" क्या होता है?
+
+मान लीजिए कुछ attackers username और password का अनुमान लगाने की कोशिश कर रहे हैं।
+
+और वे username `johndoe` और password `love123` के साथ एक request भेजते हैं।
+
+तब आपकी application में Python code कुछ इस तरह के बराबर होगा:
+
+```Python
+if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
+ ...
+```
+
+लेकिन जैसे ही Python `johndoe` में पहले `j` की तुलना `stanleyjobson` में पहले `s` से करता है, यह `False` लौटा देगा, क्योंकि उसे पहले से पता है कि ये दोनों strings समान नहीं हैं, यह सोचते हुए कि "बाकी अक्षरों की तुलना करके और computation खर्च करने की जरूरत नहीं है"। और आपकी application कहेगी "Incorrect username or password"।
+
+लेकिन फिर attackers username `stanleyjobsox` और password `love123` के साथ कोशिश करते हैं।
+
+और आपका application code कुछ ऐसा करता है:
+
+```Python
+if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
+ ...
+```
+
+Python को यह समझने से पहले कि दोनों strings समान नहीं हैं, `stanleyjobsox` और `stanleyjobson` दोनों में पूरे `stanleyjobso` की तुलना करनी पड़ेगी। इसलिए "Incorrect username or password" का reply वापस देने में कुछ extra microseconds लगेंगे।
+
+#### जवाब देने में लगा समय attackers की मदद करता है { #the-time-to-answer-helps-the-attackers }
+
+उस समय, यह देखकर कि server ने "Incorrect username or password" response भेजने में कुछ microseconds ज्यादा लिए, attackers जान जाएँगे कि उन्होंने _कुछ_ सही पाया है, शुरुआती अक्षरों में से कुछ सही थे।
+
+और फिर वे यह जानते हुए फिर कोशिश कर सकते हैं कि यह शायद `johndoe` की तुलना में `stanleyjobsox` से ज्यादा मिलता-जुलता है।
+
+#### एक "professional" attack { #a-professional-attack }
+
+बेशक, attackers यह सब हाथ से नहीं करेंगे, वे इसे करने के लिए एक program लिखेंगे, संभवतः प्रति सेकंड हजारों या लाखों tests के साथ। और उन्हें एक समय में बस एक extra सही अक्षर मिलेगा।
+
+लेकिन ऐसा करते हुए, कुछ minutes या hours में attackers ने हमारी application की "help" से सही username और password का अनुमान लगा लिया होगा, सिर्फ जवाब देने में लगे समय का उपयोग करके।
+
+#### इसे `secrets.compare_digest()` से ठीक करें { #fix-it-with-secrets-compare-digest }
+
+लेकिन हमारे code में हम वास्तव में `secrets.compare_digest()` का उपयोग कर रहे हैं।
+
+संक्षेप में, `stanleyjobsox` की तुलना `stanleyjobson` से करने में उतना ही समय लगेगा जितना `johndoe` की तुलना `stanleyjobson` से करने में लगता है। और password के लिए भी वही।
+
+इस तरह, अपने application code में `secrets.compare_digest()` का उपयोग करके, यह security attacks की इस पूरी range के विरुद्ध सुरक्षित रहेगा।
+
+### Error लौटाएँ { #return-the-error }
+
+यह detect करने के बाद कि credentials incorrect हैं, status code 401 (वही जो तब लौटाया जाता है जब कोई credentials provide नहीं किए जाते) के साथ एक `HTTPException` लौटाएँ और browser को login prompt फिर से दिखाने के लिए `WWW-Authenticate` header जोड़ें:
+
+{* ../../docs_src/security/tutorial007_an_py310.py hl[26:30] *}
diff --git a/docs/hi/docs/advanced/security/index.md b/docs/hi/docs/advanced/security/index.md
new file mode 100644
index 000000000..cd5d222c6
--- /dev/null
+++ b/docs/hi/docs/advanced/security/index.md
@@ -0,0 +1,19 @@
+# उन्नत सुरक्षा { #advanced-security }
+
+## अतिरिक्त Features { #additional-features }
+
+[Tutorial - User Guide: Security](../../tutorial/security/index.md) में शामिल चीज़ों के अलावा सुरक्षा संभालने के लिए कुछ अतिरिक्त features हैं।
+
+/// tip | सुझाव
+
+अगले sections **ज़रूरी नहीं कि "उन्नत" ही हों**।
+
+और यह संभव है कि आपके use case के लिए समाधान उनमें से किसी एक में हो।
+
+///
+
+## पहले Tutorial पढ़ें { #read-the-tutorial-first }
+
+अगले sections मानकर चलते हैं कि आपने मुख्य [Tutorial - User Guide: Security](../../tutorial/security/index.md) पहले ही पढ़ लिया है।
+
+वे सभी समान concepts पर आधारित हैं, लेकिन कुछ अतिरिक्त functionalities की अनुमति देते हैं।
diff --git a/docs/hi/docs/advanced/security/oauth2-scopes.md b/docs/hi/docs/advanced/security/oauth2-scopes.md
new file mode 100644
index 000000000..1bf01f366
--- /dev/null
+++ b/docs/hi/docs/advanced/security/oauth2-scopes.md
@@ -0,0 +1,274 @@
+# OAuth2 scopes { #oauth2-scopes }
+
+आप **FastAPI** के साथ OAuth2 scopes सीधे उपयोग कर सकते हैं, वे निर्बाध रूप से काम करने के लिए एकीकृत हैं।
+
+यह आपको OAuth2 standard का पालन करते हुए, आपकी OpenAPI application (और API docs) में एक अधिक fine-grained permission system रखने की अनुमति देगा।
+
+Scopes के साथ OAuth2 वह mechanism है जिसे कई बड़े authentication providers, जैसे Facebook, Google, GitHub, Microsoft, X (Twitter), आदि उपयोग करते हैं। वे इसका उपयोग users और applications को विशिष्ट permissions देने के लिए करते हैं।
+
+हर बार जब आप Facebook, Google, GitHub, Microsoft, X (Twitter) के साथ "log in with" करते हैं, वह application scopes के साथ OAuth2 का उपयोग कर रही होती है।
+
+इस section में आप देखेंगे कि अपनी **FastAPI** application में उसी scopes वाले OAuth2 के साथ authentication और authorization को कैसे manage करें।
+
+/// warning | चेतावनी
+
+यह थोड़ा-बहुत advanced section है। यदि आप अभी शुरू कर रहे हैं, तो आप इसे छोड़ सकते हैं।
+
+आपको अनिवार्य रूप से OAuth2 scopes की आवश्यकता नहीं है, और आप authentication और authorization को जैसे चाहें handle कर सकते हैं।
+
+लेकिन scopes के साथ OAuth2 को आपकी API (OpenAPI के साथ) और आपकी API docs में अच्छी तरह integrate किया जा सकता है।
+
+फिर भी, आप उन scopes, या किसी भी अन्य security/authorization requirement को अपने code में अपनी आवश्यकता के अनुसार enforce करते हैं।
+
+कई मामलों में, scopes के साथ OAuth2 overkill हो सकता है।
+
+लेकिन यदि आप जानते हैं कि आपको इसकी आवश्यकता है, या आप curious हैं, तो पढ़ते रहें।
+
+///
+
+## OAuth2 scopes और OpenAPI { #oauth2-scopes-and-openapi }
+
+OAuth2 specification "scopes" को spaces से अलग की गई strings की list के रूप में define करती है।
+
+इनमें से प्रत्येक string का content किसी भी format में हो सकता है, लेकिन उसमें spaces नहीं होने चाहिए।
+
+ये scopes "permissions" को दर्शाते हैं।
+
+OpenAPI में (जैसे API docs), आप "security schemes" define कर सकते हैं।
+
+जब इनमें से कोई security scheme OAuth2 का उपयोग करती है, तो आप scopes declare और उपयोग भी कर सकते हैं।
+
+प्रत्येक "scope" बस एक string है (spaces के बिना)।
+
+वे सामान्यतः विशिष्ट security permissions declare करने के लिए उपयोग किए जाते हैं, उदाहरण के लिए:
+
+* `users:read` या `users:write` आम examples हैं।
+* `instagram_basic` Facebook / Instagram द्वारा उपयोग किया जाता है।
+* `https://www.googleapis.com/auth/drive` Google द्वारा उपयोग किया जाता है।
+
+/// note | नोट
+
+OAuth2 में "scope" बस एक string है जो required विशिष्ट permission declare करती है।
+
+इससे फर्क नहीं पड़ता कि इसमें `:` जैसे अन्य characters हैं या यह एक URL है।
+
+वे details implementation specific हैं।
+
+OAuth2 के लिए वे बस strings हैं।
+
+///
+
+## Global view { #global-view }
+
+पहले, आइए जल्दी से देखें कि मुख्य **Tutorial - User Guide** में [Password के साथ OAuth2 (और hashing), JWT tokens के साथ Bearer](../../tutorial/security/oauth2-jwt.md) के examples से कौन से parts बदलते हैं। अब OAuth2 scopes का उपयोग करते हुए:
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
+
+अब आइए उन बदलावों को step by step review करें।
+
+## OAuth2 Security scheme { #oauth2-security-scheme }
+
+पहला बदलाव यह है कि अब हम OAuth2 security scheme को दो उपलब्ध scopes, `me` और `items`, के साथ declare कर रहे हैं।
+
+`scopes` parameter एक `dict` receive करता है जिसमें प्रत्येक scope key के रूप में और description value के रूप में होती है:
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *}
+
+क्योंकि अब हम उन scopes को declare कर रहे हैं, वे API docs में तब दिखाई देंगे जब आप log-in/authorize करेंगे।
+
+और आप select कर सकेंगे कि आप किन scopes को access देना चाहते हैं: `me` और `items`।
+
+यह वही mechanism है जिसका उपयोग तब होता है जब आप Facebook, Google, GitHub, आदि के साथ log in करते समय permissions देते हैं:
+
+
+
+## Scopes के साथ JWT token { #jwt-token-with-scopes }
+
+अब, token *path operation* को modify करें ताकि requested scopes return हों।
+
+हम अभी भी वही `OAuth2PasswordRequestForm` उपयोग कर रहे हैं। इसमें `scopes` property शामिल है जिसमें `str` की `list` होती है, और request में received प्रत्येक scope होता है।
+
+और हम scopes को JWT token के part के रूप में return करते हैं।
+
+/// danger | खतरा
+
+सरलता के लिए, यहाँ हम received scopes को सीधे token में जोड़ रहे हैं।
+
+लेकिन आपकी application में, security के लिए, आपको सुनिश्चित करना चाहिए कि आप केवल वे scopes जोड़ें जिन्हें user वास्तव में रख सकता है, या जिन्हें आपने predefine किया है।
+
+///
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[157] *}
+
+## *path operations* और dependencies में scopes declare करें { #declare-scopes-in-path-operations-and-dependencies }
+
+अब हम declare करते हैं कि `/users/me/items/` के लिए *path operation* को scope `items` required है।
+
+इसके लिए, हम `fastapi` से `Security` import और उपयोग करते हैं।
+
+आप dependencies declare करने के लिए `Security` का उपयोग कर सकते हैं (बिल्कुल `Depends` की तरह), लेकिन `Security` एक parameter `scopes` भी receive करता है जिसमें scopes (strings) की list होती है।
+
+इस case में, हम dependency function `get_current_active_user` को `Security` में pass करते हैं (उसी तरह जैसे हम `Depends` के साथ करते)।
+
+लेकिन हम scopes की एक `list` भी pass करते हैं, इस case में केवल एक scope के साथ: `items` (इसमें और भी हो सकते थे)।
+
+और dependency function `get_current_active_user` sub-dependencies भी declare कर सकता है, न केवल `Depends` के साथ बल्कि `Security` के साथ भी। अपना sub-dependency function (`get_current_user`) और अधिक scope requirements declare करते हुए।
+
+इस case में, इसे scope `me` required है (इसे एक से अधिक scope required हो सकते थे)।
+
+/// note | नोट
+
+आपको अलग-अलग जगहों पर अलग-अलग scopes जोड़ना अनिवार्य नहीं है।
+
+हम यहाँ यह demonstrate करने के लिए कर रहे हैं कि **FastAPI** अलग-अलग levels पर declared scopes को कैसे handle करता है।
+
+///
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}
+
+/// note | तकनीकी विवरण
+
+`Security` वास्तव में `Depends` का subclass है, और इसमें केवल एक extra parameter है जिसे हम बाद में देखेंगे।
+
+लेकिन `Depends` के बजाय `Security` का उपयोग करके, **FastAPI** जान जाएगा कि यह security scopes declare कर सकता है, उन्हें internally उपयोग कर सकता है, और API को OpenAPI के साथ document कर सकता है।
+
+लेकिन जब आप `fastapi` से `Query`, `Path`, `Depends`, `Security` और अन्य import करते हैं, तो वे वास्तव में functions हैं जो special classes return करते हैं।
+
+///
+
+## `SecurityScopes` का उपयोग करें { #use-securityscopes }
+
+अब dependency `get_current_user` को update करें।
+
+यह वही है जिसका उपयोग ऊपर की dependencies द्वारा किया जाता है।
+
+यहीं हम पहले बनाई गई उसी OAuth2 scheme का उपयोग कर रहे हैं, इसे dependency के रूप में declare करते हुए: `oauth2_scheme`।
+
+क्योंकि इस dependency function की अपनी कोई scope requirements नहीं हैं, हम `oauth2_scheme` के साथ `Depends` उपयोग कर सकते हैं, जब हमें security scopes specify करने की आवश्यकता नहीं है तो हमें `Security` उपयोग करने की आवश्यकता नहीं है।
+
+हम `SecurityScopes` type का एक special parameter भी declare करते हैं, जिसे `fastapi.security` से import किया गया है।
+
+यह `SecurityScopes` class `Request` के समान है (`Request` का उपयोग request object को सीधे प्राप्त करने के लिए किया गया था)।
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *}
+
+## `scopes` का उपयोग करें { #use-the-scopes }
+
+Parameter `security_scopes` का type `SecurityScopes` होगा।
+
+इसमें property `scopes` होगी जिसमें एक list होगी, जिसमें स्वयं और इसे sub-dependency के रूप में उपयोग करने वाली सभी dependencies द्वारा required सभी scopes शामिल होंगे। इसका मतलब है, सभी "dependants"... यह confusing लग सकता है, इसे नीचे फिर से समझाया गया है।
+
+`security_scopes` object (`SecurityScopes` class का) एक `scope_str` attribute भी provide करता है जिसमें एक single string होती है, जिसमें वे scopes spaces से अलग होते हैं (हम इसका उपयोग करेंगे)।
+
+हम एक `HTTPException` बनाते हैं जिसे हम बाद में कई points पर reuse (`raise`) कर सकते हैं।
+
+इस exception में, हम required scopes (यदि कोई हों) को spaces से अलग की गई string के रूप में शामिल करते हैं (`scope_str` का उपयोग करके)। हम scopes वाली उस string को `WWW-Authenticate` header में रखते हैं (यह spec का part है)।
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *}
+
+## `username` और data shape verify करें { #verify-the-username-and-data-shape }
+
+हम verify करते हैं कि हमें `username` मिलता है, और scopes extract करते हैं।
+
+और फिर हम उस data को Pydantic model के साथ validate करते हैं (`ValidationError` exception को catch करते हुए), और यदि JWT token पढ़ने या Pydantic के साथ data validate करने में error मिलता है, तो हम पहले बनाया हुआ `HTTPException` raise करते हैं।
+
+इसके लिए, हम Pydantic model `TokenData` को नई property `scopes` के साथ update करते हैं।
+
+Pydantic के साथ data validate करके हम यह सुनिश्चित कर सकते हैं कि हमारे पास, उदाहरण के लिए, scopes के साथ बिल्कुल `str` की `list` और `username` के साथ `str` है।
+
+उदाहरण के लिए, `dict`, या कुछ और नहीं, क्योंकि यह बाद में किसी point पर application को break कर सकता है, जिससे यह security risk बन सकता है।
+
+हम यह भी verify करते हैं कि हमारे पास उस username वाला user है, और यदि नहीं, तो हम वही exception raise करते हैं जो हमने पहले बनाया था।
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:129] *}
+
+## `scopes` verify करें { #verify-the-scopes }
+
+अब हम verify करते हैं कि इस dependency और सभी dependants (जिसमें *path operations* शामिल हैं) द्वारा required सभी scopes, received token में provided scopes में शामिल हैं, अन्यथा `HTTPException` raise करते हैं।
+
+इसके लिए, हम `security_scopes.scopes` का उपयोग करते हैं, जिसमें इन सभी scopes की `list` `str` के रूप में होती है।
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[130:136] *}
+
+## Dependency tree और scopes { #dependency-tree-and-scopes }
+
+आइए इस dependency tree और scopes को फिर से review करें।
+
+क्योंकि `get_current_active_user` dependency में `get_current_user` sub-dependency के रूप में है, `get_current_active_user` पर declared scope `"me"` required scopes की उस list में शामिल होगा जो `get_current_user` को pass किए गए `security_scopes.scopes` में होती है।
+
+*path operation* स्वयं भी एक scope, `"items"`, declare करता है, इसलिए यह भी `get_current_user` को pass किए गए `security_scopes.scopes` की list में होगा।
+
+Dependencies और scopes की hierarchy इस तरह दिखती है:
+
+* *path operation* `read_own_items` में है:
+ * Dependency के साथ required scopes `["items"]`:
+ * `get_current_active_user`:
+ * Dependency function `get_current_active_user` में है:
+ * Dependency के साथ required scopes `["me"]`:
+ * `get_current_user`:
+ * Dependency function `get_current_user` में है:
+ * स्वयं द्वारा required कोई scopes नहीं।
+ * `oauth2_scheme` का उपयोग करने वाली dependency।
+ * `SecurityScopes` type का एक `security_scopes` parameter:
+ * इस `security_scopes` parameter में property `scopes` है जिसमें ऊपर declared इन सभी scopes वाली `list` है, इसलिए:
+ * *path operation* `read_own_items` के लिए `security_scopes.scopes` में `["me", "items"]` होगा।
+ * *path operation* `read_users_me` के लिए `security_scopes.scopes` में `["me"]` होगा, क्योंकि यह dependency `get_current_active_user` में declared है।
+ * *path operation* `read_system_status` के लिए `security_scopes.scopes` में `[]` (कुछ नहीं) होगा, क्योंकि उसने `scopes` के साथ कोई `Security` declare नहीं किया, और उसकी dependency, `get_current_user`, भी कोई `scopes` declare नहीं करती।
+
+/// tip | सुझाव
+
+यहाँ महत्वपूर्ण और "magic" बात यह है कि प्रत्येक *path operation* के लिए `get_current_user` के पास check करने हेतु `scopes` की अलग list होगी।
+
+यह सब उस specific *path operation* के dependency tree में प्रत्येक *path operation* और प्रत्येक dependency में declared `scopes` पर निर्भर करता है।
+
+///
+
+## `SecurityScopes` के बारे में अधिक details { #more-details-about-securityscopes }
+
+आप `SecurityScopes` का उपयोग किसी भी point पर, और multiple जगहों पर कर सकते हैं, इसका "root" dependency पर होना ज़रूरी नहीं है।
+
+इसमें हमेशा current `Security` dependencies और **उस specific** *path operation* तथा **उस specific** dependency tree के सभी dependants में declared security scopes होंगे।
+
+क्योंकि `SecurityScopes` में dependants द्वारा declared सभी scopes होंगे, आप इसका उपयोग यह verify करने के लिए कर सकते हैं कि token में required scopes हैं, एक central dependency function में, और फिर अलग-अलग *path operations* में अलग-अलग scope requirements declare कर सकते हैं।
+
+उन्हें प्रत्येक *path operation* के लिए independently check किया जाएगा।
+
+## इसे check करें { #check-it }
+
+यदि आप API docs खोलते हैं, तो आप authenticate कर सकते हैं और specify कर सकते हैं कि आप किन scopes को authorize करना चाहते हैं।
+
+
+
+यदि आप कोई scope select नहीं करते हैं, तो आप "authenticated" होंगे, लेकिन जब आप `/users/me/` या `/users/me/items/` access करने की कोशिश करेंगे तो आपको error मिलेगा कि आपके पास पर्याप्त permissions नहीं हैं। आप फिर भी `/status/` access कर पाएंगे।
+
+और यदि आप scope `me` select करते हैं लेकिन scope `items` नहीं, तो आप `/users/me/` access कर पाएंगे लेकिन `/users/me/items/` नहीं।
+
+ऐसा ही किसी third party application के साथ होगा जो user द्वारा provided token के साथ इन *path operations* में से किसी एक को access करने की कोशिश करती, यह इस पर निर्भर करता है कि user ने application को कितनी permissions दीं।
+
+## Third party integrations के बारे में { #about-third-party-integrations }
+
+इस example में हम OAuth2 "password" flow का उपयोग कर रहे हैं।
+
+यह तब appropriate है जब हम अपनी ही application में log in कर रहे हों, शायद अपने ही frontend के साथ।
+
+क्योंकि हम इस पर भरोसा कर सकते हैं कि यह `username` और `password` receive करे, क्योंकि हम इसे control करते हैं।
+
+लेकिन यदि आप ऐसी OAuth2 application बना रहे हैं जिससे दूसरे connect करेंगे (अर्थात, यदि आप Facebook, Google, GitHub, आदि के बराबर authentication provider बना रहे हैं) तो आपको अन्य flows में से किसी एक का उपयोग करना चाहिए।
+
+सबसे common implicit flow है।
+
+सबसे secure code flow है, लेकिन इसे implement करना अधिक complex है क्योंकि इसमें अधिक steps required हैं। क्योंकि यह अधिक complex है, कई providers अंततः implicit flow suggest करते हैं।
+
+/// note | नोट
+
+यह common है कि प्रत्येक authentication provider अपने flows को अलग तरीके से name करता है, ताकि इसे अपने brand का part बना सके।
+
+लेकिन अंततः, वे वही OAuth2 standard implement कर रहे होते हैं।
+
+///
+
+**FastAPI** में इन सभी OAuth2 authentication flows के लिए utilities `fastapi.security.oauth2` में शामिल हैं।
+
+## Decorator `dependencies` में `Security` { #security-in-decorator-dependencies }
+
+जिस तरह आप decorator के `dependencies` parameter में `Depends` की `list` define कर सकते हैं (जैसा कि [path operation decorators में Dependencies](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md) में समझाया गया है), आप वहाँ `scopes` के साथ `Security` भी उपयोग कर सकते हैं।
diff --git a/docs/hi/docs/advanced/settings.md b/docs/hi/docs/advanced/settings.md
new file mode 100644
index 000000000..0c4d3c061
--- /dev/null
+++ b/docs/hi/docs/advanced/settings.md
@@ -0,0 +1,302 @@
+# Settings और Environment Variables { #settings-and-environment-variables }
+
+कई मामलों में आपकी application को कुछ बाहरी settings या configurations की ज़रूरत हो सकती है, उदाहरण के लिए secret keys, database credentials, email services के लिए credentials, आदि।
+
+इनमें से ज़्यादातर settings variable होती हैं (बदल सकती हैं), जैसे database URLs। और कई sensitive हो सकती हैं, जैसे secrets।
+
+इसी कारण उन्हें आम तौर पर environment variables में दिया जाता है जिन्हें application पढ़ती है।
+
+/// tip | सुझाव
+
+Environment variables को समझने के लिए आप [Environment Variables](../environment-variables.md) पढ़ सकते हैं।
+
+///
+
+## Types और validation { #types-and-validation }
+
+ये environment variables केवल text strings को handle कर सकते हैं, क्योंकि ये Python के बाहर होते हैं और इन्हें दूसरे programs और system के बाकी हिस्सों के साथ compatible होना होता है (और अलग-अलग operating systems, जैसे Linux, Windows, और macOS के साथ भी)।
+
+इसका मतलब है कि Python में किसी environment variable से पढ़ी गई कोई भी value एक `str` होगी, और किसी अलग type में कोई भी conversion या कोई भी validation code में करनी होगी।
+
+## Pydantic `Settings` { #pydantic-settings }
+
+सौभाग्य से, Pydantic environment variables से आने वाली इन settings को handle करने के लिए एक बेहतरीन utility देता है: [Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/)।
+
+### `pydantic-settings` install करें { #install-pydantic-settings }
+
+सबसे पहले, सुनिश्चित करें कि आप अपना [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर `pydantic-settings` package install करते हैं:
+
+
+
+और फिर, sub-application के लिए docs को [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs) पर खोलें।
+
+आप sub-application के लिए automatic API docs देखेंगे, जिसमें केवल उसके अपने _path operations_ शामिल होंगे, सभी सही sub-path prefix `/subapi` के अंतर्गत:
+
+
+
+अगर आप दोनों user interfaces में से किसी के साथ interact करने की कोशिश करते हैं, तो वे सही तरह काम करेंगे, क्योंकि browser हर specific app या sub-app से बात कर पाएगा।
+
+### तकनीकी विवरण: `root_path` { #technical-details-root-path }
+
+जब आप ऊपर बताए गए तरीके से कोई sub-application mount करते हैं, तो FastAPI sub-application के लिए mount path communicate करने का ध्यान रखेगा, ASGI specification के एक mechanism का उपयोग करके जिसे `root_path` कहा जाता है।
+
+इस तरह, sub-application को पता होगा कि docs UI के लिए उस path prefix का उपयोग करना है।
+
+और sub-application की अपनी mounted sub-applications भी हो सकती हैं और सब कुछ सही तरह काम करेगा, क्योंकि FastAPI इन सभी `root_path`s को अपने आप handle करता है।
+
+आप `root_path` के बारे में और इसे स्पष्ट रूप से कैसे उपयोग करें, यह [Behind a Proxy](behind-a-proxy.md) वाले section में और सीखेंगे।
diff --git a/docs/hi/docs/advanced/templates.md b/docs/hi/docs/advanced/templates.md
new file mode 100644
index 000000000..b16ef4a6e
--- /dev/null
+++ b/docs/hi/docs/advanced/templates.md
@@ -0,0 +1,126 @@
+# Templates { #templates }
+
+आप **FastAPI** के साथ अपनी पसंद का कोई भी template engine उपयोग कर सकते हैं।
+
+एक आम विकल्प Jinja2 है, वही जिसे Flask और अन्य tools उपयोग करते हैं।
+
+इसे आसानी से configure करने के लिए utilities उपलब्ध हैं जिन्हें आप सीधे अपने **FastAPI** application में उपयोग कर सकते हैं (Starlette द्वारा प्रदान की गई)।
+
+## Dependencies install करें { #install-dependencies }
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और `jinja2` install करें:
+
+
+
+आप input box में messages टाइप कर सकते हैं, और उन्हें भेज सकते हैं:
+
+
+
+और WebSockets के साथ आपका **FastAPI** application जवाब देगा:
+
+
+
+आप कई messages भेज (और receive कर) सकते हैं:
+
+
+
+और वे सभी उसी WebSocket connection का उपयोग करेंगे।
+
+## `Depends` और अन्य का उपयोग { #using-depends-and-others }
+
+WebSocket endpoints में आप `fastapi` से import कर सकते हैं और उपयोग कर सकते हैं:
+
+* `Depends`
+* `Security`
+* `Cookie`
+* `Header`
+* `Path`
+* `Query`
+
+वे अन्य FastAPI endpoints/*path operations* की तरह ही काम करते हैं:
+
+{* ../../docs_src/websockets_/tutorial002_an_py310.py hl[68:69,82] *}
+
+/// note | नोट
+
+क्योंकि यह एक WebSocket है, इसलिए `HTTPException` raise करना वास्तव में उचित नहीं है, इसके बजाय हम `WebSocketException` raise करते हैं।
+
+आप [specification में परिभाषित valid codes](https://tools.ietf.org/html/rfc6455#section-7.4.1) में से एक closing code का उपयोग कर सकते हैं।
+
+///
+
+### dependencies के साथ WebSockets आज़माएँ { #try-the-websockets-with-dependencies }
+
+अपना application चलाएँ:
+
+
+
+## disconnections और कई clients को handle करना { #handling-disconnections-and-multiple-clients }
+
+जब WebSocket connection बंद होता है, तो `await websocket.receive_text()` एक `WebSocketDisconnect` exception raise करेगा, जिसे आप इस उदाहरण की तरह catch और handle कर सकते हैं।
+
+{* ../../docs_src/websockets_/tutorial003_py310.py hl[79:81] *}
+
+इसे आज़माने के लिए:
+
+* app को कई browser tabs में खोलें।
+* उनसे messages लिखें।
+* फिर tabs में से एक को बंद करें।
+
+इससे `WebSocketDisconnect` exception raise होगा, और बाकी सभी clients को ऐसा message मिलेगा:
+
+```
+Client #1596980209979 left the chat
+```
+
+/// tip | सुझाव
+
+ऊपर दिया गया app एक minimal और सरल उदाहरण है, जो दिखाता है कि कई WebSocket connections को messages कैसे handle और broadcast किए जाएँ।
+
+लेकिन ध्यान रखें कि, चूँकि सब कुछ memory में, एक ही list में handle किया जाता है, यह केवल तब तक काम करेगा जब तक process चल रहा है, और केवल एक single process के साथ काम करेगा।
+
+अगर आपको कुछ ऐसा चाहिए जिसे FastAPI के साथ integrate करना आसान हो लेकिन जो अधिक robust हो, Redis, PostgreSQL या अन्य द्वारा supported हो, तो [encode/broadcaster](https://github.com/encode/broadcaster) देखें।
+
+///
+
+## अधिक जानकारी { #more-info }
+
+विकल्पों के बारे में अधिक जानने के लिए, इनके लिए Starlette का documentation देखें:
+
+* [`WebSocket` class](https://www.starlette.dev/websockets/)।
+* [Class-based WebSocket handling](https://www.starlette.dev/endpoints/#websocketendpoint)।
diff --git a/docs/hi/docs/advanced/wsgi.md b/docs/hi/docs/advanced/wsgi.md
new file mode 100644
index 000000000..1ea60d4e9
--- /dev/null
+++ b/docs/hi/docs/advanced/wsgi.md
@@ -0,0 +1,51 @@
+# WSGI शामिल करना - Flask, Django, अन्य { #including-wsgi-flask-django-others }
+
+आप WSGI applications को mount कर सकते हैं, जैसा आपने [Sub Applications - Mounts](sub-applications.md), [Proxy के पीछे](behind-a-proxy.md) में देखा।
+
+इसके लिए, आप `WSGIMiddleware` का उपयोग कर सकते हैं और इसे अपनी WSGI application को wrap करने के लिए इस्तेमाल कर सकते हैं, उदाहरण के लिए, Flask, Django, आदि।
+
+## `WSGIMiddleware` का उपयोग करना { #using-wsgimiddleware }
+
+/// note | नोट
+
+इसके लिए `a2wsgi` install करना required है, उदाहरण के लिए `pip install a2wsgi` के साथ।
+
+///
+
+आपको `a2wsgi` से `WSGIMiddleware` import करना होगा।
+
+फिर WSGI (जैसे Flask) app को middleware के साथ wrap करें।
+
+और फिर उसे किसी path के अंतर्गत mount करें।
+
+{* ../../docs_src/wsgi/tutorial001_py310.py hl[1,3,23] *}
+
+/// note | नोट
+
+पहले, `fastapi.middleware.wsgi` से `WSGIMiddleware` का उपयोग करने की सलाह दी जाती थी, लेकिन अब यह deprecated है।
+
+इसके बजाय `a2wsgi` package का उपयोग करने की सलाह दी जाती है। उपयोग वही रहता है।
+
+बस यह सुनिश्चित करें कि आपके पास `a2wsgi` package install है और आप `a2wsgi` से `WSGIMiddleware` को सही ढंग से import करते हैं।
+
+///
+
+## इसे जाँचें { #check-it }
+
+अब, path `/v1/` के अंतर्गत हर request को Flask application द्वारा handle किया जाएगा।
+
+और बाकी को **FastAPI** द्वारा handle किया जाएगा।
+
+यदि आप इसे run करते हैं और [http://localhost:8000/v1/](http://localhost:8000/v1/) पर जाते हैं, तो आपको Flask से response दिखाई देगा:
+
+```txt
+Hello, World from Flask!
+```
+
+और यदि आप [http://localhost:8000/v2](http://localhost:8000/v2) पर जाते हैं, तो आपको FastAPI से response दिखाई देगा:
+
+```JSON
+{
+ "message": "Hello World"
+}
+```
diff --git a/docs/hi/docs/deployment/cloud.md b/docs/hi/docs/deployment/cloud.md
new file mode 100644
index 000000000..f4c6087d3
--- /dev/null
+++ b/docs/hi/docs/deployment/cloud.md
@@ -0,0 +1,24 @@
+# Cloud Providers पर FastAPI Deploy करें { #deploy-fastapi-on-cloud-providers }
+
+आप अपनी FastAPI application deploy करने के लिए वस्तुतः **किसी भी cloud provider** का उपयोग कर सकते हैं।
+
+अधिकांश मामलों में, मुख्य cloud providers के पास उनके साथ FastAPI deploy करने के लिए guides होती हैं।
+
+## FastAPI Cloud { #fastapi-cloud }
+
+**[FastAPI Cloud](https://fastapicloud.com)** को **FastAPI** के पीछे मौजूद उसी author और team ने बनाया है।
+
+यह न्यूनतम प्रयास के साथ API को **build**, **deploy**, और **access** करने की प्रक्रिया को सरल बनाता है।
+
+यह FastAPI के साथ apps बनाने वाले उसी **developer experience** को उन्हें cloud पर **deploy** करने में भी लाता है। 🎉
+
+FastAPI Cloud, *FastAPI and friends* open source projects का प्राथमिक sponsor और funding provider है। ✨
+
+## Cloud Providers - Sponsors { #cloud-providers-sponsors }
+
+कुछ अन्य cloud providers भी ✨ [**FastAPI को sponsor करते हैं**](https://github.com/sponsors/tiangolo) ✨। 🙇
+
+आप उनकी guides का पालन करने और उनकी services आज़माने के लिए उन पर भी विचार कर सकते हैं:
+
+* [Render](https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi)
+* [Railway](https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi)
diff --git a/docs/hi/docs/deployment/concepts.md b/docs/hi/docs/deployment/concepts.md
new file mode 100644
index 000000000..de085e34b
--- /dev/null
+++ b/docs/hi/docs/deployment/concepts.md
@@ -0,0 +1,321 @@
+# Deployments की अवधारणाएँ { #deployments-concepts }
+
+जब आप एक **FastAPI** application, या वास्तव में किसी भी प्रकार की web API, deploy करते हैं, तो कई अवधारणाएँ होती हैं जिनकी आपको शायद परवाह होगी, और उनका उपयोग करके आप अपनी application को **deploy करने** का **सबसे उपयुक्त** तरीका ढूँढ सकते हैं।
+
+कुछ महत्वपूर्ण अवधारणाएँ हैं:
+
+* सुरक्षा - HTTPS
+* startup पर चलना
+* Restarts
+* Replication (चल रहे processes की संख्या)
+* Memory
+* शुरू करने से पहले के पिछले steps
+
+हम देखेंगे कि ये **deployments** को कैसे प्रभावित करेंगे।
+
+अंत में, अंतिम उद्देश्य यह है कि आप अपने **API clients को serve** कर सकें, वह भी ऐसे तरीके से जो **सुरक्षित** हो, **disruptions से बचाए**, और **compute resources** (जैसे remote servers/virtual machines) का यथासंभव कुशलता से उपयोग करे। 🚀
+
+मैं यहाँ इन **अवधारणाओं** के बारे में थोड़ा और बताऊँगा, और उम्मीद है कि इससे आपको वह **intuition** मिलेगी जिसकी आपको अपनी API को बहुत अलग-अलग environments में deploy करने का निर्णय लेने के लिए आवश्यकता होगी, संभवतः ऐसे **future** environments में भी जो अभी मौजूद नहीं हैं।
+
+इन अवधारणाओं पर विचार करके, आप **अपनी खुद की APIs** को deploy करने का सबसे अच्छा तरीका **evaluate और design** कर पाएँगे।
+
+अगले chapters में, मैं आपको FastAPI applications deploy करने के लिए अधिक **ठोस recipes** दूँगा।
+
+लेकिन अभी के लिए, आइए इन महत्वपूर्ण **conceptual ideas** को देखें। ये अवधारणाएँ किसी भी अन्य प्रकार की web API पर भी लागू होती हैं। 💡
+
+## सुरक्षा - HTTPS { #security-https }
+
+[HTTPS के बारे में पिछले chapter](https.md) में हमने सीखा कि HTTPS आपकी API के लिए encryption कैसे प्रदान करता है।
+
+हमने यह भी देखा कि HTTPS सामान्यतः आपके application server से **external** एक component, एक **TLS Termination Proxy**, द्वारा प्रदान किया जाता है।
+
+और **HTTPS certificates renew** करने का प्रभारी कुछ होना चाहिए, यह वही component हो सकता है या कुछ अलग भी हो सकता है।
+
+### HTTPS के लिए उदाहरण Tools { #example-tools-for-https }
+
+TLS Termination Proxy के रूप में आप जिन tools का उपयोग कर सकते हैं, उनमें से कुछ हैं:
+
+* Traefik
+ * Certificate renewals को अपने-आप संभालता है ✨
+* Caddy
+ * Certificate renewals को अपने-आप संभालता है ✨
+* Nginx
+ * Certificate renewals के लिए Certbot जैसे external component के साथ
+* HAProxy
+ * Certificate renewals के लिए Certbot जैसे external component के साथ
+* Nginx जैसे Ingress Controller के साथ Kubernetes
+ * Certificate renewals के लिए cert-manager जैसे external component के साथ
+* Cloud provider द्वारा उनकी services के हिस्से के रूप में internally संभाला गया (नीचे पढ़ें 👇)
+
+एक और विकल्प यह है कि आप एक **cloud service** का उपयोग कर सकते हैं जो HTTPS setup करने सहित अधिक काम करती है। इसमें कुछ restrictions हो सकती हैं या आपसे अधिक charge लिया जा सकता है, आदि। लेकिन उस स्थिति में, आपको स्वयं TLS Termination Proxy setup नहीं करना पड़ेगा।
+
+अगले chapters में मैं आपको कुछ ठोस उदाहरण दिखाऊँगा।
+
+---
+
+फिर विचार करने के लिए अगले concepts उस program के बारे में हैं जो आपकी वास्तविक API चला रहा है (जैसे Uvicorn)।
+
+## Program और Process { #program-and-process }
+
+हम चल रहे "**process**" के बारे में बहुत बात करेंगे, इसलिए यह स्पष्ट होना उपयोगी है कि इसका क्या अर्थ है, और "**program**" शब्द से इसका क्या अंतर है।
+
+### Program क्या है { #what-is-a-program }
+
+**Program** शब्द का उपयोग आम तौर पर कई चीजों का वर्णन करने के लिए किया जाता है:
+
+* वह **code** जो आप लिखते हैं, **Python files**।
+* वह **file** जिसे operating system द्वारा **execute** किया जा सकता है, उदाहरण के लिए: `python`, `python.exe` या `uvicorn`।
+* कोई विशेष program जब वह operating system पर **चल रहा** हो, CPU का उपयोग कर रहा हो, और memory में चीजें store कर रहा हो। इसे **process** भी कहा जाता है।
+
+### Process क्या है { #what-is-a-process }
+
+**Process** शब्द सामान्यतः अधिक विशिष्ट तरीके से उपयोग किया जाता है, केवल उस चीज़ के लिए जो operating system में चल रही होती है (जैसे ऊपर के अंतिम point में):
+
+* कोई विशेष program जब वह operating system पर **चल रहा** हो।
+ * यह न तो file को refer करता है, न code को, यह **विशेष रूप से** उस चीज़ को refer करता है जिसे operating system द्वारा **execute** और manage किया जा रहा है।
+* कोई भी program, कोई भी code, **केवल तभी कुछ कर सकता है** जब उसे **execute** किया जा रहा हो। यानी, जब कोई **process चल रहा** हो।
+* Process को आपके द्वारा, या operating system द्वारा **terminate** (या "kill") किया जा सकता है। उस point पर, वह चलना/execute होना बंद कर देता है, और वह **अब कुछ नहीं कर सकता**।
+* आपके computer पर चल रही प्रत्येक application के पीछे कोई process होता है, प्रत्येक running program, प्रत्येक window, आदि। और computer चालू होने पर सामान्यतः कई processes **एक ही समय में** चल रहे होते हैं।
+* **एक ही program** के **multiple processes** एक ही समय में चल सकते हैं।
+
+यदि आप अपने operating system में "task manager" या "system monitor" (या समान tools) देखते हैं, तो आप उनमें से कई processes चलते हुए देख पाएँगे।
+
+और, उदाहरण के लिए, आप शायद देखेंगे कि एक ही browser program (Firefox, Chrome, Edge, आदि) को चलाने वाले multiple processes हैं। वे सामान्यतः प्रति tab एक process चलाते हैं, साथ में कुछ अन्य extra processes भी।
+
+
+
+---
+
+अब जब हम **process** और **program** शब्दों के बीच अंतर जानते हैं, तो deployments के बारे में बात जारी रखते हैं।
+
+## startup पर चलना { #running-on-startup }
+
+अधिकांश मामलों में, जब आप एक web API बनाते हैं, तो आप चाहते हैं कि वह **हमेशा चलती रहे**, बिना interruption के, ताकि आपके clients हमेशा उसे access कर सकें। यह निश्चित रूप से तब तक है जब तक आपके पास कोई विशेष कारण न हो कि आप उसे केवल कुछ स्थितियों में ही चलाना चाहते हैं, लेकिन अधिकांश समय आप चाहते हैं कि वह लगातार चलती रहे और **available** रहे।
+
+### Remote Server में { #in-a-remote-server }
+
+जब आप एक remote server (एक cloud server, एक virtual machine, आदि) setup करते हैं, तो सबसे सरल चीज़ जो आप कर सकते हैं वह है `fastapi run` (जो Uvicorn का उपयोग करता है) या कुछ समान, manually, ठीक उसी तरह जैसे आप local development करते समय करते हैं।
+
+और यह काम करेगा और **development के दौरान** उपयोगी होगा।
+
+लेकिन यदि server से आपका connection खो जाता है, तो **running process** शायद मर जाएगा।
+
+और यदि server restart होता है (उदाहरण के लिए updates के बाद, या cloud provider से migrations के बाद) तो आप शायद **इसे notice नहीं करेंगे**। और इसके कारण, आपको यह भी पता नहीं चलेगा कि आपको process को manually restart करना है। इसलिए, आपकी API बस dead ही रहेगी। 😱
+
+### Startup पर Automatically चलाना { #run-automatically-on-startup }
+
+सामान्यतः, आप शायद चाहेंगे कि server program (जैसे Uvicorn) server startup पर automatically start हो, और किसी **human intervention** की आवश्यकता के बिना, ताकि आपकी API के साथ हमेशा एक process चल रहा हो (जैसे Uvicorn आपकी FastAPI app चला रहा हो)।
+
+### अलग Program { #separate-program }
+
+इसे हासिल करने के लिए, आपके पास सामान्यतः एक **अलग program** होगा जो सुनिश्चित करेगा कि आपकी application startup पर चले। और कई मामलों में, यह यह भी सुनिश्चित करेगा कि अन्य components या applications भी चलें, उदाहरण के लिए, एक database।
+
+### Startup पर चलाने के लिए उदाहरण Tools { #example-tools-to-run-at-startup }
+
+इस काम को करने वाले tools के कुछ उदाहरण हैं:
+
+* Docker
+* Kubernetes
+* Docker Compose
+* Docker in Swarm Mode
+* Systemd
+* Supervisor
+* Cloud provider द्वारा उनकी services के हिस्से के रूप में internally संभाला गया
+* अन्य...
+
+अगले chapters में मैं आपको अधिक ठोस उदाहरण दूँगा।
+
+## Restarts { #restarts }
+
+यह सुनिश्चित करने जैसा कि आपकी application startup पर चले, आप शायद यह भी सुनिश्चित करना चाहेंगे कि failures के बाद उसे **restart** किया जाए।
+
+### हम गलतियाँ करते हैं { #we-make-mistakes }
+
+हम, मनुष्य के रूप में, हर समय **गलतियाँ** करते हैं। Software में लगभग *हमेशा* अलग-अलग जगहों पर **bugs** छिपे होते हैं। 🐛
+
+और हम developers उन bugs को खोजते हुए और नई features implement करते हुए code को बेहतर बनाते रहते हैं (संभवतः नए bugs भी जोड़ते हुए 😅)।
+
+### छोटे Errors Automatically संभाले जाते हैं { #small-errors-automatically-handled }
+
+FastAPI के साथ web APIs बनाते समय, यदि हमारे code में कोई error है, तो FastAPI सामान्यतः उसे उस single request तक सीमित रखेगा जिसने error trigger किया। 🛡
+
+Client को उस request के लिए **500 Internal Server Error** मिलेगा, लेकिन application पूरी तरह crash होने के बजाय अगली requests के लिए काम करती रहेगी।
+
+### बड़े Errors - Crashes { #bigger-errors-crashes }
+
+फिर भी, ऐसे मामले हो सकते हैं जहाँ हम कुछ code लिखते हैं जो **पूरी application को crash** कर देता है, जिससे Uvicorn और Python crash हो जाते हैं। 💥
+
+और फिर भी, आप शायद नहीं चाहेंगे कि application केवल इसलिए dead रहे क्योंकि एक जगह error था, आप शायद चाहेंगे कि वह कम से कम उन *path operations* के लिए **चलती रहे** जो broken नहीं हैं।
+
+### Crash के बाद Restart { #restart-after-crash }
+
+लेकिन उन मामलों में जहाँ वास्तव में खराब errors running **process** को crash कर देते हैं, आप चाहेंगे कि एक external component process को **restart** करने का प्रभारी हो, कम से कम कुछ बार...
+
+/// tip | सुझाव
+
+...हालाँकि यदि पूरी application बस **तुरंत crash** हो रही है तो शायद उसे हमेशा restart करते रहने का कोई अर्थ नहीं है। लेकिन ऐसे मामलों में, आप शायद इसे development के दौरान, या कम से कम deployment के ठीक बाद notice करेंगे।
+
+तो आइए मुख्य मामलों पर focus करें, जहाँ यह **future** में कुछ विशेष मामलों में पूरी तरह crash हो सकती है, और फिर भी उसे restart करना समझ में आता है।
+
+///
+
+आप शायद चाहेंगे कि आपकी application को restart करने का प्रभारी एक **external component** हो, क्योंकि उस point तक, Uvicorn और Python वाली वही application पहले ही crash हो चुकी होती है, इसलिए उसी app के उसी code में ऐसा कुछ नहीं होता जो इसके बारे में कुछ कर सके।
+
+### Automatically Restart करने के लिए उदाहरण Tools { #example-tools-to-restart-automatically }
+
+अधिकांश मामलों में, वही tool जो **startup पर program चलाने** के लिए उपयोग होता है, automatic **restarts** संभालने के लिए भी उपयोग होता है।
+
+उदाहरण के लिए, इसे ये संभाल सकते हैं:
+
+* Docker
+* Kubernetes
+* Docker Compose
+* Docker in Swarm Mode
+* Systemd
+* Supervisor
+* Cloud provider द्वारा उनकी services के हिस्से के रूप में internally संभाला गया
+* अन्य...
+
+## Replication - Processes और Memory { #replication-processes-and-memory }
+
+FastAPI application के साथ, Uvicorn चलाने वाले `fastapi` command जैसे server program का उपयोग करते हुए, उसे **एक process** में एक बार चलाना multiple clients को concurrently serve कर सकता है।
+
+लेकिन कई मामलों में, आप एक ही समय में कई worker processes चलाना चाहेंगे।
+
+### Multiple Processes - Workers { #multiple-processes-workers }
+
+यदि आपके पास single process द्वारा handle किए जा सकने से अधिक clients हैं (उदाहरण के लिए यदि virtual machine बहुत बड़ी नहीं है) और server के CPU में **multiple cores** हैं, तो आप एक ही application के साथ **multiple processes** एक ही समय में चला सकते हैं, और सभी requests को उनके बीच distribute कर सकते हैं।
+
+जब आप उसी API program के **multiple processes** चलाते हैं, तो उन्हें आम तौर पर **workers** कहा जाता है।
+
+### Worker Processes और Ports { #worker-processes-and-ports }
+
+Docs [About HTTPS](https.md) से याद करें कि server में port और IP address के एक combination पर केवल एक process listen कर सकता है?
+
+यह अभी भी सही है।
+
+इसलिए, एक ही समय में **multiple processes** रखने में सक्षम होने के लिए, एक **single process port पर listening** होना चाहिए जो फिर communication को किसी तरीके से प्रत्येक worker process तक transmit करे।
+
+### प्रति Process Memory { #memory-per-process }
+
+अब, जब program memory में चीजें load करता है, उदाहरण के लिए, किसी variable में machine learning model, या किसी बड़े file की contents किसी variable में, तो वह सब server की **memory (RAM) का थोड़ा हिस्सा consume** करता है।
+
+और multiple processes सामान्यतः **कोई memory share नहीं करते**। इसका मतलब है कि प्रत्येक running process की अपनी चीजें, variables, और memory होती है। और यदि आप अपने code में बड़ी मात्रा में memory consume कर रहे हैं, तो **प्रत्येक process** उतनी ही memory consume करेगा।
+
+### Server Memory { #server-memory }
+
+उदाहरण के लिए, यदि आपका code **1 GB size** वाला Machine Learning model load करता है, तो जब आप अपनी API के साथ एक process चलाते हैं, तो वह कम से कम 1 GB RAM consume करेगा। और यदि आप **4 processes** (4 workers) start करते हैं, तो प्रत्येक 1 GB RAM consume करेगा। इसलिए कुल मिलाकर, आपकी API **4 GB RAM** consume करेगी।
+
+और यदि आपके remote server या virtual machine में केवल 3 GB RAM है, तो 4 GB से अधिक RAM load करने की कोशिश problems पैदा करेगी। 🚨
+
+### Multiple Processes - एक उदाहरण { #multiple-processes-an-example }
+
+इस उदाहरण में, एक **Manager Process** है जो दो **Worker Processes** start और control करता है।
+
+यह Manager Process शायद IP में **port** पर listen करने वाला होगा। और यह सभी communication को worker processes तक transmit करेगा।
+
+वे worker processes वे होंगे जो आपकी application चला रहे होंगे, वे **request** प्राप्त करने और **response** return करने के लिए मुख्य computations करेंगे, और वे RAM में variables में डाली गई कोई भी चीज़ load करेंगे।
+
+
+
+और निश्चित रूप से, उसी machine पर आपकी application के अलावा शायद **अन्य processes** भी चल रहे होंगे।
+
+एक दिलचस्प detail यह है कि प्रत्येक process द्वारा **उपयोग किए गए CPU** का percentage समय के साथ बहुत **बदल** सकता है, लेकिन **memory (RAM)** सामान्यतः कम या ज्यादा **stable** रहती है।
+
+यदि आपके पास एक API है जो हर बार comparable amount की computations करती है और आपके पास बहुत सारे clients हैं, तो **CPU utilization** शायद *stable भी रहेगा* (लगातार तेजी से ऊपर-नीचे जाने के बजाय)।
+
+### Replication Tools और Strategies के उदाहरण { #examples-of-replication-tools-and-strategies }
+
+इसे हासिल करने के कई approaches हो सकते हैं, और मैं अगले chapters में specific strategies के बारे में अधिक बताऊँगा, उदाहरण के लिए Docker और containers के बारे में बात करते समय।
+
+विचार करने की मुख्य constraint यह है कि **public IP** में **port** को handle करने वाला एक **single** component होना चाहिए। और फिर उसके पास replicated **processes/workers** तक communication **transmit** करने का कोई तरीका होना चाहिए।
+
+यहाँ कुछ संभावित combinations और strategies हैं:
+
+* **Uvicorn** `--workers` के साथ
+ * एक Uvicorn **process manager** **IP** और **port** पर listen करेगा, और यह **multiple Uvicorn worker processes** start करेगा।
+* **Kubernetes** और अन्य distributed **container systems**
+ * **Kubernetes** layer में कुछ **IP** और **port** पर listen करेगा। Replication **multiple containers** रखने से होगी, प्रत्येक में **एक Uvicorn process** चल रहा होगा।
+* **Cloud services** जो यह आपके लिए संभालती हैं
+ * Cloud service शायद **आपके लिए replication handle** करेगी। यह संभवतः आपको **चलाने के लिए process**, या उपयोग करने के लिए **container image** define करने देगी, किसी भी स्थिति में, यह बहुत संभवतः **एक single Uvicorn process** होगा, और cloud service उसे replicate करने की प्रभारी होगी।
+
+/// tip | सुझाव
+
+यदि **containers**, Docker, या Kubernetes के बारे में इनमें से कुछ items अभी अधिक समझ में नहीं आते हैं तो चिंता न करें।
+
+मैं future chapter में container images, Docker, Kubernetes, आदि के बारे में अधिक बताऊँगा: [Containers में FastAPI - Docker](docker.md)।
+
+///
+
+## शुरू करने से पहले के पिछले Steps { #previous-steps-before-starting }
+
+कई मामले ऐसे होते हैं जहाँ आप अपनी application **start करने से पहले** कुछ steps perform करना चाहते हैं।
+
+उदाहरण के लिए, आप **database migrations** चलाना चाह सकते हैं।
+
+लेकिन अधिकांश मामलों में, आप इन steps को केवल **एक बार** perform करना चाहेंगे।
+
+इसलिए, आप application start करने से पहले उन **previous steps** को perform करने के लिए एक **single process** रखना चाहेंगे।
+
+और आपको यह सुनिश्चित करना होगा कि उन previous steps को चलाने वाला एक ही process हो, *भले ही* बाद में आप application के लिए **multiple processes** (multiple workers) start करें। यदि वे steps **multiple processes** द्वारा चलाए गए, तो वे उन्हें **parallel** में चलाकर काम को **duplicate** कर देंगे, और यदि steps database migration जैसी delicate चीज़ हैं, तो वे एक-दूसरे के साथ conflicts पैदा कर सकते हैं।
+
+बेशक, कुछ मामले ऐसे होते हैं जहाँ previous steps को multiple times चलाने में कोई समस्या नहीं होती, उस स्थिति में इसे handle करना बहुत आसान होता है।
+
+/// tip | सुझाव
+
+साथ ही, ध्यान रखें कि आपके setup पर निर्भर करते हुए, कुछ मामलों में आपकी application start करने से पहले आपको **शायद किसी previous steps की आवश्यकता भी न हो**।
+
+उस स्थिति में, आपको इनमें से किसी भी चीज़ की चिंता नहीं करनी होगी। 🤷
+
+///
+
+### Previous Steps Strategies के उदाहरण { #examples-of-previous-steps-strategies }
+
+यह इस बात पर **बहुत अधिक निर्भर** करेगा कि आप **अपना system कैसे deploy** करते हैं, और यह शायद programs start करने, restarts handle करने, आदि के तरीके से जुड़ा होगा।
+
+यहाँ कुछ संभावित ideas हैं:
+
+* Kubernetes में एक "Init Container" जो आपके app container से पहले चलता है
+* एक bash script जो previous steps चलाती है और फिर आपकी application start करती है
+ * आपको फिर भी *उस* bash script को start/restart करने, errors detect करने, आदि का तरीका चाहिए होगा।
+
+/// tip | सुझाव
+
+Containers के साथ ऐसा करने के लिए मैं future chapter में अधिक ठोस उदाहरण दूँगा: [Containers में FastAPI - Docker](docker.md)।
+
+///
+
+## Resource Utilization { #resource-utilization }
+
+आपके server(s) एक **resource** हैं, जिन्हें आप अपने programs के साथ consume या **utilize** कर सकते हैं, CPUs पर computation time और उपलब्ध RAM memory का उपयोग करके।
+
+आप system resources का कितना हिस्सा consume/utilize करना चाहते हैं? "बहुत ज्यादा नहीं" सोचना आसान हो सकता है, लेकिन वास्तव में, आप शायद **crash किए बिना जितना संभव हो उतना** consume करना चाहेंगे।
+
+यदि आप 3 servers के लिए भुगतान कर रहे हैं लेकिन उनकी RAM और CPU का केवल थोड़ा सा उपयोग कर रहे हैं, तो आप शायद **पैसा बर्बाद कर रहे हैं** 💸, और शायद **server की electric power बर्बाद कर रहे हैं** 🌎, आदि।
+
+उस स्थिति में, केवल 2 servers रखना और उनके resources (CPU, memory, disk, network bandwidth, आदि) का उच्च percentage उपयोग करना बेहतर हो सकता है।
+
+दूसरी ओर, यदि आपके पास 2 servers हैं और आप उनके **CPU और RAM का 100%** उपयोग कर रहे हैं, तो किसी point पर एक process अधिक memory माँगेगा, और server को disk को "memory" के रूप में उपयोग करना पड़ेगा (जो हजारों गुना धीमा हो सकता है), या वह **crash** भी हो सकता है। या किसी process को कुछ computation करनी हो सकती है और उसे CPU के फिर से free होने तक wait करना पड़ेगा।
+
+इस मामले में, **एक extra server** लेना और उस पर कुछ processes चलाना बेहतर होगा ताकि उन सभी के पास **पर्याप्त RAM और CPU time** हो।
+
+यह भी संभावना है कि किसी कारण से आपकी API के usage में **spike** हो। शायद यह viral हो गई, या शायद कुछ अन्य services या bots इसका उपयोग शुरू कर दें। और आप उन मामलों में safe रहने के लिए extra resources रखना चाह सकते हैं।
+
+आप target करने के लिए एक **arbitrary number** रख सकते हैं, उदाहरण के लिए, resource utilization का **50% से 90% के बीच** कुछ। बात यह है कि ये शायद वे मुख्य चीजें हैं जिन्हें आप measure करना और अपने deployments tweak करने के लिए उपयोग करना चाहेंगे।
+
+आप अपने server में उपयोग किए गए CPU और RAM या प्रत्येक process द्वारा उपयोग की गई मात्रा देखने के लिए `htop` जैसे simple tools का उपयोग कर सकते हैं। या आप अधिक complex monitoring tools का उपयोग कर सकते हैं, जो servers में distributed हो सकते हैं, आदि।
+
+## Recap { #recap }
+
+आपने यहाँ कुछ मुख्य अवधारणाएँ पढ़ी हैं जिन्हें अपनी application को कैसे deploy करना है, यह तय करते समय आपको शायद ध्यान में रखना होगा:
+
+* सुरक्षा - HTTPS
+* startup पर चलना
+* Restarts
+* Replication (चल रहे processes की संख्या)
+* Memory
+* शुरू करने से पहले के पिछले steps
+
+इन ideas को समझना और उन्हें apply करना आपको अपने deployments configure और tweak करते समय कोई भी decisions लेने के लिए आवश्यक intuition देना चाहिए। 🤓
+
+अगले sections में, मैं आपको उन संभावित strategies के अधिक ठोस उदाहरण दूँगा जिनका आप पालन कर सकते हैं। 🚀
diff --git a/docs/hi/docs/deployment/docker.md b/docs/hi/docs/deployment/docker.md
new file mode 100644
index 000000000..6e8bea03a
--- /dev/null
+++ b/docs/hi/docs/deployment/docker.md
@@ -0,0 +1,618 @@
+# Containers में FastAPI - Docker { #fastapi-in-containers-docker }
+
+FastAPI applications deploy करते समय एक आम तरीका **Linux container image** बनाना है। यह सामान्यतः [**Docker**](https://www.docker.com/) का उपयोग करके किया जाता है। फिर आप उस container image को कुछ संभावित तरीकों में से किसी एक में deploy कर सकते हैं।
+
+Linux containers का उपयोग करने के कई लाभ हैं, जिनमें **security**, **replicability**, **simplicity**, और अन्य शामिल हैं।
+
+/// tip | टिप
+
+जल्दी में हैं और यह सब पहले से जानते हैं? नीचे दिए गए [`Dockerfile` पर जाएँ 👇](#build-a-docker-image-for-fastapi).
+
+///
+
+
+
+### TLS Handshake Start { #tls-handshake-start }
+
+Browser फिर उस IP address से **port 443** (HTTPS port) पर communicate करेगा।
+
+Communication का पहला हिस्सा केवल client और server के बीच connection establish करना और वे कौन-सी cryptographic keys उपयोग करेंगे आदि तय करना है।
+
+
+
+TLS connection establish करने के लिए client और server के बीच इस interaction को **TLS handshake** कहा जाता है।
+
+### SNI Extension के साथ TLS { #tls-with-sni-extension }
+
+Server में **केवल एक process** किसी विशिष्ट **IP address** में किसी विशिष्ट **port** पर listen कर सकता है। उसी IP address में दूसरे ports पर अन्य processes listen कर सकते हैं, लेकिन IP address और port के हर combination के लिए केवल एक।
+
+TLS (HTTPS) by default विशिष्ट port `443` का उपयोग करता है। इसलिए हमें इसी port की जरूरत होगी।
+
+क्योंकि इस port पर केवल एक process listen कर सकता है, जो process यह करेगा वह **TLS Termination Proxy** होगा।
+
+TLS Termination Proxy के पास एक या अधिक **TLS certificates** (HTTPS certificates) तक access होगा।
+
+ऊपर चर्चा किए गए **SNI extension** का उपयोग करके, TLS Termination Proxy check करेगा कि इस connection के लिए उपलब्ध TLS (HTTPS) certificates में से किसका उपयोग करना चाहिए, client द्वारा expected domain से match करने वाले certificate का उपयोग करते हुए।
+
+इस मामले में, यह `someapp.example.com` के लिए certificate का उपयोग करेगा।
+
+
+
+Client पहले से ही उस entity पर **trust** करता है जिसने वह TLS certificate generate किया है (इस मामले में Let's Encrypt, लेकिन हम इसके बारे में बाद में देखेंगे), इसलिए यह **verify** कर सकता है कि certificate valid है।
+
+फिर, certificate का उपयोग करके, client और TLS Termination Proxy **तय करते हैं कि बाकी TCP communication को कैसे encrypt करना है**। इससे **TLS Handshake** वाला हिस्सा पूरा होता है।
+
+इसके बाद, client और server के पास एक **encrypted TCP connection** होता है, यही TLS प्रदान करता है। और फिर वे उस connection का उपयोग वास्तविक **HTTP communication** शुरू करने के लिए कर सकते हैं।
+
+और **HTTPS** यही है, यह pure (unencrypted) TCP connection के बजाय एक **secure TLS connection** के अंदर साधारण **HTTP** ही है।
+
+/// tip | सुझाव
+
+ध्यान दें कि communication का encryption **TCP level** पर होता है, HTTP level पर नहीं।
+
+///
+
+### HTTPS Request { #https-request }
+
+अब जबकि client और server (विशेष रूप से browser और TLS Termination Proxy) के पास एक **encrypted TCP connection** है, वे **HTTP communication** शुरू कर सकते हैं।
+
+तो, client एक **HTTPS request** भेजता है। यह encrypted TLS connection के माध्यम से बस एक HTTP request है।
+
+
+
+### Request को Decrypt करें { #decrypt-the-request }
+
+TLS Termination Proxy सहमत किए गए encryption का उपयोग **request को decrypt** करने के लिए करेगा, और **साधारण (decrypted) HTTP request** को application चलाने वाले process तक transmit करेगा (उदाहरण के लिए FastAPI application चलाने वाले Uvicorn के साथ एक process)।
+
+
+
+### HTTP Response { #http-response }
+
+Application request को process करेगी और TLS Termination Proxy को एक **साधारण (unencrypted) HTTP response** भेजेगी।
+
+
+
+### HTTPS Response { #https-response }
+
+TLS Termination Proxy फिर पहले सहमत cryptography (जो `someapp.example.com` के लिए certificate से शुरू हुई थी) का उपयोग करके **response को encrypt** करेगा, और इसे browser को वापस भेजेगा।
+
+इसके बाद, browser verify करेगा कि response valid है और सही cryptographic key आदि से encrypted है। फिर वह **response को decrypt** करेगा और process करेगा।
+
+
+
+Client (browser) को पता होगा कि response सही server से आया है क्योंकि यह उस cryptography का उपयोग कर रहा है जिस पर उन्होंने पहले **HTTPS certificate** का उपयोग करके सहमति की थी।
+
+### Multiple Applications { #multiple-applications }
+
+उसी server (या servers) में, **multiple applications** हो सकती हैं, उदाहरण के लिए, अन्य API programs या database।
+
+केवल एक process विशिष्ट IP और port handle कर सकता है (हमारे उदाहरण में TLS Termination Proxy) लेकिन अन्य applications/processes भी server(s) पर चल सकते हैं, जब तक वे **public IP और port के उसी combination** का उपयोग करने की कोशिश नहीं करते।
+
+
+
+इस तरह, TLS Termination Proxy **multiple domains** के लिए, multiple applications के लिए HTTPS और certificates handle कर सकता है, और फिर हर मामले में requests को सही application तक transmit कर सकता है।
+
+### Certificate Renewal { #certificate-renewal }
+
+भविष्य में किसी समय, प्रत्येक certificate **expire** हो जाएगा (इसे प्राप्त करने के लगभग 3 महीने बाद)।
+
+और फिर, कोई दूसरा program होगा (कुछ मामलों में यह दूसरा program होता है, कुछ मामलों में यह वही TLS Termination Proxy हो सकता है) जो Let's Encrypt से बात करेगा, और certificate(s) को renew करेगा।
+
+
+
+**TLS certificates** किसी **domain name** से **associated** होते हैं, IP address से नहीं।
+
+इसलिए, certificates renew करने के लिए, renewal program को authority (Let's Encrypt) को **prove** करना होगा कि वह वास्तव में उस domain को **"own" और control** करता है।
+
+ऐसा करने के लिए, और अलग-अलग application needs को accommodate करने के लिए, इसे करने के कई तरीके हैं। कुछ लोकप्रिय तरीके हैं:
+
+* **कुछ DNS records modify करें**।
+ * इसके लिए, renewal program को DNS provider की APIs support करनी होंगी, इसलिए, आप जिस DNS provider का उपयोग कर रहे हैं, उसके आधार पर यह option हो भी सकता है या नहीं भी।
+* Domain से associated public IP address पर (कम से कम certificate acquisition process के दौरान) **server के रूप में चलें**।
+ * जैसा कि हमने ऊपर कहा, केवल एक process किसी विशिष्ट IP और port पर listen कर सकता है।
+ * यह उन कारणों में से एक है कि जब वही TLS Termination Proxy certificate renewal process का भी ध्यान रखता है तो यह बहुत उपयोगी होता है।
+ * अन्यथा, आपको TLS Termination Proxy को momentarily stop करना पड़ सकता है, certificates प्राप्त करने के लिए renewal program start करना पड़ सकता है, फिर उन्हें TLS Termination Proxy के साथ configure करना पड़ सकता है, और फिर TLS Termination Proxy को restart करना पड़ सकता है। यह ideal नहीं है, क्योंकि जिस समय TLS Termination Proxy off होगा, उस दौरान आपकी app(s) available नहीं होंगी।
+
+App को serve करते हुए भी यह पूरा renewal process, उन मुख्य कारणों में से एक है कि आप application server के साथ सीधे TLS certificates (जैसे Uvicorn) का उपयोग करने के बजाय TLS Termination Proxy के साथ **HTTPS handle करने के लिए एक अलग system** रखना चाहेंगे।
+
+## Proxy Forwarded Headers { #proxy-forwarded-headers }
+
+HTTPS handle करने के लिए proxy का उपयोग करते समय, आपका **application server** (उदाहरण के लिए FastAPI CLI के माध्यम से Uvicorn) HTTPS process के बारे में कुछ नहीं जानता, यह **TLS Termination Proxy** के साथ plain HTTP में communicate करता है।
+
+यह **proxy** सामान्यतः request को **application server** तक transmit करने से पहले कुछ HTTP headers on the fly set करेगा, ताकि application server को पता चल सके कि request proxy द्वारा **forwarded** की जा रही है।
+
+/// note | तकनीकी विवरण
+
+Proxy headers हैं:
+
+* [X-Forwarded-For](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For)
+* [X-Forwarded-Proto](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto)
+* [X-Forwarded-Host](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host)
+
+///
+
+फिर भी, क्योंकि **application server** नहीं जानता कि वह trusted **proxy** के पीछे है, by default, वह उन headers पर trust नहीं करेगा।
+
+लेकिन आप **application server** को **proxy** द्वारा भेजे गए *forwarded* headers पर trust करने के लिए configure कर सकते हैं। अगर आप FastAPI CLI का उपयोग कर रहे हैं, तो आप *CLI Option* `--forwarded-allow-ips` का उपयोग करके उसे बता सकते हैं कि उसे किन IPs से आने वाले उन *forwarded* headers पर trust करना चाहिए।
+
+उदाहरण के लिए, अगर **application server** केवल trusted **proxy** से communication receive कर रहा है, तो आप इसे `--forwarded-allow-ips="*"` पर set कर सकते हैं ताकि यह सभी incoming IPs पर trust करे, क्योंकि यह केवल उसी IP से requests receive करेगा जिसका उपयोग **proxy** कर रहा है।
+
+इस तरह application यह जान पाएगी कि उसका अपना public URL क्या है, क्या वह HTTPS का उपयोग कर रही है, domain, आदि।
+
+यह उदाहरण के लिए redirects को ठीक से handle करने में उपयोगी होगा।
+
+/// tip | सुझाव
+
+आप इसके बारे में documentation में और सीख सकते हैं: [Proxy के पीछे - Proxy Forwarded Headers सक्षम करें](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers)
+
+///
+
+## Recap { #recap }
+
+**HTTPS** होना बहुत महत्वपूर्ण है, और अधिकांश मामलों में काफी **critical** है। HTTPS के आसपास एक developer के रूप में आपको जो ज़्यादातर effort लगाना होता है, वह बस **इन concepts को समझने** और वे कैसे काम करते हैं, इसे समझने के बारे में है।
+
+लेकिन एक बार जब आप **developers के लिए HTTPS** की मूल जानकारी जान लेते हैं, तो आप सब कुछ सरल तरीके से manage करने में मदद के लिए अलग-अलग tools को आसानी से combine और configure कर सकते हैं।
+
+अगले कुछ chapters में, मैं आपको **FastAPI** applications के लिए **HTTPS** setup करने के कई ठोस उदाहरण दिखाऊँगा। 🔒
diff --git a/docs/hi/docs/deployment/index.md b/docs/hi/docs/deployment/index.md
new file mode 100644
index 000000000..7b0c5b2d5
--- /dev/null
+++ b/docs/hi/docs/deployment/index.md
@@ -0,0 +1,23 @@
+# Deployment { #deployment }
+
+**FastAPI** application को deploy करना अपेक्षाकृत आसान है।
+
+## Deployment का क्या अर्थ है { #what-does-deployment-mean }
+
+किसी application को **deploy** करने का अर्थ है उसे **users के लिए उपलब्ध** कराने के लिए आवश्यक चरण पूरे करना।
+
+किसी **web API** के लिए, इसमें सामान्यतः उसे एक **remote machine** में रखना शामिल होता है, एक **server program** के साथ जो अच्छा performance, stability आदि प्रदान करता है, ताकि आपके **users** application को कुशलता से और बिना रुकावटों या समस्याओं के **access** कर सकें।
+
+यह **development** चरणों के विपरीत है, जहाँ आप लगातार code बदल रहे होते हैं, उसे तोड़ते और ठीक करते हैं, development server को रोकते और फिर से शुरू करते हैं, आदि।
+
+## Deployment Strategies { #deployment-strategies }
+
+इसे करने के कई तरीके हैं, जो आपके विशिष्ट use case और आपके द्वारा उपयोग किए जाने वाले tools पर निर्भर करते हैं।
+
+आप tools के संयोजन का उपयोग करके स्वयं **server deploy** कर सकते हैं, आप कोई **cloud service** उपयोग कर सकते हैं जो आपके लिए काम का कुछ हिस्सा करती है, या अन्य संभावित विकल्प चुन सकते हैं।
+
+उदाहरण के लिए, हमने, FastAPI के पीछे की team ने, [**FastAPI Cloud**](https://fastapicloud.com) बनाया, ताकि FastAPI apps को cloud पर deploy करना जितना संभव हो उतना streamlined हो, FastAPI के साथ काम करने के समान developer experience के साथ।
+
+मैं आपको कुछ मुख्य concepts दिखाऊँगा जिन्हें **FastAPI** application deploy करते समय शायद ध्यान में रखना चाहिए (हालाँकि इनमें से अधिकतर किसी भी अन्य प्रकार की web application पर लागू होता है)।
+
+अगले sections में आपको ध्यान में रखने के लिए अधिक details और इसे करने की कुछ techniques दिखेंगी। ✨
diff --git a/docs/hi/docs/deployment/manually.md b/docs/hi/docs/deployment/manually.md
new file mode 100644
index 000000000..840421513
--- /dev/null
+++ b/docs/hi/docs/deployment/manually.md
@@ -0,0 +1,156 @@
+# Server को मैन्युअली चलाएँ { #run-a-server-manually }
+
+## `fastapi run` Command का उपयोग करें { #use-the-fastapi-run-command }
+
+संक्षेप में, अपनी FastAPI application serve करने के लिए `fastapi run` का उपयोग करें:
+
+
+
+लेकिन आप `syntaxHighlight` को `False` पर set करके इसे disable कर सकते हैं:
+
+{* ../../docs_src/configure_swagger_ui/tutorial001_py310.py hl[3] *}
+
+...और फिर Swagger UI अब syntax highlighting नहीं दिखाएगा:
+
+
+
+## Theme बदलें { #change-the-theme }
+
+इसी तरह आप key `"syntaxHighlight.theme"` के साथ syntax highlighting theme set कर सकते हैं (ध्यान दें कि इसके बीच में एक dot है):
+
+{* ../../docs_src/configure_swagger_ui/tutorial002_py310.py hl[3] *}
+
+वह configuration syntax highlighting color theme बदल देगी:
+
+
+
+## Default Swagger UI Parameters बदलें { #change-default-swagger-ui-parameters }
+
+FastAPI में ज़्यादातर use cases के लिए उपयुक्त कुछ default configuration parameters शामिल हैं।
+
+इसमें ये default configurations शामिल हैं:
+
+{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
+
+आप `swagger_ui_parameters` argument में अलग value set करके इनमें से किसी को भी override कर सकते हैं।
+
+उदाहरण के लिए, `deepLinking` disable करने के लिए आप ये settings `swagger_ui_parameters` में pass कर सकते हैं:
+
+{* ../../docs_src/configure_swagger_ui/tutorial003_py310.py hl[3] *}
+
+## अन्य Swagger UI Parameters { #other-swagger-ui-parameters }
+
+आप जिन अन्य सभी संभावित configurations का उपयोग कर सकते हैं, उन्हें देखने के लिए आधिकारिक [Swagger UI parameters के docs](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/) पढ़ें।
+
+## केवल JavaScript settings { #javascript-only-settings }
+
+Swagger UI अन्य configurations को **केवल JavaScript** objects (उदाहरण के लिए, JavaScript functions) होने की भी अनुमति देता है।
+
+FastAPI में ये केवल JavaScript `presets` settings भी शामिल हैं:
+
+```JavaScript
+presets: [
+ SwaggerUIBundle.presets.apis,
+ SwaggerUIBundle.SwaggerUIStandalonePreset
+]
+```
+
+ये **JavaScript** objects हैं, strings नहीं, इसलिए आप इन्हें सीधे Python code से pass नहीं कर सकते।
+
+अगर आपको ऐसी केवल JavaScript configurations का उपयोग करना है, तो आप ऊपर दिए गए methods में से किसी एक का उपयोग कर सकते हैं। पूरी Swagger UI *path operation* को override करें और आपको जो भी JavaScript चाहिए उसे manually लिखें।
diff --git a/docs/hi/docs/how-to/custom-docs-ui-assets.md b/docs/hi/docs/how-to/custom-docs-ui-assets.md
new file mode 100644
index 000000000..5f22186df
--- /dev/null
+++ b/docs/hi/docs/how-to/custom-docs-ui-assets.md
@@ -0,0 +1,185 @@
+# कस्टम Docs UI Static Assets (Self-Hosting) { #custom-docs-ui-static-assets-self-hosting }
+
+API docs **Swagger UI** और **ReDoc** का उपयोग करते हैं, और उनमें से प्रत्येक को कुछ JavaScript और CSS files की जरूरत होती है।
+
+Default रूप से, वे files एक CDN से serve की जाती हैं।
+
+लेकिन इसे customize करना संभव है, आप कोई विशिष्ट CDN set कर सकते हैं, या files को स्वयं serve कर सकते हैं।
+
+## JavaScript और CSS के लिए कस्टम CDN { #custom-cdn-for-javascript-and-css }
+
+मान लें कि आप कोई अलग CDN उपयोग करना चाहते हैं, उदाहरण के लिए आप `https://unpkg.com/` उपयोग करना चाहते हैं।
+
+यह उपयोगी हो सकता है अगर, उदाहरण के लिए, आप ऐसे देश में रहते हैं जो कुछ URLs को restrict करता है।
+
+### Automatic docs को disable करें { #disable-the-automatic-docs }
+
+पहला step automatic docs को disable करना है, क्योंकि default रूप से, वे default CDN का उपयोग करते हैं।
+
+उन्हें disable करने के लिए, अपना `FastAPI` app बनाते समय उनके URLs को `None` पर set करें:
+
+{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[8] *}
+
+### कस्टम docs शामिल करें { #include-the-custom-docs }
+
+अब आप कस्टम docs के लिए *path operations* बना सकते हैं।
+
+आप docs के लिए HTML pages बनाने हेतु FastAPI के internal functions को reuse कर सकते हैं, और उन्हें जरूरी arguments pass कर सकते हैं:
+
+* `openapi_url`: वह URL जहां docs के लिए HTML page आपके API के लिए OpenAPI schema प्राप्त कर सकता है। आप यहां attribute `app.openapi_url` का उपयोग कर सकते हैं।
+* `title`: आपके API का title।
+* `oauth2_redirect_url`: default उपयोग करने के लिए आप यहां `app.swagger_ui_oauth2_redirect_url` का उपयोग कर सकते हैं।
+* `swagger_js_url`: वह URL जहां आपके Swagger UI docs के लिए HTML **JavaScript** file प्राप्त कर सकता है। यह कस्टम CDN URL है।
+* `swagger_css_url`: वह URL जहां आपके Swagger UI docs के लिए HTML **CSS** file प्राप्त कर सकता है। यह कस्टम CDN URL है।
+
+और ReDoc के लिए भी इसी तरह...
+
+{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[2:6,11:19,22:24,27:33] *}
+
+/// tip | सुझाव
+
+`swagger_ui_redirect` के लिए *path operation* तब एक helper है जब आप OAuth2 का उपयोग करते हैं।
+
+यदि आप अपने API को किसी OAuth2 provider के साथ integrate करते हैं, तो आप authenticate कर पाएंगे और प्राप्त credentials के साथ API docs पर वापस आ पाएंगे। और वास्तविक OAuth2 authentication का उपयोग करके उससे interact कर पाएंगे।
+
+Swagger UI आपके लिए इसे behind the scenes handle करेगा, लेकिन इसके लिए इस "redirect" helper की जरूरत होती है।
+
+///
+
+### इसे test करने के लिए एक *path operation* बनाएं { #create-a-path-operation-to-test-it }
+
+अब, यह test करने के लिए कि सब कुछ काम करता है, एक *path operation* बनाएं:
+
+{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[36:38] *}
+
+### इसे test करें { #test-it }
+
+अब, आप अपने docs पर [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) जा सकेंगे, और page reload करने पर, यह उन assets को नए CDN से load करेगा।
+
+## Docs के लिए JavaScript और CSS की Self-hosting { #self-hosting-javascript-and-css-for-docs }
+
+JavaScript और CSS की self-hosting उपयोगी हो सकती है अगर, उदाहरण के लिए, आपको चाहिए कि आपका app offline रहने पर भी, खुले Internet access के बिना, या local network में काम करता रहे।
+
+यहां आप देखेंगे कि उन files को स्वयं, उसी FastAPI app में कैसे serve किया जाए, और docs को उनका उपयोग करने के लिए कैसे configure किया जाए।
+
+### Project file structure { #project-file-structure }
+
+मान लें आपके project की file structure ऐसी दिखती है:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+```
+
+अब उन static files को store करने के लिए एक directory बनाएं।
+
+आपकी नई file structure ऐसी दिख सकती है:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+└── static/
+```
+
+### Files download करें { #download-the-files }
+
+Docs के लिए जरूरी static files download करें और उन्हें उस `static/` directory में रखें।
+
+आप शायद प्रत्येक link पर right-click करके "Save link as..." जैसा कोई option select कर सकते हैं।
+
+**Swagger UI** files का उपयोग करता है:
+
+* [`swagger-ui-bundle.js`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js)
+* [`swagger-ui.css`](https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css)
+
+और **ReDoc** file का उपयोग करता है:
+
+* [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
+
+उसके बाद, आपकी file structure ऐसी दिख सकती है:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+└── static
+ ├── redoc.standalone.js
+ ├── swagger-ui-bundle.js
+ └── swagger-ui.css
+```
+
+### Static files serve करें { #serve-the-static-files }
+
+* `StaticFiles` import करें।
+* किसी विशिष्ट path में `StaticFiles()` instance को "Mount" करें।
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[7,11] *}
+
+### Static files को test करें { #test-the-static-files }
+
+अपना application start करें और [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js) पर जाएं।
+
+आपको **ReDoc** के लिए एक बहुत लंबी JavaScript file दिखनी चाहिए।
+
+यह कुछ इस तरह से शुरू हो सकती है:
+
+```JavaScript
+/*! For license information please see redoc.standalone.js.LICENSE.txt */
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t(require("null")):
+...
+```
+
+यह confirm करता है कि आप अपने app से static files serve कर पा रहे हैं, और आपने docs के लिए static files को सही जगह पर रखा है।
+
+अब हम app को docs के लिए उन static files का उपयोग करने के लिए configure कर सकते हैं।
+
+### Static files के लिए automatic docs को disable करें { #disable-the-automatic-docs-for-static-files }
+
+कस्टम CDN का उपयोग करने जैसा ही, पहला step automatic docs को disable करना है, क्योंकि वे default रूप से CDN का उपयोग करते हैं।
+
+उन्हें disable करने के लिए, अपना `FastAPI` app बनाते समय उनके URLs को `None` पर set करें:
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[9] *}
+
+### Static files के लिए कस्टम docs शामिल करें { #include-the-custom-docs-for-static-files }
+
+और कस्टम CDN की तरह ही, अब आप कस्टम docs के लिए *path operations* बना सकते हैं।
+
+फिर से, आप docs के लिए HTML pages बनाने हेतु FastAPI के internal functions को reuse कर सकते हैं, और उन्हें जरूरी arguments pass कर सकते हैं:
+
+* `openapi_url`: वह URL जहां docs के लिए HTML page आपके API के लिए OpenAPI schema प्राप्त कर सकता है। आप यहां attribute `app.openapi_url` का उपयोग कर सकते हैं।
+* `title`: आपके API का title।
+* `oauth2_redirect_url`: default उपयोग करने के लिए आप यहां `app.swagger_ui_oauth2_redirect_url` का उपयोग कर सकते हैं।
+* `swagger_js_url`: वह URL जहां आपके Swagger UI docs के लिए HTML **JavaScript** file प्राप्त कर सकता है। **यह वही है जिसे अब आपका अपना app serve कर रहा है**।
+* `swagger_css_url`: वह URL जहां आपके Swagger UI docs के लिए HTML **CSS** file प्राप्त कर सकता है। **यह वही है जिसे अब आपका अपना app serve कर रहा है**।
+
+और ReDoc के लिए भी इसी तरह...
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[2:6,14:22,25:27,30:36] *}
+
+/// tip | सुझाव
+
+`swagger_ui_redirect` के लिए *path operation* तब एक helper है जब आप OAuth2 का उपयोग करते हैं।
+
+यदि आप अपने API को किसी OAuth2 provider के साथ integrate करते हैं, तो आप authenticate कर पाएंगे और प्राप्त credentials के साथ API docs पर वापस आ पाएंगे। और वास्तविक OAuth2 authentication का उपयोग करके उससे interact कर पाएंगे।
+
+Swagger UI आपके लिए इसे behind the scenes handle करेगा, लेकिन इसके लिए इस "redirect" helper की जरूरत होती है।
+
+///
+
+### Static files को test करने के लिए एक *path operation* बनाएं { #create-a-path-operation-to-test-static-files }
+
+अब, यह test करने के लिए कि सब कुछ काम करता है, एक *path operation* बनाएं:
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[39:41] *}
+
+### Static Files UI को test करें { #test-static-files-ui }
+
+अब, आप अपना WiFi disconnect कर सकेंगे, अपने docs पर [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) जा सकेंगे, और page reload कर सकेंगे।
+
+और Internet के बिना भी, आप अपने API के docs देख पाएंगे और उससे interact कर पाएंगे।
diff --git a/docs/hi/docs/how-to/custom-request-and-route.md b/docs/hi/docs/how-to/custom-request-and-route.md
new file mode 100644
index 000000000..97743d169
--- /dev/null
+++ b/docs/hi/docs/how-to/custom-request-and-route.md
@@ -0,0 +1,109 @@
+# Custom Request और APIRoute class { #custom-request-and-apiroute-class }
+
+कुछ मामलों में, आप `Request` और `APIRoute` classes द्वारा उपयोग किए जाने वाले logic को override करना चाह सकते हैं।
+
+विशेष रूप से, यह middleware में logic का एक अच्छा विकल्प हो सकता है।
+
+उदाहरण के लिए, अगर आप request body को आपके application द्वारा process किए जाने से पहले पढ़ना या manipulate करना चाहते हैं।
+
+/// danger | खतरा
+
+यह एक "advanced" feature है।
+
+अगर आप अभी-अभी **FastAPI** के साथ शुरुआत कर रहे हैं, तो शायद आप इस section को छोड़ना चाहेंगे।
+
+///
+
+## Use cases { #use-cases }
+
+कुछ use cases में शामिल हैं:
+
+* non-JSON request bodies को JSON में convert करना (जैसे [`msgpack`](https://msgpack.org/index.html)).
+* gzip-compressed request bodies को decompress करना।
+* सभी request bodies को automatically log करना।
+
+## Custom request body encodings को संभालना { #handling-custom-request-body-encodings }
+
+आइए देखें कि gzip requests को decompress करने के लिए custom `Request` subclass का उपयोग कैसे करें।
+
+और उस custom request class का उपयोग करने के लिए एक `APIRoute` subclass।
+
+### Custom `GzipRequest` class बनाएँ { #create-a-custom-gziprequest-class }
+
+/// tip | सुझाव
+
+यह दिखाने के लिए एक सरल उदाहरण है कि यह कैसे काम करता है, अगर आपको Gzip support चाहिए, तो आप दिए गए [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware) का उपयोग कर सकते हैं।
+
+///
+
+सबसे पहले, हम एक `GzipRequest` class बनाते हैं, जो उपयुक्त header की मौजूदगी में body को decompress करने के लिए `Request.body()` method को overwrite करेगी।
+
+अगर header में `gzip` नहीं है, तो यह body को decompress करने की कोशिश नहीं करेगी।
+
+इस तरह, वही route class gzip compressed या uncompressed requests को संभाल सकती है।
+
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}
+
+### Custom `GzipRoute` class बनाएँ { #create-a-custom-gziproute-class }
+
+इसके बाद, हम `fastapi.routing.APIRoute` की एक custom subclass बनाते हैं जो `GzipRequest` का उपयोग करेगी।
+
+इस बार, यह `APIRoute.get_route_handler()` method को overwrite करेगी।
+
+यह method एक function return करता है। और वही function एक request प्राप्त करेगा और response return करेगा।
+
+यहाँ हम इसका उपयोग original request से `GzipRequest` बनाने के लिए करते हैं।
+
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[19:27] *}
+
+/// note | तकनीकी विवरण
+
+एक `Request` में `request.scope` attribute होता है, जो बस एक Python `dict` है जिसमें request से संबंधित metadata होता है।
+
+एक `Request` में `request.receive` भी होता है, जो request की body को "receive" करने के लिए एक function है।
+
+`scope` `dict` और `receive` function दोनों ASGI specification का हिस्सा हैं।
+
+और ये दो चीजें, `scope` और `receive`, नई `Request` instance बनाने के लिए आवश्यक हैं।
+
+`Request` के बारे में अधिक जानने के लिए [Requests के बारे में Starlette के docs](https://www.starlette.dev/requests/) देखें।
+
+///
+
+`GzipRequest.get_route_handler` द्वारा return किए गए function का केवल एक अलग काम है: `Request` को `GzipRequest` में convert करना।
+
+ऐसा करने से, हमारा `GzipRequest` data को हमारे *path operations* तक पास करने से पहले decompress करने का ध्यान रखेगा (अगर आवश्यक हो)।
+
+उसके बाद, processing logic सब वही रहता है।
+
+लेकिन `GzipRequest.body` में हमारे बदलावों की वजह से, request body जरूरत पड़ने पर **FastAPI** द्वारा load किए जाने पर automatically decompress हो जाएगी।
+
+## Exception handler में request body तक पहुँचना { #accessing-the-request-body-in-an-exception-handler }
+
+/// tip | सुझाव
+
+इसी समस्या को हल करने के लिए, `RequestValidationError` के custom handler में `body` का उपयोग करना शायद बहुत आसान है ([Errors संभालना](../tutorial/handling-errors.md#use-the-requestvalidationerror-body))।
+
+लेकिन यह उदाहरण अभी भी valid है और यह दिखाता है कि internal components के साथ कैसे interact करें।
+
+///
+
+हम इसी approach का उपयोग exception handler में request body तक पहुँचने के लिए भी कर सकते हैं।
+
+हमें बस request को `try`/`except` block के अंदर संभालना है:
+
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[14,16] *}
+
+अगर कोई exception होता है, तो `Request` instance अभी भी scope में होगी, इसलिए error संभालते समय हम request body को पढ़ सकते हैं और उसका उपयोग कर सकते हैं:
+
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[17:19] *}
+
+## Router में custom `APIRoute` class { #custom-apiroute-class-in-a-router }
+
+आप `APIRouter` का `route_class` parameter भी set कर सकते हैं:
+
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[26] *}
+
+इस उदाहरण में, `router` के अंतर्गत *path operations* custom `TimedRoute` class का उपयोग करेंगे, और response में एक अतिरिक्त `X-Response-Time` header होगा जिसमें response generate करने में लगा समय होगा:
+
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[13:20] *}
diff --git a/docs/hi/docs/how-to/extending-openapi.md b/docs/hi/docs/how-to/extending-openapi.md
new file mode 100644
index 000000000..f3bebfa66
--- /dev/null
+++ b/docs/hi/docs/how-to/extending-openapi.md
@@ -0,0 +1,88 @@
+# OpenAPI को विस्तारित करना { #extending-openapi }
+
+कुछ मामलों में आपको generated OpenAPI schema को संशोधित करने की ज़रूरत हो सकती है।
+
+इस section में आप देखेंगे कि कैसे।
+
+## सामान्य process { #the-normal-process }
+
+सामान्य (default) process इस प्रकार है।
+
+एक `FastAPI` application (instance) में एक `.openapi()` method होता है, जिससे OpenAPI schema return करने की अपेक्षा की जाती है।
+
+application object बनाने के हिस्से के रूप में, `/openapi.json` के लिए (या आपने अपने `openapi_url` में जो भी set किया है उसके लिए) एक *path operation* registered होता है।
+
+यह बस application के `.openapi()` method के result के साथ एक JSON response return करता है।
+
+Default रूप से, method `.openapi()` जो करता है वह यह है कि property `.openapi_schema` को check करता है कि उसमें contents हैं या नहीं, और उन्हें return करता है।
+
+अगर नहीं हैं, तो यह उन्हें `fastapi.openapi.utils.get_openapi` में utility function का उपयोग करके generate करता है।
+
+और वह function `get_openapi()` parameters के रूप में ये प्राप्त करता है:
+
+* `title`: OpenAPI title, जो docs में दिखाया जाता है।
+* `version`: आपके API का version, जैसे `2.5.0`।
+* `openapi_version`: उपयोग की गई OpenAPI specification का version। Default रूप से, latest: `3.1.0`।
+* `summary`: API का एक छोटा summary।
+* `description`: आपके API का description, इसमें markdown शामिल हो सकता है और यह docs में दिखाया जाएगा।
+* `routes`: application से routes, जो `app.routes` से लिए जाते हैं। FastAPI इन्हें registered *path operations* collect करने के लिए उपयोग करता है, जिनमें included routers से आने वाले भी शामिल हैं।
+
+/// tip | तकनीकी विवरण
+
+`app.routes` एक lower-level route tree है। इसमें route candidates शामिल हो सकते हैं जिन्हें FastAPI internally included routers के लिए उपयोग करता है, केवल final `APIRoute` objects ही नहीं।
+
+आप फिर भी `app.routes` को `get_openapi()` में pass कर सकते हैं। FastAPI effective path operations collect करने के लिए उस route tree को traverse करेगा।
+
+///
+
+/// note | नोट
+
+parameter `summary` OpenAPI 3.1.0 और उससे ऊपर में उपलब्ध है, जिसे FastAPI 0.99.0 और उससे ऊपर support करता है।
+
+///
+
+## Defaults को override करना { #overriding-the-defaults }
+
+ऊपर दी गई जानकारी का उपयोग करके, आप OpenAPI schema generate करने और अपनी ज़रूरत के अनुसार प्रत्येक हिस्से को override करने के लिए उसी utility function का उपयोग कर सकते हैं।
+
+उदाहरण के लिए, आइए [custom logo शामिल करने के लिए ReDoc का OpenAPI extension](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo) जोड़ें।
+
+### सामान्य **FastAPI** { #normal-fastapi }
+
+सबसे पहले, अपनी पूरी **FastAPI** application सामान्य रूप से लिखें:
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[1,4,7:9] *}
+
+### OpenAPI schema generate करें { #generate-the-openapi-schema }
+
+फिर, `custom_openapi()` function के अंदर, OpenAPI schema generate करने के लिए उसी utility function का उपयोग करें:
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[2,15:21] *}
+
+### OpenAPI schema को संशोधित करें { #modify-the-openapi-schema }
+
+अब आप OpenAPI schema में `info` "object" में custom `x-logo` जोड़कर ReDoc extension जोड़ सकते हैं:
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[22:24] *}
+
+### OpenAPI schema को cache करें { #cache-the-openapi-schema }
+
+आप अपनी generated schema store करने के लिए property `.openapi_schema` को "cache" के रूप में उपयोग कर सकते हैं।
+
+इस तरह, जब भी कोई user आपके API docs खोलेगा, आपकी application को हर बार schema generate नहीं करना पड़ेगा।
+
+यह केवल एक बार generate होगा, और फिर अगली requests के लिए वही cached schema उपयोग किया जाएगा।
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[13:14,25:26] *}
+
+### Method को override करें { #override-the-method }
+
+अब आप `.openapi()` method को अपने नए function से replace कर सकते हैं।
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[29] *}
+
+### इसे check करें { #check-it }
+
+जब आप [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर जाएंगे, तो आप देखेंगे कि आप अपना custom logo उपयोग कर रहे हैं (इस उदाहरण में, **FastAPI** का logo):
+
+
diff --git a/docs/hi/docs/how-to/general.md b/docs/hi/docs/how-to/general.md
new file mode 100644
index 000000000..95c8bb653
--- /dev/null
+++ b/docs/hi/docs/how-to/general.md
@@ -0,0 +1,43 @@
+# सामान्य - How To - Recipes { #general-how-to-recipes }
+
+सामान्य या अक्सर पूछे जाने वाले प्रश्नों के लिए, docs में अन्य जगहों के कई pointers यहाँ दिए गए हैं।
+
+## Data फ़िल्टर करें - सुरक्षा { #filter-data-security }
+
+यह सुनिश्चित करने के लिए कि आप जितना data लौटाना चाहिए उससे अधिक न लौटाएँ, [Tutorial - Response Model - Return Type](../tutorial/response-model.md) के docs पढ़ें।
+
+## Response Performance को optimize करें - Response Model - Return Type { #optimize-response-performance-response-model-return-type }
+
+JSON data लौटाते समय performance को optimize करने के लिए, return type या response model का उपयोग करें, इस तरह Pydantic JSON में serialization को Rust side पर संभालेगा, Python से गुज़रे बिना। अधिक पढ़ें [Tutorial - Response Model - Return Type](../tutorial/response-model.md) के docs में।
+
+## Documentation Tags - OpenAPI { #documentation-tags-openapi }
+
+अपने *path operations* में tags जोड़ने और उन्हें docs UI में group करने के लिए, [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags) के docs पढ़ें।
+
+## Documentation Summary और Description - OpenAPI { #documentation-summary-and-description-openapi }
+
+अपने *path operations* में summary और description जोड़ने, और उन्हें docs UI में दिखाने के लिए, [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description) के docs पढ़ें।
+
+## Documentation Response description - OpenAPI { #documentation-response-description-openapi }
+
+response का description define करने के लिए, जो docs UI में दिखाया जाता है, [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description) के docs पढ़ें।
+
+## Documentation में *Path Operation* को Deprecate करें - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
+
+किसी *path operation* को deprecate करने और उसे docs UI में दिखाने के लिए, [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation) के docs पढ़ें।
+
+## किसी भी Data को JSON-compatible में convert करें { #convert-any-data-to-json-compatible }
+
+किसी भी data को JSON-compatible में convert करने के लिए, [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md) के docs पढ़ें।
+
+## OpenAPI Metadata - Docs { #openapi-metadata-docs }
+
+अपने OpenAPI schema में metadata जोड़ने के लिए, जिसमें license, version, contact, आदि शामिल हैं, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md) के docs पढ़ें।
+
+## OpenAPI Custom URL { #openapi-custom-url }
+
+OpenAPI URL को customize करने (या हटाने) के लिए, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url) के docs पढ़ें।
+
+## OpenAPI Docs URLs { #openapi-docs-urls }
+
+अपने-आप generate किए गए docs user interfaces के लिए उपयोग किए जाने वाले URLs को update करने के लिए, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls) के docs पढ़ें।
diff --git a/docs/hi/docs/how-to/graphql.md b/docs/hi/docs/how-to/graphql.md
new file mode 100644
index 000000000..7a8fbdb3d
--- /dev/null
+++ b/docs/hi/docs/how-to/graphql.md
@@ -0,0 +1,60 @@
+# GraphQL { #graphql }
+
+क्योंकि **FastAPI** **ASGI** standard पर आधारित है, इसलिए ASGI के साथ compatible किसी भी **GraphQL** library को integrate करना बहुत आसान है।
+
+आप उसी application में सामान्य FastAPI *path operations* को GraphQL के साथ combine कर सकते हैं।
+
+/// tip | सुझाव
+
+**GraphQL** कुछ बहुत specific use cases को solve करता है।
+
+Common **web APIs** की तुलना में इसके **advantages** और **disadvantages** हैं।
+
+सुनिश्चित करें कि आप evaluate करें कि आपके use case के लिए **benefits**, **drawbacks** की भरपाई करते हैं या नहीं। 🤓
+
+///
+
+## GraphQL Libraries { #graphql-libraries }
+
+यहाँ कुछ **GraphQL** libraries हैं जिनमें **ASGI** support है। आप उन्हें **FastAPI** के साथ उपयोग कर सकते हैं:
+
+* [Strawberry](https://strawberry.rocks/) 🍓
+ * [FastAPI के लिए docs](https://strawberry.rocks/docs/integrations/fastapi) के साथ
+* [Ariadne](https://ariadnegraphql.org/)
+ * [FastAPI के लिए docs](https://ariadnegraphql.org/docs/fastapi-integration) के साथ
+* [Tartiflette](https://tartiflette.io/)
+ * ASGI integration प्रदान करने के लिए [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) के साथ
+* [Graphene](https://graphene-python.org/)
+ * [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3) के साथ
+
+## Strawberry के साथ GraphQL { #graphql-with-strawberry }
+
+यदि आपको **GraphQL** के साथ काम करने की ज़रूरत है या आप करना चाहते हैं, तो [**Strawberry**](https://strawberry.rocks/) **recommended** library है क्योंकि इसका design **FastAPI** के design के सबसे करीब है, यह पूरी तरह **type annotations** पर आधारित है।
+
+आपके use case के आधार पर, आप कोई अलग library उपयोग करना पसंद कर सकते हैं, लेकिन अगर आप मुझसे पूछें, तो मैं शायद सुझाव दूँगा कि आप **Strawberry** आज़माएँ।
+
+यहाँ एक छोटा preview है कि आप Strawberry को FastAPI के साथ कैसे integrate कर सकते हैं:
+
+{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
+
+आप [Strawberry documentation](https://strawberry.rocks/) में Strawberry के बारे में और जान सकते हैं।
+
+और [FastAPI के साथ Strawberry](https://strawberry.rocks/docs/integrations/fastapi) के बारे में docs भी।
+
+## Starlette से पुराना `GraphQLApp` { #older-graphqlapp-from-starlette }
+
+Starlette के पिछले versions में [Graphene](https://graphene-python.org/) के साथ integrate करने के लिए एक `GraphQLApp` class शामिल थी।
+
+इसे Starlette से deprecated कर दिया गया था, लेकिन यदि आपके पास ऐसा code है जो इसका उपयोग करता था, तो आप आसानी से [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3) पर **migrate** कर सकते हैं, जो वही use case cover करता है और जिसका **लगभग identical interface** है।
+
+/// tip | सुझाव
+
+यदि आपको GraphQL की ज़रूरत है, तो मैं फिर भी recommend करूँगा कि आप [Strawberry](https://strawberry.rocks/) देखें, क्योंकि यह custom classes और types की बजाय type annotations पर आधारित है।
+
+///
+
+## और जानें { #learn-more }
+
+आप [official GraphQL documentation](https://graphql.org/) में **GraphQL** के बारे में और जान सकते हैं।
+
+आप ऊपर वर्णित उन libraries में से प्रत्येक के बारे में उनके links में और भी पढ़ सकते हैं।
diff --git a/docs/hi/docs/how-to/index.md b/docs/hi/docs/how-to/index.md
new file mode 100644
index 000000000..c42c2dd0c
--- /dev/null
+++ b/docs/hi/docs/how-to/index.md
@@ -0,0 +1,13 @@
+# कैसे करें - रेसिपी { #how-to-recipes }
+
+यहाँ आप **कई topics** के लिए अलग-अलग recipes या "how to" guides देखेंगे।
+
+इनमें से ज़्यादातर ideas कमोबेश **स्वतंत्र** होंगे, और ज़्यादातर मामलों में आपको इन्हें केवल तभी पढ़ने की ज़रूरत होगी जब वे सीधे **आपके project** पर लागू होते हों।
+
+अगर कुछ आपके project के लिए रोचक और उपयोगी लगता है, तो आगे बढ़कर उसे देखें, लेकिन नहीं तो आप शायद उन्हें छोड़ सकते हैं।
+
+/// tip | सुझाव
+
+अगर आप **FastAPI सीखना** structured तरीके से चाहते हैं (recommended), तो इसके बजाय [ट्यूटोरियल - यूज़र गाइड](../tutorial/index.md) को अध्याय-दर-अध्याय पढ़ें।
+
+///
diff --git a/docs/hi/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md b/docs/hi/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
new file mode 100644
index 000000000..68bc07e30
--- /dev/null
+++ b/docs/hi/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
@@ -0,0 +1,153 @@
+# Pydantic v1 से Pydantic v2 में माइग्रेट करें { #migrate-from-pydantic-v1-to-pydantic-v2 }
+
+अगर आपके पास कोई पुराना FastAPI app है, तो हो सकता है कि आप Pydantic version 1 का उपयोग कर रहे हों।
+
+FastAPI version 0.100.0 में Pydantic v1 या v2, दोनों में से किसी के लिए support था। यह वही उपयोग करता था जो आपने install किया हुआ था।
+
+FastAPI version 0.119.0 ने Pydantic v2 के अंदर से Pydantic v1 के लिए आंशिक support पेश किया (`pydantic.v1` के रूप में), ताकि v2 में migration आसान हो सके।
+
+FastAPI 0.126.0 ने Pydantic v1 के लिए support हटा दिया, लेकिन थोड़े समय के लिए `pydantic.v1` को support करना जारी रखा।
+
+FastAPI 0.128.0 ने `pydantic.v1` के लिए support भी हटा दिया, इसलिए FastAPI के नवीनतम versions के लिए Pydantic v2 required है।
+
+/// warning | चेतावनी
+
+Pydantic team ने **Python 3.14** से शुरू करते हुए, Python के नवीनतम versions के लिए Pydantic v1 का support बंद कर दिया।
+
+इसमें `pydantic.v1` भी शामिल है, जो अब Python 3.14 और उससे ऊपर में supported नहीं है।
+
+अगर आप Python की नवीनतम features का उपयोग करना चाहते हैं, तो आपको यह सुनिश्चित करना होगा कि आप Pydantic v2 का उपयोग करें।
+
+///
+
+अगर आपके पास Pydantic v1 वाला कोई पुराना FastAPI app है, तो यहाँ मैं आपको दिखाऊँगा कि उसे Pydantic v2 में कैसे migrate करें, और gradual migration में मदद के लिए **FastAPI 0.119.0 की features** भी दिखाऊँगा।
+
+## आधिकारिक गाइड { #official-guide }
+
+Pydantic के पास v1 से v2 के लिए एक आधिकारिक [Migration Guide](https://docs.pydantic.dev/latest/migration/) है।
+
+इसमें यह भी शामिल है कि क्या बदला है, validations अब कैसे अधिक सही और strict हैं, संभावित caveats आदि।
+
+क्या बदला है इसे बेहतर समझने के लिए आप इसे पढ़ सकते हैं।
+
+## Tests { #tests }
+
+सुनिश्चित करें कि आपके app के लिए [tests](../tutorial/testing.md) हैं और आप उन्हें continuous integration (CI) पर चलाते हैं।
+
+इस तरह, आप upgrade कर सकते हैं और सुनिश्चित कर सकते हैं कि सब कुछ अभी भी अपेक्षा के अनुसार काम कर रहा है।
+
+## `bump-pydantic` { #bump-pydantic }
+
+कई मामलों में, जब आप customizations के बिना regular Pydantic models का उपयोग करते हैं, तो आप Pydantic v1 से Pydantic v2 में migration की अधिकांश प्रक्रिया automate कर पाएँगे।
+
+आप उसी Pydantic team का [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) उपयोग कर सकते हैं।
+
+यह tool आपको उस अधिकांश code को अपने आप बदलने में मदद करेगा जिसे बदलने की ज़रूरत है।
+
+इसके बाद, आप tests चला सकते हैं और जाँच सकते हैं कि सब कुछ काम करता है या नहीं। अगर करता है, तो आपका काम हो गया। 😎
+
+## v2 में Pydantic v1 { #pydantic-v1-in-v2 }
+
+Pydantic v2 में Pydantic v1 की सभी चीज़ें `pydantic.v1` submodule के रूप में शामिल हैं। लेकिन यह Python 3.13 से ऊपर के versions में अब supported नहीं है।
+
+इसका मतलब है कि आप Pydantic v2 का नवीनतम version install कर सकते हैं और इस submodule से पुराने Pydantic v1 components को import और उपयोग कर सकते हैं, जैसे कि आपके पास पुराना Pydantic v1 install हो।
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial001_an_py310.py hl[1,4] *}
+
+### v2 में Pydantic v1 के लिए FastAPI support { #fastapi-support-for-pydantic-v1-in-v2 }
+
+/// warning | चेतावनी
+
+`pydantic.v1` models के लिए यह FastAPI support **FastAPI 0.119.0** में जोड़ा गया था और **FastAPI 0.128.0** में हटा दिया गया। इसका उद्देश्य Pydantic v2 में migration के लिए अस्थायी सहायता होना था।
+
+FastAPI के वर्तमान versions में, अपने app में `pydantic.v1` model का उपयोग करने पर error आएगा।
+
+इस section का बाकी हिस्सा केवल उन पुराने versions में उपलब्ध अस्थायी support का वर्णन करता है।
+
+///
+
+FastAPI 0.119.0 से, Pydantic v2 के अंदर से Pydantic v1 के लिए आंशिक support भी है, ताकि v2 में migration आसान हो सके।
+
+इसलिए, आप Pydantic को नवीनतम version 2 में upgrade कर सकते थे, और imports को `pydantic.v1` submodule का उपयोग करने के लिए बदल सकते थे, और कई मामलों में यह बस काम कर जाता।
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial002_an_py310.py hl[2,5,15] *}
+
+/// warning | चेतावनी
+
+ध्यान रखें कि Pydantic team अब Python के हाल के versions में Pydantic v1 को support नहीं करती, Python 3.14 से शुरू करते हुए, इसलिए `pydantic.v1` का उपयोग भी Python 3.14 और उससे ऊपर में supported नहीं है।
+
+///
+
+### एक ही app में Pydantic v1 और v2 { #pydantic-v1-and-v2-on-the-same-app }
+
+Pydantic द्वारा यह **supported नहीं है** कि Pydantic v2 का कोई model हो जिसके अपने fields Pydantic v1 models के रूप में defined हों, या इसका उल्टा।
+
+```mermaid
+graph TB
+ subgraph "❌ Not Supported"
+ direction TB
+ subgraph V2["Pydantic v2 Model"]
+ V1Field["Pydantic v1 Model"]
+ end
+ subgraph V1["Pydantic v1 Model"]
+ V2Field["Pydantic v2 Model"]
+ end
+ end
+
+ style V2 fill:#f9fff3
+ style V1 fill:#fff6f0
+ style V1Field fill:#fff6f0
+ style V2Field fill:#f9fff3
+```
+
+...लेकिन आपके पास एक ही app में अलग-अलग models हो सकते हैं, कुछ Pydantic v1 का उपयोग करते हुए और कुछ Pydantic v2 का उपयोग करते हुए।
+
+```mermaid
+graph TB
+ subgraph "✅ Supported"
+ direction TB
+ subgraph V2["Pydantic v2 Model"]
+ V2Field["Pydantic v2 Model"]
+ end
+ subgraph V1["Pydantic v1 Model"]
+ V1Field["Pydantic v1 Model"]
+ end
+ end
+
+ style V2 fill:#f9fff3
+ style V1 fill:#fff6f0
+ style V1Field fill:#fff6f0
+ style V2Field fill:#f9fff3
+```
+
+कुछ मामलों में, आपके FastAPI app में एक ही **path operation** में Pydantic v1 और v2 दोनों models होना भी संभव है:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
+
+ऊपर दिए गए इस उदाहरण में, input model एक Pydantic v1 model है, और output model (`response_model=ItemV2` में defined) एक Pydantic v2 model है।
+
+### Pydantic v1 parameters { #pydantic-v1-parameters }
+
+अगर आपको Pydantic v1 models के साथ parameters के लिए FastAPI-specific tools जैसे `Body`, `Query`, `Form` आदि का उपयोग करना है, तो Pydantic v2 में migration पूरा करते समय आप उन्हें `fastapi.temp_pydantic_v1_params` से import कर सकते हैं:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial004_an_py310.py hl[4,18] *}
+
+### चरणों में माइग्रेट करें { #migrate-in-steps }
+
+/// warning | चेतावनी
+
+नीचे वर्णित, एक ही app में Pydantic v1 और v2 दोनों models का उपयोग करके gradual migration केवल **FastAPI 0.119.0 से 0.127.x** में काम करता है। इसे **FastAPI 0.128.0** में हटा दिया गया, नवीनतम versions के लिए **Pydantic v2** models required हैं।
+
+///
+
+/// tip | सुझाव
+
+पहले `bump-pydantic` के साथ कोशिश करें, अगर आपके tests pass हो जाते हैं और वह काम करता है, तो आपका काम एक command में हो गया। ✨
+
+///
+
+अगर `bump-pydantic` आपके use case के लिए काम नहीं करता, तो आप Pydantic v2 में gradual migration करने के लिए एक ही app में Pydantic v1 और v2 दोनों models के support का उपयोग कर सकते हैं।
+
+आप पहले Pydantic को नवीनतम version 2 का उपयोग करने के लिए upgrade कर सकते हैं, और अपने सभी models के लिए `pydantic.v1` का उपयोग करने के लिए imports बदल सकते हैं।
+
+फिर, आप gradual steps में, groups के रूप में अपने models को Pydantic v1 से v2 में migrate करना शुरू कर सकते हैं। 🚶
diff --git a/docs/hi/docs/how-to/separate-openapi-schemas.md b/docs/hi/docs/how-to/separate-openapi-schemas.md
new file mode 100644
index 000000000..c5d2b17a0
--- /dev/null
+++ b/docs/hi/docs/how-to/separate-openapi-schemas.md
@@ -0,0 +1,102 @@
+# Input और Output के लिए अलग OpenAPI Schemas या नहीं { #separate-openapi-schemas-for-input-and-output-or-not }
+
+जबसे **Pydantic v2** रिलीज़ हुआ है, generated OpenAPI पहले की तुलना में थोड़ा अधिक सटीक और **सही** है। 😎
+
+वास्तव में, कुछ मामलों में, एक ही Pydantic model के लिए OpenAPI में **दो JSON Schemas** भी होंगे, input और output के लिए, इस पर निर्भर करते हुए कि उनमें **default values** हैं या नहीं।
+
+आइए देखते हैं कि यह कैसे काम करता है और अगर आपको ज़रूरत हो तो इसे कैसे बदलना है।
+
+## Input और Output के लिए Pydantic Models { #pydantic-models-for-input-and-output }
+
+मान लीजिए आपके पास default values वाला एक Pydantic model है, जैसे यह:
+
+{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:7] hl[7] *}
+
+### Input के लिए Model { #model-for-input }
+
+अगर आप इस model को यहाँ की तरह input के रूप में उपयोग करते हैं:
+
+{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:15] hl[14] *}
+
+...तो `description` field **required नहीं होगा**। क्योंकि इसका default value `None` है।
+
+### Docs में Input Model { #input-model-in-docs }
+
+आप docs में इसकी पुष्टि कर सकते हैं, `description` field के पास **लाल asterisk** नहीं है, इसे required के रूप में mark नहीं किया गया है:
+
+
+
+
+
+
+
+
+वही file structure comments के साथ:
+
+```bash
+.
+├── app # "app" एक Python package है
+│ ├── __init__.py # यह file "app" को "Python package" बनाती है
+│ ├── main.py # "main" module, जैसे import app.main
+│ ├── dependencies.py # "dependencies" module, जैसे import app.dependencies
+│ └── routers # "routers" एक "Python subpackage" है
+│ │ ├── __init__.py # "routers" को "Python subpackage" बनाता है
+│ │ ├── items.py # "items" submodule, जैसे import app.routers.items
+│ │ └── users.py # "users" submodule, जैसे import app.routers.users
+│ └── internal # "internal" एक "Python subpackage" है
+│ ├── __init__.py # "internal" को "Python subpackage" बनाता है
+│ └── admin.py # "admin" submodule, जैसे import app.internal.admin
+```
+
+## `APIRouter` { #apirouter }
+
+मान लीजिए सिर्फ users को handle करने के लिए dedicated file `/app/routers/users.py` पर submodule है।
+
+आप अपने users से संबंधित *path operations* को बाकी code से अलग रखना चाहते हैं, ताकि यह व्यवस्थित रहे।
+
+लेकिन यह अभी भी उसी **FastAPI** application/web API का हिस्सा है (यह उसी "Python Package" का हिस्सा है)।
+
+आप उस module के लिए *path operations* `APIRouter` का उपयोग करके बना सकते हैं।
+
+### `APIRouter` import करें { #import-apirouter }
+
+आप इसे import करते हैं और उसी तरह एक "instance" बनाते हैं जैसे आप `FastAPI` class के साथ करते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/users.py hl[1,3] title["app/routers/users.py"] *}
+
+### `APIRouter` के साथ *Path operations* { #path-operations-with-apirouter }
+
+और फिर आप इसका उपयोग अपने *path operations* declare करने के लिए करते हैं।
+
+इसे उसी तरह उपयोग करें जैसे आप `FastAPI` class का उपयोग करते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
+
+आप `APIRouter` को एक "mini `FastAPI`" class की तरह सोच सकते हैं।
+
+सभी वही options समर्थित हैं।
+
+सभी वही `parameters`, `responses`, `dependencies`, `tags`, आदि।
+
+/// tip | टिप
+
+इस उदाहरण में, variable को `router` कहा गया है, लेकिन आप इसे अपनी इच्छा अनुसार कोई भी नाम दे सकते हैं।
+
+///
+
+हम इस `APIRouter` को main `FastAPI` app में शामिल करने जा रहे हैं, लेकिन पहले, dependencies और एक और `APIRouter` देखें।
+
+## Dependencies { #dependencies }
+
+हम देखते हैं कि हमें application के कई स्थानों पर उपयोग होने वाली कुछ dependencies की ज़रूरत होगी।
+
+इसलिए हम उन्हें उनके अपने `dependencies` module (`app/dependencies.py`) में रखते हैं।
+
+अब हम एक custom `X-Token` header पढ़ने के लिए एक सरल dependency का उपयोग करेंगे:
+
+{* ../../docs_src/bigger_applications/app_an_py310/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
+
+/// tip | टिप
+
+हम इस उदाहरण को सरल बनाने के लिए एक काल्पनिक header का उपयोग कर रहे हैं।
+
+लेकिन वास्तविक मामलों में आपको integrated [Security utilities](security/index.md) का उपयोग करके बेहतर परिणाम मिलेंगे।
+
+///
+
+## `APIRouter` के साथ एक और module { #another-module-with-apirouter }
+
+मान लीजिए आपके application से "items" को handle करने के लिए dedicated endpoints भी `app/routers/items.py` module में हैं।
+
+आपके पास इनके लिए *path operations* हैं:
+
+* `/items/`
+* `/items/{item_id}`
+
+यह सब `app/routers/users.py` जैसी ही structure है।
+
+लेकिन हम थोड़े अधिक smart होना चाहते हैं और code को थोड़ा simplify करना चाहते हैं।
+
+हम जानते हैं कि इस module के सभी *path operations* में वही हैं:
+
+* Path `prefix`: `/items`.
+* `tags`: (सिर्फ एक tag: `items`).
+* अतिरिक्त `responses`.
+* `dependencies`: उन सभी को वह `X-Token` dependency चाहिए जो हमने बनाई है।
+
+इसलिए, यह सब प्रत्येक *path operation* में जोड़ने के बजाय, हम इसे `APIRouter` में जोड़ सकते हैं।
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
+
+क्योंकि प्रत्येक *path operation* का path `/` से शुरू होना चाहिए, जैसे:
+
+```Python hl_lines="1"
+@router.get("/{item_id}")
+async def read_item(item_id: str):
+ ...
+```
+
+...prefix में अंत में `/` शामिल नहीं होना चाहिए।
+
+इसलिए, इस मामले में prefix `/items` है।
+
+हम `tags` की list और अतिरिक्त `responses` भी जोड़ सकते हैं जो इस router में शामिल सभी *path operations* पर लागू होंगे।
+
+और हम `dependencies` की list जोड़ सकते हैं जो router के सभी *path operations* में जोड़ी जाएगी और उन पर किए गए हर request के लिए execute/solve की जाएगी।
+
+/// tip | टिप
+
+ध्यान दें कि, [*path operation decorators* में dependencies](dependencies/dependencies-in-path-operation-decorators.md) की तरह ही, आपके *path operation function* को कोई value pass नहीं की जाएगी।
+
+///
+
+अंतिम परिणाम यह है कि item paths अब ये हैं:
+
+* `/items/`
+* `/items/{item_id}`
+
+...जैसा हमने चाहा था।
+
+* उन्हें tags की list से mark किया जाएगा जिसमें एक ही string `"items"` होगी।
+ * ये "tags" automatic interactive documentation systems (OpenAPI का उपयोग करते हुए) के लिए विशेष रूप से उपयोगी हैं।
+* उन सभी में predefined `responses` शामिल होंगे।
+* इन सभी *path operations* से पहले `dependencies` की list evaluate/execute की जाएगी।
+ * अगर आप किसी specific *path operation* में भी dependencies declare करते हैं, **तो वे भी execute होंगी**।
+ * router dependencies पहले execute होती हैं, फिर decorator में [`dependencies`](dependencies/dependencies-in-path-operation-decorators.md), और फिर normal parameter dependencies।
+ * आप [`Security` dependencies with `scopes`](../advanced/security/oauth2-scopes.md) भी जोड़ सकते हैं।
+
+/// tip | टिप
+
+`APIRouter` में `dependencies` होने का उपयोग, उदाहरण के लिए, *path operations* के पूरे group के लिए authentication require करने के लिए किया जा सकता है। भले ही dependencies उनमें से हर एक में individually न जोड़ी गई हों।
+
+///
+
+/// tip | टिप
+
+`prefix`, `tags`, `responses`, और `dependencies` parameters (कई अन्य मामलों की तरह) **FastAPI** की एक feature हैं जो आपको code duplication से बचने में मदद करती है।
+
+///
+
+### dependencies import करें { #import-the-dependencies }
+
+यह code `app.routers.items` module, file `app/routers/items.py` में रहता है।
+
+और हमें dependency function `app.dependencies` module, file `app/dependencies.py` से लेनी है।
+
+इसलिए हम dependencies के लिए `..` के साथ relative import का उपयोग करते हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[3] title["app/routers/items.py"] *}
+
+#### Relative imports कैसे काम करते हैं { #how-relative-imports-work }
+
+/// tip | टिप
+
+अगर आप पूरी तरह जानते हैं कि imports कैसे काम करते हैं, तो नीचे वाले अगले section पर जाएँ।
+
+///
+
+एक single dot `.`, जैसे:
+
+```Python
+from .dependencies import get_token_header
+```
+
+का मतलब होगा:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* module `dependencies` ढूँढना (`app/routers/dependencies.py` पर एक काल्पनिक file)...
+* और उससे, function `get_token_header` import करना।
+
+लेकिन वह file मौजूद नहीं है, हमारी dependencies `app/dependencies.py` पर एक file में हैं।
+
+याद रखें कि हमारी app/file structure कैसी दिखती है:
+
+
+
+---
+
+दो dots `..`, जैसे:
+
+```Python
+from ..dependencies import get_token_header
+```
+
+का मतलब है:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* parent package (directory `app/`) पर जाना...
+* और वहाँ, module `dependencies` ढूँढना (file `app/dependencies.py` पर)...
+* और उससे, function `get_token_header` import करना।
+
+यह सही तरीके से काम करता है! 🎉
+
+---
+
+उसी तरह, अगर हमने तीन dots `...` का उपयोग किया होता, जैसे:
+
+```Python
+from ...dependencies import get_token_header
+```
+
+तो उसका मतलब होगा:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/routers/items.py`) रहता है (directory `app/routers/`)...
+* parent package (directory `app/`) पर जाना...
+* फिर उस package के parent पर जाना (कोई parent package नहीं है, `app` top level है 😱)...
+* और वहाँ, module `dependencies` ढूँढना (file `app/dependencies.py` पर)...
+* और उससे, function `get_token_header` import करना।
+
+यह `app/` के ऊपर किसी package को refer करेगा, जिसकी अपनी file `__init__.py` आदि होगी। लेकिन हमारे पास वह नहीं है। इसलिए, हमारे उदाहरण में इससे error आएगा। 🚨
+
+लेकिन अब आप जानते हैं कि यह कैसे काम करता है, इसलिए आप अपने apps में relative imports का उपयोग कर सकते हैं, चाहे वे कितने भी complex हों। 🤓
+
+### कुछ custom `tags`, `responses`, और `dependencies` जोड़ें { #add-some-custom-tags-responses-and-dependencies }
+
+हम प्रत्येक *path operation* में prefix `/items` या `tags=["items"]` नहीं जोड़ रहे हैं क्योंकि हमने उन्हें `APIRouter` में जोड़ दिया है।
+
+लेकिन हम अभी भी _अधिक_ `tags` जोड़ सकते हैं जो किसी specific *path operation* पर लागू होंगे, और उस *path operation* के लिए specific कुछ अतिरिक्त `responses` भी:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[30:31] title["app/routers/items.py"] *}
+
+/// tip | टिप
+
+इस आखिरी path operation में tags का combination होगा: `["items", "custom"]`।
+
+और documentation में इसके दोनों responses भी होंगे, एक `404` के लिए और एक `403` के लिए।
+
+///
+
+## मुख्य `FastAPI` { #the-main-fastapi }
+
+अब, `app/main.py` पर module देखें।
+
+यहीं आप `FastAPI` class import और use करते हैं।
+
+यह आपके application की main file होगी जो सब कुछ एक साथ जोड़ती है।
+
+और क्योंकि आपका अधिकतर logic अब अपने-अपने specific module में रहेगा, main file काफी सरल होगी।
+
+### `FastAPI` import करें { #import-fastapi }
+
+आप सामान्य रूप से `FastAPI` class import और create करते हैं।
+
+और हम [global dependencies](dependencies/global-dependencies.md) भी declare कर सकते हैं जिन्हें प्रत्येक `APIRouter` के लिए dependencies के साथ combine किया जाएगा:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[1,3,7] title["app/main.py"] *}
+
+### `APIRouter` import करें { #import-the-apirouter }
+
+अब हम उन अन्य submodules को import करते हैं जिनके पास `APIRouter`s हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[4:5] title["app/main.py"] *}
+
+क्योंकि files `app/routers/users.py` और `app/routers/items.py` ऐसे submodules हैं जो उसी Python package `app` का हिस्सा हैं, हम "relative imports" का उपयोग करके उन्हें import करने के लिए single dot `.` का उपयोग कर सकते हैं।
+
+### importing कैसे काम करता है { #how-the-importing-works }
+
+section:
+
+```Python
+from .routers import items, users
+```
+
+का मतलब है:
+
+* उसी package से शुरू करना जिसमें यह module (file `app/main.py`) रहता है (directory `app/`)...
+* subpackage `routers` ढूँढना (directory `app/routers/` पर)...
+* और उससे, submodule `items` (file `app/routers/items.py` पर) और `users` (file `app/routers/users.py` पर) import करना...
+
+module `items` में एक variable `router` (`items.router`) होगा। यह वही है जो हमने file `app/routers/items.py` में बनाया था, यह एक `APIRouter` object है।
+
+और फिर हम module `users` के लिए भी वही करते हैं।
+
+हम उन्हें इस तरह भी import कर सकते थे:
+
+```Python
+from app.routers import items, users
+```
+
+/// note | नोट
+
+पहला version एक "relative import" है:
+
+```Python
+from .routers import items, users
+```
+
+दूसरा version एक "absolute import" है:
+
+```Python
+from app.routers import items, users
+```
+
+Python Packages और Modules के बारे में अधिक जानने के लिए, [Modules के बारे में official Python documentation](https://docs.python.org/3/tutorial/modules.html) पढ़ें।
+
+///
+
+### नामों के collisions से बचें { #avoid-name-collisions }
+
+हम submodule `items` को directly import कर रहे हैं, केवल उसके variable `router` को import करने के बजाय।
+
+ऐसा इसलिए है क्योंकि हमारे पास submodule `users` में भी `router` नाम का एक और variable है।
+
+अगर हमने एक के बाद एक import किया होता, जैसे:
+
+```Python
+from .routers.items import router
+from .routers.users import router
+```
+
+तो `users` का `router`, `items` वाले को overwrite कर देता और हम उन्हें एक ही समय में use नहीं कर पाते।
+
+इसलिए, उन्हें एक ही file में दोनों को use करने में सक्षम होने के लिए, हम submodules को directly import करते हैं:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[5] title["app/main.py"] *}
+
+### `users` और `items` के लिए `APIRouter`s include करें { #include-the-apirouters-for-users-and-items }
+
+अब, submodules `users` और `items` से `router`s include करें:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[10:11] title["app/main.py"] *}
+
+/// note | नोट
+
+`users.router` file `app/routers/users.py` के अंदर मौजूद `APIRouter` को contain करता है।
+
+और `items.router` file `app/routers/items.py` के अंदर मौजूद `APIRouter` को contain करता है।
+
+///
+
+`app.include_router()` के साथ हम प्रत्येक `APIRouter` को main `FastAPI` application में जोड़ सकते हैं।
+
+यह उस router के सभी routes को उसका हिस्सा बनाकर include करेगा।
+
+/// note | तकनीकी विवरण
+
+FastAPI मूल `APIRouter` और उसके `APIRoute`s को active रखता है जब router main application में include किया जाता है।
+
+इसका मतलब है कि custom `APIRouter` और `APIRoute` subclasses router include होने के बाद भी participate कर सकते हैं।
+
+///
+
+/// tip | टिप
+
+routers include करते समय आपको performance के बारे में चिंता करने की ज़रूरत नहीं है।
+
+इसे lightweight होने और हर request में overhead जोड़ने से बचने के लिए design किया गया है।
+
+इसलिए यह performance को affect नहीं करेगा। ⚡
+
+///
+
+### custom `prefix`, `tags`, `responses`, और `dependencies` के साथ `APIRouter` include करें { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
+
+अब, कल्पना करें कि आपकी organization ने आपको `app/internal/admin.py` file दी है।
+
+इसमें कुछ admin *path operations* वाला `APIRouter` है जिसे आपकी organization कई projects के बीच share करती है।
+
+इस उदाहरण के लिए यह बहुत सरल होगा। लेकिन मान लीजिए कि क्योंकि यह organization में अन्य projects के साथ shared है, हम इसे modify नहीं कर सकते और `prefix`, `dependencies`, `tags`, आदि directly `APIRouter` में नहीं जोड़ सकते:
+
+{* ../../docs_src/bigger_applications/app_an_py310/internal/admin.py hl[3] title["app/internal/admin.py"] *}
+
+लेकिन हम फिर भी `APIRouter` include करते समय एक custom `prefix` set करना चाहते हैं ताकि इसके सभी *path operations* `/admin` से शुरू हों, हम इसे इस project के लिए पहले से मौजूद `dependencies` के साथ secure करना चाहते हैं, और हम `tags` और `responses` include करना चाहते हैं।
+
+हम original `APIRouter` को modify किए बिना यह सब declare कर सकते हैं, उन parameters को `app.include_router()` में pass करके:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[14:17] title["app/main.py"] *}
+
+इस तरह, original `APIRouter` unmodified रहेगा, इसलिए हम वही `app/internal/admin.py` file organization में अन्य projects के साथ अब भी share कर सकते हैं।
+
+परिणाम यह है कि हमारी app में, `admin` module से प्रत्येक *path operation* में होगा:
+
+* prefix `/admin`.
+* tag `admin`.
+* dependency `get_token_header`.
+* response `418`. 🍵
+
+लेकिन यह केवल हमारी app में उस `APIRouter` को affect करेगा, उसे use करने वाले किसी अन्य code को नहीं।
+
+इसलिए, उदाहरण के लिए, अन्य projects उसी `APIRouter` को किसी अलग authentication method के साथ use कर सकते हैं।
+
+### एक *path operation* include करें { #include-a-path-operation }
+
+हम सीधे `FastAPI` app में भी *path operations* जोड़ सकते हैं।
+
+यहाँ हम ऐसा करते हैं... बस यह दिखाने के लिए कि हम कर सकते हैं 🤷:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[21:23] title["app/main.py"] *}
+
+और यह `app.include_router()` के साथ जोड़े गए सभी अन्य *path operations* के साथ सही तरीके से काम करेगा।
+
+/// note | बहुत तकनीकी विवरण
+
+**नोट**: यह बहुत technical detail है जिसे आप शायद **बस skip** कर सकते हैं।
+
+---
+
+`APIRouter`s "mounted" नहीं होते, वे बाकी application से isolated नहीं होते।
+
+ऐसा इसलिए है क्योंकि हम उनके *path operations* को OpenAPI schema और user interfaces में include करना चाहते हैं।
+
+FastAPI original routers और path operations को active रखता है, और requests handle करते समय और OpenAPI generate करते समय router prefixes, dependencies, tags, responses, और अन्य metadata को combine करता है।
+
+///
+
+## `pyproject.toml` में `entrypoint` configure करें { #configure-the-entrypoint-in-pyproject-toml }
+
+क्योंकि आपका FastAPI `app` object `app/main.py` में रहता है, आप अपने `pyproject.toml` file में `entrypoint` को इस तरह configure कर सकते हैं:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+यह इस तरह import करने के बराबर है:
+
+```python
+from app.main import app
+```
+
+इस तरह `fastapi` command जान जाएगा कि आपकी app कहाँ मिलेगी।
+
+/// Note | नोट
+
+आप command को path भी pass कर सकते हैं, जैसे:
+
+```console
+$ fastapi dev app/main.py
+```
+
+लेकिन हर बार `fastapi` command call करते समय आपको सही path pass करना याद रखना होगा।
+
+इसके अलावा, अन्य tools शायद इसे ढूँढ न पाएँ, उदाहरण के लिए [VS Code Extension](../editor-support.md) या [FastAPI Cloud](https://fastapicloud.com), इसलिए `pyproject.toml` में `entrypoint` का उपयोग करने की सलाह दी जाती है।
+
+///
+
+## automatic API docs जाँचें { #check-the-automatic-api-docs }
+
+अब, अपनी app चलाएँ:
+
+
+
+## अलग-अलग `prefix` के साथ उसी router को multiple times include करें { #include-the-same-router-multiple-times-with-different-prefix }
+
+आप अलग-अलग prefixes का उपयोग करके *same* router के साथ `.include_router()` को multiple times भी use कर सकते हैं।
+
+यह उपयोगी हो सकता है, उदाहरण के लिए, उसी API को अलग-अलग prefixes के तहत expose करने के लिए, जैसे `/api/v1` और `/api/latest`।
+
+यह एक advanced usage है जिसकी आपको शायद सच में ज़रूरत न हो, लेकिन अगर हो तो यह मौजूद है।
+
+## एक `APIRouter` को दूसरे में include करें { #include-an-apirouter-in-another }
+
+जिस तरह आप `FastAPI` application में `APIRouter` include कर सकते हैं, उसी तरह आप एक `APIRouter` को दूसरे `APIRouter` में include कर सकते हैं:
+
+```Python
+router.include_router(other_router)
+```
+
+आप यह `FastAPI` app में `router` include करने से पहले या बाद में कर सकते हैं। FastAPI फिर भी `other_router` से *path operations* को routing और OpenAPI में include करेगा।
+
+बाद में routers में जोड़े गए *path operations* पर भी यही लागू होता है। वे पहले वाली inclusion के माध्यम से भी visible होंगे।
+
+/// warning | तकनीकी विवरण
+
+router include करने के बाद `router.routes` को directly mutate करने से बचें। FastAPI router inclusion को live मानता है, इसलिए original router और उसके routes routing और OpenAPI generation का हिस्सा बने रहते हैं।
+
+routes और routers जोड़ने के लिए documented APIs जैसे path operation decorators और `.include_router()` का उपयोग करें।
+
+`router.routes` को एक lower-level route tree की तरह treat करें जिसमें route definitions और included routers हो सकते हैं, और इस पर final path operations की flat list की तरह rely करने से बचें।
+
+///
diff --git a/docs/hi/docs/tutorial/body-fields.md b/docs/hi/docs/tutorial/body-fields.md
new file mode 100644
index 000000000..22f5d38fd
--- /dev/null
+++ b/docs/hi/docs/tutorial/body-fields.md
@@ -0,0 +1,61 @@
+# Body - Fields { #body-fields }
+
+जिस तरह आप *path operation function* के parameters में `Query`, `Path` और `Body` के साथ अतिरिक्त validation और metadata घोषित कर सकते हैं, उसी तरह आप Pydantic के `Field` का उपयोग करके Pydantic models के अंदर validation और metadata घोषित कर सकते हैं।
+
+## `Field` import करें { #import-field }
+
+सबसे पहले, आपको इसे import करना होगा:
+
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[4] *}
+
+
+/// warning | चेतावनी
+
+ध्यान दें कि `Field` को सीधे `pydantic` से import किया जाता है, `fastapi` से नहीं, जैसे बाकी सभी (`Query`, `Path`, `Body`, आदि) किए जाते हैं।
+
+///
+
+## model attributes घोषित करें { #declare-model-attributes }
+
+फिर आप model attributes के साथ `Field` का उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_fields/tutorial001_an_py310.py hl[11:14] *}
+
+`Field` उसी तरह काम करता है जैसे `Query`, `Path` और `Body`, इसमें वही सभी parameters आदि होते हैं।
+
+/// note | तकनीकी विवरण
+
+वास्तव में, `Query`, `Path` और अन्य जिन्हें आप आगे देखेंगे, एक सामान्य `Param` class के subclasses के objects बनाते हैं, जो स्वयं Pydantic की `FieldInfo` class का subclass है।
+
+और Pydantic का `Field` भी `FieldInfo` का एक instance लौटाता है।
+
+`Body` भी सीधे `FieldInfo` के subclass के objects लौटाता है। और कुछ अन्य भी हैं जिन्हें आप बाद में देखेंगे, जो `Body` class के subclasses हैं।
+
+याद रखें कि जब आप `fastapi` से `Query`, `Path` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं जो विशेष classes लौटाते हैं।
+
+///
+
+/// tip | सुझाव
+
+ध्यान दें कि type, default value और `Field` वाले हर model के attribute की संरचना *path operation function* के parameter जैसी ही होती है, बस `Path`, `Query` और `Body` की जगह `Field` होता है।
+
+///
+
+## अतिरिक्त जानकारी जोड़ें { #add-extra-information }
+
+आप `Field`, `Query`, `Body` आदि में अतिरिक्त जानकारी घोषित कर सकते हैं। और यह जनरेट किए गए JSON Schema में शामिल होगी।
+
+आप docs में आगे examples घोषित करना सीखते समय अतिरिक्त जानकारी जोड़ने के बारे में और जानेंगे।
+
+/// warning | चेतावनी
+
+`Field` को दिए गए अतिरिक्त keys आपके application के परिणामी OpenAPI schema में भी मौजूद होंगे।
+क्योंकि ये keys जरूरी नहीं कि OpenAPI specification का हिस्सा हों, इसलिए कुछ OpenAPI tools, उदाहरण के लिए [OpenAPI validator](https://validator.swagger.io/), आपके जनरेट किए गए schema के साथ काम नहीं कर सकते।
+
+///
+
+## Recap { #recap }
+
+आप model attributes के लिए अतिरिक्त validations और metadata घोषित करने के लिए Pydantic के `Field` का उपयोग कर सकते हैं।
+
+आप अतिरिक्त JSON Schema metadata पास करने के लिए extra keyword arguments का भी उपयोग कर सकते हैं।
diff --git a/docs/hi/docs/tutorial/body-multiple-params.md b/docs/hi/docs/tutorial/body-multiple-params.md
new file mode 100644
index 000000000..0d095ddf3
--- /dev/null
+++ b/docs/hi/docs/tutorial/body-multiple-params.md
@@ -0,0 +1,169 @@
+# Body - कई Parameters { #body-multiple-parameters }
+
+अब जबकि हमने देख लिया है कि `Path` और `Query` का उपयोग कैसे करना है, आइए request body declarations के और उन्नत उपयोग देखें।
+
+## `Path`, `Query` और body parameters को मिलाएँ { #mix-path-query-and-body-parameters }
+
+सबसे पहले, बेशक, आप `Path`, `Query` और request body parameter declarations को स्वतंत्र रूप से मिला सकते हैं और **FastAPI** जान जाएगा कि क्या करना है।
+
+और आप body parameters को optional भी declare कर सकते हैं, default को `None` पर सेट करके:
+
+{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
+
+/// note | नोट
+
+ध्यान दें कि, इस मामले में, body से लिया जाने वाला `item` optional है। क्योंकि इसका default value `None` है।
+
+///
+
+## कई body parameters { #multiple-body-parameters }
+
+पिछले उदाहरण में, *path operations* एक JSON body की अपेक्षा करेंगे जिसमें `Item` के attributes हों, जैसे:
+
+```JSON
+{
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+}
+```
+
+लेकिन आप कई body parameters भी declare कर सकते हैं, उदाहरण के लिए `item` और `user`:
+
+{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
+
+
+इस मामले में, **FastAPI** ध्यान देगा कि function में एक से अधिक body parameter हैं (दो parameters हैं जो Pydantic models हैं)।
+
+तो, फिर यह parameter names को body में keys (field names) के रूप में उपयोग करेगा, और ऐसी body की अपेक्षा करेगा:
+
+```JSON
+{
+ "item": {
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+ },
+ "user": {
+ "username": "dave",
+ "full_name": "Dave Grohl"
+ }
+}
+```
+
+/// note | नोट
+
+ध्यान दें कि भले ही `item` को पहले की तरह ही declare किया गया था, अब उससे अपेक्षा की जाती है कि वह body के अंदर key `item` के साथ हो।
+
+///
+
+**FastAPI** request से automatic conversion करेगा, ताकि parameter `item` को उसकी विशिष्ट content मिले और `user` के लिए भी यही हो।
+
+यह compound data का validation करेगा, और इसे OpenAPI schema और automatic docs के लिए उसी तरह document करेगा।
+
+## body में एकल values { #singular-values-in-body }
+
+जिस तरह query और path parameters के लिए extra data define करने हेतु `Query` और `Path` हैं, **FastAPI** एक समान `Body` प्रदान करता है।
+
+उदाहरण के लिए, पिछले model को extend करते हुए, आप तय कर सकते हैं कि आप उसी body में `item` और `user` के अलावा एक और key `importance` रखना चाहते हैं।
+
+यदि आप इसे जैसे है वैसे declare करते हैं, क्योंकि यह एक single value है, **FastAPI** मान लेगा कि यह एक query parameter है।
+
+लेकिन आप **FastAPI** को `Body` का उपयोग करके इसे एक और body key के रूप में treat करने का निर्देश दे सकते हैं:
+
+{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
+
+
+इस मामले में, **FastAPI** ऐसी body की अपेक्षा करेगा:
+
+```JSON
+{
+ "item": {
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+ },
+ "user": {
+ "username": "dave",
+ "full_name": "Dave Grohl"
+ },
+ "importance": 5
+}
+```
+
+फिर से, यह data types को convert करेगा, validate करेगा, document करेगा, आदि।
+
+## कई body params और query { #multiple-body-params-and-query }
+
+बेशक, आप जब भी ज़रूरत हो, किसी भी body parameters के अतिरिक्त, extra query parameters भी declare कर सकते हैं।
+
+क्योंकि default रूप से, single values को query parameters के रूप में interpret किया जाता है, आपको स्पष्ट रूप से `Query` जोड़ने की ज़रूरत नहीं है, आप बस ऐसा कर सकते हैं:
+
+```Python
+q: str | None = None
+```
+
+उदाहरण के लिए:
+
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
+
+
+/// note | नोट
+
+`Body` में भी वही सभी extra validation और metadata parameters हैं जो `Query`, `Path` और अन्य में हैं जिन्हें आप बाद में देखेंगे।
+
+///
+
+## एक single body parameter को embed करें { #embed-a-single-body-parameter }
+
+मान लीजिए आपके पास Pydantic model `Item` से केवल एक single `item` body parameter है।
+
+default रूप से, **FastAPI** फिर सीधे उसकी body की अपेक्षा करेगा।
+
+लेकिन यदि आप चाहते हैं कि यह key `item` के साथ JSON की अपेक्षा करे और उसके अंदर model contents हों, जैसा कि यह तब करता है जब आप extra body parameters declare करते हैं, तो आप special `Body` parameter `embed` का उपयोग कर सकते हैं:
+
+```Python
+item: Annotated[Item, Body(embed=True)]
+```
+
+जैसे कि:
+
+{* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
+
+
+इस मामले में **FastAPI** ऐसी body की अपेक्षा करेगा:
+
+```JSON hl_lines="2"
+{
+ "item": {
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+ }
+}
+```
+
+इसके बजाय:
+
+```JSON
+{
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+}
+```
+
+## Recap { #recap }
+
+आप अपनी *path operation function* में कई body parameters जोड़ सकते हैं, भले ही एक request में केवल एक ही body हो सकती है।
+
+लेकिन **FastAPI** इसे handle करेगा, आपको आपके function में सही data देगा, और *path operation* में सही schema को validate और document करेगा।
+
+आप single values को body के हिस्से के रूप में receive करने के लिए भी declare कर सकते हैं।
+
+और आप **FastAPI** को body को एक key में embed करने का निर्देश दे सकते हैं, भले ही केवल एक single parameter declare किया गया हो।
diff --git a/docs/hi/docs/tutorial/body-nested-models.md b/docs/hi/docs/tutorial/body-nested-models.md
new file mode 100644
index 000000000..04ac55bfd
--- /dev/null
+++ b/docs/hi/docs/tutorial/body-nested-models.md
@@ -0,0 +1,221 @@
+# Body - Nested Models { #body-nested-models }
+
+**FastAPI** के साथ, आप arbitrarily deeply nested models को define, validate, document, और use कर सकते हैं (Pydantic की बदौलत)।
+
+## List fields { #list-fields }
+
+आप किसी attribute को subtype के रूप में define कर सकते हैं। उदाहरण के लिए, एक Python `list`:
+
+{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}
+
+यह `tags` को एक list बना देगा, हालांकि यह list के elements का type declare नहीं करता।
+
+## Type parameter के साथ List fields { #list-fields-with-type-parameter }
+
+लेकिन Python में internal types, या "type parameters" के साथ lists declare करने का एक खास तरीका है:
+
+### Type parameter के साथ `list` declare करें { #declare-a-list-with-a-type-parameter }
+
+ऐसे types declare करने के लिए जिनमें type parameters (internal types) होते हैं, जैसे `list`, `dict`, `tuple`,
+internal type(s) को square brackets: `[` और `]` का उपयोग करके "type parameters" के रूप में pass करें
+
+```Python
+my_list: list[str]
+```
+
+Type declarations के लिए यह सब standard Python syntax है।
+
+Internal types वाले model attributes के लिए भी वही standard syntax उपयोग करें।
+
+तो, हमारे उदाहरण में, हम `tags` को खास तौर पर "strings की list" बना सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
+
+## Set types { #set-types }
+
+लेकिन फिर हम इस पर सोचते हैं, और समझते हैं कि tags repeat नहीं होने चाहिए, वे शायद unique strings होंगे।
+
+और Python में unique items के sets के लिए एक खास data type है, `set`।
+
+फिर हम `tags` को strings के set के रूप में declare कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
+
+इसके साथ, भले ही आपको duplicate data वाला request मिले, वह unique items के set में convert हो जाएगा।
+
+और जब भी आप उस data को output करेंगे, भले ही source में duplicates हों, वह unique items के set के रूप में output होगा।
+
+और इसे उसी अनुसार annotate / document भी किया जाएगा।
+
+## Nested Models { #nested-models }
+
+Pydantic model के हर attribute का एक type होता है।
+
+लेकिन वह type खुद भी कोई दूसरा Pydantic model हो सकता है।
+
+इसलिए, आप खास attribute names, types और validations के साथ deeply nested JSON "objects" declare कर सकते हैं।
+
+यह सब, मनचाही गहराई तक nested हो सकता है।
+
+### Submodel define करें { #define-a-submodel }
+
+उदाहरण के लिए, हम एक `Image` model define कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
+
+### Submodel को type के रूप में उपयोग करें { #use-the-submodel-as-a-type }
+
+और फिर हम इसे किसी attribute के type के रूप में उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}
+
+इसका मतलब होगा कि **FastAPI** कुछ इस तरह के body की अपेक्षा करेगा:
+
+```JSON
+{
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2,
+ "tags": ["rock", "metal", "bar"],
+ "image": {
+ "url": "http://example.com/baz.jpg",
+ "name": "The Foo live"
+ }
+}
+```
+
+फिर से, सिर्फ वह declaration करने से, **FastAPI** के साथ आपको मिलता है:
+
+* Editor support (completion, आदि), nested models के लिए भी
+* Data conversion
+* Data validation
+* Automatic documentation
+
+## Special types और validation { #special-types-and-validation }
+
+`str`, `int`, `float`, आदि जैसे सामान्य singular types के अलावा, आप अधिक complex singular types उपयोग कर सकते हैं जो `str` से inherit करते हैं।
+
+आपके पास मौजूद सभी options देखने के लिए, [Pydantic का Type Overview](https://docs.pydantic.dev/latest/concepts/types/) देखें। अगले chapter में आपको कुछ उदाहरण दिखेंगे।
+
+उदाहरण के लिए, जैसा कि `Image` model में हमारे पास एक `url` field है, हम इसे `str` के बजाय Pydantic के `HttpUrl` का instance declare कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
+
+String को valid URL होने के लिए check किया जाएगा, और JSON Schema / OpenAPI में उसी तरह document किया जाएगा।
+
+## Submodels की lists वाले attributes { #attributes-with-lists-of-submodels }
+
+आप Pydantic models को `list`, `set`, आदि के subtypes के रूप में भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
+
+यह इस तरह के JSON body की अपेक्षा करेगा (convert, validate, document, आदि):
+
+```JSON hl_lines="11"
+{
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2,
+ "tags": [
+ "rock",
+ "metal",
+ "bar"
+ ],
+ "images": [
+ {
+ "url": "http://example.com/baz.jpg",
+ "name": "The Foo live"
+ },
+ {
+ "url": "http://example.com/dave.jpg",
+ "name": "The Baz"
+ }
+ ]
+}
+```
+
+/// note | नोट
+
+ध्यान दें कि `images` key में अब image objects की एक list है।
+
+///
+
+## Deeply nested models { #deeply-nested-models }
+
+आप arbitrarily deeply nested models define कर सकते हैं:
+
+{* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}
+
+/// note | नोट
+
+ध्यान दें कि `Offer` में `Item`s की एक list है, जिनमें आगे `Image`s की एक optional list है
+
+///
+
+## Pure lists के bodies { #bodies-of-pure-lists }
+
+अगर जिस JSON body की आप अपेक्षा करते हैं उसका top level value एक JSON `array` (एक Python `list`) है, तो आप function के parameter में type declare कर सकते हैं, बिल्कुल Pydantic models की तरह:
+
+```Python
+images: list[Image]
+```
+
+जैसे कि:
+
+{* ../../docs_src/body_nested_models/tutorial008_py310.py hl[13] *}
+
+## हर जगह editor support { #editor-support-everywhere }
+
+और आपको हर जगह editor support मिलता है।
+
+Lists के अंदर के items के लिए भी:
+
+
+
+अगर आप Pydantic models के बजाय सीधे `dict` के साथ काम कर रहे होते, तो आपको इस तरह का editor support नहीं मिल सकता था।
+
+लेकिन आपको उनकी चिंता भी करने की ज़रूरत नहीं है, आने वाले dicts अपने आप convert हो जाते हैं और आपका output भी अपने आप JSON में convert हो जाता है।
+
+## Arbitrary `dict`s के bodies { #bodies-of-arbitrary-dicts }
+
+आप body को एक `dict` के रूप में भी declare कर सकते हैं, जिसकी keys किसी type की हों और values किसी दूसरे type की।
+
+इस तरह, आपको पहले से यह जानने की ज़रूरत नहीं होती कि valid field/attribute names क्या हैं (जैसा कि Pydantic models के साथ होता)।
+
+यह तब उपयोगी होगा जब आप ऐसी keys receive करना चाहते हैं जिन्हें आप पहले से नहीं जानते।
+
+---
+
+एक और उपयोगी case वह है जब आप किसी दूसरे type (जैसे, `int`) की keys रखना चाहते हैं।
+
+यही हम यहाँ देखने जा रहे हैं।
+
+इस case में, आप कोई भी `dict` accept करेंगे, जब तक कि उसमें `float` values वाली `int` keys हों:
+
+{* ../../docs_src/body_nested_models/tutorial009_py310.py hl[7] *}
+
+/// tip | टिप
+
+ध्यान रखें कि JSON केवल `str` को keys के रूप में support करता है।
+
+लेकिन Pydantic में automatic data conversion है।
+
+इसका मतलब है कि, भले ही आपके API clients केवल strings को keys के रूप में भेज सकते हैं, जब तक उन strings में pure integers हैं, Pydantic उन्हें convert और validate कर देगा।
+
+और `weights` के रूप में आपको जो `dict` receive होगा, उसमें वास्तव में `int` keys और `float` values होंगी।
+
+///
+
+## Recap { #recap }
+
+**FastAPI** के साथ आपके पास Pydantic models द्वारा दी गई अधिकतम flexibility होती है, जबकि आपका code simple, short और elegant बना रहता है।
+
+लेकिन सभी benefits के साथ:
+
+* Editor support (हर जगह completion!)
+* Data conversion (a.k.a. parsing / serialization)
+* Data validation
+* Schema documentation
+* Automatic docs
diff --git a/docs/hi/docs/tutorial/body-updates.md b/docs/hi/docs/tutorial/body-updates.md
new file mode 100644
index 000000000..cab762e47
--- /dev/null
+++ b/docs/hi/docs/tutorial/body-updates.md
@@ -0,0 +1,100 @@
+# Body - अपडेट्स { #body-updates }
+
+## `PUT` के साथ बदलकर अपडेट करना { #update-replacing-with-put }
+
+किसी item को अपडेट करने के लिए आप [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) operation का उपयोग कर सकते हैं।
+
+आप input data को ऐसे data में बदलने के लिए `jsonable_encoder` का उपयोग कर सकते हैं जिसे JSON के रूप में संग्रहीत किया जा सके (जैसे NoSQL database के साथ)। उदाहरण के लिए, `datetime` को `str` में बदलना।
+
+{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
+
+`PUT` का उपयोग ऐसा data प्राप्त करने के लिए किया जाता है जो मौजूदा data को बदल दे।
+
+### बदलने के बारे में चेतावनी { #warning-about-replacing }
+
+इसका मतलब है कि अगर आप item `bar` को `PUT` का उपयोग करके ऐसे body के साथ अपडेट करना चाहते हैं जिसमें यह हो:
+
+```Python
+{
+ "name": "Barz",
+ "price": 3,
+ "description": None,
+}
+```
+
+क्योंकि इसमें पहले से संग्रहीत attribute `"tax": 20.2` शामिल नहीं है, input model `"tax": 10.5` की default value लेगा।
+
+और data उस "नए" `tax` `10.5` के साथ सहेजा जाएगा।
+
+## `PATCH` के साथ आंशिक अपडेट्स { #partial-updates-with-patch }
+
+आप data को *आंशिक रूप से* अपडेट करने के लिए [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) operation का भी उपयोग कर सकते हैं।
+
+इसका मतलब है कि आप केवल वही data भेज सकते हैं जिसे आप अपडेट करना चाहते हैं, बाकी को वैसा ही छोड़ते हुए।
+
+/// note | नोट
+
+`PATCH`, `PUT` की तुलना में कम सामान्य रूप से उपयोग और जाना जाता है।
+
+और कई teams आंशिक अपडेट्स के लिए भी केवल `PUT` का उपयोग करती हैं।
+
+आप इन्हें जैसे चाहें वैसे उपयोग करने के लिए **स्वतंत्र** हैं, **FastAPI** कोई प्रतिबंध नहीं लगाता।
+
+लेकिन यह गाइड आपको मोटे तौर पर दिखाती है कि इन्हें कैसे उपयोग करने का इरादा है।
+
+///
+
+### Pydantic के `exclude_unset` parameter का उपयोग करना { #using-pydantics-exclude-unset-parameter }
+
+अगर आप आंशिक अपडेट्स प्राप्त करना चाहते हैं, तो Pydantic के model के `.model_dump()` में parameter `exclude_unset` का उपयोग करना बहुत उपयोगी है।
+
+जैसे `item.model_dump(exclude_unset=True)`।
+
+इससे केवल उस data के साथ एक `dict` बनेगा जो `item` model बनाते समय सेट किया गया था, default values को छोड़कर।
+
+फिर आप इसका उपयोग केवल उस data के साथ एक `dict` बनाने के लिए कर सकते हैं जो सेट किया गया था (request में भेजा गया), default values को छोड़ते हुए:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
+
+### Pydantic के `update` parameter का उपयोग करना { #using-pydantics-update-parameter }
+
+अब, आप `.model_copy()` का उपयोग करके मौजूदा model की एक copy बना सकते हैं, और अपडेट करने के लिए data वाले `dict` के साथ `update` parameter पास कर सकते हैं।
+
+जैसे `stored_item_model.model_copy(update=update_data)`:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
+
+### आंशिक अपडेट्स Recap { #partial-updates-recap }
+
+संक्षेप में, आंशिक अपडेट्स लागू करने के लिए आप:
+
+* (वैकल्पिक रूप से) `PUT` के बजाय `PATCH` का उपयोग करें।
+* संग्रहीत data प्राप्त करें।
+* उस data को Pydantic model में रखें।
+* input model से default values के बिना एक `dict` बनाएँ (`exclude_unset` का उपयोग करके)।
+ * इस तरह आप केवल उन values को अपडेट कर सकते हैं जिन्हें वास्तव में user ने सेट किया है, बजाय इसके कि आपके model में पहले से संग्रहीत values को default values से override कर दें।
+* संग्रहीत model की एक copy बनाएँ, और प्राप्त आंशिक अपडेट्स के साथ उसके attributes को अपडेट करें (`update` parameter का उपयोग करके)।
+* copied model को ऐसी चीज़ में बदलें जिसे आपकी DB में संग्रहीत किया जा सके (उदाहरण के लिए, `jsonable_encoder` का उपयोग करके)।
+ * यह model की `.model_dump()` method को फिर से उपयोग करने जैसा है, लेकिन यह सुनिश्चित करता है (और बदलता है) कि values ऐसे data types में हों जिन्हें JSON में बदला जा सके, उदाहरण के लिए, `datetime` को `str` में।
+* data को अपनी DB में सहेजें।
+* अपडेट किया गया model लौटाएँ।
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}
+
+/// tip | टिप
+
+आप वास्तव में इसी तकनीक का उपयोग HTTP `PUT` operation के साथ भी कर सकते हैं।
+
+लेकिन यहाँ का उदाहरण `PATCH` का उपयोग करता है क्योंकि इसे इन्हीं use cases के लिए बनाया गया था।
+
+///
+
+/// note | नोट
+
+ध्यान दें कि input model अभी भी validate किया जाता है।
+
+इसलिए, अगर आप ऐसे आंशिक अपडेट्स प्राप्त करना चाहते हैं जो सभी attributes को छोड़ सकते हैं, तो आपको ऐसा model चाहिए जिसमें सभी attributes optional के रूप में चिह्नित हों (default values या `None` के साथ)।
+
+**अपडेट्स** के लिए सभी optional values वाले models और **creation** के लिए required values वाले models में अंतर करने के लिए, आप [Extra Models](extra-models.md) में बताए गए विचारों का उपयोग कर सकते हैं।
+
+///
diff --git a/docs/hi/docs/tutorial/body.md b/docs/hi/docs/tutorial/body.md
new file mode 100644
index 000000000..dfccf3726
--- /dev/null
+++ b/docs/hi/docs/tutorial/body.md
@@ -0,0 +1,166 @@
+# Request Body { #request-body }
+
+जब आपको किसी client (मान लें, एक browser) से अपनी API को data भेजना होता है, तो आप उसे **request body** के रूप में भेजते हैं।
+
+**request** body वह data है जो client आपकी API को भेजता है। **response** body वह data है जो आपकी API client को भेजती है।
+
+आपकी API को लगभग हमेशा **response** body भेजनी होती है। लेकिन clients को हर समय **request bodies** भेजने की ज़रूरत नहीं होती, कभी-कभी वे केवल एक path request करते हैं, शायद कुछ query parameters के साथ, लेकिन body नहीं भेजते।
+
+**request** body घोषित करने के लिए, आप [Pydantic](https://docs.pydantic.dev/) models का उनकी पूरी शक्ति और लाभों के साथ उपयोग करते हैं।
+
+/// note | नोट
+
+Data भेजने के लिए, आपको इनमें से किसी एक का उपयोग करना चाहिए: `POST` (सबसे आम), `PUT`, `DELETE` या `PATCH`.
+
+`GET` request के साथ body भेजने का व्यवहार specifications में undefined है, फिर भी, FastAPI इसे support करता है, केवल बहुत जटिल/चरम use cases के लिए।
+
+क्योंकि इसे discouraged किया जाता है, Swagger UI वाले interactive docs `GET` का उपयोग करते समय body के लिए documentation नहीं दिखाएँगे, और बीच में मौजूद proxies इसे support नहीं कर सकते।
+
+///
+
+## Pydantic के `BaseModel` को import करें { #import-pydantics-basemodel }
+
+सबसे पहले, आपको `pydantic` से `BaseModel` import करना होगा:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
+
+## अपना data model बनाएँ { #create-your-data-model }
+
+फिर आप अपने data model को एक class के रूप में घोषित करते हैं जो `BaseModel` से inherit करती है।
+
+सभी attributes के लिए standard Python types का उपयोग करें:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
+
+
+Query parameters घोषित करते समय की तरह, जब किसी model attribute का default value होता है, तो वह required नहीं होता। अन्यथा, वह required होता है। उसे केवल optional बनाने के लिए `None` का उपयोग करें।
+
+उदाहरण के लिए, ऊपर दिया गया यह model इस तरह का JSON "`object`" (या Python `dict`) घोषित करता है:
+
+```JSON
+{
+ "name": "Foo",
+ "description": "An optional description",
+ "price": 45.2,
+ "tax": 3.5
+}
+```
+
+...क्योंकि `description` और `tax` optional हैं (`None` के default value के साथ), यह JSON "`object`" भी valid होगा:
+
+```JSON
+{
+ "name": "Foo",
+ "price": 45.2
+}
+```
+
+## इसे एक parameter के रूप में घोषित करें { #declare-it-as-a-parameter }
+
+इसे अपनी *path operation* में जोड़ने के लिए, इसे उसी तरह घोषित करें जैसे आपने path और query parameters घोषित किए थे:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
+
+...और इसके type को आपके बनाए हुए model, `Item`, के रूप में घोषित करें।
+
+## परिणाम { #results }
+
+सिर्फ उस Python type declaration के साथ, **FastAPI** यह करेगा:
+
+* request के body को JSON के रूप में पढ़ेगा।
+* संबंधित types को convert करेगा (यदि ज़रूरत हो)।
+* data को validate करेगा।
+ * यदि data invalid है, तो यह एक अच्छा और स्पष्ट error return करेगा, जो ठीक-ठीक बताएगा कि गलत data कहाँ और क्या था।
+* आपको प्राप्त data parameter `item` में देगा।
+ * क्योंकि आपने इसे function में `Item` type का घोषित किया है, आपको इसके सभी attributes और उनके types के लिए पूरा editor support (completion, आदि) भी मिलेगा।
+* आपके model के लिए [JSON Schema](https://json-schema.org) definitions generate करेगा, यदि आपके project के लिए उचित हो तो आप उन्हें कहीं और भी उपयोग कर सकते हैं।
+* वे schemas generated OpenAPI schema का हिस्सा होंगे, और automatic documentation UIs द्वारा उपयोग किए जाएँगे।
+
+## स्वचालित docs { #automatic-docs }
+
+आपके models के JSON Schemas आपके OpenAPI generated schema का हिस्सा होंगे, और interactive API docs में दिखाए जाएँगे:
+
+
+
+और वे API docs में हर उस *path operation* के अंदर भी उपयोग किए जाएँगे जिसे उनकी ज़रूरत है:
+
+
+
+## Editor support { #editor-support }
+
+अपने editor में, अपने function के अंदर आपको हर जगह type hints और completion मिलेंगे (यदि आपको Pydantic model के बजाय `dict` मिला होता, तो ऐसा नहीं होता):
+
+
+
+आपको incorrect type operations के लिए error checks भी मिलते हैं:
+
+
+
+यह संयोग से नहीं है, पूरा framework इसी design के इर्द-गिर्द बनाया गया था।
+
+और किसी भी implementation से पहले, design phase में इसे पूरी तरह test किया गया था, ताकि सुनिश्चित किया जा सके कि यह सभी editors के साथ काम करेगा।
+
+इसे support करने के लिए Pydantic में भी कुछ बदलाव किए गए थे।
+
+पिछले screenshots [Visual Studio Code](https://code.visualstudio.com) के साथ लिए गए थे।
+
+लेकिन आपको [PyCharm](https://www.jetbrains.com/pycharm/) और अधिकांश अन्य Python editors के साथ भी वही editor support मिलेगा:
+
+
+
+/// tip | सुझाव
+
+यदि आप [PyCharm](https://www.jetbrains.com/pycharm/) को अपने editor के रूप में उपयोग करते हैं, तो आप [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/) का उपयोग कर सकते हैं।
+
+यह Pydantic models के लिए editor support को बेहतर बनाता है, इन चीज़ों के साथ:
+
+* auto-completion
+* type checks
+* refactoring
+* searching
+* inspections
+
+///
+
+## model का उपयोग करें { #use-the-model }
+
+Function के अंदर, आप model object के सभी attributes को सीधे access कर सकते हैं:
+
+{* ../../docs_src/body/tutorial002_py310.py *}
+
+## Request body + path parameters { #request-body-path-parameters }
+
+आप path parameters और request body को एक ही समय में घोषित कर सकते हैं।
+
+**FastAPI** पहचानेगा कि वे function parameters जो path parameters से match करते हैं, उन्हें **path से लिया जाना चाहिए**, और वे function parameters जो Pydantic models के रूप में घोषित हैं, उन्हें **request body से लिया जाना चाहिए**।
+
+{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+
+
+## Request body + path + query parameters { #request-body-path-query-parameters }
+
+आप **body**, **path** और **query** parameters को भी एक ही समय में घोषित कर सकते हैं।
+
+**FastAPI** उनमें से प्रत्येक को पहचानेगा और data को सही जगह से लेगा।
+
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
+
+Function parameters को इस प्रकार पहचाना जाएगा:
+
+* यदि parameter **path** में भी घोषित है, तो उसे path parameter के रूप में उपयोग किया जाएगा।
+* यदि parameter **singular type** का है (जैसे `int`, `float`, `str`, `bool`, आदि), तो उसे **query** parameter के रूप में interpret किया जाएगा।
+* यदि parameter को **Pydantic model** के type का घोषित किया गया है, तो उसे request **body** के रूप में interpret किया जाएगा।
+
+/// note | नोट
+
+FastAPI जान जाएगा कि `q` का value required नहीं है क्योंकि उसका default value `= None` है।
+
+`str | None` का उपयोग FastAPI यह निर्धारित करने के लिए नहीं करता कि value required नहीं है, वह जान जाएगा कि यह required नहीं है क्योंकि इसका default value `= None` है।
+
+लेकिन type annotations जोड़ने से आपका editor आपको बेहतर support दे सकेगा और errors detect कर सकेगा।
+
+///
+
+## Pydantic के बिना { #without-pydantic }
+
+यदि आप Pydantic models का उपयोग नहीं करना चाहते, तो आप **Body** parameters का भी उपयोग कर सकते हैं। [Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body) के docs देखें।
diff --git a/docs/hi/docs/tutorial/cookie-param-models.md b/docs/hi/docs/tutorial/cookie-param-models.md
new file mode 100644
index 000000000..38ea681b2
--- /dev/null
+++ b/docs/hi/docs/tutorial/cookie-param-models.md
@@ -0,0 +1,76 @@
+# Cookie Parameter Models { #cookie-parameter-models }
+
+अगर आपके पास संबंधित **cookies** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं। 🍪
+
+यह आपको **model को फिर से उपयोग** करने की अनुमति देगा, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare करने की भी। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से supported है। 🤓
+
+///
+
+/// tip | सुझाव
+
+यही तकनीक `Query`, `Cookie`, और `Header` पर लागू होती है। 😎
+
+///
+
+## Pydantic Model के साथ Cookies { #cookies-with-a-pydantic-model }
+
+जिन **cookie** parameters की आपको ज़रूरत है, उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Cookie` के रूप में declare करें:
+
+{* ../../docs_src/cookie_param_models/tutorial001_an_py310.py hl[9:12,16] *}
+
+**FastAPI** request में प्राप्त **cookies** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में defined cookies देख सकते हैं:
+
+
+
+
+---
+
+अगर आप PyCharm का उपयोग करते हैं, तो आप यह कर सकते हैं:
+
+* "Run" menu खोलें।
+* "Debug..." option चुनें।
+* फिर एक context menu दिखाई देता है।
+* debug करने के लिए file चुनें (इस मामले में, `main.py`)।
+
+फिर यह आपके **FastAPI** code के साथ server start करेगा, आपके breakpoints पर रुकेगा, आदि।
+
+यह कुछ ऐसा दिख सकता है:
+
+
diff --git a/docs/hi/docs/tutorial/dependencies/classes-as-dependencies.md b/docs/hi/docs/tutorial/dependencies/classes-as-dependencies.md
new file mode 100644
index 000000000..0d166e7ea
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/classes-as-dependencies.md
@@ -0,0 +1,288 @@
+# Dependencies के रूप में Classes { #classes-as-dependencies }
+
+**Dependency Injection** system में और गहराई में जाने से पहले, पिछले उदाहरण को बेहतर बनाते हैं।
+
+## पिछले उदाहरण से एक `dict` { #a-dict-from-the-previous-example }
+
+पिछले उदाहरण में, हम अपनी dependency ("dependable") से एक `dict` return कर रहे थे:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}
+
+लेकिन फिर हमें *path operation function* के parameter `commons` में एक `dict` मिलता है।
+
+और हम जानते हैं कि editors `dict`s के लिए ज़्यादा support (जैसे completion) नहीं दे सकते, क्योंकि वे उनकी keys और value types नहीं जान सकते।
+
+हम इससे बेहतर कर सकते हैं...
+
+## Dependency किससे बनती है { #what-makes-a-dependency }
+
+अब तक आपने dependencies को functions के रूप में declare होते देखा है।
+
+लेकिन dependencies declare करने का यही एकमात्र तरीका नहीं है (हालाँकि शायद यह अधिक common होगा)।
+
+मुख्य बात यह है कि dependency एक "callable" होनी चाहिए।
+
+Python में "**callable**" वह कोई भी चीज़ है जिसे Python एक function की तरह "call" कर सकता है।
+
+तो, अगर आपके पास कोई object `something` है (जो शायद function _न_ हो) और आप उसे इस तरह "call" (execute) कर सकते हैं:
+
+```Python
+something()
+```
+
+या
+
+```Python
+something(some_argument, some_keyword_argument="foo")
+```
+
+तो वह एक "callable" है।
+
+## Dependencies के रूप में Classes { #classes-as-dependencies_1 }
+
+आप ध्यान दे सकते हैं कि Python class का instance बनाने के लिए भी आप वही syntax उपयोग करते हैं।
+
+उदाहरण के लिए:
+
+```Python
+class Cat:
+ def __init__(self, name: str):
+ self.name = name
+
+
+fluffy = Cat(name="Mr Fluffy")
+```
+
+इस case में, `fluffy` class `Cat` का एक instance है।
+
+और `fluffy` बनाने के लिए, आप `Cat` को "call" कर रहे हैं।
+
+इसलिए, Python class भी एक **callable** है।
+
+फिर, **FastAPI** में, आप Python class को dependency के रूप में उपयोग कर सकते हैं।
+
+FastAPI वास्तव में यह check करता है कि वह एक "callable" (function, class या कुछ और) है और उसमें parameters defined हैं।
+
+अगर आप **FastAPI** में dependency के रूप में कोई "callable" pass करते हैं, तो यह उस "callable" के parameters को analyze करेगा, और उन्हें *path operation function* के parameters की तरह ही process करेगा। इसमें sub-dependencies भी शामिल हैं।
+
+यह उन callables पर भी लागू होता है जिनमें कोई parameters नहीं होते। ठीक वैसे ही जैसे बिना parameters वाले *path operation functions* के लिए होता।
+
+फिर, हम ऊपर वाली dependency "dependable" `common_parameters` को class `CommonQueryParams` में बदल सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[11:15] *}
+
+Class का instance बनाने के लिए उपयोग की गई `__init__` method पर ध्यान दें:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[12] *}
+
+...इसमें वही parameters हैं जो हमारे पिछले `common_parameters` में थे:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8] *}
+
+यही parameters **FastAPI** dependency को "solve" करने के लिए उपयोग करेगा।
+
+दोनों cases में, इसमें होगा:
+
+* एक optional `q` query parameter जो `str` है।
+* एक `skip` query parameter जो `int` है, जिसका default `0` है।
+* एक `limit` query parameter जो `int` है, जिसका default `100` है।
+
+दोनों cases में data converted, validated, OpenAPI schema पर documented, आदि किया जाएगा।
+
+## इसका उपयोग करें { #use-it }
+
+अब आप इस class का उपयोग करके अपनी dependency declare कर सकते हैं।
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[19] *}
+
+**FastAPI** `CommonQueryParams` class को call करता है। यह उस class का एक "instance" बनाता है और वह instance आपके function को parameter `commons` के रूप में pass किया जाएगा।
+
+## Type annotation बनाम `Depends` { #type-annotation-vs-depends }
+
+ध्यान दें कि ऊपर के code में हम `CommonQueryParams` को दो बार कैसे लिखते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+आखिरी `CommonQueryParams`, इसमें:
+
+```Python
+... Depends(CommonQueryParams)
+```
+
+...वही है जिसे **FastAPI** वास्तव में यह जानने के लिए उपयोग करेगा कि dependency क्या है।
+
+FastAPI इसी से declared parameters extract करेगा और वास्तव में इसी को call करेगा।
+
+---
+
+इस case में, पहला `CommonQueryParams`, इसमें:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, ...
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams ...
+```
+
+////
+
+...का **FastAPI** के लिए कोई विशेष अर्थ नहीं है। FastAPI इसे data conversion, validation, आदि के लिए उपयोग नहीं करेगा। (क्योंकि वह इसके लिए `Depends(CommonQueryParams)` का उपयोग कर रहा है)।
+
+आप वास्तव में सिर्फ यह लिख सकते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[Any, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons = Depends(CommonQueryParams)
+```
+
+////
+
+...जैसे:
+
+{* ../../docs_src/dependencies/tutorial003_an_py310.py hl[19] *}
+
+लेकिन type declare करने को प्रोत्साहित किया जाता है क्योंकि इस तरह आपका editor जान पाएगा कि parameter `commons` के रूप में क्या pass होगा, और फिर यह code completion, type checks, आदि में आपकी मदद कर सकता है:
+
+
+
+## Shortcut { #shortcut }
+
+लेकिन आप देखते हैं कि यहाँ कुछ code repetition हो रहा है, `CommonQueryParams` को दो बार लिखते हुए:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+**FastAPI** ऐसे cases के लिए एक shortcut प्रदान करता है, जहाँ dependency *specifically* एक class है जिसे **FastAPI** class का instance बनाने के लिए "call" करेगा।
+
+उन specific cases के लिए, आप यह कर सकते हैं:
+
+यह लिखने के बजाय:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends(CommonQueryParams)
+```
+
+////
+
+...आप लिखते हैं:
+
+//// tab | Python 3.10+
+
+```Python
+commons: Annotated[CommonQueryParams, Depends()]
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+संभव हो तो `Annotated` version का उपयोग करना बेहतर है।
+
+///
+
+```Python
+commons: CommonQueryParams = Depends()
+```
+
+////
+
+आप dependency को parameter के type के रूप में declare करते हैं, और `Depends(CommonQueryParams)` के अंदर पूरी class को *फिर से* लिखने के बजाय, आप बिना किसी parameter के `Depends()` का उपयोग करते हैं।
+
+फिर वही उदाहरण इस तरह दिखेगा:
+
+{* ../../docs_src/dependencies/tutorial004_an_py310.py hl[19] *}
+
+...और **FastAPI** जान जाएगा कि क्या करना है।
+
+/// tip | सुझाव
+
+अगर यह मददगार से ज़्यादा confusing लगता है, तो इसे अनदेखा करें, आपको इसकी *ज़रूरत* नहीं है।
+
+यह सिर्फ एक shortcut है। क्योंकि **FastAPI** आपको code repetition कम करने में मदद करने की परवाह करता है।
+
+///
diff --git a/docs/hi/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/hi/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
new file mode 100644
index 000000000..6e051ef5d
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
@@ -0,0 +1,69 @@
+# path operation decorators में Dependencies { #dependencies-in-path-operation-decorators }
+
+कुछ मामलों में आपको अपनी *path operation function* के अंदर किसी dependency की return value की वास्तव में ज़रूरत नहीं होती।
+
+या dependency कोई value return नहीं करती।
+
+लेकिन फिर भी आपको उसका execute/solve होना चाहिए।
+
+ऐसे मामलों के लिए, `Depends` के साथ *path operation function* parameter declare करने के बजाय, आप *path operation decorator* में `dependencies` की एक `list` जोड़ सकते हैं।
+
+## *path operation decorator* में `dependencies` जोड़ें { #add-dependencies-to-the-path-operation-decorator }
+
+*path operation decorator* एक optional argument `dependencies` प्राप्त करता है।
+
+यह `Depends()` की एक `list` होनी चाहिए:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[19] *}
+
+ये dependencies normal dependencies की तरह ही execute/solve होंगी। लेकिन उनकी value (यदि वे कोई return करती हैं) आपकी *path operation function* को pass नहीं की जाएगी।
+
+/// tip | सुझाव
+
+कुछ editors unused function parameters की जाँच करते हैं, और उन्हें errors के रूप में दिखाते हैं।
+
+*path operation decorator* में इन `dependencies` का उपयोग करके आप सुनिश्चित कर सकते हैं कि वे execute हों, साथ ही editor/tooling errors से बच सकें।
+
+यह नए developers के लिए भ्रम से बचने में भी मदद कर सकता है, जो आपके code में unused parameter देखकर सोच सकते हैं कि यह अनावश्यक है।
+
+///
+
+/// note | नोट
+
+इस example में हम बनाए गए custom headers `X-Key` और `X-Token` का उपयोग करते हैं।
+
+लेकिन वास्तविक मामलों में, security implement करते समय, आपको integrated [Security utilities (अगला अध्याय)](../security/index.md) का उपयोग करने से अधिक लाभ मिलेंगे।
+
+///
+
+## Dependencies errors और return values { #dependencies-errors-and-return-values }
+
+आप वही dependency *functions* उपयोग कर सकते हैं जिन्हें आप सामान्य रूप से उपयोग करते हैं।
+
+### Dependency requirements { #dependency-requirements }
+
+वे request requirements (जैसे headers) या अन्य sub-dependencies declare कर सकती हैं:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[8,13] *}
+
+### Exceptions raise करें { #raise-exceptions }
+
+ये dependencies normal dependencies की तरह ही exceptions `raise` कर सकती हैं:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}
+
+### Return values { #return-values }
+
+और वे values return कर सकती हैं या नहीं भी कर सकतीं, values का उपयोग नहीं किया जाएगा।
+
+इसलिए, आप एक normal dependency (जो value return करती है) को फिर से उपयोग कर सकते हैं जिसे आप पहले से कहीं और उपयोग करते हैं, और भले ही value का उपयोग न हो, dependency execute होगी:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[11,16] *}
+
+## *path operations* के समूह के लिए Dependencies { #dependencies-for-a-group-of-path-operations }
+
+बाद में, जब आप बड़े applications को structure करने के बारे में पढ़ेंगे ([बड़े Applications - कई Files](../../tutorial/bigger-applications.md)), संभवतः कई files के साथ, तो आप सीखेंगे कि *path operations* के समूह के लिए एक ही `dependencies` parameter कैसे declare किया जाए।
+
+## Global Dependencies { #global-dependencies }
+
+आगे हम देखेंगे कि पूरे `FastAPI` application में dependencies कैसे जोड़ी जाएँ, ताकि वे हर *path operation* पर लागू हों।
diff --git a/docs/hi/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/hi/docs/tutorial/dependencies/dependencies-with-yield.md
new file mode 100644
index 000000000..e85d7401a
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -0,0 +1,289 @@
+# `yield` वाली Dependencies { #dependencies-with-yield }
+
+FastAPI ऐसी dependencies को support करता है जो पूरा होने के बाद अतिरिक्त steps करती हैं।
+
+ऐसा करने के लिए, `return` की जगह `yield` का उपयोग करें, और अतिरिक्त steps (code) उसके बाद लिखें।
+
+/// tip | सुझाव
+
+हर dependency में `yield` का उपयोग केवल एक बार करना सुनिश्चित करें।
+
+///
+
+/// note | तकनीकी विवरण
+
+कोई भी function जो इनके साथ उपयोग करने के लिए valid है:
+
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) या
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
+
+वह **FastAPI** dependency के रूप में उपयोग करने के लिए valid होगी।
+
+वास्तव में, FastAPI internally इन दोनों decorators का उपयोग करता है।
+
+///
+
+## `yield` वाली database dependency { #a-database-dependency-with-yield }
+
+उदाहरण के लिए, आप इसका उपयोग database session बनाने और पूरा होने के बाद उसे close करने के लिए कर सकते हैं।
+
+`yield` statement से पहले और उसे शामिल करते हुए केवल वही code response बनाने से पहले execute होता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[2:4] *}
+
+yield किया गया value वही होता है जिसे *path operations* और अन्य dependencies में inject किया जाता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[4] *}
+
+`yield` statement के बाद वाला code response के बाद execute होता है:
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[5:6] *}
+
+/// tip | सुझाव
+
+आप `async` या regular functions का उपयोग कर सकते हैं।
+
+**FastAPI** हर एक के साथ सही काम करेगा, ठीक normal dependencies की तरह।
+
+///
+
+## `yield` और `try` वाली dependency { #a-dependency-with-yield-and-try }
+
+अगर आप `yield` वाली dependency में `try` block का उपयोग करते हैं, तो dependency का उपयोग करते समय throw की गई कोई भी exception आपको मिलेगी।
+
+उदाहरण के लिए, अगर बीच में किसी point पर, किसी दूसरी dependency में या किसी *path operation* में, कुछ code ने database transaction को "rollback" किया या कोई अन्य exception बनाई, तो आपको अपनी dependency में वह exception मिलेगी।
+
+इसलिए, आप `except SomeException` के साथ dependency के अंदर उस specific exception को देख सकते हैं।
+
+इसी तरह, आप `finally` का उपयोग यह सुनिश्चित करने के लिए कर सकते हैं कि exit steps execute हों, चाहे exception आई हो या नहीं।
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[3,5] *}
+
+## `yield` वाली Sub-dependencies { #sub-dependencies-with-yield }
+
+आपके पास किसी भी size और shape की sub-dependencies और sub-dependencies के "trees" हो सकते हैं, और उनमें से कोई भी या सभी `yield` का उपयोग कर सकती हैं।
+
+**FastAPI** यह सुनिश्चित करेगा कि `yield` वाली हर dependency में "exit code" सही क्रम में run हो।
+
+उदाहरण के लिए, `dependency_c` की dependency `dependency_b` पर हो सकती है, और `dependency_b` की `dependency_a` पर:
+
+{* ../../docs_src/dependencies/tutorial008_an_py310.py hl[6,14,22] *}
+
+और वे सभी `yield` का उपयोग कर सकती हैं।
+
+इस case में `dependency_c` को अपना exit code execute करने के लिए `dependency_b` से मिला value (यहाँ `dep_b` नाम दिया गया है) अभी भी उपलब्ध चाहिए।
+
+और, बदले में, `dependency_b` को अपने exit code के लिए `dependency_a` से मिला value (यहाँ `dep_a` नाम दिया गया है) उपलब्ध चाहिए।
+
+{* ../../docs_src/dependencies/tutorial008_an_py310.py hl[18:19,26:27] *}
+
+इसी तरह, आपके पास कुछ dependencies `yield` वाली और कुछ अन्य dependencies `return` वाली हो सकती हैं, और उनमें से कुछ बाकी कुछ पर depend कर सकती हैं।
+
+और आपके पास एक single dependency हो सकती है जिसे `yield` वाली कई अन्य dependencies required हों, आदि।
+
+आप dependencies के कोई भी combinations रख सकते हैं।
+
+**FastAPI** यह सुनिश्चित करेगा कि सब कुछ सही क्रम में run हो।
+
+/// note | तकनीकी विवरण
+
+यह Python के [Context Managers](https://docs.python.org/3/library/contextlib.html) की वजह से काम करता है।
+
+**FastAPI** इसे हासिल करने के लिए internally उनका उपयोग करता है।
+
+///
+
+## `yield` और `HTTPException` वाली Dependencies { #dependencies-with-yield-and-httpexception }
+
+आपने देखा कि आप `yield` वाली dependencies का उपयोग कर सकते हैं और ऐसे `try` blocks रख सकते हैं जो कुछ code execute करने की कोशिश करते हैं और फिर `finally` के बाद कुछ exit code run करते हैं।
+
+आप raise की गई exception को catch करने और उसके साथ कुछ करने के लिए `except` का भी उपयोग कर सकते हैं।
+
+उदाहरण के लिए, आप कोई अलग exception raise कर सकते हैं, जैसे `HTTPException`।
+
+/// tip | सुझाव
+
+यह थोड़ी advanced technique है, और ज्यादातर cases में आपको वास्तव में इसकी ज़रूरत नहीं होगी, क्योंकि आप अपने application code के बाकी हिस्से के अंदर से exceptions (जिसमें `HTTPException` भी शामिल है) raise कर सकते हैं, उदाहरण के लिए, *path operation function* में।
+
+लेकिन अगर आपको इसकी ज़रूरत हो तो यह उपलब्ध है। 🤓
+
+///
+
+{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
+
+अगर आप exceptions को catch करके उसके आधार पर custom response बनाना चाहते हैं, तो [Custom Exception Handler](../handling-errors.md#install-custom-exception-handlers) बनाएँ।
+
+## `yield` और `except` वाली Dependencies { #dependencies-with-yield-and-except }
+
+अगर आप `yield` वाली dependency में `except` का उपयोग करके exception catch करते हैं और उसे फिर से raise नहीं करते (या कोई नई exception raise नहीं करते), तो FastAPI यह notice नहीं कर पाएगा कि कोई exception हुई थी, ठीक वैसे ही जैसे regular Python में होता:
+
+{* ../../docs_src/dependencies/tutorial008c_an_py310.py hl[15:16] *}
+
+इस case में, client को *HTTP 500 Internal Server Error* response दिखेगा, जैसा कि होना चाहिए, क्योंकि हम `HTTPException` या उसके जैसी कोई चीज़ raise नहीं कर रहे हैं, लेकिन server के पास **कोई logs नहीं होंगे** या error क्या था इसका कोई अन्य संकेत नहीं होगा। 😱
+
+### `yield` और `except` वाली Dependencies में हमेशा `raise` करें { #always-raise-in-dependencies-with-yield-and-except }
+
+अगर आप `yield` वाली dependency में exception catch करते हैं, तो जब तक आप कोई दूसरी `HTTPException` या similar चीज़ raise नहीं कर रहे हैं, **आपको original exception को फिर से raise करना चाहिए**।
+
+आप `raise` का उपयोग करके उसी exception को फिर से raise कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial008d_an_py310.py hl[17] *}
+
+अब client को वही *HTTP 500 Internal Server Error* response मिलेगा, लेकिन server के logs में हमारा custom `InternalError` होगा। 😎
+
+## `yield` वाली dependencies का Execution { #execution-of-dependencies-with-yield }
+
+Execution का sequence कमोबेश इस diagram जैसा है। Time ऊपर से नीचे की ओर चलता है। और हर column code के साथ interact करने या execute करने वाले parts में से एक है।
+
+```mermaid
+sequenceDiagram
+
+participant client as Client
+participant handler as Exception handler
+participant dep as Dep with yield
+participant operation as Path Operation
+participant tasks as Background tasks
+
+ Note over client,operation: Can raise exceptions, including HTTPException
+ client ->> dep: Start request
+ Note over dep: Run code up to yield
+ opt raise Exception
+ dep -->> handler: Raise Exception
+ handler -->> client: HTTP error response
+ end
+ dep ->> operation: Run dependency, e.g. DB session
+ opt raise
+ operation -->> dep: Raise Exception (e.g. HTTPException)
+ opt handle
+ dep -->> dep: Can catch exception, raise a new HTTPException, raise other exception
+ end
+ handler -->> client: HTTP error response
+ end
+
+ operation ->> client: Return response to client
+ Note over client,operation: Response is already sent, can't change it anymore
+ opt Tasks
+ operation -->> tasks: Send background tasks
+ end
+ opt Raise other exception
+ tasks -->> tasks: Handle exceptions in the background task code
+ end
+```
+
+/// note | नोट
+
+Client को केवल **एक response** भेजा जाएगा। यह error responses में से एक हो सकता है या *path operation* से आया response होगा।
+
+उन responses में से एक भेजे जाने के बाद, कोई अन्य response नहीं भेजा जा सकता।
+
+///
+
+/// tip | सुझाव
+
+अगर आप *path operation function* के code में कोई भी exception raise करते हैं, तो उसे yield वाली dependencies को pass किया जाएगा, जिसमें `HTTPException` भी शामिल है। ज्यादातर cases में आप चाहेंगे कि `yield` वाली dependency से वही exception या कोई नई exception फिर से raise करें ताकि यह सुनिश्चित हो सके कि उसे सही तरीके से handle किया गया है।
+
+///
+
+## Early exit और `scope` { #early-exit-and-scope }
+
+आम तौर पर `yield` वाली dependencies का exit code client को **response** भेजे जाने के बाद execute होता है।
+
+लेकिन अगर आपको पता है कि *path operation function* से return करने के बाद आपको dependency का उपयोग करने की ज़रूरत नहीं होगी, तो आप `Depends(scope="function")` का उपयोग करके FastAPI को बता सकते हैं कि उसे dependency को *path operation function* के return करने के बाद, लेकिन **response भेजे जाने से पहले** close करना चाहिए।
+
+{* ../../docs_src/dependencies/tutorial008e_an_py310.py hl[12,16] *}
+
+`Depends()` एक `scope` parameter receive करता है जो यह हो सकता है:
+
+* `"function"`: request handle करने वाले *path operation function* से पहले dependency शुरू करें, *path operation function* खत्म होने के बाद dependency खत्म करें, लेकिन client को response वापस भेजे जाने से **पहले**। यानी, dependency function *path operation **function*** के **around** execute होगा।
+* `"request"`: request handle करने वाले *path operation function* से पहले dependency शुरू करें (`"function"` उपयोग करने जैसा), लेकिन client को response वापस भेजे जाने के **बाद** खत्म करें। यानी, dependency function **request** और response cycle के **around** execute होगा।
+
+अगर specify नहीं किया गया है और dependency में `yield` है, तो उसका `scope` default रूप से `"request"` होगा।
+
+### Sub-dependencies के लिए `scope` { #scope-for-sub-dependencies }
+
+जब आप `scope="request"` (default) वाली dependency declare करते हैं, तो किसी भी sub-dependency का `scope` भी `"request"` होना चाहिए।
+
+लेकिन `"function"` के `scope` वाली dependency के पास `"function"` और `"request"` scope वाली dependencies हो सकती हैं।
+
+ऐसा इसलिए है क्योंकि किसी भी dependency को sub-dependencies से पहले अपना exit code run करने में सक्षम होना चाहिए, क्योंकि उसे अपने exit code के दौरान अभी भी उनका उपयोग करने की ज़रूरत हो सकती है।
+
+```mermaid
+sequenceDiagram
+
+participant client as Client
+participant dep_req as Dep scope="request"
+participant dep_func as Dep scope="function"
+participant operation as Path Operation
+
+ client ->> dep_req: Start request
+ Note over dep_req: Run code up to yield
+ dep_req ->> dep_func: Pass dependency
+ Note over dep_func: Run code up to yield
+ dep_func ->> operation: Run path operation with dependency
+ operation ->> dep_func: Return from path operation
+ Note over dep_func: Run code after yield
+ Note over dep_func: ✅ Dependency closed
+ dep_func ->> client: Send response to client
+ Note over client: Response sent
+ Note over dep_req: Run code after yield
+ Note over dep_req: ✅ Dependency closed
+```
+
+## `yield`, `HTTPException`, `except` और Background Tasks वाली Dependencies { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+`yield` वाली Dependencies समय के साथ अलग-अलग use cases cover करने और कुछ issues fix करने के लिए evolve हुई हैं।
+
+अगर आप देखना चाहते हैं कि FastAPI के अलग-अलग versions में क्या बदला है, तो आप इसके बारे में advanced guide में, [Advanced Dependencies - `yield`, `HTTPException`, `except` और Background Tasks वाली Dependencies](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks) में और पढ़ सकते हैं।
+
+## Context Managers { #context-managers }
+
+### "Context Managers" क्या हैं { #what-are-context-managers }
+
+"Context Managers" उन Python objects में से कोई भी हैं जिनका उपयोग आप `with` statement में कर सकते हैं।
+
+उदाहरण के लिए, [आप file पढ़ने के लिए `with` का उपयोग कर सकते हैं](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files):
+
+```Python
+with open("./somefile.txt") as f:
+ contents = f.read()
+ print(contents)
+```
+
+अंदर से, `open("./somefile.txt")` एक object बनाता है जिसे "Context Manager" कहा जाता है।
+
+जब `with` block खत्म होता है, तो यह file को close करना सुनिश्चित करता है, भले ही exceptions आई हों।
+
+जब आप `yield` वाली dependency बनाते हैं, तो **FastAPI** internally उसके लिए एक context manager बनाएगा, और उसे कुछ अन्य related tools के साथ combine करेगा।
+
+### `yield` वाली dependencies में context managers का उपयोग करना { #using-context-managers-in-dependencies-with-yield }
+
+/// warning | चेतावनी
+
+यह कमोबेश एक "advanced" idea है।
+
+अगर आप अभी **FastAPI** शुरू ही कर रहे हैं, तो शायद आप इसे अभी skip करना चाहेंगे।
+
+///
+
+Python में, आप [दो methods वाली class बनाकर: `__enter__()` और `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers) Context Managers बना सकते हैं।
+
+आप dependency function के अंदर `with` या `async with` statements का उपयोग करके इन्हें `yield` वाली **FastAPI** dependencies के अंदर भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial010_py310.py hl[1:9,13] *}
+
+/// tip | सुझाव
+
+Context manager बनाने का एक और तरीका है:
+
+* [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) या
+* [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)
+
+इनका उपयोग single `yield` वाले function को decorate करने के लिए करना।
+
+**FastAPI** internally `yield` वाली dependencies के लिए यही उपयोग करता है।
+
+लेकिन आपको FastAPI dependencies के लिए decorators का उपयोग करने की ज़रूरत नहीं है (और आपको नहीं करना चाहिए)।
+
+FastAPI internally आपके लिए यह कर देगा।
+
+///
diff --git a/docs/hi/docs/tutorial/dependencies/global-dependencies.md b/docs/hi/docs/tutorial/dependencies/global-dependencies.md
new file mode 100644
index 000000000..e313b40f0
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/global-dependencies.md
@@ -0,0 +1,16 @@
+# वैश्विक Dependencies { #global-dependencies }
+
+कुछ प्रकार के applications के लिए आप पूरे application में dependencies जोड़ना चाह सकते हैं।
+
+जिस तरह आप [*path operation decorators* में `dependencies` जोड़ सकते हैं](dependencies-in-path-operation-decorators.md), उसी तरह आप उन्हें `FastAPI` application में भी जोड़ सकते हैं।
+
+उस स्थिति में, वे application की सभी *path operations* पर लागू होंगी:
+
+{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
+
+
+और [*path operation decorators* में `dependencies` जोड़ने](dependencies-in-path-operation-decorators.md) वाले section की सभी बातें अभी भी लागू होती हैं, लेकिन इस मामले में, app की सभी *path operations* पर।
+
+## *path operations* के समूहों के लिए Dependencies { #dependencies-for-groups-of-path-operations }
+
+बाद में, जब आप बड़े applications को संरचित करने के तरीके के बारे में पढ़ेंगे ([बड़े Applications - कई Files](../../tutorial/bigger-applications.md)), संभवतः कई files के साथ, तो आप सीखेंगे कि *path operations* के एक समूह के लिए एक ही `dependencies` parameter कैसे declare किया जाए।
diff --git a/docs/hi/docs/tutorial/dependencies/index.md b/docs/hi/docs/tutorial/dependencies/index.md
new file mode 100644
index 000000000..903e43391
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/index.md
@@ -0,0 +1,250 @@
+# Dependencies { #dependencies }
+
+**FastAPI** में एक बहुत शक्तिशाली लेकिन सहज **Dependency Injection** system है।
+
+इसे उपयोग में बहुत सरल होने के लिए, और किसी भी developer के लिए दूसरे components को **FastAPI** के साथ integrate करना बहुत आसान बनाने के लिए design किया गया है।
+
+## "Dependency Injection" क्या है { #what-is-dependency-injection }
+
+**"Dependency Injection"** का मतलब programming में यह है कि आपके code (इस मामले में, आपके *path operation functions*) के पास यह declare करने का एक तरीका होता है कि उसे काम करने और उपयोग करने के लिए किन चीज़ों की ज़रूरत है: "dependencies"।
+
+और फिर, वह system (इस मामले में **FastAPI**) आपके code को वे ज़रूरी dependencies उपलब्ध कराने के लिए जो भी required है, उसका ध्यान रखेगा (dependencies को "inject" करेगा)।
+
+यह तब बहुत उपयोगी होता है जब आपको:
+
+* shared logic चाहिए (वही code logic बार-बार)।
+* database connections share करने हों।
+* security, authentication, role requirements, आदि enforce करने हों।
+* और भी कई चीज़ें...
+
+ये सब, code repetition को कम से कम रखते हुए।
+
+## पहले कदम { #first-steps }
+
+आइए एक बहुत सरल उदाहरण देखते हैं। यह इतना सरल होगा कि अभी के लिए बहुत उपयोगी नहीं है।
+
+लेकिन इस तरह हम इस बात पर focus कर सकते हैं कि **Dependency Injection** system कैसे काम करता है।
+
+### एक dependency, या "dependable" बनाएँ { #create-a-dependency-or-dependable }
+
+पहले dependency पर focus करते हैं।
+
+यह बस एक function है जो वे सभी समान parameters ले सकता है जो एक *path operation function* ले सकता है:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}
+
+बस इतना ही।
+
+**2 lines**।
+
+और इसका shape और structure वही है जो आपके सभी *path operation functions* का होता है।
+
+आप इसे "decorator" के बिना एक *path operation function* के रूप में सोच सकते हैं (`@app.get("/some-path")` के बिना)।
+
+और यह आपकी इच्छा के अनुसार कुछ भी return कर सकता है।
+
+इस मामले में, यह dependency अपेक्षा करती है:
+
+* एक optional query parameter `q` जो `str` है।
+* एक optional query parameter `skip` जो `int` है, और default रूप से `0` है।
+* एक optional query parameter `limit` जो `int` है, और default रूप से `100` है।
+
+और फिर यह बस उन values वाला एक `dict` return करता है।
+
+/// note | नोट
+
+FastAPI ने version 0.95.0 में `Annotated` के लिए support जोड़ा (और इसे recommend करना शुरू किया)।
+
+अगर आपके पास पुराना version है, तो `Annotated` का उपयोग करने की कोशिश करते समय आपको errors मिलेंगे।
+
+`Annotated` का उपयोग करने से पहले सुनिश्चित करें कि आप [FastAPI version को Upgrade](../../deployment/versions.md#upgrading-the-fastapi-versions) करके कम से कम 0.95.1 कर लें।
+
+///
+
+### `Depends` import करें { #import-depends }
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[3] *}
+
+### "dependant" में dependency declare करें { #declare-the-dependency-in-the-dependant }
+
+जिस तरह आप अपने *path operation function* parameters के साथ `Body`, `Query`, आदि का उपयोग करते हैं, उसी तरह एक नए parameter के साथ `Depends` का उपयोग करें:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[13,18] *}
+
+हालाँकि आप अपने function के parameters में `Depends` का उपयोग उसी तरह करते हैं जैसे आप `Body`, `Query`, आदि का उपयोग करते हैं, `Depends` थोड़ा अलग तरीके से काम करता है।
+
+आप `Depends` को केवल एक parameter देते हैं।
+
+यह parameter किसी function जैसा होना चाहिए।
+
+आप इसे सीधे **call नहीं करते** (अंत में parentheses नहीं जोड़ते), आप बस इसे `Depends()` को एक parameter के रूप में pass करते हैं।
+
+और वह function उसी तरह parameters लेता है जैसे *path operation functions* लेते हैं।
+
+/// tip | सुझाव
+
+अगले chapter में आप देखेंगे कि functions के अलावा कौन सी दूसरी "चीज़ें" dependencies के रूप में उपयोग की जा सकती हैं।
+
+///
+
+जब भी कोई नया request आता है, **FastAPI** इन बातों का ध्यान रखेगा:
+
+* आपकी dependency ("dependable") function को सही parameters के साथ call करना।
+* आपके function से result लेना।
+* उस result को आपके *path operation function* के parameter को assign करना।
+
+```mermaid
+graph TB
+
+common_parameters(["common_parameters"])
+read_items["/items/"]
+read_users["/users/"]
+
+common_parameters --> read_items
+common_parameters --> read_users
+```
+
+इस तरह आप shared code एक बार लिखते हैं और **FastAPI** आपके *path operations* के लिए उसे call करने का ध्यान रखता है।
+
+/// tip | सुझाव
+
+ध्यान दें कि आपको कोई special class बनाकर उसे **FastAPI** को "register" करने के लिए कहीं pass करने या ऐसा कुछ करने की ज़रूरत नहीं है।
+
+आप बस इसे `Depends` को pass करते हैं और **FastAPI** जानता है कि बाकी कैसे करना है।
+
+///
+
+## `Annotated` dependencies share करें { #share-annotated-dependencies }
+
+ऊपर के उदाहरणों में, आप देखते हैं कि **code duplication** का थोड़ा सा हिस्सा है।
+
+जब आपको `common_parameters()` dependency का उपयोग करना हो, तो आपको type annotation और `Depends()` के साथ पूरा parameter लिखना पड़ता है:
+
+```Python
+commons: Annotated[dict, Depends(common_parameters)]
+```
+
+लेकिन क्योंकि हम `Annotated` का उपयोग कर रहे हैं, हम उस `Annotated` value को एक variable में store कर सकते हैं और कई जगहों पर उपयोग कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial001_02_an_py310.py hl[12,16,21] *}
+
+/// tip | सुझाव
+
+यह बस standard Python है, इसे "type alias" कहा जाता है, यह वास्तव में **FastAPI** के लिए specific नहीं है।
+
+लेकिन क्योंकि **FastAPI** Python standards पर आधारित है, जिसमें `Annotated` भी शामिल है, आप अपने code में इस trick का उपयोग कर सकते हैं। 😎
+
+///
+
+dependencies अपेक्षित रूप से काम करती रहेंगी, और **सबसे अच्छी बात** यह है कि **type information preserve रहेगी**, जिसका मतलब है कि आपका editor आपको **autocompletion**, **inline errors**, आदि प्रदान करना जारी रख सकेगा। यही बात `mypy` जैसे दूसरे tools के लिए भी लागू होती है।
+
+यह खास तौर पर तब उपयोगी होगा जब आप इसे एक **large code base** में उपयोग करते हैं जहाँ आप **वही dependencies** बार-बार **कई *path operations*** में उपयोग करते हैं।
+
+## `async` करें या `async` न करें { #to-async-or-not-to-async }
+
+क्योंकि dependencies को भी **FastAPI** द्वारा call किया जाएगा (आपके *path operation functions* की तरह), functions define करते समय वही rules लागू होते हैं।
+
+आप `async def` या सामान्य `def` का उपयोग कर सकते हैं।
+
+और आप normal `def` *path operation functions* के अंदर `async def` dependencies declare कर सकते हैं, या `async def` *path operation functions* के अंदर `def` dependencies, आदि।
+
+इससे फर्क नहीं पड़ता। **FastAPI** जानता होगा कि क्या करना है।
+
+/// note | नोट
+
+अगर आपको नहीं पता, तो docs में `async` और `await` के बारे में [Async: *"In a hurry?"*](../../async.md#in-a-hurry) section देखें।
+
+///
+
+## OpenAPI के साथ integrated { #integrated-with-openapi }
+
+आपकी dependencies (और sub-dependencies) की सभी request declarations, validations और requirements उसी OpenAPI schema में integrate की जाएँगी।
+
+इसलिए, interactive docs में इन dependencies की सारी जानकारी भी होगी:
+
+
+
+## सरल उपयोग { #simple-usage }
+
+अगर आप इसे देखें, तो *path operation functions* इस तरह declare किए जाते हैं कि जब भी कोई *path* और *operation* match करता है, उनका उपयोग किया जाए, और फिर **FastAPI** सही parameters के साथ function को call करने और request से data extract करने का ध्यान रखता है।
+
+असल में, सभी (या अधिकांश) web frameworks इसी तरह काम करते हैं।
+
+आप उन functions को कभी सीधे call नहीं करते। वे आपके framework द्वारा call किए जाते हैं (इस मामले में, **FastAPI**)।
+
+Dependency Injection system के साथ, आप **FastAPI** को यह भी बता सकते हैं कि आपका *path operation function* किसी और चीज़ पर भी "depend" करता है जिसे आपके *path operation function* से पहले execute किया जाना चाहिए, और **FastAPI** उसे execute करने और results को "inject" करने का ध्यान रखेगा।
+
+"dependency injection" के इसी idea के लिए अन्य common terms हैं:
+
+* resources
+* providers
+* services
+* injectables
+* components
+
+## **FastAPI** plug-ins { #fastapi-plug-ins }
+
+Integrations और "plug-ins" **Dependency Injection** system का उपयोग करके बनाए जा सकते हैं। लेकिन वास्तव में, **"plug-ins" बनाने की कोई ज़रूरत नहीं है**, क्योंकि dependencies का उपयोग करके अनगिनत integrations और interactions declare किए जा सकते हैं जो आपके *path operation functions* के लिए उपलब्ध हो जाते हैं।
+
+और dependencies को बहुत सरल और सहज तरीके से बनाया जा सकता है, जिससे आप बस अपने required Python packages import कर सकते हैं, और उन्हें अपने API functions के साथ कुछ lines of code में integrate कर सकते हैं, *literally*।
+
+आप अगले chapters में relational और NoSQL databases, security, आदि के बारे में इसके examples देखेंगे।
+
+## **FastAPI** compatibility { #fastapi-compatibility }
+
+Dependency injection system की सरलता **FastAPI** को इनके साथ compatible बनाती है:
+
+* सभी relational databases
+* NoSQL databases
+* external packages
+* external APIs
+* authentication और authorization systems
+* API usage monitoring systems
+* response data injection systems
+* आदि।
+
+## सरल और शक्तिशाली { #simple-and-powerful }
+
+हालाँकि hierarchical dependency injection system को define और use करना बहुत सरल है, फिर भी यह बहुत शक्तिशाली है।
+
+आप ऐसी dependencies define कर सकते हैं जो बदले में खुद dependencies define कर सकती हैं।
+
+अंत में, dependencies का एक hierarchical tree बनता है, और **Dependency Injection** system आपके लिए इन सभी dependencies (और उनकी sub-dependencies) को solve करने और हर step पर results प्रदान करने (inject करने) का ध्यान रखता है।
+
+उदाहरण के लिए, मान लें कि आपके पास 4 API endpoints (*path operations*) हैं:
+
+* `/items/public/`
+* `/items/private/`
+* `/users/{user_id}/activate`
+* `/items/pro/`
+
+तो आप उनमें से हर एक के लिए अलग-अलग permission requirements केवल dependencies और sub-dependencies के साथ जोड़ सकते हैं:
+
+```mermaid
+graph TB
+
+current_user(["current_user"])
+active_user(["active_user"])
+admin_user(["admin_user"])
+paying_user(["paying_user"])
+
+public["/items/public/"]
+private["/items/private/"]
+activate_user["/users/{user_id}/activate"]
+pro_items["/items/pro/"]
+
+current_user --> active_user
+active_user --> admin_user
+active_user --> paying_user
+
+current_user --> public
+active_user --> private
+admin_user --> activate_user
+paying_user --> pro_items
+```
+
+## **OpenAPI** के साथ integrated { #integrated-with-openapi_1 }
+
+ये सभी dependencies, अपनी requirements declare करते समय, आपके *path operations* में parameters, validations, आदि भी जोड़ती हैं।
+
+**FastAPI** यह सब OpenAPI schema में जोड़ने का ध्यान रखेगा, ताकि यह interactive documentation systems में दिखाया जा सके।
diff --git a/docs/hi/docs/tutorial/dependencies/sub-dependencies.md b/docs/hi/docs/tutorial/dependencies/sub-dependencies.md
new file mode 100644
index 000000000..7fb4bbdb7
--- /dev/null
+++ b/docs/hi/docs/tutorial/dependencies/sub-dependencies.md
@@ -0,0 +1,105 @@
+# Sub-dependencies { #sub-dependencies }
+
+आप ऐसी dependencies बना सकते हैं जिनकी अपनी **sub-dependencies** हों।
+
+वे उतनी **deep** हो सकती हैं जितनी आपको चाहिए।
+
+**FastAPI** उन्हें solve करने का ध्यान रखेगा।
+
+## पहली dependency "dependable" { #first-dependency-dependable }
+
+आप पहली dependency ("dependable") इस तरह बना सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}
+
+यह एक optional query parameter `q` को `str` के रूप में declare करता है, और फिर बस उसे return करता है।
+
+यह काफी सरल है (बहुत उपयोगी नहीं), लेकिन इससे हमें यह समझने पर ध्यान देने में मदद मिलेगी कि sub-dependencies कैसे काम करती हैं।
+
+## दूसरी dependency, "dependable" और "dependant" { #second-dependency-dependable-and-dependant }
+
+फिर आप एक और dependency function (एक "dependable") बना सकते हैं जो उसी समय अपनी खुद की dependency declare करता है (इसलिए यह एक "dependant" भी है):
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[13] *}
+
+आइए declared parameters पर ध्यान दें:
+
+* भले ही यह function खुद एक dependency ("dependable") है, यह एक और dependency भी declare करता है (यह किसी और चीज़ पर "depends" करता है)।
+ * यह `query_extractor` पर depends करता है, और उसके द्वारा return किए गए value को parameter `q` में assign करता है।
+* यह एक optional `last_query` cookie को भी `str` के रूप में declare करता है।
+ * अगर user ने कोई query `q` provide नहीं की, तो हम पिछली इस्तेमाल की गई query का उपयोग करते हैं, जिसे हमने पहले एक cookie में save किया था।
+
+## dependency का उपयोग करें { #use-the-dependency }
+
+फिर हम dependency का उपयोग इस तरह कर सकते हैं:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[23] *}
+
+/// note | नोट
+
+ध्यान दें कि हम *path operation function* में केवल एक dependency declare कर रहे हैं, `query_or_cookie_extractor`।
+
+लेकिन **FastAPI** को पता होगा कि `query_or_cookie_extractor` को call करते समय उसके results pass करने के लिए पहले `query_extractor` को solve करना है।
+
+///
+
+```mermaid
+graph TB
+
+query_extractor(["query_extractor"])
+query_or_cookie_extractor(["query_or_cookie_extractor"])
+
+read_query["/items/"]
+
+query_extractor --> query_or_cookie_extractor --> read_query
+```
+
+## उसी dependency को कई बार उपयोग करना { #using-the-same-dependency-multiple-times }
+
+अगर आपकी किसी dependency को उसी *path operation* के लिए कई बार declare किया गया है, उदाहरण के लिए, कई dependencies की कोई common sub-dependency है, तो **FastAPI** जानता होगा कि उस sub-dependency को प्रति request केवल एक बार call करना है।
+
+और यह return किए गए value को एक "cache" में save करेगा और उसे उन सभी "dependants" को pass करेगा जिन्हें उस specific request में इसकी ज़रूरत है, बजाय उसी request के लिए dependency को कई बार call करने के।
+
+एक advanced scenario में, जहाँ आप जानते हैं कि आपको उसी request में "cached" value का उपयोग करने के बजाय हर step पर dependency को call करवाना है (संभवतः कई बार), आप `Depends` का उपयोग करते समय parameter `use_cache=False` set कर सकते हैं:
+
+//// tab | Python 3.10+
+
+```Python hl_lines="1"
+async def needy_dependency(fresh_value: Annotated[str, Depends(get_value, use_cache=False)]):
+ return {"fresh_value": fresh_value}
+```
+
+////
+
+//// tab | Python 3.10+ non-Annotated
+
+/// tip | सुझाव
+
+अगर संभव हो तो `Annotated` version का उपयोग करना पसंद करें।
+
+///
+
+```Python hl_lines="1"
+async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False)):
+ return {"fresh_value": fresh_value}
+```
+
+////
+
+## Recap { #recap }
+
+यहाँ इस्तेमाल किए गए सभी fancy words को छोड़ दें, तो **Dependency Injection** system काफी सरल है।
+
+बस ऐसे functions जो *path operation functions* जैसे ही दिखते हैं।
+
+लेकिन फिर भी, यह बहुत powerful है, और आपको arbitrarily deeply nested dependency "graphs" (trees) declare करने देता है।
+
+/// tip | सुझाव
+
+इन सरल examples के साथ यह सब इतना उपयोगी नहीं लग सकता।
+
+लेकिन **security** के बारे में chapters में आप देखेंगे कि यह कितना उपयोगी है।
+
+और आप यह भी देखेंगे कि यह आपका कितना code बचाएगा।
+
+///
diff --git a/docs/hi/docs/tutorial/encoder.md b/docs/hi/docs/tutorial/encoder.md
new file mode 100644
index 000000000..66dbbca2b
--- /dev/null
+++ b/docs/hi/docs/tutorial/encoder.md
@@ -0,0 +1,35 @@
+# JSON संगत Encoder { #json-compatible-encoder }
+
+कुछ मामलों में आपको किसी data type (जैसे Pydantic model) को JSON के साथ संगत किसी चीज़ (जैसे `dict`, `list`, आदि) में convert करने की ज़रूरत पड़ सकती है।
+
+उदाहरण के लिए, अगर आपको इसे database में store करना हो।
+
+इसके लिए, **FastAPI** एक `jsonable_encoder()` function प्रदान करता है।
+
+## `jsonable_encoder` का उपयोग करना { #using-the-jsonable-encoder }
+
+कल्पना करें कि आपके पास एक database `fake_db` है जो केवल JSON संगत data ही स्वीकार करता है।
+
+उदाहरण के लिए, यह `datetime` objects स्वीकार नहीं करता, क्योंकि वे JSON के साथ संगत नहीं होते।
+
+इसलिए, एक `datetime` object को [ISO format](https://en.wikipedia.org/wiki/ISO_8601) में data रखने वाले `str` में convert करना होगा।
+
+इसी तरह, यह database Pydantic model (attributes वाला एक object) स्वीकार नहीं करेगा, केवल एक `dict`।
+
+इसके लिए आप `jsonable_encoder` का उपयोग कर सकते हैं।
+
+यह एक object, जैसे Pydantic model, प्राप्त करता है और JSON संगत version लौटाता है:
+
+{* ../../docs_src/encoder/tutorial001_py310.py hl[4,21] *}
+
+इस उदाहरण में, यह Pydantic model को `dict` में और `datetime` को `str` में convert करेगा।
+
+इसे call करने का परिणाम कुछ ऐसा होता है जिसे Python standard [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps) के साथ encode किया जा सकता है।
+
+यह JSON format में data रखने वाला कोई बड़ा `str` (string के रूप में) return नहीं करता। यह एक Python standard data structure (जैसे `dict`) return करता है, जिसमें values और sub-values होती हैं जो सभी JSON के साथ संगत होती हैं।
+
+/// note | नोट
+
+`jsonable_encoder` वास्तव में **FastAPI** द्वारा internally data convert करने के लिए उपयोग किया जाता है। लेकिन यह कई अन्य scenarios में भी उपयोगी है।
+
+///
diff --git a/docs/hi/docs/tutorial/extra-data-types.md b/docs/hi/docs/tutorial/extra-data-types.md
new file mode 100644
index 000000000..a157ea017
--- /dev/null
+++ b/docs/hi/docs/tutorial/extra-data-types.md
@@ -0,0 +1,62 @@
+# अतिरिक्त Data Types { #extra-data-types }
+
+अब तक, आप सामान्य data types का उपयोग करते रहे हैं, जैसे:
+
+* `int`
+* `float`
+* `str`
+* `bool`
+
+लेकिन आप अधिक जटिल data types भी उपयोग कर सकते हैं।
+
+और आपको अब तक देखी गई वही features मिलती रहेंगी:
+
+* शानदार editor support.
+* आने वाली requests से data conversion.
+* response data के लिए data conversion.
+* Data validation.
+* Automatic annotation और documentation.
+
+## अन्य data types { #other-data-types }
+
+यहाँ कुछ अतिरिक्त data types हैं जिनका आप उपयोग कर सकते हैं:
+
+* `UUID`:
+ * एक standard "Universally Unique Identifier", जो कई databases और systems में ID के रूप में आम है।
+ * requests और responses में इसे `str` के रूप में दर्शाया जाएगा।
+* `datetime.datetime`:
+ * एक Python `datetime.datetime`.
+ * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `2008-09-15T15:53:00+05:00`.
+* `datetime.date`:
+ * Python `datetime.date`.
+ * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `2008-09-15`.
+* `datetime.time`:
+ * एक Python `datetime.time`.
+ * requests और responses में इसे ISO 8601 format में `str` के रूप में दर्शाया जाएगा, जैसे: `14:23:55.003`.
+* `datetime.timedelta`:
+ * एक Python `datetime.timedelta`.
+ * requests और responses में इसे कुल seconds के `float` के रूप में दर्शाया जाएगा।
+ * Pydantic इसे "ISO 8601 time diff encoding" के रूप में दर्शाने की अनुमति भी देता है, [अधिक जानकारी के लिए docs देखें](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers).
+* `frozenset`:
+ * requests और responses में, इसे `set` जैसा ही माना जाता है:
+ * requests में, एक list पढ़ी जाएगी, duplicates हटाए जाएँगे और उसे `set` में convert किया जाएगा।
+ * responses में, `set` को `list` में convert किया जाएगा।
+ * generate किया गया schema बताएगा कि `set` values unique हैं (JSON Schema के `uniqueItems` का उपयोग करते हुए)।
+* `bytes`:
+ * Standard Python `bytes`.
+ * requests और responses में इसे `str` की तरह माना जाएगा।
+ * generate किया गया schema बताएगा कि यह `binary` "format" वाला `str` है।
+* `Decimal`:
+ * Standard Python `Decimal`.
+ * requests और responses में, इसे `float` जैसा ही handle किया जाएगा।
+* आप सभी valid Pydantic data types यहाँ देख सकते हैं: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/).
+
+## उदाहरण { #example }
+
+यहाँ ऊपर दिए गए कुछ types का उपयोग करते हुए parameters वाला एक उदाहरण *path operation* है।
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
+
+ध्यान दें कि function के अंदर parameters के अपने natural data type होते हैं, और उदाहरण के लिए, आप सामान्य date manipulations कर सकते हैं, जैसे:
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[18:19] *}
diff --git a/docs/hi/docs/tutorial/extra-models.md b/docs/hi/docs/tutorial/extra-models.md
new file mode 100644
index 000000000..93a4e91dc
--- /dev/null
+++ b/docs/hi/docs/tutorial/extra-models.md
@@ -0,0 +1,211 @@
+# Extra Models { #extra-models }
+
+पिछले उदाहरण को आगे बढ़ाते हुए, एक से अधिक संबंधित model होना आम बात होगी।
+
+यह खासकर user models के मामले में होता है, क्योंकि:
+
+* **input model** में password हो सकने की क्षमता चाहिए।
+* **output model** में password नहीं होना चाहिए।
+* **database model** में शायद hashed password होना चाहिए।
+
+/// danger | खतरा
+
+user के plaintext passwords कभी store न करें। हमेशा एक "secure hash" store करें जिसे आप बाद में verify कर सकें।
+
+अगर आप नहीं जानते, तो आप [security chapters](security/simple-oauth2.md#password-hashing) में सीखेंगे कि "password hash" क्या होता है।
+
+///
+
+## कई models { #multiple-models }
+
+यह एक सामान्य idea है कि models अपने password fields और जहाँ वे इस्तेमाल होते हैं, वहाँ कैसे दिख सकते हैं:
+
+{* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
+
+### `**user_in.model_dump()` के बारे में { #about-user-in-model-dump }
+
+#### Pydantic का `.model_dump()` { #pydantics-model-dump }
+
+`user_in`, class `UserIn` का एक Pydantic model है।
+
+Pydantic models में एक `.model_dump()` method होता है जो model के data के साथ एक `dict` return करता है।
+
+तो, अगर हम इस तरह एक Pydantic object `user_in` बनाते हैं:
+
+```Python
+user_in = UserIn(username="john", password="secret", email="john.doe@example.com")
+```
+
+और फिर हम call करते हैं:
+
+```Python
+user_dict = user_in.model_dump()
+```
+
+तो अब हमारे पास variable `user_dict` में data के साथ एक `dict` है (यह Pydantic model object के बजाय एक `dict` है)।
+
+और अगर हम call करते हैं:
+
+```Python
+print(user_dict)
+```
+
+तो हमें यह Python `dict` मिलेगा:
+
+```Python
+{
+ 'username': 'john',
+ 'password': 'secret',
+ 'email': 'john.doe@example.com',
+ 'full_name': None,
+}
+```
+
+#### एक `dict` को unpack करना { #unpacking-a-dict }
+
+अगर हम `user_dict` जैसा एक `dict` लेते हैं और उसे किसी function (या class) को `**user_dict` के साथ pass करते हैं, तो Python उसे "unpack" करेगा। यह `user_dict` की keys और values को सीधे key-value arguments के रूप में pass करेगा।
+
+तो, ऊपर वाले `user_dict` को जारी रखते हुए, यह लिखना:
+
+```Python
+UserInDB(**user_dict)
+```
+
+कुछ इस equivalent result देगा:
+
+```Python
+UserInDB(
+ username="john",
+ password="secret",
+ email="john.doe@example.com",
+ full_name=None,
+)
+```
+
+या अधिक सही रूप में, `user_dict` को सीधे इस्तेमाल करते हुए, उसमें भविष्य में जो भी contents हों:
+
+```Python
+UserInDB(
+ username = user_dict["username"],
+ password = user_dict["password"],
+ email = user_dict["email"],
+ full_name = user_dict["full_name"],
+)
+```
+
+#### दूसरे model के contents से एक Pydantic model { #a-pydantic-model-from-the-contents-of-another }
+
+जैसा कि ऊपर के उदाहरण में हमें `user_in.model_dump()` से `user_dict` मिला, यह code:
+
+```Python
+user_dict = user_in.model_dump()
+UserInDB(**user_dict)
+```
+
+इसके equivalent होगा:
+
+```Python
+UserInDB(**user_in.model_dump())
+```
+
+...क्योंकि `user_in.model_dump()` एक `dict` है, और फिर हम उसे `**` prefix के साथ `UserInDB` को pass करके Python से उसे "unpack" करवाते हैं।
+
+तो, हमें एक Pydantic model के data से दूसरा Pydantic model मिलता है।
+
+#### एक `dict` को unpack करना और extra keywords { #unpacking-a-dict-and-extra-keywords }
+
+और फिर extra keyword argument `hashed_password=hashed_password` जोड़ना, जैसे:
+
+```Python
+UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
+```
+
+...अंत में ऐसा बन जाता है:
+
+```Python
+UserInDB(
+ username = user_dict["username"],
+ password = user_dict["password"],
+ email = user_dict["email"],
+ full_name = user_dict["full_name"],
+ hashed_password = hashed_password,
+)
+```
+
+/// warning | चेतावनी
+
+supporting additional functions `fake_password_hasher` और `fake_save_user` सिर्फ data के एक possible flow को demo करने के लिए हैं, लेकिन वे निश्चित रूप से कोई real security नहीं दे रहे हैं।
+
+///
+
+## Duplication कम करें { #reduce-duplication }
+
+Code duplication कम करना **FastAPI** के core ideas में से एक है।
+
+क्योंकि code duplication बढ़ने से bugs, security issues, code desynchronization issues (जब आप एक जगह update करते हैं लेकिन बाकी जगह नहीं), आदि की संभावना बढ़ जाती है।
+
+और ये models बहुत सारा data share कर रहे हैं और attribute names और types को duplicate कर रहे हैं।
+
+हम इससे बेहतर कर सकते हैं।
+
+हम एक `UserBase` model declare कर सकते हैं जो हमारे दूसरे models के लिए base की तरह काम करता है। और फिर हम उस model की subclasses बना सकते हैं जो उसके attributes (type declarations, validation, आदि) inherit करती हैं।
+
+सारा data conversion, validation, documentation, आदि सामान्य रूप से काम करता रहेगा।
+
+इस तरह, हम केवल models के बीच के अंतर declare कर सकते हैं (plaintext `password` के साथ, `hashed_password` के साथ और password के बिना):
+
+{* ../../docs_src/extra_models/tutorial002_py310.py hl[7,13:14,17:18,21:22] *}
+
+## `Union` या `anyOf` { #union-or-anyof }
+
+आप response को दो या अधिक types के `Union` के रूप में declare कर सकते हैं, जिसका मतलब है कि response उनमें से कोई भी हो सकता है।
+
+इसे OpenAPI में `anyOf` के साथ define किया जाएगा।
+
+ऐसा करने के लिए, standard Python type hint [`typing.Union`](https://docs.python.org/3/library/typing.html#typing.Union) का इस्तेमाल करें:
+
+/// note | नोट
+
+[`Union`](https://docs.pydantic.dev/latest/concepts/types/#unions) define करते समय, सबसे specific type को पहले include करें, उसके बाद कम specific type को। नीचे दिए गए उदाहरण में, अधिक specific `PlaneItem`, `Union[PlaneItem, CarItem]` में `CarItem` से पहले आता है।
+
+///
+
+{* ../../docs_src/extra_models/tutorial003_py310.py hl[1,14:15,18:20,33] *}
+
+### Python 3.10 में `Union` { #union-in-python-3-10 }
+
+इस उदाहरण में हम argument `response_model` की value के रूप में `Union[PlaneItem, CarItem]` pass करते हैं।
+
+क्योंकि हम इसे **type annotation** में रखने के बजाय **argument को value** के रूप में pass कर रहे हैं, इसलिए हमें Python 3.10 में भी `Union` इस्तेमाल करना होगा।
+
+अगर यह type annotation में होता तो हम vertical bar इस्तेमाल कर सकते थे, जैसे:
+
+```Python
+some_variable: PlaneItem | CarItem
+```
+
+लेकिन अगर हम इसे assignment `response_model=PlaneItem | CarItem` में डालते, तो हमें error मिलता, क्योंकि Python इसे type annotation के रूप में interpret करने के बजाय `PlaneItem` और `CarItem` के बीच एक **invalid operation** perform करने की कोशिश करता।
+
+## Models की list { #list-of-models }
+
+इसी तरह, आप objects की lists के responses declare कर सकते हैं।
+
+इसके लिए, standard Python `list` इस्तेमाल करें:
+
+{* ../../docs_src/extra_models/tutorial004_py310.py hl[18] *}
+
+## Arbitrary `dict` के साथ response { #response-with-arbitrary-dict }
+
+आप plain arbitrary `dict` का इस्तेमाल करके भी response declare कर सकते हैं, जिसमें Pydantic model का इस्तेमाल किए बिना केवल keys और values का type declare किया जाता है।
+
+यह तब उपयोगी है जब आपको valid field/attribute names (जो Pydantic model के लिए चाहिए होंगे) पहले से नहीं पता हों।
+
+इस मामले में, आप `dict` इस्तेमाल कर सकते हैं:
+
+{* ../../docs_src/extra_models/tutorial005_py310.py hl[6] *}
+
+## Recap { #recap }
+
+हर case के लिए कई Pydantic models इस्तेमाल करें और freely inherit करें।
+
+अगर किसी entity में अलग-अलग "states" हो सकने चाहिए, तो आपको प्रति entity एक ही data model रखने की जरूरत नहीं है। **user** "entity" एक उदाहरण है, जिसमें states में `password`, `password_hash`, या कोई password नहीं होना शामिल है।
diff --git a/docs/hi/docs/tutorial/first-steps.md b/docs/hi/docs/tutorial/first-steps.md
new file mode 100644
index 000000000..aa6fd4e37
--- /dev/null
+++ b/docs/hi/docs/tutorial/first-steps.md
@@ -0,0 +1,421 @@
+# पहले कदम { #first-steps }
+
+सबसे सरल FastAPI file ऐसी दिख सकती है:
+
+{* ../../docs_src/first_steps/tutorial001_py310.py *}
+
+इसे `main.py` नाम की file में copy करें।
+
+live server चलाएँ:
+
+get operation का उपयोग करते हुए
+
+/// note | `@decorator` जानकारी
+
+Python में उस `@something` syntax को "decorator" कहा जाता है।
+
+आप इसे किसी function के ऊपर लगाते हैं। जैसे एक सुंदर सजावटी टोपी (मुझे लगता है term वहीं से आया है)।
+
+एक "decorator" नीचे वाले function को लेता है और उसके साथ कुछ करता है।
+
+हमारे मामले में, यह decorator **FastAPI** को बताता है कि नीचे वाला function **path** `/` के साथ **operation** `get` से संबंधित है।
+
+यह "**path operation decorator**" है।
+
+///
+
+आप दूसरे operations भी उपयोग कर सकते हैं:
+
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+
+और कुछ अधिक असामान्य वाले:
+
+* `@app.options()`
+* `@app.head()`
+* `@app.patch()`
+* `@app.trace()`
+
+/// tip | सुझाव
+
+आप हर operation (HTTP method) को अपनी इच्छा के अनुसार उपयोग करने के लिए स्वतंत्र हैं।
+
+**FastAPI** कोई specific अर्थ enforce नहीं करता।
+
+यहाँ दी गई जानकारी guideline के रूप में प्रस्तुत की गई है, requirement के रूप में नहीं।
+
+उदाहरण के लिए, GraphQL का उपयोग करते समय आप आम तौर पर सभी actions केवल `POST` operations का उपयोग करके करते हैं।
+
+///
+
+### चरण 4: **path operation function** define करें { #step-4-define-the-path-operation-function }
+
+यह हमारा "**path operation function**" है:
+
+* **path**: `/` है।
+* **operation**: `get` है।
+* **function**: "decorator" के नीचे वाला function है (`@app.get("/")` के नीचे)।
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[7] *}
+
+यह एक Python function है।
+
+जब भी **FastAPI** को `GET` operation का उपयोग करके URL "`/`" पर कोई request मिलती है, तो यह इसे call करेगा।
+
+इस मामले में, यह एक `async` function है।
+
+---
+
+आप इसे `async def` के बजाय normal function के रूप में भी define कर सकते हैं:
+
+{* ../../docs_src/first_steps/tutorial003_py310.py hl[7] *}
+
+/// note | नोट
+
+अगर आपको अंतर नहीं पता है, तो [Async: *"In a hurry?"*](../async.md#in-a-hurry) देखें।
+
+///
+
+### चरण 5: content return करें { #step-5-return-the-content }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[8] *}
+
+आप `dict`, `list`, `str`, `int` आदि जैसे singular values return कर सकते हैं।
+
+आप Pydantic models भी return कर सकते हैं (इसके बारे में आप आगे और देखेंगे)।
+
+कई अन्य objects और models हैं जिन्हें अपने आप JSON में convert किया जाएगा (ORMs आदि सहित)। अपने पसंदीदा ones उपयोग करके देखें, बहुत संभावना है कि वे पहले से supported हों।
+
+### चरण 6: इसे Deploy करें { #step-6-deploy-it }
+
+अपनी app को **[FastAPI Cloud](https://fastapicloud.com)** पर एक command से deploy करें: `fastapi deploy`। 🎉
+
+#### FastAPI Cloud के बारे में { #about-fastapi-cloud }
+
+**[FastAPI Cloud](https://fastapicloud.com)** को **FastAPI** के पीछे मौजूद उसी author और team ने बनाया है।
+
+यह कम से कम प्रयास के साथ API को **बनाने**, **deploy करने**, और **access करने** की process को streamlined करता है।
+
+यह FastAPI के साथ apps बनाने जैसा ही **developer experience**, उन्हें cloud पर **deploy** करने में लाता है। 🎉
+
+FastAPI Cloud *FastAPI and friends* open source projects का प्राथमिक sponsor और funding provider है। ✨
+
+#### दूसरे cloud providers पर deploy करें { #deploy-to-other-cloud-providers }
+
+FastAPI open source है और standards पर आधारित है। आप FastAPI apps को अपनी पसंद के किसी भी cloud provider पर deploy कर सकते हैं।
+
+FastAPI apps को उनके साथ deploy करने के लिए अपने cloud provider की guides follow करें। 🤓
+
+## Recap { #recap }
+
+* `FastAPI` import करें।
+* एक `app` instance बनाएँ।
+* `@app.get("/")` जैसे decorators का उपयोग करके एक **path operation decorator** लिखें।
+* एक **path operation function** define करें; उदाहरण के लिए, `def root(): ...`।
+* `fastapi dev` command का उपयोग करके development server चलाएँ।
+* वैकल्पिक रूप से अपनी app को `fastapi deploy` के साथ deploy करें।
diff --git a/docs/hi/docs/tutorial/frontend.md b/docs/hi/docs/tutorial/frontend.md
new file mode 100644
index 000000000..bc8e188fc
--- /dev/null
+++ b/docs/hi/docs/tutorial/frontend.md
@@ -0,0 +1,139 @@
+# Frontend { #frontend }
+
+आप `app.frontend()` (या `router.frontend()`) के साथ static frontend apps serve कर सकते हैं।
+
+यह उन frontend tools के लिए उपयोगी है जो static files generate करते हैं, जैसे React with Vite, TanStack Router, Astro, Vue, Svelte, Angular, Solid, और अन्य।
+
+इन tools के साथ, आपके पास आमतौर पर एक step होता है जो frontend को build करता है, जैसे इस command के साथ:
+
+```bash
+npm run build
+```
+
+यह आपके frontend files के साथ `./dist/` जैसी एक directory generate करेगा।
+
+आप उस directory को इन frontend frameworks के लिए required conventions के अनुसार serve करने के लिए `app.frontend()` का उपयोग कर सकते हैं।
+
+**FastAPI** पहले *path operations* की जाँच करता है। frontend files की जाँच केवल तब की जाती है जब कोई सामान्य route match नहीं हुआ हो, इसलिए आपकी API प्रभावित नहीं होगी।
+
+## Frontend Serve करें { #serve-a-frontend }
+
+अपना frontend build करने के बाद, उदाहरण के लिए `npm run build` के साथ, generate की गई files को किसी directory में रखें, उदाहरण के लिए, `dist`।
+
+आपकी project संरचना ऐसी दिख सकती है:
+
+```text
+.
+├── pyproject.toml
+├── app
+│ ├── __init__.py
+│ └── main.py
+└── dist
+ ├── index.html
+ └── assets
+ └── app.js
+```
+
+फिर इसे `app.frontend()` के साथ serve करें:
+
+{* ../../docs_src/frontend/tutorial001_py310.py hl[5] *}
+
+इसके साथ, `/assets/app.js` के लिए एक request `dist/assets/app.js` serve कर सकती है।
+
+अगर आपके पास एक **FastAPI** *path operation* भी है, तो *path operation* को प्राथमिकता मिलती है।
+
+## Client-Side Routing { #client-side-routing }
+
+कई frontend apps, जिनमें **single-page apps** (SPAs) शामिल हैं, client-side routing का उपयोग करते हैं। `/dashboard/settings` जैसा path असली file नहीं हो सकता है, लेकिन framework इसे handle करने का ध्यान रखेगा।
+
+इसलिए, अगर उस URL को सीधे access किया जा रहा है (app के अंदर navigate करने के बजाय), तो backend को frontend app को `index.html` से serve करना चाहिए, ताकि frontend framework फिर client-side routing को handle कर सके।
+
+इसके लिए, `fallback="index.html"` का उपयोग करें:
+
+{* ../../docs_src/frontend/tutorial002_py310.py hl[5] *}
+
+**FastAPI** इस fallback का उपयोग केवल उन `GET` और `HEAD` requests के लिए करता है जो browser navigation जैसी दिखती हैं। JavaScript, CSS, और images जैसी missing files अभी भी `404` लौटाती हैं।
+
+अन्य methods वाली requests, जैसे `POST` या `PUT`, उन paths पर जो केवल frontend fallback से match करते हैं, वे भी `404` लौटाती हैं। नियमित **FastAPI** *path operations* की priority अभी भी frontend routes से अधिक होती है।
+
+/// tip | सुझाव
+
+Default रूप से, `fallback` की value `fallback="auto"` होती है। अधिकतर मामलों में आपको `fallback` specify करने की ज़रूरत नहीं होगी। विवरण के लिए नीचे पढ़ें।
+
+///
+
+यह वही है जो आप कई frontend apps के साथ चाहेंगे जो client-side routing का उपयोग करते हैं, उदाहरण के लिए, React with TanStack Router, Vue, Angular, SvelteKit, या Solid।
+
+## Custom 404 Page { #custom-404-page }
+
+आप missing frontend paths के लिए static `404.html` page भी serve कर सकते हैं:
+
+{* ../../docs_src/frontend/tutorial003_py310.py hl[5] *}
+
+वह response `404` का status code बनाए रखती है।
+
+इस मामले में, **FastAPI** missing frontend paths के लिए `index.html` serve नहीं करेगा। इसके बजाय यह `404.html` file लौटाएगा।
+
+/// tip | सुझाव
+
+Default रूप से, `fallback` की value `fallback="auto"` होती है। इसके साथ, अगर `404.html` file मिलती है, तो उसे अपने-आप fallback के रूप में उपयोग किया जाएगा।
+
+इसलिए, आप सामान्यतः `fallback` argument छोड़ सकते हैं।
+
+///
+
+यह उन frontend tools के साथ उपयोगी है जो हर page के लिए static HTML files generate करते हैं, जैसे Astro।
+
+## Fallback Auto { #fallback-auto }
+
+Default रूप से, `app.frontend()` `fallback="auto"` का उपयोग करता है।
+
+अगर frontend directory में `404.html` file है, तो missing frontend paths उस file को status code `404` के साथ serve करते हैं।
+
+अन्यथा, अगर `index.html` file है, तो missing browser navigation paths `index.html` serve करते हैं, जो client-side routing वाले कई frontend apps अपेक्षा करते हैं।
+
+इसलिए, अधिकतर मामलों में आप `fallback` argument specify किए बिना `app.frontend("/", directory="dist")` का उपयोग कर सकते हैं।
+
+{* ../../docs_src/frontend/tutorial001_py310.py hl[5] *}
+
+## Fallback बंद करें { #disable-fallback }
+
+अगर आप missing frontend paths के लिए fallback file serve नहीं करना चाहते, तो `fallback=None` का उपयोग करें:
+
+{* ../../docs_src/frontend/tutorial005_py310.py hl[5] *}
+
+फिर missing frontend paths सामान्य `404` लौटाते हैं।
+
+## Directory जाँचें { #check-directory }
+
+Default रूप से, `app.frontend()` app बनाते समय जाँचता है कि directory मौजूद है।
+
+यह configuration errors को जल्दी पकड़ने में मदद करता है। उदाहरण के लिए, अगर frontend build output directory missing है, तो **FastAPI** startup पर error raise करेगा।
+
+अगर आपकी frontend files बाद में बनाई जाती हैं, उदाहरण के लिए app object बनने के बाद किसी अलग build step द्वारा, तो `check_dir=False` set करें:
+
+{* ../../docs_src/frontend/tutorial006_py310.py hl[5] *}
+
+`check_dir=False` के साथ, **FastAPI** app बनाते समय directory की जाँच नहीं करेगा। अगर configured directory किसी request को handle करते समय अभी भी missing है, तो **FastAPI** तब error raise करेगा।
+
+## इसे `APIRouter` के साथ उपयोग करें { #use-it-with-apirouter }
+
+आप frontend files को `APIRouter` में भी जोड़ सकते हैं और उसे prefix के साथ include कर सकते हैं:
+
+{* ../../docs_src/frontend/tutorial004_py310.py hl[6,7] *}
+
+इस उदाहरण में, frontend paths `/app` के अंतर्गत serve किए जाते हैं।
+
+App में कोई भी नियमित *path operations* अभी भी precedence लेंगे, अन्य routers में शामिल ones भी।
+
+## Dependencies और Middleware { #dependencies-and-middleware }
+
+Frontend responses सामान्य **FastAPI** application के अंदर run करती हैं, इसलिए HTTP middleware उन पर लागू होता है।
+
+App से, `APIRouter` से, और `include_router()` से dependencies भी frontend responses पर लागू होती हैं। यह cookie authentication या इसी तरह से frontend को protect करने के लिए उपयोगी हो सकता है।
+
+## केवल Static Build Output { #static-build-output-only }
+
+`app.frontend()` आपके frontend build द्वारा पहले से generate की गई files serve करता है।
+
+यह server-side rendering run नहीं करता। यह उन frontend frameworks के लिए है जो static files generate करते हैं, न कि उन frameworks के लिए जिन्हें हर request के लिए server पर dynamic rendering की ज़रूरत होती है।
diff --git a/docs/hi/docs/tutorial/handling-errors.md b/docs/hi/docs/tutorial/handling-errors.md
new file mode 100644
index 000000000..ee4570761
--- /dev/null
+++ b/docs/hi/docs/tutorial/handling-errors.md
@@ -0,0 +1,244 @@
+# Errors को हैंडल करना { #handling-errors }
+
+ऐसी कई स्थितियाँ होती हैं जिनमें आपको अपनी API का उपयोग कर रहे client को error report करना पड़ता है।
+
+यह client frontend वाला कोई browser, किसी और का code, कोई IoT device आदि हो सकता है।
+
+आपको client को यह बताने की ज़रूरत पड़ सकती है कि:
+
+* client के पास उस operation के लिए पर्याप्त privileges नहीं हैं।
+* client के पास उस resource का access नहीं है।
+* जिस item को client access करने की कोशिश कर रहा था, वह मौजूद नहीं है।
+* आदि।
+
+इन मामलों में, आप सामान्यतः **400** की range (400 से 499 तक) में एक **HTTP status code** return करेंगे।
+
+यह 200 HTTP status codes (200 से 299 तक) जैसा ही है। वे "200" status codes का मतलब है कि request में किसी तरह "success" हुआ था।
+
+400 range के status codes का मतलब है कि client की तरफ़ से कोई error था।
+
+वे सभी **"404 Not Found"** errors (और jokes) याद हैं?
+
+## `HTTPException` का उपयोग करें { #use-httpexception }
+
+Client को errors वाली HTTP responses return करने के लिए आप `HTTPException` का उपयोग करते हैं।
+
+### `HTTPException` import करें { #import-httpexception }
+
+{* ../../docs_src/handling_errors/tutorial001_py310.py hl[1] *}
+
+### अपने code में `HTTPException` raise करें { #raise-an-httpexception-in-your-code }
+
+`HTTPException` APIs के लिए प्रासंगिक अतिरिक्त data के साथ एक सामान्य Python exception है।
+
+क्योंकि यह एक Python exception है, आप इसे `return` नहीं करते, आप इसे `raise` करते हैं।
+
+इसका यह भी मतलब है कि अगर आप किसी utility function के अंदर हैं जिसे आप अपनी *path operation function* के अंदर call कर रहे हैं, और आप उस utility function के अंदर से `HTTPException` raise करते हैं, तो यह *path operation function* में बाकी code नहीं चलाएगा, यह उस request को तुरंत समाप्त कर देगा और `HTTPException` से HTTP error client को भेज देगा।
+
+किसी value को return करने के बजाय exception raise करने का लाभ Dependencies और Security वाले section में अधिक स्पष्ट होगा।
+
+इस example में, जब client किसी ऐसे ID से item request करता है जो मौजूद नहीं है, तो `404` के status code के साथ exception raise करें:
+
+{* ../../docs_src/handling_errors/tutorial001_py310.py hl[11] *}
+
+### परिणामी response { #the-resulting-response }
+
+अगर client `http://example.com/items/foo` (एक `item_id` `"foo"`) request करता है, तो उस client को 200 का HTTP status code और यह JSON response मिलेगा:
+
+```JSON
+{
+ "item": "The Foo Wrestlers"
+}
+```
+
+लेकिन अगर client `http://example.com/items/bar` (एक non-existent `item_id` `"bar"`) request करता है, तो उस client को 404 का HTTP status code ("not found" error) और यह JSON response मिलेगा:
+
+```JSON
+{
+ "detail": "Item not found"
+}
+```
+
+/// tip | सुझाव
+
+`HTTPException` raise करते समय, आप `detail` parameter के रूप में ऐसी कोई भी value pass कर सकते हैं जिसे JSON में convert किया जा सकता हो, केवल `str` ही नहीं।
+
+आप `dict`, `list` आदि pass कर सकते हैं।
+
+इन्हें **FastAPI** अपने आप handle करता है और JSON में convert करता है।
+
+///
+
+## custom headers जोड़ें { #add-custom-headers }
+
+कुछ स्थितियाँ ऐसी होती हैं जहाँ HTTP error में custom headers जोड़ पाना उपयोगी होता है। उदाहरण के लिए, कुछ प्रकार की security के लिए।
+
+आपको शायद अपने code में सीधे इसका उपयोग करने की ज़रूरत नहीं होगी।
+
+लेकिन अगर किसी advanced scenario में आपको इसकी ज़रूरत पड़े, तो आप custom headers जोड़ सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial002_py310.py hl[14] *}
+
+## custom exception handlers install करें { #install-custom-exception-handlers }
+
+आप [Starlette से वही exception utilities](https://www.starlette.dev/exceptions/) के साथ custom exception handlers जोड़ सकते हैं।
+
+मान लीजिए आपके पास एक custom exception `UnicornException` है जिसे आप (या कोई library जिसका आप उपयोग करते हैं) `raise` कर सकते हैं।
+
+और आप इस exception को FastAPI के साथ globally handle करना चाहते हैं।
+
+आप `@app.exception_handler()` के साथ custom exception handler जोड़ सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial003_py310.py hl[5:7,13:18,24] *}
+
+यहाँ, अगर आप `/unicorns/yolo` request करते हैं, तो *path operation* एक `UnicornException` `raise` करेगा।
+
+लेकिन इसे `unicorn_exception_handler` द्वारा handle किया जाएगा।
+
+इसलिए, आपको `418` के HTTP status code और इस JSON content के साथ एक साफ़ error मिलेगा:
+
+```JSON
+{"message": "Oops! yolo did something. There goes a rainbow..."}
+```
+
+/// note | Technical Details
+
+आप `from starlette.requests import Request` और `from starlette.responses import JSONResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए `starlette.responses` को `fastapi.responses` के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं। `Request` के साथ भी यही है।
+
+///
+
+## default exception handlers को override करें { #override-the-default-exception-handlers }
+
+**FastAPI** में कुछ default exception handlers होते हैं।
+
+ये handlers default JSON responses return करने के लिए ज़िम्मेदार होते हैं, जब आप `HTTPException` `raise` करते हैं और जब request में invalid data होता है।
+
+आप इन exception handlers को अपने खुद के handlers से override कर सकते हैं।
+
+### request validation exceptions को override करें { #override-request-validation-exceptions }
+
+जब किसी request में invalid data होता है, तो **FastAPI** internally एक `RequestValidationError` raise करता है।
+
+और इसमें इसके लिए एक default exception handler भी शामिल होता है।
+
+इसे override करने के लिए, `RequestValidationError` import करें और exception handler को decorate करने के लिए इसे `@app.exception_handler(RequestValidationError)` के साथ उपयोग करें।
+
+Exception handler को एक `Request` और exception मिलेगा।
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[2,14:19] *}
+
+अब, अगर आप `/items/foo` पर जाते हैं, तो default JSON error पाने के बजाय:
+
+```JSON
+{
+ "detail": [
+ {
+ "loc": [
+ "path",
+ "item_id"
+ ],
+ "msg": "value is not a valid integer",
+ "type": "type_error.integer"
+ }
+ ]
+}
+```
+
+आपको text version मिलेगा, जिसमें होगा:
+
+```
+Validation errors:
+Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
+```
+
+### `HTTPException` error handler को override करें { #override-the-httpexception-error-handler }
+
+उसी तरह, आप `HTTPException` handler को override कर सकते हैं।
+
+उदाहरण के लिए, आप इन errors के लिए JSON के बजाय plain text response return करना चाह सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[3:4,9:11,25] *}
+
+/// note | Technical Details
+
+आप `from starlette.responses import PlainTextResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी, developer की, सुविधा के लिए `starlette.responses` को `fastapi.responses` के रूप में उपलब्ध कराता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+///
+
+/// warning | चेतावनी
+
+ध्यान रखें कि `RequestValidationError` में file name और उस line की जानकारी होती है जहाँ validation error होता है, ताकि अगर आप चाहें तो relevant जानकारी के साथ उसे अपने logs में दिखा सकें।
+
+लेकिन इसका मतलब है कि अगर आप इसे केवल string में convert करके वह जानकारी सीधे return कर देते हैं, तो आप अपने system के बारे में थोड़ी जानकारी leak कर सकते हैं, इसलिए यहाँ code हर error को अलग-अलग extract करके दिखाता है।
+
+///
+
+### `RequestValidationError` body का उपयोग करें { #use-the-requestvalidationerror-body }
+
+`RequestValidationError` में वह `body` होता है जो इसे invalid data के साथ मिला था।
+
+आप अपनी app develop करते समय body को log और debug करने, user को return करने आदि के लिए इसका उपयोग कर सकते हैं।
+
+{* ../../docs_src/handling_errors/tutorial005_py310.py hl[14] *}
+
+अब ऐसा invalid item भेजकर देखें:
+
+```JSON
+{
+ "title": "towel",
+ "size": "XL"
+}
+```
+
+आपको एक response मिलेगा जो बताता है कि data invalid है और जिसमें received body शामिल होगा:
+
+```JSON hl_lines="12-15"
+{
+ "detail": [
+ {
+ "loc": [
+ "body",
+ "size"
+ ],
+ "msg": "value is not a valid integer",
+ "type": "type_error.integer"
+ }
+ ],
+ "body": {
+ "title": "towel",
+ "size": "XL"
+ }
+}
+```
+
+#### FastAPI का `HTTPException` बनाम Starlette का `HTTPException` { #fastapis-httpexception-vs-starlettes-httpexception }
+
+**FastAPI** का अपना `HTTPException` है।
+
+और **FastAPI** की `HTTPException` error class, Starlette की `HTTPException` error class से inherit करती है।
+
+केवल अंतर यह है कि **FastAPI** का `HTTPException`, `detail` field के लिए कोई भी JSON-able data accept करता है, जबकि Starlette का `HTTPException` इसके लिए केवल strings accept करता है।
+
+इसलिए, आप अपने code में सामान्य रूप से **FastAPI** का `HTTPException` raise करते रह सकते हैं।
+
+लेकिन जब आप exception handler register करते हैं, तो आपको उसे Starlette के `HTTPException` के लिए register करना चाहिए।
+
+इस तरह, अगर Starlette के internal code का कोई हिस्सा, या कोई Starlette extension या plug-in, Starlette `HTTPException` raise करता है, तो आपका handler उसे catch और handle कर पाएगा।
+
+इस example में, एक ही code में दोनों `HTTPException`s रखने के लिए, Starlette के exceptions को `StarletteHTTPException` नाम दिया गया है:
+
+```Python
+from starlette.exceptions import HTTPException as StarletteHTTPException
+```
+
+### **FastAPI** के exception handlers का फिर से उपयोग करें { #reuse-fastapis-exception-handlers }
+
+अगर आप **FastAPI** के उन्हीं default exception handlers के साथ exception का उपयोग करना चाहते हैं, तो आप `fastapi.exception_handlers` से default exception handlers import करके उनका फिर से उपयोग कर सकते हैं:
+
+{* ../../docs_src/handling_errors/tutorial006_py310.py hl[2:5,15,21] *}
+
+इस example में आप केवल error को बहुत expressive message के साथ print कर रहे हैं, लेकिन आप बात समझ गए। आप exception का उपयोग कर सकते हैं और फिर बस default exception handlers का फिर से उपयोग कर सकते हैं।
diff --git a/docs/hi/docs/tutorial/header-param-models.md b/docs/hi/docs/tutorial/header-param-models.md
new file mode 100644
index 000000000..4c15aa579
--- /dev/null
+++ b/docs/hi/docs/tutorial/header-param-models.md
@@ -0,0 +1,72 @@
+# Header Parameter Models { #header-parameter-models }
+
+अगर आपके पास संबंधित **header parameters** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं।
+
+इससे आप **model को फिर से उपयोग** कर पाएंगे, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare कर पाएंगे। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से समर्थित है। 🤓
+
+///
+
+## Pydantic Model के साथ Header Parameters { #header-parameters-with-a-pydantic-model }
+
+जिन **header parameters** की आपको ज़रूरत है, उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Header` के रूप में declare करें:
+
+{* ../../docs_src/header_param_models/tutorial001_an_py310.py hl[9:14,18] *}
+
+**FastAPI** request में **headers** से **हर field** का data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में required headers देख सकते हैं:
+
+
+contact fields| Parameter | Type | विवरण |
|---|---|---|
name | str | contact person/organization का identifying name। |
url | str | contact information की ओर point करने वाला URL। URL के format में होना चाहिए। |
email | str | contact person/organization का email address। email address के format में होना चाहिए। |
license_info fields| Parameter | Type | विवरण |
|---|---|---|
name | str | REQUIRED (यदि license_info set किया गया हो)। API के लिए उपयोग किया गया license name। |
identifier | str | API के लिए एक [SPDX](https://spdx.org/licenses/) license expression। identifier field, url field के साथ mutually exclusive है। OpenAPI 3.1.0, FastAPI 0.99.0 से उपलब्ध। |
url | str | API के लिए उपयोग किए गए license का URL। URL के format में होना चाहिए। |
+
+## License identifier { #license-identifier }
+
+OpenAPI 3.1.0 और FastAPI 0.99.0 से, आप `license_info` को `url` के बजाय `identifier` के साथ भी set कर सकते हैं।
+
+उदाहरण के लिए:
+
+{* ../../docs_src/metadata/tutorial001_1_py310.py hl[31] *}
+
+## Tags के लिए Metadata { #metadata-for-tags }
+
+आप अपने path operations को group करने के लिए उपयोग किए गए अलग-अलग tags के लिए `openapi_tags` parameter के साथ अतिरिक्त metadata भी जोड़ सकते हैं।
+
+यह प्रत्येक tag के लिए एक dictionary वाली list लेता है।
+
+प्रत्येक dictionary में हो सकता है:
+
+* `name` (**required**): वही tag name वाला `str`, जिसे आप अपने *path operations* और `APIRouter`s में `tags` parameter में उपयोग करते हैं।
+* `description`: tag के लिए short description वाला `str`। इसमें Markdown हो सकता है और यह docs UI में दिखाया जाएगा।
+* `externalDocs`: external documentation का वर्णन करने वाला `dict`, जिसमें:
+ * `description`: external docs के लिए short description वाला `str`।
+ * `url` (**required**): external documentation के लिए URL वाला `str`।
+
+### Tags के लिए metadata बनाएँ { #create-metadata-for-tags }
+
+आइए इसे `users` और `items` के tags वाले एक उदाहरण में आज़माते हैं।
+
+अपने tags के लिए metadata बनाएँ और उसे `openapi_tags` parameter में pass करें:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[3:16,18] *}
+
+ध्यान दें कि आप descriptions के अंदर Markdown का उपयोग कर सकते हैं, उदाहरण के लिए "login" bold (**login**) में दिखेगा और "fancy" italics (_fancy_) में दिखेगा।
+
+/// tip | सुझाव
+
+आपको अपने उपयोग किए गए सभी tags के लिए metadata जोड़ना ज़रूरी नहीं है।
+
+///
+
+### अपने tags का उपयोग करें { #use-your-tags }
+
+अपने *path operations* (और `APIRouter`s) के साथ `tags` parameter का उपयोग करें, ताकि उन्हें अलग-अलग tags में assign किया जा सके:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[21,26] *}
+
+/// note | नोट
+
+Tags के बारे में और पढ़ें [Path Operation Configuration](path-operation-configuration.md#tags) में।
+
+///
+
+### Docs जाँचें { #check-the-docs }
+
+अब, अगर आप docs जाँचते हैं, तो वे सभी अतिरिक्त metadata दिखाएँगे:
+
+
+
+### Tags का क्रम { #order-of-tags }
+
+हर tag metadata dictionary का क्रम भी docs UI में दिखाए जाने वाले क्रम को define करता है।
+
+उदाहरण के लिए, भले ही `users` alphabetical order में `items` के बाद आता, यह उनसे पहले दिखाया जाता है, क्योंकि हमने उनकी metadata को list में पहली dictionary के रूप में जोड़ा था।
+
+## OpenAPI URL { #openapi-url }
+
+Default रूप से, OpenAPI schema `/openapi.json` पर serve किया जाता है।
+
+लेकिन आप इसे `openapi_url` parameter के साथ configure कर सकते हैं।
+
+उदाहरण के लिए, इसे `/api/v1/openapi.json` पर serve करने के लिए set करने हेतु:
+
+{* ../../docs_src/metadata/tutorial002_py310.py hl[3] *}
+
+यदि आप OpenAPI schema को पूरी तरह disable करना चाहते हैं, तो आप `openapi_url=None` set कर सकते हैं, इससे इसका उपयोग करने वाले documentation user interfaces भी disable हो जाएँगे।
+
+## Docs URLs { #docs-urls }
+
+आप शामिल किए गए दो documentation user interfaces configure कर सकते हैं:
+
+* **Swagger UI**: `/docs` पर serve किया जाता है।
+ * आप इसका URL `docs_url` parameter के साथ set कर सकते हैं।
+ * आप `docs_url=None` set करके इसे disable कर सकते हैं।
+* **ReDoc**: `/redoc` पर serve किया जाता है।
+ * आप इसका URL `redoc_url` parameter के साथ set कर सकते हैं।
+ * आप `redoc_url=None` set करके इसे disable कर सकते हैं।
+
+उदाहरण के लिए, Swagger UI को `/documentation` पर serve करने के लिए set करना और ReDoc को disable करना:
+
+{* ../../docs_src/metadata/tutorial003_py310.py hl[3] *}
diff --git a/docs/hi/docs/tutorial/middleware.md b/docs/hi/docs/tutorial/middleware.md
new file mode 100644
index 000000000..0fd2be7a9
--- /dev/null
+++ b/docs/hi/docs/tutorial/middleware.md
@@ -0,0 +1,95 @@
+# Middleware { #middleware }
+
+आप **FastAPI** applications में middleware जोड़ सकते हैं।
+
+"middleware" एक function है जो हर **request** के साथ काम करता है, इससे पहले कि उसे किसी विशेष *path operation* द्वारा process किया जाए। और हर **response** के साथ भी, उसे लौटाने से पहले।
+
+* यह आपके application में आने वाली हर **request** लेता है।
+* फिर यह उस **request** के साथ कुछ कर सकता है या कोई required code चला सकता है।
+* फिर यह **request** को application के बाकी हिस्से द्वारा process होने के लिए आगे भेजता है (किसी *path operation* द्वारा)।
+* फिर यह application द्वारा generate किया गया **response** लेता है (किसी *path operation* द्वारा)।
+* यह उस **response** के साथ कुछ कर सकता है या कोई required code चला सकता है।
+* फिर यह **response** लौटाता है।
+
+/// note | तकनीकी विवरण
+
+अगर आपके पास `yield` वाली dependencies हैं, तो exit code middleware के *बाद* चलेगा।
+
+अगर कोई background tasks थे ([Background Tasks](background-tasks.md) section में कवर किया गया है, आप इसे बाद में देखेंगे), तो वे सभी middleware के *बाद* चलेंगे।
+
+///
+
+## Middleware बनाएं { #create-a-middleware }
+
+middleware बनाने के लिए आप किसी function के ऊपर decorator `@app.middleware("http")` का उपयोग करते हैं।
+
+middleware function को मिलता है:
+
+* `request`।
+* एक function `call_next` जो `request` को parameter के रूप में प्राप्त करेगा।
+ * यह function `request` को संबंधित *path operation* तक पास करेगा।
+ * फिर यह संबंधित *path operation* द्वारा generate किया गया `response` लौटाता है।
+* फिर आप `response` लौटाने से पहले उसे और modify कर सकते हैं।
+
+{* ../../docs_src/middleware/tutorial001_py310.py hl[8:9,11,14] *}
+
+/// tip | सुझाव
+
+ध्यान रखें कि custom proprietary headers को [`X-` prefix का उपयोग करके](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) जोड़ा जा सकता है।
+
+लेकिन अगर आपके पास custom headers हैं जिन्हें आप browser में client को दिखाना चाहते हैं, तो आपको उन्हें अपने CORS configurations ([CORS (Cross-Origin Resource Sharing)](cors.md)) में `expose_headers` parameter का उपयोग करके जोड़ना होगा, जैसा कि [Starlette के CORS docs](https://www.starlette.dev/middleware/#corsmiddleware) में documented है।
+
+///
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.requests import Request` भी उपयोग कर सकते हैं।
+
+**FastAPI** इसे आपके लिए, developer की सुविधा के रूप में provide करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+### `response` से पहले और बाद में { #before-and-after-the-response }
+
+आप `request` के साथ चलाने के लिए code जोड़ सकते हैं, इससे पहले कि कोई *path operation* उसे प्राप्त करे।
+
+और `response` generate होने के बाद भी, उसे लौटाने से पहले।
+
+उदाहरण के लिए, आप एक custom header `X-Process-Time` जोड़ सकते हैं जिसमें seconds में वह time हो जो request को process करने और response generate करने में लगा:
+
+{* ../../docs_src/middleware/tutorial001_py310.py hl[10,12:13] *}
+
+/// tip | सुझाव
+
+यहाँ हम `time.time()` के बजाय [`time.perf_counter()`](https://docs.python.org/3/library/time.html#time.perf_counter) का उपयोग करते हैं क्योंकि यह इन use cases के लिए अधिक precise हो सकता है। 🤓
+
+///
+
+## कई middleware का execution order { #multiple-middleware-execution-order }
+
+जब आप `@app.middleware()` decorator या `app.add_middleware()` method का उपयोग करके कई middleware जोड़ते हैं, तो हर नया middleware application को wrap करता है, जिससे एक stack बनता है। जो middleware अंत में जोड़ा जाता है वह *outermost* होता है, और पहला *innermost* होता है।
+
+request path पर, *outermost* middleware पहले चलता है।
+
+response path पर, यह अंत में चलता है।
+
+उदाहरण के लिए:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+इससे execution order यह होता है:
+
+* **Request**: MiddlewareB → MiddlewareA → route
+
+* **Response**: route → MiddlewareA → MiddlewareB
+
+यह stacking behavior सुनिश्चित करता है कि middleware एक predictable और controllable order में execute हों।
+
+## अन्य middleware { #other-middlewares }
+
+आप बाद में [Advanced User Guide: Advanced Middleware](../advanced/middleware.md) में अन्य middleware के बारे में और पढ़ सकते हैं।
+
+आप अगले section में middleware के साथ CORS को handle करने के बारे में पढ़ेंगे।
diff --git a/docs/hi/docs/tutorial/path-operation-configuration.md b/docs/hi/docs/tutorial/path-operation-configuration.md
new file mode 100644
index 000000000..99c63aec9
--- /dev/null
+++ b/docs/hi/docs/tutorial/path-operation-configuration.md
@@ -0,0 +1,107 @@
+# Path Operation Configuration { #path-operation-configuration }
+
+कई parameters हैं जिन्हें आप अपने *path operation decorator* को configure करने के लिए pass कर सकते हैं।
+
+/// warning | चेतावनी
+
+ध्यान दें कि ये parameters सीधे *path operation decorator* को pass किए जाते हैं, आपके *path operation function* को नहीं।
+
+///
+
+## Response Status Code { #response-status-code }
+
+आप अपनी *path operation* की response में उपयोग किए जाने वाला (HTTP) `status_code` define कर सकते हैं।
+
+आप सीधे `int` code pass कर सकते हैं, जैसे `404`।
+
+लेकिन अगर आपको याद नहीं है कि हर number code किसके लिए है, तो आप `status` में shortcut constants का उपयोग कर सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}
+
+वह status code response में उपयोग किया जाएगा और OpenAPI schema में जोड़ा जाएगा।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette import status` भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.status` `fastapi.status` के रूप में प्रदान करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+## Tags { #tags }
+
+आप अपनी *path operation* में tags जोड़ सकते हैं, parameter `tags` को `str` की `list` के साथ pass करें (आम तौर पर सिर्फ एक `str`):
+
+{* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *}
+
+वे OpenAPI schema में जोड़े जाएंगे और automatic documentation interfaces द्वारा उपयोग किए जाएंगे:
+
+
+
+### Enums के साथ Tags { #tags-with-enums }
+
+अगर आपके पास एक बड़ी application है, तो आप अंत में **कई tags** जमा कर सकते हैं, और आप यह सुनिश्चित करना चाहेंगे कि related *path operations* के लिए आप हमेशा **एक ही tag** का उपयोग करें।
+
+इन मामलों में, tags को एक `Enum` में store करना समझदारी हो सकती है।
+
+**FastAPI** इसे plain strings की तरह ही support करता है:
+
+{* ../../docs_src/path_operation_configuration/tutorial002b_py310.py hl[1,8:10,13,18] *}
+
+## Summary और description { #summary-and-description }
+
+आप `summary` और `description` जोड़ सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+
+## Docstring से description { #description-from-docstring }
+
+क्योंकि descriptions आम तौर पर लंबी होती हैं और कई lines में फैलती हैं, आप *path operation* की description को function docstring में declare कर सकते हैं और **FastAPI** उसे वहीं से पढ़ेगा।
+
+आप docstring में [Markdown](https://en.wikipedia.org/wiki/Markdown) लिख सकते हैं, इसे सही तरीके से interpret और display किया जाएगा (docstring indentation को ध्यान में रखते हुए)।
+
+{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
+
+इसे interactive docs में उपयोग किया जाएगा:
+
+
+
+## Response description { #response-description }
+
+आप parameter `response_description` के साथ response description specify कर सकते हैं:
+
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+
+/// note | नोट
+
+ध्यान दें कि `response_description` विशेष रूप से response को refer करता है, जबकि `description` सामान्य रूप से *path operation* को refer करता है।
+
+///
+
+/// tip | सुझाव
+
+OpenAPI specify करता है कि प्रत्येक *path operation* को response description required होती है।
+
+इसलिए, अगर आप कोई provide नहीं करते, तो **FastAPI** अपने आप "Successful response" generate कर देगा।
+
+///
+
+
+
+## एक *path operation* को Deprecated करें { #deprecate-a-path-operation }
+
+अगर आपको किसी *path operation* को deprecated के रूप में mark करना है, लेकिन उसे हटाना नहीं है, तो parameter `deprecated` pass करें:
+
+{* ../../docs_src/path_operation_configuration/tutorial006_py310.py hl[16] *}
+
+इसे interactive docs में स्पष्ट रूप से deprecated के रूप में mark किया जाएगा:
+
+
+
+देखें कि deprecated और non-deprecated *path operations* कैसे दिखते हैं:
+
+
+
+## Recap { #recap }
+
+आप *path operation decorators* को parameters pass करके अपनी *path operations* के लिए metadata आसानी से configure और add कर सकते हैं।
diff --git a/docs/hi/docs/tutorial/path-params-numeric-validations.md b/docs/hi/docs/tutorial/path-params-numeric-validations.md
new file mode 100644
index 000000000..59ecd7c4e
--- /dev/null
+++ b/docs/hi/docs/tutorial/path-params-numeric-validations.md
@@ -0,0 +1,154 @@
+# Path Parameters और संख्यात्मक Validations { #path-parameters-and-numeric-validations }
+
+जिस तरह आप `Query` के साथ query parameters के लिए अधिक validations और metadata घोषित कर सकते हैं, उसी तरह आप `Path` के साथ path parameters के लिए उसी प्रकार की validations और metadata घोषित कर सकते हैं।
+
+## `Path` import करें { #import-path }
+
+सबसे पहले, `fastapi` से `Path` import करें, और `Annotated` import करें:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[1,3] *}
+
+/// note | नोट
+
+FastAPI ने version 0.95.0 में `Annotated` के लिए support जोड़ा था (और इसकी सिफारिश करना शुरू किया था)।
+
+अगर आपके पास पुराना version है, तो `Annotated` का उपयोग करने की कोशिश करते समय आपको errors मिलेंगे।
+
+`Annotated` का उपयोग करने से पहले सुनिश्चित करें कि आप [FastAPI version को Upgrade करें](../deployment/versions.md#upgrading-the-fastapi-versions) कम से कम 0.95.1 तक।
+
+///
+
+## Metadata घोषित करें { #declare-metadata }
+
+आप `Query` के लिए जैसे सभी parameters घोषित करते हैं, वैसे ही यहाँ भी कर सकते हैं।
+
+उदाहरण के लिए, path parameter `item_id` के लिए `title` metadata value घोषित करने के लिए आप लिख सकते हैं:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
+
+/// note | नोट
+
+एक path parameter हमेशा required होता है क्योंकि उसे path का हिस्सा होना होता है। भले ही आपने इसे `None` के साथ घोषित किया हो या कोई default value सेट की हो, इससे कुछ भी प्रभावित नहीं होगा, यह फिर भी हमेशा required रहेगा।
+
+///
+
+## Parameters को अपनी ज़रूरत के अनुसार क्रम दें { #order-the-parameters-as-you-need }
+
+/// tip | सुझाव
+
+यदि आप `Annotated` का उपयोग करते हैं, तो यह शायद उतना महत्वपूर्ण या ज़रूरी नहीं है।
+
+///
+
+मान लें कि आप query parameter `q` को required `str` के रूप में घोषित करना चाहते हैं।
+
+और आपको उस parameter के लिए कुछ और घोषित करने की ज़रूरत नहीं है, इसलिए वास्तव में आपको `Query` का उपयोग करने की ज़रूरत नहीं है।
+
+लेकिन आपको फिर भी `item_id` path parameter के लिए `Path` का उपयोग करना होगा। और किसी कारण से आप `Annotated` का उपयोग नहीं करना चाहते।
+
+यदि आप किसी ऐसे value को, जिसके पास "default" है, ऐसे value से पहले रखते हैं जिसके पास "default" नहीं है, तो Python शिकायत करेगा।
+
+लेकिन आप उनका क्रम बदल सकते हैं, और बिना default वाले value (query parameter `q`) को पहले रख सकते हैं।
+
+**FastAPI** के लिए इससे फर्क नहीं पड़ता। यह parameters को उनके नामों, types और default declarations (`Query`, `Path`, आदि) से पहचान लेगा, इसे क्रम से कोई फर्क नहीं पड़ता।
+
+तो, आप अपनी function इस तरह घोषित कर सकते हैं:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_py310.py hl[7] *}
+
+लेकिन ध्यान रखें कि यदि आप `Annotated` का उपयोग करते हैं, तो आपको यह समस्या नहीं होगी, क्योंकि आप `Query()` या `Path()` के लिए function parameter default values का उपयोग नहीं कर रहे हैं।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py310.py *}
+
+## Parameters को अपनी ज़रूरत के अनुसार क्रम दें, tricks { #order-the-parameters-as-you-need-tricks }
+
+/// tip | सुझाव
+
+यदि आप `Annotated` का उपयोग करते हैं, तो यह शायद उतना महत्वपूर्ण या ज़रूरी नहीं है।
+
+///
+
+यहाँ एक **छोटी trick** है जो काम आ सकती है, लेकिन आपको इसकी अक्सर ज़रूरत नहीं पड़ेगी।
+
+यदि आप चाहते हैं कि:
+
+* `q` query parameter को बिना `Query` और बिना किसी default value के घोषित करें
+* path parameter `item_id` को `Path` का उपयोग करके घोषित करें
+* उन्हें अलग क्रम में रखें
+* `Annotated` का उपयोग न करें
+
+...तो Python में इसके लिए एक छोटी विशेष syntax है।
+
+function के पहले parameter के रूप में `*` पास करें।
+
+Python उस `*` के साथ कुछ नहीं करेगा, लेकिन उसे पता चल जाएगा कि उसके बाद आने वाले सभी parameters को keyword arguments (key-value pairs) के रूप में call किया जाना चाहिए, जिन्हें kwargs भी कहा जाता है। भले ही उनके पास default value न हो।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_py310.py hl[7] *}
+
+### `Annotated` के साथ बेहतर { #better-with-annotated }
+
+ध्यान रखें कि यदि आप `Annotated` का उपयोग करते हैं, तो चूँकि आप function parameter default values का उपयोग नहीं कर रहे हैं, आपको यह समस्या नहीं होगी, और शायद आपको `*` का उपयोग करने की ज़रूरत नहीं पड़ेगी।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py310.py hl[10] *}
+
+## Number validations: greater than or equal { #number-validations-greater-than-or-equal }
+
+`Query` और `Path` (और अन्य जिन्हें आप बाद में देखेंगे) के साथ आप number constraints घोषित कर सकते हैं।
+
+यहाँ, `ge=1` के साथ, `item_id` को `1` से "`g`reater than or `e`qual" integer number होना होगा।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py310.py hl[10] *}
+
+## Number validations: greater than और less than or equal { #number-validations-greater-than-and-less-than-or-equal }
+
+यही बात इन पर भी लागू होती है:
+
+* `gt`: `g`reater `t`han
+* `le`: `l`ess than or `e`qual
+
+{* ../../docs_src/path_params_numeric_validations/tutorial005_an_py310.py hl[10] *}
+
+## Number validations: floats, greater than और less than { #number-validations-floats-greater-than-and-less-than }
+
+Number validations `float` values के लिए भी काम करती हैं।
+
+यहीं पर gt घोषित कर पाना महत्वपूर्ण हो जाता है, सिर्फ ge नहीं। क्योंकि इसके साथ आप, उदाहरण के लिए, यह require कर सकते हैं कि कोई value `0` से अधिक होनी चाहिए, भले ही वह `1` से कम हो।
+
+तो, `0.5` एक valid value होगा। लेकिन `0.0` या `0` नहीं होंगे।
+
+और यही बात lt के लिए भी है।
+
+{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}
+
+## Recap { #recap }
+
+`Query`, `Path` (और अन्य जिन्हें आपने अभी तक नहीं देखा है) के साथ आप metadata और string validations उसी तरह घोषित कर सकते हैं जैसे [Query Parameters और String Validations](query-params-str-validations.md) के साथ।
+
+और आप numeric validations भी घोषित कर सकते हैं:
+
+* `gt`: `g`reater `t`han
+* `ge`: `g`reater than or `e`qual
+* `lt`: `l`ess `t`han
+* `le`: `l`ess than or `e`qual
+
+/// note | नोट
+
+`Query`, `Path`, और अन्य classes जिन्हें आप बाद में देखेंगे, एक common `Param` class की subclasses हैं।
+
+वे सभी अतिरिक्त validation और metadata के लिए वही parameters साझा करती हैं जिन्हें आपने देखा है।
+
+///
+
+/// note | तकनीकी विवरण
+
+जब आप `fastapi` से `Query`, `Path` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं।
+
+जब उन्हें call किया जाता है, तो वे उसी नाम की classes के instances return करते हैं।
+
+तो, आप `Query` import करते हैं, जो एक function है। और जब आप इसे call करते हैं, तो यह `Query` नाम की class का एक instance return करता है।
+
+ये functions इसलिए हैं (classes को सीधे उपयोग करने के बजाय) ताकि आपका editor उनके types के बारे में errors mark न करे।
+
+इस तरह आप उन errors को ignore करने के लिए custom configurations जोड़े बिना अपने सामान्य editor और coding tools का उपयोग कर सकते हैं।
+
+///
diff --git a/docs/hi/docs/tutorial/path-params.md b/docs/hi/docs/tutorial/path-params.md
new file mode 100644
index 000000000..602ff1212
--- /dev/null
+++ b/docs/hi/docs/tutorial/path-params.md
@@ -0,0 +1,251 @@
+# Path Parameters { #path-parameters }
+
+आप Python format strings द्वारा इस्तेमाल किए जाने वाले समान syntax के साथ path "parameters" या "variables" declare कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial001_py310.py hl[6:7] *}
+
+path parameter `item_id` की value आपके function को argument `item_id` के रूप में pass की जाएगी।
+
+इसलिए, अगर आप यह example run करते हैं और [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo) पर जाते हैं, तो आपको ऐसा response दिखाई देगा:
+
+```JSON
+{"item_id":"foo"}
+```
+
+## Types के साथ Path parameters { #path-parameters-with-types }
+
+आप standard Python type annotations का उपयोग करके function में किसी path parameter का type declare कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial002_py310.py hl[7] *}
+
+इस मामले में, `item_id` को `int` declare किया गया है।
+
+/// tip | सुझाव
+
+इससे आपको अपने function के अंदर editor support मिलेगा, जिसमें error checks, completion आदि शामिल हैं।
+
+///
+
+## Data conversion { #data-conversion }
+
+अगर आप यह example run करते हैं और अपने browser में [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3) खोलते हैं, तो आपको ऐसा response दिखाई देगा:
+
+```JSON
+{"item_id":3}
+```
+
+/// tip | सुझाव
+
+ध्यान दें कि आपके function ने जो value प्राप्त की (और return की) वह `3` है, Python `int` के रूप में, न कि string `"3"`।
+
+तो, उस type declaration के साथ, **FastAPI** आपको automatic request "parsing" देता है।
+
+///
+
+## Data validation { #data-validation }
+
+लेकिन अगर आप browser में [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo) पर जाते हैं, तो आपको ऐसा अच्छा HTTP error दिखाई देगा:
+
+```JSON
+{
+ "detail": [
+ {
+ "type": "int_parsing",
+ "loc": [
+ "path",
+ "item_id"
+ ],
+ "msg": "Input should be a valid integer, unable to parse string as an integer",
+ "input": "foo"
+ }
+ ]
+}
+```
+
+क्योंकि path parameter `item_id` की value `"foo"` थी, जो कि `int` नहीं है।
+
+अगर आपने `int` के बजाय `float` दिया, तो भी वही error दिखाई देगा, जैसे: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
+
+/// tip | सुझाव
+
+तो, उसी Python type declaration के साथ, **FastAPI** आपको data validation देता है।
+
+ध्यान दें कि error यह भी स्पष्ट रूप से बताता है कि validation किस जगह pass नहीं हुआ।
+
+यह आपके API के साथ interact करने वाले code को develop और debug करते समय बेहद मददगार होता है।
+
+///
+
+## Documentation { #documentation }
+
+और जब आप अपने browser में [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) खोलते हैं, तो आपको ऐसा automatic, interactive, API documentation दिखाई देगा:
+
+
+
+/// tip | सुझाव
+
+फिर से, बस उसी Python type declaration के साथ, **FastAPI** आपको automatic, interactive documentation देता है (Swagger UI को integrate करते हुए)।
+
+ध्यान दें कि path parameter को integer के रूप में declare किया गया है।
+
+///
+
+## Standard-आधारित लाभ, वैकल्पिक documentation { #standards-based-benefits-alternative-documentation }
+
+और क्योंकि generate किया गया schema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md) standard से है, इसलिए कई compatible tools हैं।
+
+इसी वजह से, **FastAPI** स्वयं एक वैकल्पिक API documentation प्रदान करता है (ReDoc का उपयोग करते हुए), जिसे आप [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) पर access कर सकते हैं:
+
+
+
+इसी तरह, कई compatible tools हैं। इनमें कई भाषाओं के लिए code generation tools भी शामिल हैं।
+
+## Pydantic { #pydantic }
+
+सारा data validation अंदरूनी तौर पर [Pydantic](https://docs.pydantic.dev/) द्वारा किया जाता है, इसलिए आपको इसके सभी लाभ मिलते हैं। और आप जानते हैं कि आप अच्छे हाथों में हैं।
+
+आप `str`, `float`, `bool` और कई अन्य जटिल data types के साथ वही type declarations इस्तेमाल कर सकते हैं।
+
+इनमें से कई को tutorial के अगले chapters में explore किया गया है।
+
+## क्रम मायने रखता है { #order-matters }
+
+*path operations* बनाते समय, आपको ऐसी स्थितियाँ मिल सकती हैं जहाँ आपके पास एक fixed path हो।
+
+जैसे `/users/me`, मान लें कि यह current user के बारे में data प्राप्त करने के लिए है।
+
+और फिर आपके पास `/users/{user_id}` path भी हो सकता है, किसी specific user के बारे में किसी user ID से data प्राप्त करने के लिए।
+
+क्योंकि *path operations* का evaluation क्रम में किया जाता है, आपको यह सुनिश्चित करना होगा कि `/users/me` के लिए path, `/users/{user_id}` वाले path से पहले declare किया गया हो:
+
+{* ../../docs_src/path_params/tutorial003_py310.py hl[6,11] *}
+
+अन्यथा, `/users/{user_id}` के लिए path `/users/me` से भी match करेगा, यह "सोचते हुए" कि उसे `user_id` parameter मिल रहा है जिसकी value `"me"` है।
+
+इसी तरह, आप किसी path operation को फिर से define नहीं कर सकते:
+
+{* ../../docs_src/path_params/tutorial003b_py310.py hl[6,11] *}
+
+पहला वाला हमेशा इस्तेमाल किया जाएगा क्योंकि path पहले match करता है।
+
+## पहले से तय values { #predefined-values }
+
+अगर आपके पास ऐसा *path operation* है जो एक *path parameter* प्राप्त करता है, लेकिन आप चाहते हैं कि संभव valid *path parameter* values पहले से तय हों, तो आप standard Python `Enum` का उपयोग कर सकते हैं।
+
+### एक `Enum` class बनाएं { #create-an-enum-class }
+
+`Enum` import करें और एक sub-class बनाएं जो `str` और `Enum` से inherit करती हो।
+
+`str` से inherit करने पर API docs यह जान पाएंगे कि values का type `string` होना चाहिए और उन्हें सही तरह से render कर पाएंगे।
+
+फिर fixed values के साथ class attributes बनाएं, जो उपलब्ध valid values होंगी:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[1,6:9] *}
+
+/// tip | सुझाव
+
+अगर आप सोच रहे हैं, "AlexNet", "ResNet", और "LeNet" बस Machine Learning models के नाम हैं।
+
+///
+
+### एक *path parameter* declare करें { #declare-a-path-parameter }
+
+फिर आपके द्वारा बनाई गई enum class (`ModelName`) का उपयोग करके type annotation के साथ एक *path parameter* बनाएं:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[16] *}
+
+### Docs देखें { #check-the-docs }
+
+क्योंकि *path parameter* के लिए उपलब्ध values पहले से तय हैं, interactive docs उन्हें अच्छे से दिखा सकते हैं:
+
+
+
+### Python *enumerations* के साथ काम करना { #working-with-python-enumerations }
+
+*path parameter* की value एक *enumeration member* होगी।
+
+#### *Enumeration members* की तुलना करें { #compare-enumeration-members }
+
+आप इसकी तुलना अपने बनाए हुए enum `ModelName` में मौजूद *enumeration member* से कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[17] *}
+
+#### *Enumeration value* प्राप्त करें { #get-the-enumeration-value }
+
+आप `model_name.value` का उपयोग करके actual value (इस मामले में एक `str`) प्राप्त कर सकते हैं, या सामान्य रूप से, `your_enum_member.value`:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[20] *}
+
+/// tip | सुझाव
+
+आप `ModelName.lenet.value` के साथ value `"lenet"` भी access कर सकते हैं।
+
+///
+
+#### *Enumeration members* return करें { #return-enumeration-members }
+
+आप अपने *path operation* से *enum members* return कर सकते हैं, यहाँ तक कि JSON body में nested भी (जैसे एक `dict`)।
+
+Client को return करने से पहले उन्हें उनकी संबंधित values (इस मामले में strings) में convert कर दिया जाएगा:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[18,21,23] *}
+
+अपने client में आपको ऐसा JSON response मिलेगा:
+
+```JSON
+{
+ "model_name": "alexnet",
+ "message": "Deep Learning FTW!"
+}
+```
+
+## Paths रखने वाले Path parameters { #path-parameters-containing-paths }
+
+मान लें आपके पास path `/files/{file_path}` के साथ एक *path operation* है।
+
+लेकिन आपको `file_path` में स्वयं एक *path* रखना है, जैसे `home/johndoe/myfile.txt`।
+
+तो, उस file के लिए URL कुछ ऐसा होगा: `/files/home/johndoe/myfile.txt`।
+
+### OpenAPI support { #openapi-support }
+
+OpenAPI किसी *path parameter* को उसके अंदर एक *path* रखने के लिए declare करने का तरीका support नहीं करता, क्योंकि इससे ऐसे scenarios बन सकते हैं जिन्हें test और define करना कठिन हो।
+
+फिर भी, आप **FastAPI** में Starlette के internal tools में से एक का उपयोग करके यह कर सकते हैं।
+
+और docs फिर भी काम करेंगे, हालांकि ऐसा कोई documentation नहीं जोड़ेंगे जो बताए कि parameter में path होना चाहिए।
+
+### Path convertor { #path-convertor }
+
+Starlette से सीधे एक option का उपयोग करके, आप इस तरह के URL का उपयोग करते हुए एक *path* रखने वाला *path parameter* declare कर सकते हैं:
+
+```
+/files/{file_path:path}
+```
+
+इस मामले में, parameter का नाम `file_path` है, और आखिरी हिस्सा, `:path`, इसे बताता है कि parameter किसी भी *path* से match करना चाहिए।
+
+तो, आप इसे इसके साथ इस्तेमाल कर सकते हैं:
+
+{* ../../docs_src/path_params/tutorial004_py310.py hl[6] *}
+
+/// tip | सुझाव
+
+आपको parameter में `/home/johndoe/myfile.txt` रखना पड़ सकता है, leading slash (`/`) के साथ।
+
+उस मामले में, URL होगा: `/files//home/johndoe/myfile.txt`, `files` और `home` के बीच double slash (`//`) के साथ।
+
+///
+
+## Recap { #recap }
+
+**FastAPI** के साथ, छोटे, सहज और standard Python type declarations का उपयोग करके, आपको मिलता है:
+
+* Editor support: error checks, autocompletion आदि।
+* Data "parsing"
+* Data validation
+* API annotation और automatic documentation
+
+और आपको इन्हें केवल एक बार declare करना होता है।
+
+वैकल्पिक frameworks की तुलना में **FastAPI** का शायद यही मुख्य दिखने वाला लाभ है (raw performance के अलावा)।
diff --git a/docs/hi/docs/tutorial/query-param-models.md b/docs/hi/docs/tutorial/query-param-models.md
new file mode 100644
index 000000000..1727b7654
--- /dev/null
+++ b/docs/hi/docs/tutorial/query-param-models.md
@@ -0,0 +1,68 @@
+# Query Parameter Models { #query-parameter-models }
+
+अगर आपके पास संबंधित **query parameters** का एक समूह है, तो आप उन्हें declare करने के लिए एक **Pydantic model** बना सकते हैं।
+
+इससे आप **model को फिर से उपयोग** कर पाएँगे, **कई जगहों** पर, और साथ ही सभी parameters के लिए validations और metadata एक साथ declare कर पाएँगे। 😎
+
+/// note | नोट
+
+यह FastAPI version `0.115.0` से supported है। 🤓
+
+///
+
+## Pydantic Model के साथ Query Parameters { #query-parameters-with-a-pydantic-model }
+
+जिन **query parameters** की आपको ज़रूरत है उन्हें एक **Pydantic model** में declare करें, और फिर parameter को `Query` के रूप में declare करें:
+
+{* ../../docs_src/query_param_models/tutorial001_an_py310.py hl[9:13,17] *}
+
+**FastAPI** request में मौजूद **query parameters** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs देखें { #check-the-docs }
+
+आप `/docs` पर docs UI में query parameters देख सकते हैं:
+
+
+
+
+### Defaults के साथ Query parameter list / multiple values { #query-parameter-list-multiple-values-with-defaults }
+
+अगर कोई values provide नहीं की गई हैं, तो आप values की default `list` भी define कर सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial012_an_py310.py hl[9] *}
+
+अगर आप यहाँ जाते हैं:
+
+```
+http://localhost:8000/items/
+```
+
+`q` का default होगा: `["foo", "bar"]` और आपका response होगा:
+
+```JSON
+{
+ "q": [
+ "foo",
+ "bar"
+ ]
+}
+```
+
+#### केवल `list` use करना { #using-just-list }
+
+आप `list[str]` के बजाय सीधे `list` भी use कर सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial013_an_py310.py hl[9] *}
+
+/// note | नोट
+
+ध्यान रखें कि इस case में, FastAPI list की contents check नहीं करेगा।
+
+उदाहरण के लिए, `list[int]` check (और document) करेगा कि list की contents integers हैं। लेकिन केवल `list` ऐसा नहीं करेगा।
+
+///
+
+## अधिक metadata declare करें { #declare-more-metadata }
+
+आप parameter के बारे में अधिक जानकारी जोड़ सकते हैं।
+
+वह जानकारी generated OpenAPI में शामिल होगी और documentation user interfaces और external tools द्वारा use की जाएगी।
+
+/// note | नोट
+
+ध्यान रखें कि अलग-अलग tools में OpenAPI support के अलग-अलग levels हो सकते हैं।
+
+उनमें से कुछ अभी declare की गई सारी extra information नहीं दिखा सकते, हालांकि अधिकतर cases में, missing feature पहले से ही development के लिए planned है।
+
+///
+
+आप एक `title` जोड़ सकते हैं:
+
+{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
+
+और एक `description`:
+
+{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
+
+## Alias parameters { #alias-parameters }
+
+कल्पना करें कि आप parameter को `item-query` बनाना चाहते हैं।
+
+जैसे:
+
+```
+http://127.0.0.1:8000/items/?item-query=foobaritems
+```
+
+लेकिन `item-query` valid Python variable name नहीं है।
+
+सबसे निकटतम `item_query` होगा।
+
+लेकिन आपको अभी भी यह exactly `item-query` ही चाहिए...
+
+तब आप एक `alias` declare कर सकते हैं, और वही alias parameter value खोजने के लिए use किया जाएगा:
+
+{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
+
+## Parameters को deprecate करना { #deprecating-parameters }
+
+अब मान लीजिए कि आपको यह parameter अब पसंद नहीं है।
+
+आपको इसे कुछ समय के लिए वहीं छोड़ना होगा क्योंकि clients इसे use कर रहे हैं, लेकिन आप चाहते हैं कि docs इसे स्पष्ट रूप से deprecated के रूप में दिखाएँ।
+
+फिर parameter `deprecated=True` को `Query` में pass करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
+
+docs इसे इस तरह दिखाएँगे:
+
+
+
+## OpenAPI से parameters exclude करें { #exclude-parameters-from-openapi }
+
+generated OpenAPI schema से query parameter exclude करने के लिए (और इस प्रकार, automatic documentation systems से), `Query` के parameter `include_in_schema` को `False` पर set करें:
+
+{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+
+## Custom Validation { #custom-validation }
+
+ऐसे cases हो सकते हैं जहाँ आपको कुछ **custom validation** करना पड़े जो ऊपर दिखाए गए parameters से नहीं किया जा सकता।
+
+ऐसे cases में, आप एक **custom validator function** use कर सकते हैं जो normal validation के बाद apply होता है (जैसे value के `str` होने की validation के बाद)।
+
+आप इसे `Annotated` के अंदर [Pydantic के `AfterValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator) का उपयोग करके हासिल कर सकते हैं।
+
+/// tip | टिप
+
+Pydantic में [`BeforeValidator`](https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator) और अन्य भी हैं। 🤓
+
+///
+
+उदाहरण के लिए, यह custom validator check करता है कि item ID किसी ISBN book number के लिए `isbn-` से शुरू होती है या किसी IMDB movie URL ID के लिए `imdb-` से:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// note | नोट
+
+यह Pydantic version 2 या उससे ऊपर के साथ available है। 😎
+
+///
+
+/// tip | टिप
+
+अगर आपको किसी भी प्रकार की validation करनी है जिसके लिए किसी **external component** से communicate करना required है, जैसे database या कोई अन्य API, तो आपको इसके बजाय **FastAPI Dependencies** use करनी चाहिए, आप इनके बारे में बाद में सीखेंगे।
+
+ये custom validators उन चीज़ों के लिए हैं जिन्हें request में provide किए गए **सिर्फ** **उसी data** से check किया जा सकता है।
+
+///
+
+### उस Code को समझें { #understand-that-code }
+
+महत्वपूर्ण बात बस **`Annotated` के अंदर एक function के साथ `AfterValidator` use करना** है। आप चाहें तो इस part को skip कर सकते हैं। 🤸
+
+---
+
+लेकिन अगर आप इस specific code example के बारे में curious हैं और अभी भी entertained हैं, तो यहाँ कुछ extra details हैं।
+
+#### `value.startswith()` के साथ String { #string-with-value-startswith }
+
+क्या आपने ध्यान दिया? `value.startswith()` use करने वाली string tuple ले सकती है, और यह tuple की हर value check करेगी:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### एक Random Item { #a-random-item }
+
+`data.items()` के साथ हमें tuples वाला एक iterable object मिलता है जिसमें हर dictionary item के लिए key और value होती है।
+
+हम इस iterable object को `list(data.items())` के साथ proper `list` में convert करते हैं।
+
+फिर `random.choice()` के साथ हम list से एक **random value** प्राप्त कर सकते हैं, तो हमें `(id, name)` वाला tuple मिलता है। यह कुछ ऐसा होगा `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`।
+
+फिर हम tuple की **उन दो values को assign** करते हैं variables `id` और `name` को।
+
+तो, अगर user ने item ID provide नहीं की, तब भी उन्हें एक random suggestion receive होगा।
+
+...हम यह सब **एक single simple line** में करते हैं। 🤯 क्या आपको Python पसंद नहीं है? 🐍
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## Recap { #recap }
+
+आप अपने parameters के लिए अतिरिक्त validations और metadata declare कर सकते हैं।
+
+Generic validations और metadata:
+
+* `alias`
+* `title`
+* `description`
+* `deprecated`
+
+Strings के लिए specific validations:
+
+* `min_length`
+* `max_length`
+* `pattern`
+
+`AfterValidator` का उपयोग करके custom validations।
+
+इन examples में आपने देखा कि `str` values के लिए validations कैसे declare करें।
+
+अगले chapters देखें ताकि आप सीख सकें कि numbers जैसे अन्य types के लिए validations कैसे declare करें।
diff --git a/docs/hi/docs/tutorial/query-params.md b/docs/hi/docs/tutorial/query-params.md
new file mode 100644
index 000000000..bc8573179
--- /dev/null
+++ b/docs/hi/docs/tutorial/query-params.md
@@ -0,0 +1,188 @@
+# Query Parameters { #query-parameters }
+
+जब आप ऐसे दूसरे function parameters declare करते हैं जो path parameters का हिस्सा नहीं हैं, तो उन्हें अपने-आप "query" parameters के रूप में समझा जाता है।
+
+{* ../../docs_src/query_params/tutorial001_py310.py hl[9] *}
+
+query उन key-value pairs का सेट है जो URL में `?` के बाद आते हैं, और `&` characters से अलग किए जाते हैं।
+
+उदाहरण के लिए, इस URL में:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+...query parameters हैं:
+
+* `skip`: `0` value के साथ
+* `limit`: `10` value के साथ
+
+क्योंकि वे URL का हिस्सा हैं, वे "स्वाभाविक रूप से" strings होते हैं।
+
+लेकिन जब आप उन्हें Python types के साथ declare करते हैं (ऊपर दिए गए उदाहरण में, `int` के रूप में), तो उन्हें उस type में convert किया जाता है और उसके अनुसार validate किया जाता है।
+
+path parameters पर लागू होने वाली सभी वही प्रक्रियाएँ query parameters पर भी लागू होती हैं:
+
+* Editor support (स्पष्ट रूप से)
+* Data "parsing"
+* Data validation
+* Automatic documentation
+
+## Defaults { #defaults }
+
+क्योंकि query parameters किसी path का fixed हिस्सा नहीं होते, वे optional हो सकते हैं और उनके default values हो सकते हैं।
+
+ऊपर दिए गए उदाहरण में उनके default values `skip=0` और `limit=10` हैं।
+
+तो, इस URL पर जाना:
+
+```
+http://127.0.0.1:8000/items/
+```
+
+इस पर जाने जैसा ही होगा:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+लेकिन अगर आप, उदाहरण के लिए, इस पर जाते हैं:
+
+```
+http://127.0.0.1:8000/items/?skip=20
+```
+
+तो आपके function में parameter values होंगी:
+
+* `skip=20`: क्योंकि आपने इसे URL में सेट किया है
+* `limit=10`: क्योंकि वह default value था
+
+## Optional parameters { #optional-parameters }
+
+उसी तरह, आप optional query parameters declare कर सकते हैं, उनका default `None` सेट करके:
+
+{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
+
+इस मामले में, function parameter `q` optional होगा, और default रूप से `None` होगा।
+
+/// tip | सुझाव
+
+यह भी ध्यान दें कि **FastAPI** इतना smart है कि यह पहचान लेता है कि path parameter `item_id` एक path parameter है और `q` नहीं है, इसलिए, यह एक query parameter है।
+
+///
+
+## Query parameter type conversion { #query-parameter-type-conversion }
+
+आप `bool` types भी declare कर सकते हैं, और वे convert हो जाएँगे:
+
+{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
+
+इस मामले में, अगर आप इस पर जाते हैं:
+
+```
+http://127.0.0.1:8000/items/foo?short=1
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=True
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=true
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=on
+```
+
+या
+
+```
+http://127.0.0.1:8000/items/foo?short=yes
+```
+
+या कोई भी दूसरी case variation (uppercase, पहले अक्षर को uppercase, आदि), आपका function parameter `short` को `True` के `bool` value के साथ देखेगा। अन्यथा `False` के रूप में।
+
+
+## कई path और query parameters { #multiple-path-and-query-parameters }
+
+आप एक ही समय में कई path parameters और query parameters declare कर सकते हैं, **FastAPI** जानता है कि कौन सा कौन है।
+
+और आपको उन्हें किसी विशेष order में declare करने की ज़रूरत नहीं है।
+
+उन्हें नाम से detect किया जाएगा:
+
+{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
+
+## Required query parameters { #required-query-parameters }
+
+जब आप non-path parameters के लिए default value declare करते हैं (अभी तक, हमने केवल query parameters देखे हैं), तो वह required नहीं होता।
+
+अगर आप कोई specific value नहीं जोड़ना चाहते लेकिन बस उसे optional बनाना चाहते हैं, तो default को `None` के रूप में सेट करें।
+
+लेकिन जब आप किसी query parameter को required बनाना चाहते हैं, तो आप बस कोई default value declare न करें:
+
+{* ../../docs_src/query_params/tutorial005_py310.py hl[6:7] *}
+
+यहाँ query parameter `needy` type `str` का एक required query parameter है।
+
+अगर आप अपने browser में इस तरह का URL खोलते हैं:
+
+```
+http://127.0.0.1:8000/items/foo-item
+```
+
+...required parameter `needy` जोड़े बिना, तो आपको इस तरह की error दिखाई देगी:
+
+```JSON
+{
+ "detail": [
+ {
+ "type": "missing",
+ "loc": [
+ "query",
+ "needy"
+ ],
+ "msg": "Field required",
+ "input": null
+ }
+ ]
+}
+```
+
+क्योंकि `needy` एक required parameter है, आपको इसे URL में सेट करना होगा:
+
+```
+http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
+```
+
+...यह काम करेगा:
+
+```JSON
+{
+ "item_id": "foo-item",
+ "needy": "sooooneedy"
+}
+```
+
+और निश्चित रूप से, आप कुछ parameters को required, कुछ को default value वाला, और कुछ को पूरी तरह optional define कर सकते हैं:
+
+{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
+
+इस मामले में, 3 query parameters हैं:
+
+* `needy`, एक required `str`.
+* `skip`, default value `0` के साथ एक `int`.
+* `limit`, एक optional `int`.
+
+/// tip | सुझाव
+
+आप `Enum`s को भी उसी तरह use कर सकते हैं जैसे [Path Parameters](path-params.md#predefined-values) के साथ।
+
+///
diff --git a/docs/hi/docs/tutorial/request-files.md b/docs/hi/docs/tutorial/request-files.md
new file mode 100644
index 000000000..4a79ca2b9
--- /dev/null
+++ b/docs/hi/docs/tutorial/request-files.md
@@ -0,0 +1,176 @@
+# Request Files { #request-files }
+
+आप client द्वारा अपलोड की जाने वाली files को `File` का उपयोग करके परिभाषित कर सकते हैं।
+
+/// note | नोट
+
+अपलोड की गई files प्राप्त करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+ऐसा इसलिए है क्योंकि अपलोड की गई files "form data" के रूप में भेजी जाती हैं।
+
+///
+
+## `File` Import करें { #import-file }
+
+`fastapi` से `File` और `UploadFile` import करें:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[3] *}
+
+## `File` Parameters परिभाषित करें { #define-file-parameters }
+
+file parameters उसी तरह बनाएं जैसे आप `Body` या `Form` के लिए बनाते हैं:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[9] *}
+
+/// note | नोट
+
+`File` एक class है जो सीधे `Form` से inherit करती है।
+
+लेकिन याद रखें कि जब आप `fastapi` से `Query`, `Path`, `File` और अन्य import करते हैं, तो वे वास्तव में functions होते हैं जो विशेष classes return करते हैं।
+
+///
+
+/// tip | सुझाव
+
+File bodies घोषित करने के लिए, आपको `File` का उपयोग करना होगा, क्योंकि अन्यथा parameters को query parameters या body (JSON) parameters के रूप में समझा जाएगा।
+
+///
+
+files "form data" के रूप में अपलोड की जाएंगी।
+
+यदि आप अपने *path operation function* parameter का type `bytes` के रूप में घोषित करते हैं, तो **FastAPI** आपके लिए file पढ़ेगा और आपको सामग्री `bytes` के रूप में प्राप्त होगी।
+
+ध्यान रखें कि इसका मतलब है कि पूरी सामग्री memory में संग्रहीत होगी। यह छोटी files के लिए अच्छी तरह काम करेगा।
+
+लेकिन कई मामलों में आपको `UploadFile` का उपयोग करने से लाभ हो सकता है।
+
+## `UploadFile` के साथ File Parameters { #file-parameters-with-uploadfile }
+
+`UploadFile` type के साथ file parameter परिभाषित करें:
+
+{* ../../docs_src/request_files/tutorial001_an_py310.py hl[14] *}
+
+`bytes` की तुलना में `UploadFile` का उपयोग करने के कई फायदे हैं:
+
+* आपको parameter के default value में `File()` का उपयोग नहीं करना पड़ता।
+* यह एक "spooled" file का उपयोग करता है:
+ * एक file जो अधिकतम size limit तक memory में संग्रहीत होती है, और इस limit को पार करने के बाद disk पर संग्रहीत होती है।
+* इसका मतलब है कि यह images, videos, बड़े binaries आदि जैसी बड़ी files के लिए सारी memory का उपयोग किए बिना अच्छी तरह काम करेगा।
+* आप अपलोड की गई file से metadata प्राप्त कर सकते हैं।
+* इसमें [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) `async` interface है।
+* यह एक वास्तविक Python [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) object expose करता है जिसे आप सीधे अन्य libraries को पास कर सकते हैं जो file-like object की अपेक्षा करती हैं।
+
+### `UploadFile` { #uploadfile }
+
+`UploadFile` में निम्नलिखित attributes होते हैं:
+
+* `filename`: मूल file name के साथ एक `str` जो अपलोड किया गया था (जैसे `myimage.jpg`)।
+* `content_type`: content type (MIME type / media type) के साथ एक `str` (जैसे `image/jpeg`)।
+* `file`: एक [`SpooledTemporaryFile`](https://docs.python.org/3/library/tempfile.html#tempfile.SpooledTemporaryFile) (एक [file-like](https://docs.python.org/3/glossary.html#term-file-like-object) object)। यह वास्तविक Python file object है जिसे आप सीधे अन्य functions या libraries को पास कर सकते हैं जो "file-like" object की अपेक्षा करती हैं।
+
+`UploadFile` में निम्नलिखित `async` methods होते हैं। ये सभी अंदर से संबंधित file methods को call करते हैं (internal `SpooledTemporaryFile` का उपयोग करके)।
+
+* `write(data)`: `data` (`str` या `bytes`) को file में लिखता है।
+* `read(size)`: file के `size` (`int`) bytes/characters पढ़ता है।
+* `seek(offset)`: file में byte position `offset` (`int`) पर जाता है।
+ * उदाहरण के लिए, `await myfile.seek(0)` file की शुरुआत पर जाएगा।
+ * यह विशेष रूप से तब उपयोगी है जब आप एक बार `await myfile.read()` चलाते हैं और फिर सामग्री को दोबारा पढ़ने की आवश्यकता होती है।
+* `close()`: file को बंद करता है।
+
+क्योंकि ये सभी methods `async` methods हैं, आपको उन्हें "await" करना होगा।
+
+उदाहरण के लिए, एक `async` *path operation function* के अंदर आप सामग्री इस तरह प्राप्त कर सकते हैं:
+
+```Python
+contents = await myfile.read()
+```
+
+यदि आप एक सामान्य `def` *path operation function* के अंदर हैं, तो आप सीधे `UploadFile.file` access कर सकते हैं, उदाहरण के लिए:
+
+```Python
+contents = myfile.file.read()
+```
+
+/// note | `async` तकनीकी विवरण
+
+जब आप `async` methods का उपयोग करते हैं, तो **FastAPI** file methods को threadpool में चलाता है और उनके लिए await करता है।
+
+///
+
+/// note | Starlette तकनीकी विवरण
+
+**FastAPI** का `UploadFile` सीधे **Starlette** के `UploadFile` से inherit करता है, लेकिन **Pydantic** और FastAPI के अन्य भागों के साथ इसे compatible बनाने के लिए कुछ आवश्यक हिस्से जोड़ता है।
+
+///
+
+## "Form Data" क्या है { #what-is-form-data }
+
+HTML forms (``) सामान्यतः data को server पर भेजने के लिए उस data के लिए एक "special" encoding का उपयोग करते हैं, यह JSON से अलग होता है।
+
+**FastAPI** यह सुनिश्चित करेगा कि उस data को JSON के बजाय सही जगह से पढ़ा जाए।
+
+/// note | तकनीकी विवरण
+
+forms से data सामान्यतः "media type" `application/x-www-form-urlencoded` का उपयोग करके encoded होता है जब इसमें files शामिल नहीं होतीं।
+
+लेकिन जब form में files शामिल होती हैं, तो यह `multipart/form-data` के रूप में encoded होता है। यदि आप `File` का उपयोग करते हैं, तो **FastAPI** जान जाएगा कि उसे body के सही भाग से files प्राप्त करनी हैं।
+
+यदि आप इन encodings और form fields के बारे में अधिक पढ़ना चाहते हैं, तो [`POST` के लिए MDN web docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) पर जाएं।
+
+///
+
+/// warning | चेतावनी
+
+आप एक *path operation* में कई `File` और `Form` parameters घोषित कर सकते हैं, लेकिन आप ऐसे `Body` fields भी घोषित नहीं कर सकते जिन्हें आप JSON के रूप में प्राप्त करने की अपेक्षा करते हैं, क्योंकि request में body `application/json` के बजाय `multipart/form-data` का उपयोग करके encoded होगी।
+
+यह **FastAPI** की limitation नहीं है, यह HTTP protocol का हिस्सा है।
+
+///
+
+## Optional File Upload { #optional-file-upload }
+
+आप standard type annotations का उपयोग करके और default value `None` set करके file को optional बना सकते हैं:
+
+{* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
+
+## अतिरिक्त Metadata के साथ `UploadFile` { #uploadfile-with-additional-metadata }
+
+आप `UploadFile` के साथ `File()` का भी उपयोग कर सकते हैं, उदाहरण के लिए, अतिरिक्त metadata set करने के लिए:
+
+{* ../../docs_src/request_files/tutorial001_03_an_py310.py hl[9,15] *}
+
+## Multiple File Uploads { #multiple-file-uploads }
+
+एक ही समय में कई files अपलोड करना संभव है।
+
+वे "form data" का उपयोग करके भेजे गए उसी "form field" से संबंधित होंगी।
+
+इसका उपयोग करने के लिए, `bytes` या `UploadFile` की list घोषित करें:
+
+{* ../../docs_src/request_files/tutorial002_an_py310.py hl[10,15] *}
+
+आपको, जैसा घोषित किया गया है, `bytes` या `UploadFile`s की एक `list` प्राप्त होगी।
+
+/// note | तकनीकी विवरण
+
+आप `from starlette.responses import HTMLResponse` का भी उपयोग कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.responses` को `fastapi.responses` के रूप में प्रदान करता है। लेकिन उपलब्ध अधिकांश responses सीधे Starlette से आते हैं।
+
+///
+
+### अतिरिक्त Metadata के साथ Multiple File Uploads { #multiple-file-uploads-with-additional-metadata }
+
+और पहले की तरह ही, आप अतिरिक्त parameters set करने के लिए `File()` का उपयोग कर सकते हैं, यहां तक कि `UploadFile` के लिए भी:
+
+{* ../../docs_src/request_files/tutorial003_an_py310.py hl[11,18:20] *}
+
+## Recap { #recap }
+
+request में अपलोड की जाने वाली files घोषित करने के लिए `File`, `bytes`, और `UploadFile` का उपयोग करें, जिन्हें form data के रूप में भेजा जाता है।
diff --git a/docs/hi/docs/tutorial/request-form-models.md b/docs/hi/docs/tutorial/request-form-models.md
new file mode 100644
index 000000000..98fc91ac8
--- /dev/null
+++ b/docs/hi/docs/tutorial/request-form-models.md
@@ -0,0 +1,78 @@
+# Form Models { #form-models }
+
+आप FastAPI में **form fields** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं।
+
+/// note | नोट
+
+forms का उपयोग करने के लिए, पहले [`python-multipart`](https://github.com/Kludex/python-multipart) install करें।
+
+सुनिश्चित करें कि आप एक [virtual environment](../virtual-environments.md) बनाते हैं, उसे activate करते हैं, और फिर इसे install करते हैं, उदाहरण के लिए:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+/// note | नोट
+
+यह FastAPI version `0.113.0` से supported है। 🤓
+
+///
+
+## Forms के लिए Pydantic Models { #pydantic-models-for-forms }
+
+आपको बस उन fields के साथ एक **Pydantic model** declare करना है जिन्हें आप **form fields** के रूप में receive करना चाहते हैं, और फिर parameter को `Form` के रूप में declare करना है:
+
+{* ../../docs_src/request_form_models/tutorial001_an_py310.py hl[9:11,15] *}
+
+**FastAPI** request में मौजूद **form data** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
+
+## Docs जाँचें { #check-the-docs }
+
+आप इसे `/docs` पर docs UI में verify कर सकते हैं:
+
+
+
+
+और दोनों models interactive API documentation के लिए उपयोग किए जाएँगे:
+
+
+
+## अन्य Return Type Annotations { #other-return-type-annotations }
+
+ऐसे cases हो सकते हैं जहाँ आप कुछ ऐसा return करते हैं जो valid Pydantic field नहीं है और आप उसे function में annotate करते हैं, केवल tooling (editor, mypy, आदि) द्वारा दिए गए support को पाने के लिए।
+
+### सीधे Response Return करें { #return-a-response-directly }
+
+सबसे common case होगा [advanced docs में बाद में समझाए अनुसार सीधे Response return करना](../advanced/response-directly.md)।
+
+{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
+
+यह simple case FastAPI द्वारा automatically handle किया जाता है क्योंकि return type annotation `Response` class (या उसका subclass) है।
+
+और tools भी खुश होंगे क्योंकि `RedirectResponse` और `JSONResponse` दोनों `Response` के subclasses हैं, इसलिए type annotation सही है।
+
+### Response Subclass Annotate करें { #annotate-a-response-subclass }
+
+आप type annotation में `Response` के subclass का भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial003_03_py310.py hl[8:9] *}
+
+यह भी काम करेगा क्योंकि `RedirectResponse`, `Response` का subclass है, और FastAPI इस simple case को automatically handle करेगा।
+
+### Invalid Return Type Annotations { #invalid-return-type-annotations }
+
+लेकिन जब आप कोई अन्य arbitrary object return करते हैं जो valid Pydantic type नहीं है (जैसे database object) और आप उसे function में उसी तरह annotate करते हैं, तो FastAPI उस type annotation से Pydantic response model बनाने की कोशिश करेगा, और fail हो जाएगा।
+
+ऐसा ही होगा अगर आपके पास अलग-अलग types के बीच union जैसा कुछ हो जहाँ उनमें से एक या अधिक valid Pydantic types नहीं हैं, उदाहरण के लिए यह fail होगा 💥:
+
+{* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}
+
+...यह fail होता है क्योंकि type annotation Pydantic type नहीं है और केवल एक single `Response` class या subclass भी नहीं है, यह `Response` और `dict` के बीच union (दोनों में से कोई भी) है।
+
+### Response Model Disable करें { #disable-response-model }
+
+ऊपर दिए गए उदाहरण से आगे बढ़ते हुए, आप शायद default data validation, documentation, filtering, आदि नहीं चाहते हों जो FastAPI द्वारा किया जाता है।
+
+लेकिन आप शायद function में return type annotation फिर भी रखना चाहते हों ताकि editors और type checkers (जैसे mypy) जैसे tools से support मिल सके।
+
+इस case में, आप `response_model=None` set करके response model generation disable कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
+
+इससे FastAPI response model generation skip कर देगा और इस तरह आप अपनी जरूरत के किसी भी return type annotations का उपयोग कर सकते हैं, बिना इसके कि वह आपकी FastAPI application को प्रभावित करे। 🤓
+
+## Response Model encoding parameters { #response-model-encoding-parameters }
+
+आपके response model में default values हो सकते हैं, जैसे:
+
+{* ../../docs_src/response_model/tutorial004_py310.py hl[9,11:12] *}
+
+* `description: Union[str, None] = None` (या Python 3.10 में `str | None = None`) का default `None` है।
+* `tax: float = 10.5` का default `10.5` है।
+* `tags: List[str] = []` का default खाली list है: `[]`।
+
+लेकिन अगर वे वास्तव में store नहीं किए गए थे तो आप उन्हें result से omit करना चाह सकते हैं।
+
+उदाहरण के लिए, अगर आपके पास NoSQL database में कई optional attributes वाले models हैं, लेकिन आप default values से भरे बहुत लंबे JSON responses नहीं भेजना चाहते।
+
+### `response_model_exclude_unset` parameter का उपयोग करें { #use-the-response-model-exclude-unset-parameter }
+
+आप *path operation decorator* parameter `response_model_exclude_unset=True` set कर सकते हैं:
+
+{* ../../docs_src/response_model/tutorial004_py310.py hl[22] *}
+
+और वे default values response में शामिल नहीं होंगे, केवल वास्तव में set किए गए values ही शामिल होंगे।
+
+तो, अगर आप ID `foo` वाले item के लिए उस *path operation* को request भेजते हैं, तो response (default values शामिल किए बिना) होगा:
+
+```JSON
+{
+ "name": "Foo",
+ "price": 50.2
+}
+```
+
+/// note | नोट
+
+आप इसका भी उपयोग कर सकते हैं:
+
+* `response_model_exclude_defaults=True`
+* `response_model_exclude_none=True`
+
+जैसा कि `exclude_defaults` और `exclude_none` के लिए [Pydantic docs](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) में बताया गया है।
+
+///
+
+#### Defaults वाले fields के लिए values वाला data { #data-with-values-for-fields-with-defaults }
+
+लेकिन अगर आपके data में model के default values वाले fields के लिए values हैं, जैसे ID `bar` वाला item:
+
+```Python hl_lines="3 5"
+{
+ "name": "Bar",
+ "description": "The bartenders",
+ "price": 62,
+ "tax": 20.2
+}
+```
+
+तो वे response में शामिल होंगे।
+
+#### Defaults जैसे ही values वाला data { #data-with-the-same-values-as-the-defaults }
+
+अगर data में default values जैसे ही values हैं, जैसे ID `baz` वाला item:
+
+```Python hl_lines="3 5-6"
+{
+ "name": "Baz",
+ "description": None,
+ "price": 50.2,
+ "tax": 10.5,
+ "tags": []
+}
+```
+
+FastAPI इतना smart है (दरअसल, Pydantic इतना smart है) कि यह समझ सके कि, भले ही `description`, `tax`, और `tags` के values defaults जैसे ही हैं, उन्हें explicitly set किया गया था (defaults से लिए जाने के बजाय)।
+
+इसलिए, वे JSON response में शामिल होंगे।
+
+/// tip | सुझाव
+
+ध्यान दें कि default values कुछ भी हो सकते हैं, केवल `None` नहीं।
+
+वे list (`[]`), `10.5` का `float`, आदि हो सकते हैं।
+
+///
+
+### `response_model_include` और `response_model_exclude` { #response-model-include-and-response-model-exclude }
+
+आप *path operation decorator* parameters `response_model_include` और `response_model_exclude` का भी उपयोग कर सकते हैं।
+
+वे include करने के लिए attributes के नामों वाला `str` का `set` लेते हैं (बाकी को omit करते हुए) या exclude करने के लिए (बाकी को include करते हुए)।
+
+अगर आपके पास केवल एक Pydantic model है और आप output से कुछ data remove करना चाहते हैं, तो इसे quick shortcut के रूप में उपयोग किया जा सकता है।
+
+/// tip | सुझाव
+
+लेकिन फिर भी इन parameters के बजाय, multiple classes का उपयोग करते हुए, ऊपर दिए गए ideas का उपयोग करने की recommendation है।
+
+ऐसा इसलिए है क्योंकि आपके app के OpenAPI (और docs) में generated JSON Schema फिर भी complete model के लिए ही होगा, भले ही आप कुछ attributes omit करने के लिए `response_model_include` या `response_model_exclude` का उपयोग करें।
+
+यह `response_model_by_alias` पर भी लागू होता है जो इसी तरह काम करता है।
+
+///
+
+{* ../../docs_src/response_model/tutorial005_py310.py hl[29,35] *}
+
+/// tip | सुझाव
+
+Syntax `{"name", "description"}` उन दो values के साथ एक `set` बनाता है।
+
+यह `set(["name", "description"])` के equivalent है।
+
+///
+
+#### `set`s के बजाय `list`s का उपयोग करना { #using-lists-instead-of-sets }
+
+अगर आप `set` का उपयोग करना भूल जाते हैं और इसके बजाय `list` या `tuple` का उपयोग करते हैं, तो FastAPI फिर भी उसे `set` में convert कर देगा और यह सही तरह काम करेगा:
+
+{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
+
+## Recap { #recap }
+
+Response models define करने और खासकर private data को filter out करना सुनिश्चित करने के लिए *path operation decorator* के parameter `response_model` का उपयोग करें।
+
+केवल explicitly set किए गए values return करने के लिए `response_model_exclude_unset` का उपयोग करें।
diff --git a/docs/hi/docs/tutorial/response-status-code.md b/docs/hi/docs/tutorial/response-status-code.md
new file mode 100644
index 000000000..b11bdb0ec
--- /dev/null
+++ b/docs/hi/docs/tutorial/response-status-code.md
@@ -0,0 +1,101 @@
+# Response Status Code { #response-status-code }
+
+जिस तरह आप response model specify कर सकते हैं, उसी तरह आप किसी भी *path operations* में parameter `status_code` के साथ response के लिए इस्तेमाल किया जाने वाला HTTP status code भी declare कर सकते हैं:
+
+* `@app.get()`
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+* आदि।
+
+{* ../../docs_src/response_status_code/tutorial001_py310.py hl[6] *}
+
+/// note | नोट
+
+ध्यान दें कि `status_code`, "decorator" method (`get`, `post`, आदि) का parameter है। यह आपके *path operation function* का parameter नहीं है, जैसे बाकी सभी parameters और body होते हैं।
+
+///
+
+`status_code` parameter HTTP status code वाला एक number receive करता है।
+
+/// note | नोट
+
+`status_code` वैकल्पिक रूप से एक `IntEnum` भी receive कर सकता है, जैसे Python का [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus).
+
+///
+
+यह:
+
+* response में वह status code return करेगा।
+* उसे OpenAPI schema में उसी तरह document करेगा (और इसलिए, user interfaces में भी):
+
+
+
+/// note | नोट
+
+कुछ response codes (अगला section देखें) यह indicate करते हैं कि response में body नहीं होती।
+
+FastAPI यह जानता है, और ऐसे OpenAPI docs बनाएगा जो बताते हैं कि कोई response body नहीं है।
+
+///
+
+## HTTP status codes के बारे में { #about-http-status-codes }
+
+/// note | नोट
+
+अगर आप पहले से जानते हैं कि HTTP status codes क्या होते हैं, तो अगले section पर जाएँ।
+
+///
+
+HTTP में, आप response के हिस्से के रूप में 3 digits का एक numeric status code भेजते हैं।
+
+इन status codes के साथ एक associated name होता है जिससे उन्हें पहचानने में मदद मिलती है, लेकिन महत्वपूर्ण हिस्सा number होता है।
+
+संक्षेप में:
+
+* `100 - 199` "Information" के लिए होते हैं। आप इन्हें सीधे बहुत कम इस्तेमाल करते हैं। इन status codes वाले responses में body नहीं हो सकती।
+* **`200 - 299`** "Successful" responses के लिए होते हैं। ये वे हैं जिन्हें आप सबसे ज़्यादा इस्तेमाल करेंगे।
+ * `200` default status code है, जिसका मतलब है कि सब कुछ "OK" था।
+ * एक और उदाहरण `201`, "Created" होगा। इसे आमतौर पर database में नया record बनाने के बाद इस्तेमाल किया जाता है।
+ * एक विशेष case `204`, "No Content" है। यह response तब इस्तेमाल होता है जब client को return करने के लिए कोई content नहीं होता, और इसलिए response में body नहीं होनी चाहिए।
+* **`300 - 399`** "Redirection" के लिए होते हैं। इन status codes वाले responses में body हो भी सकती है और नहीं भी, सिवाय `304`, "Not Modified" के, जिसमें body नहीं होनी चाहिए।
+* **`400 - 499`** "Client error" responses के लिए होते हैं। ये दूसरा type है जिसे आप शायद सबसे ज़्यादा इस्तेमाल करेंगे।
+ * एक उदाहरण `404` है, "Not Found" response के लिए।
+ * client से आने वाली generic errors के लिए, आप सिर्फ़ `400` इस्तेमाल कर सकते हैं।
+* `500 - 599` server errors के लिए होते हैं। आप इन्हें लगभग कभी सीधे इस्तेमाल नहीं करते। जब आपके application code या server के किसी हिस्से में कुछ गड़बड़ होती है, तो यह अपने-आप इन status codes में से एक return करेगा।
+
+/// tip | सुझाव
+
+हर status code के बारे में और कौन-सा code किसके लिए है, यह जानने के लिए [HTTP status codes के बारे में MDN documentation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) देखें।
+
+///
+
+## नाम याद रखने का shortcut { #shortcut-to-remember-the-names }
+
+आइए पिछले example को फिर से देखें:
+
+{* ../../docs_src/response_status_code/tutorial001_py310.py hl[6] *}
+
+`201` "Created" के लिए status code है।
+
+लेकिन आपको यह याद रखने की ज़रूरत नहीं है कि इनमें से हर code का क्या मतलब है।
+
+आप `fastapi.status` से convenience variables इस्तेमाल कर सकते हैं।
+
+{* ../../docs_src/response_status_code/tutorial002_py310.py hl[1,6] *}
+
+वे सिर्फ़ एक सुविधा हैं, उनमें वही number होता है, लेकिन इस तरह आप उन्हें खोजने के लिए editor के autocomplete का इस्तेमाल कर सकते हैं:
+
+
+
+/// note | तकनीकी विवरण
+
+आप `from starlette import status` भी इस्तेमाल कर सकते हैं।
+
+**FastAPI** आपकी सुविधा के लिए, developer के रूप में, वही `starlette.status` `fastapi.status` के रूप में provide करता है। लेकिन यह सीधे Starlette से आता है।
+
+///
+
+## default बदलना { #changing-the-default }
+
+बाद में, [Advanced User Guide](../advanced/response-change-status-code.md) में, आप देखेंगे कि यहाँ declare किए जा रहे default से अलग status code कैसे return किया जाता है।
diff --git a/docs/hi/docs/tutorial/schema-extra-example.md b/docs/hi/docs/tutorial/schema-extra-example.md
new file mode 100644
index 000000000..dc8b29f58
--- /dev/null
+++ b/docs/hi/docs/tutorial/schema-extra-example.md
@@ -0,0 +1,202 @@
+# Request Example Data घोषित करें { #declare-request-example-data }
+
+आप उस data के examples घोषित कर सकते हैं जिसे आपका app receive कर सकता है।
+
+इसे करने के कई तरीके यहाँ दिए गए हैं।
+
+## Pydantic models में अतिरिक्त JSON Schema data { #extra-json-schema-data-in-pydantic-models }
+
+आप किसी Pydantic model के लिए `examples` घोषित कर सकते हैं, जिन्हें generated JSON Schema में जोड़ा जाएगा।
+
+{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
+
+वह अतिरिक्त जानकारी उस model के output **JSON Schema** में जैसी है वैसी ही जोड़ी जाएगी, और API docs में उपयोग की जाएगी।
+
+आप `model_config` attribute का उपयोग कर सकते हैं, जो एक `dict` लेता है, जैसा कि [Pydantic के docs: Configuration](https://docs.pydantic.dev/latest/api/config/) में बताया गया है।
+
+आप `"json_schema_extra"` को एक `dict` के साथ set कर सकते हैं जिसमें कोई भी अतिरिक्त data हो जिसे आप generated JSON Schema में दिखाना चाहते हैं, जिसमें `examples` भी शामिल हैं।
+
+/// tip | सुझाव
+
+आप इसी technique का उपयोग JSON Schema को extend करने और अपनी custom अतिरिक्त जानकारी जोड़ने के लिए कर सकते हैं।
+
+उदाहरण के लिए, आप इसका उपयोग frontend user interface आदि के लिए metadata जोड़ने में कर सकते हैं।
+
+///
+
+/// note | नोट
+
+OpenAPI 3.1.0 (FastAPI 0.99.0 से उपयोग किया गया) ने `examples` के लिए support जोड़ा, जो **JSON Schema** standard का हिस्सा है।
+
+उससे पहले, यह केवल keyword `example` को एक single example के साथ support करता था। यह अभी भी OpenAPI 3.1.0 द्वारा supported है, लेकिन deprecated है और JSON Schema standard का हिस्सा नहीं है। इसलिए आपको `example` से `examples` पर migrate करने के लिए प्रोत्साहित किया जाता है। 🤓
+
+आप इस page के अंत में और पढ़ सकते हैं।
+
+///
+
+## `Field` के अतिरिक्त arguments { #field-additional-arguments }
+
+Pydantic models के साथ `Field()` का उपयोग करते समय, आप अतिरिक्त `examples` भी घोषित कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial002_py310.py hl[2,8:11] *}
+
+## JSON Schema - OpenAPI में `examples` { #examples-in-json-schema-openapi }
+
+इनमें से किसी का भी उपयोग करते समय:
+
+* `Path()`
+* `Query()`
+* `Header()`
+* `Cookie()`
+* `Body()`
+* `Form()`
+* `File()`
+
+आप अतिरिक्त जानकारी के साथ `examples` का एक group भी घोषित कर सकते हैं, जिसे **OpenAPI** के अंदर उनके **JSON Schemas** में जोड़ा जाएगा।
+
+### `examples` के साथ `Body` { #body-with-examples }
+
+यहाँ हम `Body()` में अपेक्षित data के एक example वाला `examples` pass करते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial003_an_py310.py hl[22:29] *}
+
+### docs UI में Example { #example-in-the-docs-ui }
+
+ऊपर दिए गए किसी भी method के साथ यह `/docs` में इस तरह दिखेगा:
+
+
+
+### कई `examples` के साथ `Body` { #body-with-multiple-examples }
+
+बेशक आप कई `examples` भी pass कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial004_an_py310.py hl[23:38] *}
+
+जब आप ऐसा करते हैं, तो examples उस body data के internal **JSON Schema** का हिस्सा होंगे।
+
+फिर भी, यह लिखते समय, Swagger UI, वह tool जो docs UI दिखाने के लिए जिम्मेदार है, **JSON Schema** में data के लिए कई examples दिखाने को support नहीं करता। लेकिन workaround के लिए नीचे पढ़ें।
+
+### OpenAPI-specific `examples` { #openapi-specific-examples }
+
+**JSON Schema** द्वारा `examples` support किए जाने से पहले से ही, OpenAPI में एक अलग field के लिए support था जिसे `examples` भी कहा जाता था।
+
+यह **OpenAPI-specific** `examples` OpenAPI specification में किसी अन्य section में जाता है। यह प्रत्येक JSON Schema के अंदर नहीं, बल्कि **प्रत्येक *path operation* के details** में जाता है।
+
+और Swagger UI ने इस विशेष `examples` field को कुछ समय से support किया है। इसलिए, आप इसका उपयोग docs UI में अलग-अलग **examples दिखाने** के लिए कर सकते हैं।
+
+इस OpenAPI-specific field `examples` का आकार एक `dict` है जिसमें **कई examples** होते हैं (`list` के बजाय), और प्रत्येक में अतिरिक्त जानकारी होती है जो **OpenAPI** में भी जोड़ी जाएगी।
+
+यह OpenAPI में मौजूद प्रत्येक JSON Schema के अंदर नहीं जाता, यह बाहर, सीधे *path operation* में जाता है।
+
+### `openapi_examples` Parameter का उपयोग { #using-the-openapi-examples-parameter }
+
+आप FastAPI में OpenAPI-specific `examples` को parameter `openapi_examples` के साथ इनके लिए घोषित कर सकते हैं:
+
+* `Path()`
+* `Query()`
+* `Header()`
+* `Cookie()`
+* `Body()`
+* `Form()`
+* `File()`
+
+`dict` की keys प्रत्येक example की पहचान करती हैं, और प्रत्येक value एक और `dict` होती है।
+
+`examples` में प्रत्येक specific example `dict` में ये हो सकते हैं:
+
+* `summary`: example के लिए छोटा description।
+* `description`: एक लंबा description जिसमें Markdown text हो सकता है।
+* `value`: यह दिखाया गया वास्तविक example है, जैसे एक `dict`।
+* `externalValue`: `value` का alternative, example की ओर point करने वाला URL। हालांकि यह शायद `value` जितने tools द्वारा supported न हो।
+
+आप इसे इस तरह use कर सकते हैं:
+
+{* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
+
+### Docs UI में OpenAPI Examples { #openapi-examples-in-the-docs-ui }
+
+`Body()` में `openapi_examples` जोड़ने के साथ `/docs` इस तरह दिखेगा:
+
+
+
+## तकनीकी विवरण { #technical-details }
+
+/// tip | सुझाव
+
+यदि आप पहले से ही **FastAPI** version **0.99.0 या उससे ऊपर** का उपयोग कर रहे हैं, तो आप शायद ये details **skip** कर सकते हैं।
+
+ये पुराने versions के लिए अधिक relevant हैं, OpenAPI 3.1.0 उपलब्ध होने से पहले।
+
+आप इसे एक संक्षिप्त OpenAPI और JSON Schema **history lesson** मान सकते हैं। 🤓
+
+///
+
+/// warning | चेतावनी
+
+ये standards **JSON Schema** और **OpenAPI** के बारे में बहुत technical details हैं।
+
+यदि ऊपर दिए गए ideas आपके लिए पहले से ही काम कर रहे हैं, तो वह पर्याप्त हो सकता है, और शायद आपको इन details की जरूरत नहीं है, इन्हें skip करने के लिए स्वतंत्र महसूस करें।
+
+///
+
+OpenAPI 3.1.0 से पहले, OpenAPI ने **JSON Schema** के एक पुराने और modified version का उपयोग किया।
+
+JSON Schema में `examples` नहीं था, इसलिए OpenAPI ने अपने स्वयं के modified version में अपना `example` field जोड़ा।
+
+OpenAPI ने specification के अन्य हिस्सों में भी `example` और `examples` fields जोड़े:
+
+* [`Parameter Object` (specification में)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-object) जिसका उपयोग FastAPI के इनसे किया गया:
+ * `Path()`
+ * `Query()`
+ * `Header()`
+ * `Cookie()`
+* [`Request Body Object`, field `content` में, `Media Type Object` पर (specification में)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object) जिसका उपयोग FastAPI के इनसे किया गया:
+ * `Body()`
+ * `File()`
+ * `Form()`
+
+/// note | नोट
+
+यह पुराना OpenAPI-specific `examples` parameter अब FastAPI `0.103.0` से `openapi_examples` है।
+
+///
+
+### JSON Schema का `examples` field { #json-schemas-examples-field }
+
+लेकिन फिर JSON Schema ने specification के एक नए version में एक [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) field जोड़ा।
+
+और फिर नया OpenAPI 3.1.0 latest version (JSON Schema 2020-12) पर आधारित था, जिसमें यह नया field `examples` शामिल था।
+
+और अब यह नया `examples` field पुराने single (और custom) `example` field पर precedence लेता है, जो अब deprecated है।
+
+JSON Schema में यह नया `examples` field OpenAPI में अन्य जगहों (ऊपर वर्णित) की तरह अतिरिक्त metadata वाला dict नहीं है, यह **सिर्फ एक `list`** है।
+
+/// note | नोट
+
+OpenAPI 3.1.0 के JSON Schema के साथ इस नए सरल integration के साथ release होने के बाद भी, कुछ समय तक, Swagger UI, वह tool जो automatic docs प्रदान करता है, OpenAPI 3.1.0 को support नहीं करता था (यह version 5.0.0 से करता है 🎉)।
+
+इसी वजह से, 0.99.0 से पहले के FastAPI versions अभी भी OpenAPI के 3.1.0 से कम versions का उपयोग करते थे।
+
+///
+
+### Pydantic और FastAPI `examples` { #pydantic-and-fastapi-examples }
+
+जब आप Pydantic model के अंदर `examples` जोड़ते हैं, `schema_extra` या `Field(examples=["something"])` का उपयोग करके, तो वह example उस Pydantic model के **JSON Schema** में जोड़ा जाता है।
+
+और उस Pydantic model का **JSON Schema** आपकी API के **OpenAPI** में शामिल होता है, और फिर docs UI में उपयोग किया जाता है।
+
+FastAPI के 0.99.0 से पहले के versions में (0.99.0 और ऊपर वाले नए OpenAPI 3.1.0 का उपयोग करते हैं), जब आप किसी भी अन्य utilities (`Query()`, `Body()`, आदि) के साथ `example` या `examples` का उपयोग करते थे, तो वे examples उस data का वर्णन करने वाले JSON Schema में नहीं जोड़े जाते थे (OpenAPI के JSON Schema के अपने version में भी नहीं), वे सीधे OpenAPI में *path operation* declaration में जोड़े जाते थे (OpenAPI के उन parts के बाहर जो JSON Schema का उपयोग करते हैं)।
+
+लेकिन अब जबकि FastAPI 0.99.0 और ऊपर OpenAPI 3.1.0 का उपयोग करता है, जो JSON Schema 2020-12 का उपयोग करता है, और Swagger UI 5.0.0 और ऊपर, सब कुछ अधिक consistent है और examples JSON Schema में शामिल होते हैं।
+
+### Swagger UI और OpenAPI-specific `examples` { #swagger-ui-and-openapi-specific-examples }
+
+अब, क्योंकि Swagger UI कई JSON Schema examples को support नहीं करता था (2023-08-26 तक), users के पास docs में कई examples दिखाने का कोई तरीका नहीं था।
+
+इसे solve करने के लिए, FastAPI `0.103.0` ने नए parameter `openapi_examples` के साथ उसी पुराने **OpenAPI-specific** `examples` field को घोषित करने के लिए **support जोड़ा**। 🤓
+
+### Summary { #summary }
+
+मैं कहा करता था कि मुझे history उतनी पसंद नहीं है... और अब मुझे देखिए, "tech history" lessons दे रहा हूँ। 😅
+
+संक्षेप में, **FastAPI 0.99.0 या उससे ऊपर upgrade करें**, और चीजें बहुत अधिक **सरल, consistent, और intuitive** हैं, और आपको ये सारे historical details जानने की जरूरत नहीं है। 😎
diff --git a/docs/hi/docs/tutorial/security/first-steps.md b/docs/hi/docs/tutorial/security/first-steps.md
new file mode 100644
index 000000000..a7bf2e700
--- /dev/null
+++ b/docs/hi/docs/tutorial/security/first-steps.md
@@ -0,0 +1,203 @@
+# सुरक्षा - पहले कदम { #security-first-steps }
+
+मान लें कि आपका **backend** API किसी domain में है।
+
+और आपका **frontend** किसी दूसरे domain में है या उसी domain के किसी अलग path में है (या किसी mobile application में)।
+
+और आप चाहते हैं कि frontend, **username** और **password** का उपयोग करके backend के साथ authenticate कर सके।
+
+हम इसे **FastAPI** के साथ बनाने के लिए **OAuth2** का उपयोग कर सकते हैं।
+
+लेकिन आपको केवल वे छोटी-छोटी जानकारियाँ खोजने के लिए पूरी लंबी specification पढ़ने में समय न लगाना पड़े।
+
+आइए सुरक्षा संभालने के लिए **FastAPI** द्वारा दिए गए tools का उपयोग करें।
+
+## यह कैसा दिखता है { #how-it-looks }
+
+आइए पहले बस code का उपयोग करें और देखें कि यह कैसे काम करता है, और फिर हम वापस आकर समझेंगे कि क्या हो रहा है।
+
+## `main.py` बनाएँ { #create-main-py }
+
+उदाहरण को एक file `main.py` में copy करें:
+
+{* ../../docs_src/security/tutorial001_an_py310.py *}
+
+## इसे चलाएँ { #run-it }
+
+/// note | नोट
+
+[`python-multipart`](https://github.com/Kludex/python-multipart) package **FastAPI** के साथ अपने-आप install हो जाता है जब आप `pip install "fastapi[standard]"` command चलाते हैं।
+
+हालाँकि, अगर आप `pip install fastapi` command का उपयोग करते हैं, तो `python-multipart` package default रूप से शामिल नहीं होता।
+
+इसे manually install करने के लिए, सुनिश्चित करें कि आप एक [virtual environment](../../virtual-environments.md) बनाएँ, उसे activate करें, और फिर इसे इस तरह install करें:
+
+```console
+$ pip install python-multipart
+```
+
+ऐसा इसलिए है क्योंकि **OAuth2**, `username` और `password` भेजने के लिए "form data" का उपयोग करता है।
+
+///
+
+उदाहरण को इस तरह चलाएँ:
+
+
+
+/// tip | Authorize बटन!
+
+आपके पास पहले से ही एक चमकदार नया "Authorize" बटन है।
+
+और आपकी *path operation* के ऊपर-दाएँ कोने में एक छोटा-सा lock है जिस पर आप click कर सकते हैं।
+
+///
+
+और अगर आप उस पर click करते हैं, तो आपके पास `username` और `password` (और अन्य optional fields) type करने के लिए एक छोटा authorization form होगा:
+
+
+
+/// note | नोट
+
+आप form में क्या type करते हैं, इससे कोई फर्क नहीं पड़ता, यह अभी काम नहीं करेगा। लेकिन हम वहाँ तक पहुँचेंगे।
+
+///
+
+यह निश्चित रूप से final users के लिए frontend नहीं है, लेकिन यह आपके पूरे API को interactively document करने के लिए एक शानदार automatic tool है।
+
+इसे frontend team द्वारा उपयोग किया जा सकता है (जो आप खुद भी हो सकते हैं)।
+
+इसे third party applications और systems द्वारा उपयोग किया जा सकता है।
+
+और इसे आप खुद भी उसी application को debug, check और test करने के लिए उपयोग कर सकते हैं।
+
+## `password` flow { #the-password-flow }
+
+अब थोड़ा पीछे चलते हैं और समझते हैं कि यह सब क्या है।
+
+`password` "flow", OAuth2 में परिभाषित उन तरीकों ("flows") में से एक है, जिनका उपयोग security और authentication संभालने के लिए किया जाता है।
+
+OAuth2 को इस तरह design किया गया था कि backend या API उस server से independent हो सके जो user को authenticate करता है।
+
+लेकिन इस case में, वही **FastAPI** application API और authentication दोनों संभालेगा।
+
+तो, आइए इसे उस simplified दृष्टिकोण से review करें:
+
+* User frontend में `username` और `password` type करता है, और `Enter` दबाता है।
+* Frontend (जो user के browser में चल रहा है) उस `username` और `password` को हमारे API के एक specific URL पर भेजता है (`tokenUrl="token"` के साथ declare किया गया)।
+* API उस `username` और `password` को check करता है, और एक "token" के साथ respond करता है (हमने अभी तक इनमें से कुछ भी implement नहीं किया है)।
+ * एक "token" बस कुछ content वाली string है जिसका उपयोग हम बाद में इस user को verify करने के लिए कर सकते हैं।
+ * सामान्यतः, token को कुछ समय बाद expire होने के लिए set किया जाता है।
+ * इसलिए, user को बाद में किसी समय फिर से log in करना होगा।
+ * और अगर token चोरी हो जाता है, तो risk कम होता है। यह किसी permanent key जैसा नहीं है जो हमेशा काम करेगी (अधिकांश cases में)।
+* Frontend उस token को अस्थायी रूप से कहीं store करता है।
+* User frontend web app के किसी दूसरे section में जाने के लिए frontend में click करता है।
+* Frontend को API से कुछ और data fetch करने की आवश्यकता होती है।
+ * लेकिन उस specific endpoint के लिए इसे authentication चाहिए।
+ * इसलिए, हमारे API के साथ authenticate करने के लिए, यह `Authorization` header भेजता है जिसकी value `Bearer ` plus token होती है।
+ * अगर token में `foobar` है, तो `Authorization` header का content होगा: `Bearer foobar`.
+
+## **FastAPI** का `OAuth2PasswordBearer` { #fastapis-oauth2passwordbearer }
+
+**FastAPI** इन security features को implement करने के लिए abstraction के अलग-अलग levels पर कई tools देता है।
+
+इस उदाहरण में हम **OAuth2** का उपयोग करने जा रहे हैं, **Password** flow के साथ, **Bearer** token का उपयोग करते हुए। हम यह `OAuth2PasswordBearer` class का उपयोग करके करते हैं।
+
+/// note | नोट
+
+"bearer" token एकमात्र विकल्प नहीं है।
+
+लेकिन हमारे use case के लिए यह सबसे अच्छा है।
+
+और यह अधिकांश use cases के लिए सबसे अच्छा हो सकता है, जब तक कि आप OAuth2 expert न हों और ठीक-ठीक न जानते हों कि कोई दूसरा विकल्प आपकी आवश्यकताओं के लिए बेहतर क्यों है।
+
+उस case में, **FastAPI** आपको इसे बनाने के लिए tools भी देता है।
+
+///
+
+जब हम `OAuth2PasswordBearer` class का instance बनाते हैं तो हम `tokenUrl` parameter pass करते हैं। इस parameter में वह URL होता है जिसका उपयोग client (user के browser में चल रहा frontend) token पाने के लिए `username` और `password` भेजने में करेगा।
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[8] *}
+
+/// tip | सुझाव
+
+यहाँ `tokenUrl="token"` एक relative URL `token` को refer करता है जिसे हमने अभी तक बनाया नहीं है। क्योंकि यह relative URL है, यह `./token` के equivalent है।
+
+क्योंकि हम relative URL का उपयोग कर रहे हैं, अगर आपका API `https://example.com/` पर स्थित था, तो यह `https://example.com/token` को refer करेगा। लेकिन अगर आपका API `https://example.com/api/v1/` पर स्थित था, तो यह `https://example.com/api/v1/token` को refer करेगा।
+
+Relative URL का उपयोग करना महत्वपूर्ण है ताकि यह सुनिश्चित हो सके कि आपका application [Proxy के पीछे](../../advanced/behind-a-proxy.md) जैसे advanced use case में भी काम करता रहे।
+
+///
+
+यह parameter उस endpoint / *path operation* को create नहीं करता, बल्कि declare करता है कि URL `/token` वही होगा जिसका उपयोग client को token पाने के लिए करना चाहिए। उस जानकारी का उपयोग OpenAPI में किया जाता है, और फिर interactive API documentation systems में।
+
+हम जल्द ही वास्तविक path operation भी बनाएँगे।
+
+/// note | नोट
+
+अगर आप बहुत strict "Pythonista" हैं, तो आपको parameter name `tokenUrl` की style `token_url` के बजाय पसंद न आए।
+
+ऐसा इसलिए है क्योंकि यह OpenAPI spec जैसा ही name उपयोग कर रहा है। ताकि अगर आपको इनमें से किसी भी security scheme के बारे में और अधिक जाँच करनी हो, तो आप बस इसे copy और paste करके इसके बारे में और जानकारी खोज सकें।
+
+///
+
+`oauth2_scheme` variable `OAuth2PasswordBearer` का instance है, लेकिन यह एक "callable" भी है।
+
+इसे इस तरह call किया जा सकता है:
+
+```Python
+oauth2_scheme(some, parameters)
+```
+
+तो, इसे `Depends` के साथ उपयोग किया जा सकता है।
+
+### इसका उपयोग करें { #use-it }
+
+अब आप उस `oauth2_scheme` को `Depends` के साथ dependency में pass कर सकते हैं।
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}
+
+यह dependency एक `str` प्रदान करेगी जिसे *path operation function* के parameter `token` को assign किया जाता है।
+
+**FastAPI** जान जाएगा कि यह OpenAPI schema (और automatic API docs) में "security scheme" define करने के लिए इस dependency का उपयोग कर सकता है।
+
+/// note | तकनीकी विवरण
+
+**FastAPI** जान जाएगा कि यह OpenAPI में security scheme define करने के लिए `OAuth2PasswordBearer` class (जो dependency में declare की गई है) का उपयोग कर सकता है क्योंकि यह `fastapi.security.oauth2.OAuth2` से inherit करती है, जो बदले में `fastapi.security.base.SecurityBase` से inherit करती है।
+
+OpenAPI (और automatic API docs) के साथ integrate होने वाली सभी security utilities `SecurityBase` से inherit करती हैं, इसी तरह **FastAPI** जान सकता है कि उन्हें OpenAPI में कैसे integrate करना है।
+
+///
+
+## यह क्या करता है { #what-it-does }
+
+यह request में उस `Authorization` header को खोजेगा, check करेगा कि value `Bearer ` plus कोई token है या नहीं, और token को `str` के रूप में return करेगा।
+
+अगर इसे `Authorization` header नहीं दिखता, या value में `Bearer ` token नहीं है, तो यह सीधे 401 status code error (`UNAUTHORIZED`) के साथ respond करेगा।
+
+Error return करने के लिए आपको यह भी check करने की आवश्यकता नहीं है कि token मौजूद है या नहीं। आप निश्चिंत हो सकते हैं कि अगर आपकी function execute होती है, तो उस token में एक `str` होगा।
+
+आप इसे अभी interactive docs में आज़मा सकते हैं:
+
+
+
+हम अभी token की validity verify नहीं कर रहे हैं, लेकिन यह पहले से ही एक शुरुआत है।
+
+## Recap { #recap }
+
+तो, केवल 3 या 4 अतिरिक्त lines में, आपके पास पहले से ही security का कुछ primitive form है।
diff --git a/docs/hi/docs/tutorial/security/get-current-user.md b/docs/hi/docs/tutorial/security/get-current-user.md
new file mode 100644
index 000000000..403d6e7d5
--- /dev/null
+++ b/docs/hi/docs/tutorial/security/get-current-user.md
@@ -0,0 +1,105 @@
+# Current User प्राप्त करें { #get-current-user }
+
+पिछले अध्याय में security system (जो dependency injection system पर आधारित है) *path operation function* को `str` के रूप में एक `token` दे रहा था:
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}
+
+लेकिन वह अभी भी इतना उपयोगी नहीं है।
+
+आइए इसे हमें current user देने वाला बनाते हैं।
+
+## एक user model बनाएँ { #create-a-user-model }
+
+पहले, एक Pydantic user model बनाते हैं।
+
+जिस तरह हम bodies declare करने के लिए Pydantic का उपयोग करते हैं, उसी तरह हम इसे कहीं और भी उपयोग कर सकते हैं:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:16] *}
+
+## एक `get_current_user` dependency बनाएँ { #create-a-get-current-user-dependency }
+
+आइए एक dependency `get_current_user` बनाएँ।
+
+याद है कि dependencies की sub-dependencies हो सकती हैं?
+
+`get_current_user` के पास उसी `oauth2_scheme` के साथ एक dependency होगी जिसे हमने पहले बनाया था।
+
+ठीक वैसे ही जैसे हम पहले सीधे *path operation* में कर रहे थे, हमारी नई dependency `get_current_user` sub-dependency `oauth2_scheme` से `str` के रूप में एक `token` प्राप्त करेगी:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[25] *}
+
+## user प्राप्त करें { #get-the-user }
+
+`get_current_user` हमारे द्वारा बनाई गई एक (fake) utility function का उपयोग करेगी, जो token को `str` के रूप में लेती है और हमारा Pydantic `User` model लौटाती है:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[19:22,26:27] *}
+
+## current user inject करें { #inject-the-current-user }
+
+तो अब हम *path operation* में अपने `get_current_user` के साथ वही `Depends` उपयोग कर सकते हैं:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[31] *}
+
+ध्यान दें कि हम `current_user` का type Pydantic model `User` के रूप में declare करते हैं।
+
+यह function के अंदर completion और type checks में हमारी मदद करेगा।
+
+/// tip | टिप
+
+आपको याद होगा कि request bodies भी Pydantic models के साथ declare की जाती हैं।
+
+यहाँ **FastAPI** confuse नहीं होगा क्योंकि आप `Depends` का उपयोग कर रहे हैं।
+
+///
+
+/// tip | टिप
+
+जिस तरह यह dependency system design किया गया है, वह हमें अलग-अलग dependencies (अलग-अलग "dependables") रखने देता है जो सभी एक `User` model लौटाती हैं।
+
+हम केवल एक dependency तक सीमित नहीं हैं जो उस type का data लौटा सकती है।
+
+///
+
+## अन्य models { #other-models }
+
+अब आप *path operation functions* में सीधे current user प्राप्त कर सकते हैं और `Depends` का उपयोग करके **Dependency Injection** स्तर पर security mechanisms संभाल सकते हैं।
+
+और आप security requirements के लिए कोई भी model या data उपयोग कर सकते हैं (इस मामले में, Pydantic model `User`)।
+
+लेकिन आप किसी विशेष data model, class या type का उपयोग करने तक सीमित नहीं हैं।
+
+क्या आप अपने model में `id` और `email` रखना चाहते हैं और कोई `username` नहीं रखना चाहते? बिल्कुल। आप इन्हीं tools का उपयोग कर सकते हैं।
+
+क्या आप केवल एक `str` रखना चाहते हैं? या केवल एक `dict`? या सीधे database class model instance? सब कुछ उसी तरह काम करता है।
+
+असल में आपके application में login करने वाले users नहीं हैं, बल्कि robots, bots, या अन्य systems हैं, जिनके पास बस एक access token है? फिर भी, सब कुछ उसी तरह काम करता है।
+
+बस अपने application के लिए जिस भी प्रकार का model, जिस भी प्रकार की class, जिस भी प्रकार का database चाहिए, उसका उपयोग करें। **FastAPI** dependency injection system के साथ आपकी ज़रूरतें पूरी करता है।
+
+## Code size { #code-size }
+
+यह example verbose लग सकता है। ध्यान रखें कि हम security, data models, utility functions और *path operations* को उसी file में मिला रहे हैं।
+
+लेकिन यहाँ मुख्य बात है।
+
+security और dependency injection से जुड़ी चीज़ें एक बार लिखी जाती हैं।
+
+और आप इसे जितना चाहें उतना complex बना सकते हैं। फिर भी, यह केवल एक बार, एक ही जगह पर, पूरी flexibility के साथ लिखा जाता है।
+
+लेकिन आपके पास उसी security system का उपयोग करने वाले हजारों endpoints (*path operations*) हो सकते हैं।
+
+और वे सभी (या उनका कोई भी हिस्सा जिसे आप चाहें) इन dependencies या आपके द्वारा बनाई गई किसी भी अन्य dependencies को फिर से उपयोग करने का लाभ उठा सकते हैं।
+
+और ये सभी हजारों *path operations* सिर्फ 3 lines जितने छोटे हो सकते हैं:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[30:32] *}
+
+## Recap { #recap }
+
+अब आप अपने *path operation function* में सीधे current user प्राप्त कर सकते हैं।
+
+हम पहले ही आधे रास्ते तक पहुँच चुके हैं।
+
+हमें बस user/client के लिए एक *path operation* जोड़ना है ताकि वह वास्तव में `username` और `password` भेज सके।
+
+वह आगे आता है।
diff --git a/docs/hi/docs/tutorial/security/index.md b/docs/hi/docs/tutorial/security/index.md
new file mode 100644
index 000000000..43fbd0a9b
--- /dev/null
+++ b/docs/hi/docs/tutorial/security/index.md
@@ -0,0 +1,105 @@
+# Security { #security }
+
+security, authentication और authorization को handle करने के कई तरीके हैं।
+
+और यह सामान्यतः एक जटिल और "कठिन" विषय होता है।
+
+कई frameworks और systems में केवल security और authentication को handle करने में ही बहुत अधिक effort और code लग जाता है (कई मामलों में यह लिखे गए पूरे code का 50% या उससे अधिक हो सकता है)।
+
+**FastAPI** आपको **Security** से आसानी से, तेज़ी से, standard तरीके से निपटने में मदद करने के लिए कई tools प्रदान करता है, बिना सभी security specifications को पढ़ने और सीखने की ज़रूरत के।
+
+लेकिन पहले, आइए कुछ छोटे concepts देखते हैं।
+
+## जल्दी में हैं? { #in-a-hurry }
+
+अगर आपको इन terms की परवाह नहीं है और आपको बस username और password पर आधारित authentication के साथ security *अभी* जोड़नी है, तो अगले chapters पर जाएँ।
+
+## OAuth2 { #oauth2 }
+
+OAuth2 एक specification है जो authentication और authorization को handle करने के कई तरीके define करती है।
+
+यह काफ़ी विस्तृत specification है और कई जटिल use cases को cover करती है।
+
+इसमें "third party" का उपयोग करके authenticate करने के तरीके शामिल हैं।
+
+यही चीज़ अंदर से उन सभी systems में इस्तेमाल होती है जिनमें "login with Facebook, Google, X (Twitter), GitHub" होता है।
+
+### OAuth 1 { #oauth-1 }
+
+OAuth 1 भी था, जो OAuth2 से बहुत अलग और अधिक जटिल था, क्योंकि इसमें communication को encrypt करने के तरीके पर direct specifications शामिल थीं।
+
+आजकल यह बहुत लोकप्रिय या इस्तेमाल में नहीं है।
+
+OAuth2 यह specify नहीं करता कि communication को कैसे encrypt करना है, यह अपेक्षा करता है कि आपकी application HTTPS के साथ serve की जा रही हो।
+
+/// tip | सुझाव
+
+**deployment** वाले section में आप देखेंगे कि Traefik और Let's Encrypt का उपयोग करके HTTPS को मुफ्त में कैसे setup किया जाता है।
+
+///
+
+## OpenID Connect { #openid-connect }
+
+OpenID Connect एक और specification है, जो **OAuth2** पर आधारित है।
+
+यह OAuth2 को बस extend करता है और कुछ ऐसी चीज़ें specify करता है जो OAuth2 में तुलनात्मक रूप से ambiguous हैं, ताकि इसे अधिक interoperable बनाया जा सके।
+
+उदाहरण के लिए, Google login OpenID Connect का उपयोग करता है (जो अंदर से OAuth2 का उपयोग करता है)।
+
+लेकिन Facebook login OpenID Connect को support नहीं करता। उसका अपना OAuth2 flavor है।
+
+### OpenID ("OpenID Connect" नहीं) { #openid-not-openid-connect }
+
+एक "OpenID" specification भी थी। उसने वही समस्या हल करने की कोशिश की जो **OpenID Connect** करता है, लेकिन वह OAuth2 पर आधारित नहीं थी।
+
+इसलिए, वह एक पूरा अतिरिक्त system था।
+
+आजकल यह बहुत लोकप्रिय या इस्तेमाल में नहीं है।
+
+## OpenAPI { #openapi }
+
+OpenAPI (पहले Swagger के नाम से जाना जाता था) APIs बनाने के लिए open specification है (अब Linux Foundation का हिस्सा)।
+
+**FastAPI** **OpenAPI** पर आधारित है।
+
+इसी वजह से कई automatic interactive documentation interfaces, code generation, आदि होना संभव होता है।
+
+OpenAPI कई security "schemes" define करने का तरीका देता है।
+
+इनका उपयोग करके, आप इन सभी standard-based tools का लाभ उठा सकते हैं, जिनमें ये interactive documentation systems भी शामिल हैं।
+
+OpenAPI निम्नलिखित security schemes define करता है:
+
+* `apiKey`: एक application-specific key जो यहाँ से आ सकती है:
+ * एक query parameter.
+ * एक header.
+ * एक cookie.
+* `http`: standard HTTP authentication systems, जिनमें शामिल हैं:
+ * `bearer`: एक header `Authorization` जिसमें `Bearer ` plus एक token का value होता है। यह OAuth2 से inherited है।
+ * HTTP Basic authentication.
+ * HTTP Digest, आदि।
+* `oauth2`: security handle करने के सभी OAuth2 तरीके (जिन्हें "flows" कहा जाता है)।
+ * इनमें से कई flows OAuth 2.0 authentication provider बनाने के लिए उपयुक्त हैं (जैसे Google, Facebook, X (Twitter), GitHub, आदि):
+ * `implicit`
+ * `clientCredentials`
+ * `authorizationCode`
+ * लेकिन एक specific "flow" है जिसे उसी application में सीधे authentication handle करने के लिए पूरी तरह इस्तेमाल किया जा सकता है:
+ * `password`: कुछ अगले chapters इसके examples cover करेंगे।
+* `openIdConnect`: इसमें OAuth2 authentication data को automatically discover करने का तरीका होता है।
+ * यह automatic discovery वही है जो OpenID Connect specification में define की गई है।
+
+/// tip | सुझाव
+
+Google, Facebook, X (Twitter), GitHub, आदि जैसे अन्य authentication/authorization providers को integrate करना भी संभव और तुलनात्मक रूप से आसान है।
+
+सबसे जटिल समस्या उन जैसे authentication/authorization provider बनाना है, लेकिन **FastAPI** आपको इसे आसानी से करने के लिए tools देता है, और आपके लिए heavy lifting करता है।
+
+///
+
+## **FastAPI** utilities { #fastapi-utilities }
+
+FastAPI इन security schemes में से प्रत्येक के लिए `fastapi.security` module में कई tools प्रदान करता है, जो इन security mechanisms का उपयोग आसान बनाते हैं।
+
+अगले chapters में आप देखेंगे कि **FastAPI** द्वारा प्रदान किए गए उन tools का उपयोग करके अपनी API में security कैसे जोड़ें।
+
+और आप यह भी देखेंगे कि यह interactive documentation system में automatically कैसे integrate हो जाता है।
diff --git a/docs/hi/docs/tutorial/security/oauth2-jwt.md b/docs/hi/docs/tutorial/security/oauth2-jwt.md
new file mode 100644
index 000000000..2066d8f5a
--- /dev/null
+++ b/docs/hi/docs/tutorial/security/oauth2-jwt.md
@@ -0,0 +1,277 @@
+# Password के साथ OAuth2 (और hashing), JWT tokens के साथ Bearer { #oauth2-with-password-and-hashing-bearer-with-jwt-tokens }
+
+अब जब हमारे पास पूरा security flow है, तो आइए JWT tokens और secure password hashing का उपयोग करके application को वास्तव में secure बनाते हैं।
+
+यह code ऐसा है जिसे आप अपनी application में सच में उपयोग कर सकते हैं, password hashes को अपने database में save कर सकते हैं, आदि।
+
+हम पिछले chapter में जहाँ छोड़ा था, वहीं से शुरू करेंगे और उसे आगे बढ़ाएँगे।
+
+## JWT के बारे में { #about-jwt }
+
+JWT का मतलब है "JSON Web Tokens"।
+
+यह एक JSON object को बिना spaces वाली लंबी dense string में codify करने का standard है। यह ऐसा दिखता है:
+
+```
+eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
+```
+
+यह encrypted नहीं है, इसलिए कोई भी contents से जानकारी वापस प्राप्त कर सकता है।
+
+लेकिन यह signed है। इसलिए, जब आपको कोई token मिलता है जिसे आपने issue किया था, तो आप verify कर सकते हैं कि उसे आपने ही issue किया था।
+
+इस तरह, आप एक token बना सकते हैं जिसकी expiration, मान लीजिए, 1 week हो। और फिर जब user अगले दिन token के साथ वापस आता है, तो आपको पता होता है कि वह user अभी भी आपके system में logged in है।
+
+एक week के बाद, token expired हो जाएगा और user authorized नहीं होगा और नया token पाने के लिए उसे फिर से sign in करना होगा। और अगर user (या कोई third party) expiration बदलने के लिए token को modify करने की कोशिश करे, तो आप इसे पता लगा पाएँगे, क्योंकि signatures match नहीं होंगे।
+
+अगर आप JWT tokens के साथ प्रयोग करना चाहते हैं और देखना चाहते हैं कि वे कैसे काम करते हैं, तो [https://jwt.io](https://jwt.io/) देखें।
+
+## `PyJWT` install करें { #install-pyjwt }
+
+Python में JWT tokens generate और verify करने के लिए हमें `PyJWT` install करना होगा।
+
+सुनिश्चित करें कि आप एक [virtual environment](../../virtual-environments.md) बनाएँ, उसे activate करें, और फिर `pyjwt` install करें:
+
+
+
+Application को पहले की तरह ही authorize करें।
+
+Credentials का उपयोग करते हुए:
+
+Username: `johndoe`
+Password: `secret`
+
+/// tip | सुझाव
+
+ध्यान दें कि code में कहीं भी plaintext password "`secret`" नहीं है, हमारे पास केवल hashed version है।
+
+///
+
+
+
+Endpoint `/users/me/` call करें, आपको response इस तरह मिलेगा:
+
+```JSON
+{
+ "username": "johndoe",
+ "email": "johndoe@example.com",
+ "full_name": "John Doe",
+ "disabled": false
+}
+```
+
+
+
+अगर आप developer tools खोलते हैं, तो आप देख सकते हैं कि भेजे गए data में केवल token शामिल है, password केवल पहले request में user को authenticate करने और वह access token पाने के लिए भेजा जाता है, लेकिन उसके बाद नहीं:
+
+
+
+/// note | नोट
+
+`Authorization` header पर ध्यान दें, जिसका value `Bearer ` से शुरू होता है।
+
+///
+
+## `scopes` के साथ advanced उपयोग { #advanced-usage-with-scopes }
+
+OAuth2 में "scopes" की धारणा है।
+
+आप उनका उपयोग JWT token में permissions का specific set जोड़ने के लिए कर सकते हैं।
+
+फिर आप यह token सीधे किसी user या third party को दे सकते हैं, ताकि वे restrictions के set के साथ आपकी API से interact कर सकें।
+
+आप बाद में **Advanced User Guide** में सीख सकते हैं कि उनका उपयोग कैसे करें और वे **FastAPI** में कैसे integrated हैं।
+
+## Recap { #recap }
+
+अब तक आपने जो देखा है, उससे आप OAuth2 और JWT जैसे standards का उपयोग करके एक secure **FastAPI** application setup कर सकते हैं।
+
+लगभग किसी भी framework में security संभालना काफ़ी जल्दी एक जटिल विषय बन जाता है।
+
+कई packages जो इसे बहुत सरल बनाते हैं, उन्हें data model, database, और available features के साथ कई compromises करने पड़ते हैं। और इनमें से कुछ packages जो चीज़ों को बहुत अधिक सरल बना देते हैं, उनके अंदर वास्तव में security flaws होते हैं।
+
+---
+
+**FastAPI** किसी भी database, data model या tool के साथ कोई compromise नहीं करता।
+
+यह आपको उन चीज़ों को चुनने की पूरी flexibility देता है जो आपके project के लिए सबसे अच्छी हों।
+
+और आप सीधे कई well maintained और widely used packages जैसे `pwdlib` और `PyJWT` का उपयोग कर सकते हैं, क्योंकि **FastAPI** external packages integrate करने के लिए किसी complex mechanism की मांग नहीं करता।
+
+लेकिन यह आपको process को जितना संभव हो उतना सरल बनाने के लिए tools देता है, बिना flexibility, robustness, या security से compromise किए।
+
+और आप OAuth2 जैसे secure, standard protocols को अपेक्षाकृत simple तरीके से उपयोग और implement कर सकते हैं।
+
+आप **Advanced User Guide** में और सीख सकते हैं कि अधिक fine-grained permission system के लिए OAuth2 "scopes" का उपयोग कैसे करें, इन्हीं standards का पालन करते हुए। Scopes के साथ OAuth2 वह mechanism है जिसका उपयोग कई बड़े authentication providers, जैसे Facebook, Google, GitHub, Microsoft, X (Twitter), आदि करते हैं, ताकि third party applications को अपने users की ओर से उनकी APIs के साथ interact करने के लिए authorize किया जा सके।
diff --git a/docs/hi/docs/tutorial/security/simple-oauth2.md b/docs/hi/docs/tutorial/security/simple-oauth2.md
new file mode 100644
index 000000000..87c9a4a28
--- /dev/null
+++ b/docs/hi/docs/tutorial/security/simple-oauth2.md
@@ -0,0 +1,289 @@
+# Password और Bearer के साथ सरल OAuth2 { #simple-oauth2-with-password-and-bearer }
+
+अब पिछले अध्याय से आगे बढ़ते हैं और एक पूरा security flow बनाने के लिए छूटे हुए हिस्से जोड़ते हैं।
+
+## `username` और `password` प्राप्त करें { #get-the-username-and-password }
+
+हम `username` और `password` प्राप्त करने के लिए **FastAPI** security utilities का उपयोग करने वाले हैं।
+
+OAuth2 निर्दिष्ट करता है कि "password flow" (जिसका हम उपयोग कर रहे हैं) का उपयोग करते समय client/user को `username` और `password` fields को form data के रूप में भेजना होगा।
+
+और spec कहता है कि fields के नाम ऐसे ही होने चाहिए। इसलिए `user-name` या `email` काम नहीं करेगा।
+
+लेकिन चिंता न करें, frontend में आप इसे अपने अंतिम users को जैसे चाहें दिखा सकते हैं।
+
+और आपके database models कोई भी दूसरे नाम उपयोग कर सकते हैं जो आप चाहें।
+
+लेकिन login *path operation* के लिए, हमें spec के साथ compatible होने के लिए इन नामों का उपयोग करना होगा (और उदाहरण के लिए, integrated API documentation system का उपयोग कर पाने के लिए)।
+
+Spec यह भी बताता है कि `username` और `password` को form data के रूप में भेजा जाना चाहिए (इसलिए, यहाँ कोई JSON नहीं)।
+
+### `scope` { #scope }
+
+Spec यह भी कहता है कि client एक और form field "`scope`" भेज सकता है।
+
+form field का नाम `scope` है (singular में), लेकिन यह वास्तव में spaces से अलग किए गए "scopes" वाली एक लंबी string होती है।
+
+हर "scope" बस एक string है (बिना spaces के)।
+
+इनका सामान्यतः विशिष्ट security permissions घोषित करने के लिए उपयोग किया जाता है, उदाहरण के लिए:
+
+* `users:read` या `users:write` आम उदाहरण हैं।
+* `instagram_basic` Facebook / Instagram द्वारा उपयोग किया जाता है।
+* `https://www.googleapis.com/auth/drive` Google द्वारा उपयोग किया जाता है।
+
+/// note | नोट
+
+OAuth2 में "scope" बस एक string है जो किसी विशिष्ट required permission को घोषित करती है।
+
+इससे फर्क नहीं पड़ता कि उसमें `:` जैसे अन्य characters हैं या वह URL है।
+
+वे details implementation specific हैं।
+
+OAuth2 के लिए वे बस strings हैं।
+
+///
+
+## `username` और `password` प्राप्त करने का Code { #code-to-get-the-username-and-password }
+
+अब इसे संभालने के लिए **FastAPI** द्वारा प्रदान की गई utilities का उपयोग करते हैं।
+
+### `OAuth2PasswordRequestForm` { #oauth2passwordrequestform }
+
+पहले, `OAuth2PasswordRequestForm` import करें, और `/token` के *path operation* में `Depends` के साथ इसे dependency के रूप में उपयोग करें:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[4,78] *}
+
+`OAuth2PasswordRequestForm` एक class dependency है जो एक form body घोषित करती है जिसमें:
+
+* `username`।
+* `password`।
+* एक वैकल्पिक `scope` field, एक बड़ी string के रूप में, जो spaces से अलग की गई strings से बनी होती है।
+* एक वैकल्पिक `grant_type`।
+
+/// tip | टिप
+
+OAuth2 spec वास्तव में fixed value `password` के साथ एक field `grant_type` *required* करता है, लेकिन `OAuth2PasswordRequestForm` इसे enforce नहीं करता।
+
+अगर आपको इसे enforce करना है, तो `OAuth2PasswordRequestForm` की जगह `OAuth2PasswordRequestFormStrict` का उपयोग करें।
+
+///
+
+* एक वैकल्पिक `client_id` (हमारे उदाहरण के लिए हमें इसकी आवश्यकता नहीं है)।
+* एक वैकल्पिक `client_secret` (हमारे उदाहरण के लिए हमें इसकी आवश्यकता नहीं है)।
+
+/// note | नोट
+
+`OAuth2PasswordRequestForm`, **FastAPI** के लिए कोई विशेष class नहीं है जैसे `OAuth2PasswordBearer` है।
+
+`OAuth2PasswordBearer` **FastAPI** को बताता है कि यह एक security scheme है। इसलिए इसे OpenAPI में इस तरह जोड़ा जाता है।
+
+लेकिन `OAuth2PasswordRequestForm` बस एक class dependency है जिसे आप खुद भी लिख सकते थे, या आप सीधे `Form` parameters घोषित कर सकते थे।
+
+लेकिन क्योंकि यह एक सामान्य use case है, इसे आसान बनाने के लिए **FastAPI** द्वारा सीधे प्रदान किया गया है।
+
+///
+
+### form data का उपयोग करें { #use-the-form-data }
+
+/// tip | टिप
+
+dependency class `OAuth2PasswordRequestForm` के instance में spaces से अलग की गई लंबी string वाला attribute `scope` नहीं होगा, इसके बजाय, इसमें भेजे गए प्रत्येक scope के लिए actual strings की list वाला `scopes` attribute होगा।
+
+हम इस उदाहरण में `scopes` का उपयोग नहीं कर रहे हैं, लेकिन यदि आपको इसकी आवश्यकता हो तो functionality उपलब्ध है।
+
+///
+
+अब, form field से `username` का उपयोग करके (fake) database से user data प्राप्त करें।
+
+यदि ऐसा कोई user नहीं है, तो हम "Incorrect username or password" कहते हुए error लौटाते हैं।
+
+Error के लिए, हम exception `HTTPException` का उपयोग करते हैं:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[3,79:81] *}
+
+### password जाँचें { #check-the-password }
+
+इस समय हमारे पास database से user data है, लेकिन हमने password नहीं जाँचा है।
+
+पहले उस data को Pydantic `UserInDB` model में डालते हैं।
+
+आपको कभी भी plaintext passwords save नहीं करने चाहिए, इसलिए, हम (fake) password hashing system का उपयोग करेंगे।
+
+यदि passwords match नहीं करते, तो हम वही error लौटाते हैं।
+
+#### Password hashing { #password-hashing }
+
+"Hashing" का मतलब है: कुछ content (इस मामले में password) को bytes की sequence (बस एक string) में convert करना जो बेतरतीब दिखती है।
+
+जब भी आप बिल्कुल वही content (बिल्कुल वही password) पास करते हैं, तो आपको बिल्कुल वही बेतरतीब string मिलती है।
+
+लेकिन आप उस बेतरतीब string से वापस password में convert नहीं कर सकते।
+
+##### Password hashing का उपयोग क्यों करें { #why-use-password-hashing }
+
+अगर आपका database चोरी हो जाता है, तो चोर के पास आपके users के plaintext passwords नहीं होंगे, केवल hashes होंगे।
+
+इसलिए, चोर उन same passwords को किसी दूसरे system में उपयोग करने की कोशिश नहीं कर पाएगा (क्योंकि कई users हर जगह वही password उपयोग करते हैं, यह खतरनाक होगा)।
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[82:85] *}
+
+#### `**user_dict` के बारे में { #about-user-dict }
+
+`UserInDB(**user_dict)` का मतलब है:
+
+*`user_dict` की keys और values को सीधे key-value arguments के रूप में पास करें, इसके बराबर:*
+
+```Python
+UserInDB(
+ username = user_dict["username"],
+ email = user_dict["email"],
+ full_name = user_dict["full_name"],
+ disabled = user_dict["disabled"],
+ hashed_password = user_dict["hashed_password"],
+)
+```
+
+/// note | नोट
+
+`**user_dict` की अधिक पूरी explanation के लिए [**Extra Models** के documentation](../extra-models.md#about-user-in-model-dump) में वापस देखें।
+
+///
+
+## token लौटाएँ { #return-the-token }
+
+`token` endpoint का response एक JSON object होना चाहिए।
+
+इसमें `token_type` होना चाहिए। हमारे मामले में, क्योंकि हम "Bearer" tokens का उपयोग कर रहे हैं, token type "`bearer`" होना चाहिए।
+
+और इसमें `access_token` होना चाहिए, जिसमें हमारे access token वाली एक string हो।
+
+इस सरल उदाहरण के लिए, हम बस पूरी तरह insecure रहेंगे और token के रूप में वही `username` लौटाएँगे।
+
+/// tip | टिप
+
+अगले अध्याय में, आप password hashing और JWT tokens के साथ एक वास्तविक secure implementation देखेंगे।
+
+लेकिन अभी के लिए, आइए उन specific details पर ध्यान दें जिनकी हमें आवश्यकता है।
+
+///
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[87] *}
+
+/// tip | टिप
+
+Spec के अनुसार, आपको `access_token` और `token_type` के साथ एक JSON लौटाना चाहिए, बिल्कुल इस उदाहरण की तरह।
+
+यह कुछ ऐसा है जो आपको अपने code में स्वयं करना होगा, और सुनिश्चित करना होगा कि आप उन JSON keys का उपयोग करें।
+
+Specifications के compliant होने के लिए, यह लगभग एकमात्र चीज है जिसे आपको सही तरीके से खुद करना याद रखना होगा।
+
+बाकी सब **FastAPI** आपके लिए संभालता है।
+
+///
+
+## dependencies अपडेट करें { #update-the-dependencies }
+
+अब हम अपनी dependencies अपडेट करने वाले हैं।
+
+हम `current_user` को *केवल* तब प्राप्त करना चाहते हैं जब यह user active हो।
+
+इसलिए, हम एक अतिरिक्त dependency `get_current_active_user` बनाते हैं जो बदले में `get_current_user` को dependency के रूप में उपयोग करती है।
+
+ये दोनों dependencies बस एक HTTP error लौटाएँगी यदि user मौजूद नहीं है, या inactive है।
+
+इसलिए, हमारे endpoint में, हमें user केवल तभी मिलेगा जब user मौजूद हो, सही तरीके से authenticated हो, और active हो:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[58:66,69:74,94] *}
+
+/// note | नोट
+
+Value `Bearer` के साथ अतिरिक्त header `WWW-Authenticate`, जिसे हम यहाँ लौटा रहे हैं, spec का भी हिस्सा है।
+
+किसी भी HTTP (error) status code 401 "UNAUTHORIZED" को `WWW-Authenticate` header भी लौटाना चाहिए।
+
+Bearer tokens (हमारे मामले) में, उस header की value `Bearer` होनी चाहिए।
+
+आप वास्तव में उस अतिरिक्त header को छोड़ सकते हैं और फिर भी यह काम करेगा।
+
+लेकिन specifications के compliant होने के लिए इसे यहाँ प्रदान किया गया है।
+
+साथ ही, ऐसे tools हो सकते हैं जो इसकी अपेक्षा करते हैं और इसका उपयोग करते हैं (अभी या भविष्य में) और यह आपके या आपके users के लिए उपयोगी हो सकता है, अभी या भविष्य में।
+
+यही standards का लाभ है...
+
+///
+
+## इसे काम करते देखें { #see-it-in-action }
+
+Interactive docs खोलें: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)।
+
+### Authenticate करें { #authenticate }
+
+"Authorize" button पर click करें।
+
+Credentials का उपयोग करें:
+
+User: `johndoe`
+
+Password: `secret`
+
+
+
+System में authenticate होने के बाद, आप इसे ऐसे देखेंगे:
+
+
+
+### अपना user data प्राप्त करें { #get-your-own-user-data }
+
+अब path `/users/me` के साथ operation `GET` का उपयोग करें।
+
+आपको अपने user का data मिलेगा, जैसे:
+
+```JSON
+{
+ "username": "johndoe",
+ "email": "johndoe@example.com",
+ "full_name": "John Doe",
+ "disabled": false,
+ "hashed_password": "fakehashedsecret"
+}
+```
+
+
+
+यदि आप lock icon पर click करके logout करते हैं, और फिर वही operation दोबारा आज़माते हैं, तो आपको HTTP 401 error मिलेगा:
+
+```JSON
+{
+ "detail": "Not authenticated"
+}
+```
+
+### Inactive user { #inactive-user }
+
+अब एक inactive user के साथ प्रयास करें, इनके साथ authenticate करें:
+
+User: `alice`
+
+Password: `secret2`
+
+और path `/users/me` के साथ operation `GET` का उपयोग करने का प्रयास करें।
+
+आपको "Inactive user" error मिलेगा, जैसे:
+
+```JSON
+{
+ "detail": "Inactive user"
+}
+```
+
+## Recap { #recap }
+
+अब आपके पास अपनी API के लिए `username` और `password` पर आधारित एक पूरा security system implement करने के tools हैं।
+
+इन tools का उपयोग करके, आप security system को किसी भी database और किसी भी user या data model के साथ compatible बना सकते हैं।
+
+एकमात्र detail जो missing है वह यह है कि यह अभी वास्तव में "secure" नहीं है।
+
+अगले अध्याय में आप देखेंगे कि secure password hashing library और JWT tokens का उपयोग कैसे करें।
diff --git a/docs/hi/docs/tutorial/server-sent-events.md b/docs/hi/docs/tutorial/server-sent-events.md
new file mode 100644
index 000000000..cb23938df
--- /dev/null
+++ b/docs/hi/docs/tutorial/server-sent-events.md
@@ -0,0 +1,120 @@
+# Server-Sent Events (SSE) { #server-sent-events-sse }
+
+आप **Server-Sent Events** (SSE) का उपयोग करके client को data stream कर सकते हैं।
+
+यह [Stream JSON Lines](stream-json-lines.md) जैसा है, लेकिन `text/event-stream` format का उपयोग करता है, जिसे browsers [`EventSource` API](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) के साथ natively support करते हैं।
+
+/// note | नोट
+
+FastAPI 0.135.0 में जोड़ा गया।
+
+///
+
+## Server-Sent Events क्या हैं? { #what-are-server-sent-events }
+
+SSE, HTTP के माध्यम से server से client तक data stream करने के लिए एक standard है।
+
+हर event एक छोटा text block होता है जिसमें `data`, `event`, `id`, और `retry` जैसे "fields" होते हैं, जिन्हें खाली lines से अलग किया जाता है।
+
+यह ऐसा दिखता है:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE का उपयोग आमतौर पर AI chat streaming, live notifications, logs और observability, और अन्य मामलों में किया जाता है जहाँ server client को updates push करता है।
+
+/// tip | सुझाव
+
+अगर आप binary data stream करना चाहते हैं, जैसे video या audio, तो advanced guide देखें: [Data Stream करें](../advanced/stream-data.md).
+
+///
+
+## FastAPI के साथ SSE Stream करें { #stream-sse-with-fastapi }
+
+FastAPI के साथ SSE stream करने के लिए, अपनी *path operation function* में `yield` का उपयोग करें और `response_class=EventSourceResponse` set करें।
+
+`EventSourceResponse` को `fastapi.sse` से import करें:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+हर yielded item को JSON के रूप में encode किया जाता है और SSE event के `data:` field में भेजा जाता है।
+
+अगर आप return type को `AsyncIterable[Item]` के रूप में declare करते हैं, तो FastAPI इसका उपयोग Pydantic के साथ data को **validate**, **document**, और **serialize** करने के लिए करेगा।
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[10:12,23] *}
+
+/// tip | सुझाव
+
+क्योंकि Pydantic इसे **Rust** side में serialize करेगा, आपको return type declare न करने की तुलना में कहीं बेहतर **performance** मिलेगी।
+
+///
+
+### Non-async *path operation functions* { #non-async-path-operation-functions }
+
+आप नियमित `def` functions (बिना `async`) का भी उपयोग कर सकते हैं, और उसी तरह `yield` का उपयोग कर सकते हैं।
+
+FastAPI सुनिश्चित करेगा कि यह सही तरीके से run हो ताकि यह event loop को block न करे।
+
+क्योंकि इस मामले में function async नहीं है, सही return type `Iterable[Item]` होगा:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[28:31] hl[29] *}
+
+### कोई Return Type नहीं { #no-return-type }
+
+आप return type को छोड़ भी सकते हैं। FastAPI data को convert करने और भेजने के लिए [`jsonable_encoder`](./encoder.md) का उपयोग करेगा।
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+अगर आपको `event`, `id`, `retry`, या `comment` जैसे SSE fields set करने की ज़रूरत है, तो आप plain data के बजाय `ServerSentEvent` objects yield कर सकते हैं।
+
+`ServerSentEvent` को `fastapi.sse` से import करें:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` field हमेशा JSON के रूप में encode किया जाता है। आप कोई भी value pass कर सकते हैं जिसे JSON के रूप में serialize किया जा सकता हो, जिसमें Pydantic models भी शामिल हैं।
+
+## Raw Data { #raw-data }
+
+अगर आपको JSON encoding के **बिना** data भेजना है, तो `data` के बजाय `raw_data` का उपयोग करें।
+
+यह pre-formatted text, log lines, या `[DONE]` जैसे विशेष "sentinel" values भेजने के लिए उपयोगी है।
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | नोट
+
+`data` और `raw_data` mutually exclusive हैं। आप हर `ServerSentEvent` पर उनमें से केवल एक ही set कर सकते हैं।
+
+///
+
+## `Last-Event-ID` के साथ फिर से शुरू करना { #resuming-with-last-event-id }
+
+जब कोई browser connection drop होने के बाद reconnect करता है, तो वह अंतिम प्राप्त `id` को `Last-Event-ID` header में भेजता है।
+
+आप इसे header parameter के रूप में read कर सकते हैं और stream को वहाँ से resume करने के लिए उपयोग कर सकते हैं जहाँ client ने छोड़ा था:
+
+{* ../../docs_src/server_sent_events/tutorial004_py310.py hl[25,27,31] *}
+
+## POST के साथ SSE { #sse-with-post }
+
+SSE **किसी भी HTTP method** के साथ काम करता है, केवल `GET` के साथ नहीं।
+
+यह [MCP](https://modelcontextprotocol.io) जैसे protocols के लिए उपयोगी है, जो `POST` पर SSE stream करते हैं:
+
+{* ../../docs_src/server_sent_events/tutorial005_py310.py hl[14] *}
+
+## तकनीकी विवरण { #technical-details }
+
+FastAPI कुछ SSE best practices को out of the box implement करता है।
+
+* जब कोई message नहीं आया हो, तो हर 15 सेकंड में **"keep alive" `ping` comment** भेजें, ताकि कुछ proxies connection को close न कर दें, जैसा कि [HTML specification: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes) में सुझाया गया है।
+* stream की **caching रोकने** के लिए `Cache-Control: no-cache` header set करें।
+* Nginx जैसे कुछ proxies में **buffering रोकने** के लिए एक special header `X-Accel-Buffering: no` set करें।
+
+आपको इसके लिए कुछ भी करने की ज़रूरत नहीं है, यह out of the box काम करता है। 🤓
diff --git a/docs/hi/docs/tutorial/sql-databases.md b/docs/hi/docs/tutorial/sql-databases.md
new file mode 100644
index 000000000..041da16e9
--- /dev/null
+++ b/docs/hi/docs/tutorial/sql-databases.md
@@ -0,0 +1,357 @@
+# SQL (Relational) डेटाबेस { #sql-relational-databases }
+
+**FastAPI** के लिए SQL (relational) डेटाबेस इस्तेमाल करना required नहीं है। लेकिन आप **कोई भी डेटाबेस** इस्तेमाल कर सकते हैं जो आप चाहें।
+
+यहाँ हम [SQLModel](https://sqlmodel.tiangolo.com/) का उपयोग करके एक उदाहरण देखेंगे।
+
+**SQLModel**, [SQLAlchemy](https://www.sqlalchemy.org/) और Pydantic के ऊपर बना है। इसे **FastAPI** के उसी लेखक ने बनाया है ताकि यह उन FastAPI applications के लिए perfect match हो जिन्हें **SQL databases** इस्तेमाल करने की जरूरत होती है।
+
+/// tip | टिप
+
+आप अपनी पसंद की कोई भी दूसरी SQL या NoSQL डेटाबेस लाइब्रेरी इस्तेमाल कर सकते हैं (कुछ मामलों में इन्हें "ORMs" कहा जाता है), FastAPI आपको कुछ भी इस्तेमाल करने के लिए मजबूर नहीं करता। 😎
+
+///
+
+क्योंकि SQLModel, SQLAlchemy पर आधारित है, आप SQLAlchemy द्वारा **supported कोई भी डेटाबेस** आसानी से इस्तेमाल कर सकते हैं (जिससे वे SQLModel द्वारा भी supported हो जाते हैं), जैसे:
+
+* PostgreSQL
+* MySQL
+* SQLite
+* Oracle
+* Microsoft SQL Server, आदि।
+
+इस उदाहरण में, हम **SQLite** इस्तेमाल करेंगे, क्योंकि यह एक single file का उपयोग करता है और Python में इसके लिए integrated support है। इसलिए, आप इस उदाहरण को copy कर सकते हैं और जैसा है वैसा ही run कर सकते हैं।
+
+बाद में, अपनी production application के लिए, आप **PostgreSQL** जैसा database server इस्तेमाल करना चाह सकते हैं।
+
+/// tip | टिप
+
+**FastAPI** और **PostgreSQL** के साथ एक official project generator है जिसमें frontend और अधिक tools शामिल हैं: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
+
+///
+
+यह एक बहुत ही सरल और छोटा tutorial है, अगर आप सामान्य रूप से databases, SQL, या अधिक advanced features के बारे में सीखना चाहते हैं, तो [SQLModel docs](https://sqlmodel.tiangolo.com/) पर जाएँ।
+
+## `SQLModel` install करें { #install-sqlmodel }
+
+सबसे पहले, सुनिश्चित करें कि आप अपना [virtual environment](../virtual-environments.md) बनाएँ, उसे activate करें, और फिर `sqlmodel` install करें:
+
+
+
+