🌐 Update translations for hi (update-outdated) (#16647)

Co-authored-by: pr-submit[bot] <pr-submit[bot]@users.noreply.github.com>
Co-authored-by: pr-push[bot] <pr-push[bot]@users.noreply.github.com>

docs/hi/docs/advanced/advanced-python-types.md

@@ -13,7 +13,7 @@ from typing import Union
 
 
 def say_hi(name: Union[str, None]):
-        print(f"Hi {name}!")
+    print(f"Hi {name}!")
 ```
 
 `typing` में `Optional` के साथ यह declare करने का एक shortcut भी है कि कोई चीज़ `None` हो सकती है।

docs/hi/docs/advanced/async-tests.md

@@ -71,7 +71,7 @@ marker `@pytest.mark.anyio` pytest को बताता है कि इस t
 यह इसके बराबर है:
 
 ```Python
-response = client.get('/')
+response = client.get("/")
 ```
 
 ...जिसका उपयोग हम `TestClient` के साथ अपनी requests बनाने के लिए करते थे।
@@ -84,7 +84,7 @@ response = client.get('/')
 
 /// warning | चेतावनी
 
-अगर आपकी application lifespan events पर निर्भर करती है, तो `AsyncClient` इन events को trigger नहीं करेगा। यह सुनिश्चित करने के लिए कि वे trigger हों, [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage) से `LifespanManager` का उपयोग करें।
+अगर आपकी application lifespan event पर निर्भर करती है, तो `AsyncClient` इन event को trigger नहीं करेगा। यह सुनिश्चित करने के लिए कि वे trigger हों, [florimondmanca/asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage) से `LifespanManager` का उपयोग करें।
 
 ///
 

docs/hi/docs/advanced/behind-a-proxy.md

@@ -8,7 +8,7 @@
 
 आपकी application के सामने मौजूद **proxy** आम तौर पर requests को आपके **server** तक भेजने से पहले तुरंत कुछ headers सेट करेगा, ताकि server को पता चल सके कि request proxy द्वारा **forwarded** की गई थी, उसे मूल (public) URL पता चल सके, जिसमें domain शामिल हो, कि वह HTTPS उपयोग कर रहा है, आदि।
 
-**server** program (उदाहरण के लिए **FastAPI CLI** के जरिए **Uvicorn**) इन headers को समझने में सक्षम है, और फिर वह जानकारी आपकी application को पास कर सकता है।
+`fastapi run` द्वारा शुरू किया गया **server** इन headers को समझने में सक्षम है, और फिर वह जानकारी आपकी application को पास कर सकता है।
 
 लेकिन security के लिए, क्योंकि server को यह नहीं पता कि वह किसी trusted proxy के पीछे है, वह उन headers को interpret नहीं करेगा।
 
@@ -34,8 +34,6 @@ Proxy headers हैं:
 
 ```console
 $ uv run fastapi run --forwarded-allow-ips="*"
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
@@ -101,7 +99,7 @@ sequenceDiagram
 
 आपके पास ऐसा proxy हो सकता है जो आपकी application में एक path prefix जोड़ता हो।
 
-इन मामलों में आप अपनी application configure करने के लिए `root_path` का उपयोग कर सकते हैं।
+इन मामलों में आप `fastapi run --root-path` के साथ server configure कर सकते हैं।
 
 `root_path` ASGI specification द्वारा प्रदान किया गया एक mechanism है (जिस पर FastAPI, Starlette के जरिए, बना है)।
 
@@ -117,7 +115,7 @@ sequenceDiagram
 
 {* ../../docs_src/behind_a_proxy/tutorial001_py310.py hl[6] *}
 
-और proxy app server (शायद FastAPI CLI के जरिए Uvicorn) तक request भेजने से पहले तुरंत **path prefix** को **"strip"** कर देगा, आपकी application को यह भरोसा दिलाते हुए कि वह `/app` पर serve हो रही है, ताकि आपको prefix `/api/v1` शामिल करने के लिए अपना सारा code update न करना पड़े।
+और proxy server तक request भेजने से पहले तुरंत **path prefix** को **"strip"** कर देगा, आपकी application को यह भरोसा दिलाते हुए कि वह `/app` पर serve हो रही है, ताकि आपको prefix `/api/v1` शामिल करने के लिए अपना सारा code update न करना पड़े।
 
 यहाँ तक, सब कुछ सामान्य रूप से काम करेगा।
 
@@ -161,7 +159,7 @@ Docs UI को OpenAPI schema में यह declare करने की भ
 }
 ```
 
-इस उदाहरण में, "Proxy" कुछ **Traefik** जैसा हो सकता है। और server **Uvicorn** के साथ FastAPI CLI जैसा हो सकता है, जो आपकी FastAPI application चला रहा है।
+इस उदाहरण में, "Proxy" कुछ **Traefik** जैसा हो सकता है। और `fastapi run` आपकी FastAPI application चलाने वाला server शुरू करेगा।
 
 ### `root_path` प्रदान करना { #providing-the-root-path }
 
@@ -171,14 +169,10 @@ Docs UI को OpenAPI schema में यह declare करने की भ
 
 ```console
 $ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
 
-अगर आप Hypercorn उपयोग करते हैं, तो उसमें भी option `--root-path` है।
-
 /// note | तकनीकी विवरण
 
 ASGI specification इस use case के लिए `root_path` define करती है।
@@ -195,14 +189,12 @@ ASGI specification इस use case के लिए `root_path` define करत
 
 {* ../../docs_src/behind_a_proxy/tutorial001_py310.py hl[8] *}
 
-फिर, अगर आप Uvicorn को इस तरह शुरू करते हैं:
+फिर, अगर आप server को इस तरह शुरू करते हैं:
 
 <div class="termy">
 
 ```console
 $ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
@@ -216,30 +208,11 @@ Response कुछ ऐसा होगा:
 }
 ```
 
-### FastAPI app में `root_path` सेट करना { #setting-the-root-path-in-the-fastapi-app }
+/// warning | Deprecated `root_path` parameter
 
-वैकल्पिक रूप से, अगर आपके पास `--root-path` या equivalent जैसा command line option देने का तरीका नहीं है, तो आप अपनी FastAPI app बनाते समय `root_path` parameter सेट कर सकते हैं:
+FastAPI 0.145.0 और उससे पहले के versions में, `root_path` को `FastAPI()` में भी configure किया जा सकता था। यह parameter अब deprecated है क्योंकि इसका व्यवहार server configuration के अनुरूप नहीं था। इसके बजाय `fastapi run --root-path /api/v1` उपयोग करें।
 
-{* ../../docs_src/behind_a_proxy/tutorial002_py310.py hl[3] *}
-
-`root_path` को `FastAPI` में पास करना, Uvicorn या Hypercorn को `--root-path` command line option पास करने के equivalent होगा।
-
-### `root_path` के बारे में { #about-root-path }
-
-ध्यान रखें कि server (Uvicorn) उस `root_path` का उपयोग app को पास करने के अलावा किसी और चीज़ के लिए नहीं करेगा।
-
-लेकिन अगर आप अपने browser में [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app) पर जाते हैं, तो आपको normal response दिखाई देगा:
-
-```JSON
-{
-    "message": "Hello World",
-    "root_path": "/api/v1"
-}
-```
-
-इसलिए, यह `http://127.0.0.1:8000/api/v1/app` पर access किए जाने की अपेक्षा नहीं करेगा।
-
-Uvicorn अपेक्षा करेगा कि proxy Uvicorn को `http://127.0.0.1:8000/app` पर access करे, और फिर ऊपर extra `/api/v1` prefix जोड़ना proxy की जिम्मेदारी होगी।
+///
 
 ## Stripped path prefix वाले proxies के बारे में { #about-proxies-with-a-stripped-path-prefix }
 
@@ -247,7 +220,7 @@ Uvicorn अपेक्षा करेगा कि proxy Uvicorn को `http:
 
 शायद कई cases में default यह होगा कि proxy के पास stripped path prefix नहीं होगा।
 
-ऐसे case में (बिना stripped path prefix के), proxy कुछ `https://myawesomeapp.com` जैसा listen करेगा, और फिर अगर browser `https://myawesomeapp.com/api/v1/app` पर जाता है और आपका server (जैसे Uvicorn) `http://127.0.0.1:8000` पर listen करता है, तो proxy (बिना stripped path prefix के) Uvicorn को उसी path पर access करेगा: `http://127.0.0.1:8000/api/v1/app`।
+ऐसे case में (बिना stripped path prefix के), proxy कुछ `https://myawesomeapp.com` जैसा listen करेगा, और फिर अगर browser `https://myawesomeapp.com/api/v1/app` पर जाता है और आपका server `http://127.0.0.1:8000` पर listen करता है, तो proxy (बिना stripped path prefix के) server को उसी path पर access करेगा: `http://127.0.0.1:8000/api/v1/app`।
 
 ## Traefik के साथ local testing { #testing-locally-with-traefik }
 
@@ -302,7 +275,7 @@ Uvicorn अपेक्षा करेगा कि proxy Uvicorn को `http:
 
 यह file Traefik को path prefix `/api/v1` उपयोग करने के लिए configure करती है।
 
-और फिर Traefik अपनी requests को `http://127.0.0.1:8000` पर चल रहे आपके Uvicorn पर redirect करेगा।
+और फिर Traefik अपनी requests को `http://127.0.0.1:8000` पर चल रहे आपके server पर forward करेगा।
 
 अब Traefik शुरू करें:
 
@@ -322,15 +295,13 @@ INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml
 
 ```console
 $ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
 </div>
 
 ### Responses जाँचें { #check-the-responses }
 
-अब, अगर आप Uvicorn के port वाले URL पर जाते हैं: [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), तो आपको normal response दिखाई देगा:
+अब, अगर आप server के port वाले URL पर जाते हैं: [http://127.0.0.1:8000/app](http://127.0.0.1:8000/app), तो आपको normal response दिखाई देगा:
 
 ```JSON
 {
@@ -360,15 +331,15 @@ $ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
 
 बेशक, यहाँ विचार यह है कि हर कोई app को proxy के जरिए access करेगा, इसलिए path prefix `/api/v1` वाला version "correct" है।
 
-और बिना path prefix वाला version (`http://127.0.0.1:8000/app`), जो सीधे Uvicorn द्वारा प्रदान किया गया है, केवल _proxy_ (Traefik) के access के लिए होगा।
+और बिना path prefix वाला version (`http://127.0.0.1:8000/app`), जो सीधे server द्वारा प्रदान किया गया है, केवल _proxy_ (Traefik) के access के लिए होगा।
 
-यह दिखाता है कि Proxy (Traefik) path prefix का उपयोग कैसे करता है और server (Uvicorn) option `--root-path` से `root_path` का उपयोग कैसे करता है।
+यह दिखाता है कि Proxy (Traefik) path prefix का उपयोग कैसे करता है और server option `--root-path` से `root_path` का उपयोग कैसे करता है।
 
 ### Docs UI जाँचें { #check-the-docs-ui }
 
 लेकिन यहाँ मज़ेदार हिस्सा है। ✨
 
-App को access करने का "official" तरीका उस path prefix वाले proxy के जरिए होगा जिसे हमने define किया है। इसलिए, जैसा कि हम अपेक्षा करेंगे, अगर आप Uvicorn द्वारा सीधे serve किया गया docs UI try करते हैं, URL में path prefix के बिना, तो यह काम नहीं करेगा, क्योंकि यह proxy के जरिए access किए जाने की अपेक्षा करता है।
+App को access करने का "official" तरीका उस path prefix वाले proxy के जरिए होगा जिसे हमने define किया है। इसलिए, जैसा कि हम अपेक्षा करेंगे, अगर आप server द्वारा सीधे serve किया गया docs UI try करते हैं, URL में path prefix के बिना, तो यह काम नहीं करेगा, क्योंकि यह proxy के जरिए access किए जाने की अपेक्षा करता है।
 
 आप इसे [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) पर देख सकते हैं:
 
@@ -398,7 +369,7 @@ Default रूप से, **FastAPI** OpenAPI schema में `root_path` क
 
 अगर आप `servers` की custom list पास करते हैं और कोई `root_path` है (क्योंकि आपकी API proxy के पीछे रहती है), तो **FastAPI** list की शुरुआत में इस `root_path` के साथ एक "server" insert करेगा।
 
-उदाहरण के लिए:
+उदाहरण के लिए, उसी `fastapi run --root-path /api/v1` server configuration का उपयोग करने पर:
 
 {* ../../docs_src/behind_a_proxy/tutorial003_py310.py hl[4:7] *}
 
@@ -455,7 +426,7 @@ OpenAPI specification में `servers` property optional है।
 
 अगर आप नहीं चाहते कि **FastAPI** `root_path` का उपयोग करके automatic server शामिल करे, तो आप parameter `root_path_in_servers=False` उपयोग कर सकते हैं:
 
-{* ../../docs_src/behind_a_proxy/tutorial004_py310.py hl[9] *}
+{* ../../docs_src/behind_a_proxy/tutorial004_py310.py hl[8] *}
 
 और फिर यह उसे OpenAPI schema में शामिल नहीं करेगा।
 

docs/hi/docs/advanced/security/http-basic-auth.md

@@ -12,7 +12,7 @@ HTTP Basic Auth में, application एक header की अपेक्ष
 
 फिर, जब आप वह username और password टाइप करते हैं, तो browser उन्हें header में अपने-आप भेज देता है।
 
-## Simple HTTP Basic Auth { #simple-http-basic-auth }
+## सरल HTTP Basic Auth { #simple-http-basic-auth }
 
 * `HTTPBasic` और `HTTPBasicCredentials` import करें।
 * `HTTPBasic` का उपयोग करके एक "`security` scheme" बनाएँ।
@@ -45,7 +45,9 @@ HTTP Basic Auth में, application एक header की अपेक्ष
 यह इसके समान होगा:
 
 ```Python
-if not (credentials.username == "stanleyjobson") or not (credentials.password == "swordfish"):
+if not (credentials.username == "stanleyjobson") or not (
+    credentials.password == "swordfish"
+):
     # कोई error लौटाएँ
     ...
 ```

docs/hi/docs/advanced/templates.md

@@ -1,3 +1,7 @@
+---
+render_macros: false
+---
+
 # Templates { #templates }
 
 आप **FastAPI** के साथ अपनी पसंद का कोई भी template engine उपयोग कर सकते हैं।
@@ -63,14 +67,10 @@ FastAPI 0.108.0, Starlette 0.29.0 से पहले, `name` पहला param
 
 उस HTML में जिसमें यह शामिल है:
 
-{% raw %}
-
 ```jinja
 Item ID: {{ id }}
 ```
 
-{% endraw %}
-
 ...यह आपके द्वारा pass किए गए "context" `dict` से लिया गया `id` दिखाएगा:
 
 ```Python
@@ -89,22 +89,48 @@ Item ID: 42
 
 इसलिए, इस section के साथ:
 
-{% raw %}
-
 ```jinja
 <a href="{{ url_for('read_item', id=id) }}">
 ```
 
-{% endraw %}
-
 ...यह उसी URL का link generate करेगा जिसे *path operation function* `read_item(id=id)` handle करेगा।
 
-उदाहरण के लिए, `42` की ID के साथ, यह render होगा:
+`url_for()` वर्तमान request के आधार पर scheme और host सहित एक absolute URL return करता है।
+
+उदाहरण के लिए, यदि आपका application `https://example.com` पर serve किया जाता है, तो `42` की ID के साथ, यह render होगा:
+
+```html
+<a href="https://example.com/items/42">
+```
+
+### Templates में URL paths { #url-paths-in-templates }
+
+उसी साइट के links के लिए, आप केवल URL path प्राप्त करने के लिए `.path` attribute का उपयोग कर सकते हैं, उदाहरण के लिए, `templates/item_path.html` में:
+
+```jinja hl_lines="4 7"
+{!../../docs_src/templates/templates/item_path.html!}
+```
+
+Template का नाम `TemplateResponse` को pass करें:
+
+{* ../../docs_src/templates/tutorial002_py310.py ln[14:18] hl[17] *}
+
+उसी उदाहरण में, item का link इस तरह render होगा:
 
 ```html
 <a href="/items/42">
 ```
 
+शुरुआती `/` इस path को वर्तमान साइट के root के सापेक्ष बनाता है।
+
+`.path` attribute में scheme, host, query parameters और fragment शामिल नहीं होते। किसी अन्य host के links के लिए पूरे URL का उपयोग करें।
+
+/// tip | सुझाव
+
+यदि आपका application किसी proxy के पीछे है, तो [Proxy के पीछे](behind-a-proxy.md) में बताए अनुसार forwarded headers और `root_path` configure करें।
+
+///
+
 ## Templates और static files { #templates-and-static-files }
 
 आप template के अंदर `url_for()` का भी उपयोग कर सकते हैं, और इसे, उदाहरण के लिए, उन `StaticFiles` के साथ उपयोग कर सकते हैं जिन्हें आपने `name="static"` के साथ mount किया है।

docs/hi/docs/async.md

@@ -15,7 +15,7 @@ results = await some_library()
 तो, अपने *path operation functions* को `async def` के साथ declare करें, जैसे:
 
 ```Python hl_lines="2"
-@app.get('/')
+@app.get("/")
 async def read_results():
     results = await some_library()
     return results
@@ -32,7 +32,7 @@ async def read_results():
 अगर आप ऐसी third party library का उपयोग कर रहे हैं जो किसी चीज़ (database, API, file system, आदि) से communicate करती है और `await` का उपयोग करने का support नहीं रखती, (वर्तमान में अधिकांश database libraries के साथ यही स्थिति है), तो अपने *path operation functions* को सामान्य रूप से, केवल `def` के साथ declare करें, जैसे:
 
 ```Python hl_lines="2"
-@app.get('/')
+@app.get("/")
 def results():
     results = some_library()
     return results
@@ -343,7 +343,7 @@ burgers = get_burgers(2)
 तो, अगर आप कोई library use कर रहे हैं जो आपको बताती है कि आप उसे `await` के साथ call कर सकते हैं, तो आपको उसका उपयोग करने वाले *path operation functions* को `async def` के साथ create करना होगा, जैसे:
 
 ```Python hl_lines="2-3"
-@app.get('/burgers')
+@app.get("/burgers")
 async def read_burgers():
     burgers = await get_burgers(2)
     return burgers

docs/hi/docs/features.md

@@ -1,14 +1,14 @@
-# विशेषताएँ { #features }
+# Features { #features }
 
-## FastAPI की विशेषताएँ { #fastapi-features }
+## FastAPI के features { #fastapi-features }
 
 **FastAPI** आपको निम्नलिखित देता है:
 
-### खुले मानकों पर आधारित { #based-on-open-standards }
+### खुले standards पर आधारित { #based-on-open-standards }
 
 * API बनाने के लिए [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification), जिसमें <dfn title="इन्हें भी कहा जाता है: endpoints, routes">path</dfn> <dfn title="इन्हें HTTP methods भी कहा जाता है, जैसे POST, GET, PUT, DELETE">operations</dfn>, parameters, request bodies, security, आदि की घोषणाएँ शामिल हैं।
 * [**JSON Schema**](https://json-schema.org/) के साथ automatic data model documentation (क्योंकि OpenAPI स्वयं JSON Schema पर आधारित है)।
-* इन मानकों के इर्द-गिर्द डिज़ाइन किया गया, एक बहुत सावधानीपूर्वक अध्ययन के बाद। ऊपर से बाद में जोड़ी गई परत की तरह नहीं।
+* इन standards के इर्द-गिर्द डिज़ाइन किया गया, एक बहुत सावधानीपूर्वक अध्ययन के बाद। ऊपर से बाद में जोड़ी गई परत की तरह नहीं।
 * यह कई भाषाओं में automatic **client code generation** का उपयोग करने की भी अनुमति देता है।
 
 ### Automatic docs { #automatic-docs }
@@ -36,6 +36,7 @@ from datetime import date
 
 from pydantic import BaseModel
 
+
 # किसी variable को str के रूप में घोषित करें
 # और function के अंदर editor support पाएँ
 def main(user_id: str):
@@ -75,7 +76,7 @@ my_second_user: User = User(**second_user_data)
 
 पूरे framework को उपयोग में आसान और सहज बनाने के लिए डिज़ाइन किया गया था, development शुरू करने से पहले ही सभी निर्णयों को कई editors पर test किया गया, ताकि सबसे अच्छा development experience सुनिश्चित किया जा सके।
 
-Python developer surveys में, यह स्पष्ट है [कि सबसे अधिक उपयोग की जाने वाली सुविधाओं में से एक "autocompletion" है](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features)।
+Python developer surveys में, यह स्पष्ट है [कि सबसे अधिक उपयोग किए जाने वाले features में से एक "autocompletion" है](https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features)।
 
 पूरा **FastAPI** framework इसे पूरा करने के लिए डिज़ाइन किया गया है। Autocompletion हर जगह काम करता है।
 
@@ -157,7 +158,7 @@ FastAPI में एक बेहद आसान, लेकिन बेहद
 * 100% <dfn title="Python type annotations, जिनसे आपका editor और external tools आपको बेहतर support दे सकते हैं">type annotated</dfn> code base।
 * Production applications में उपयोग किया गया।
 
-## Starlette की विशेषताएँ { #starlette-features }
+## Starlette के features { #starlette-features }
 
 **FastAPI** [**Starlette**](https://starlette.dev/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Starlette code है, वह भी काम करेगा।
 
@@ -175,7 +176,7 @@ FastAPI में एक बेहद आसान, लेकिन बेहद
 * 100% test coverage।
 * 100% type annotated codebase।
 
-## Pydantic की विशेषताएँ { #pydantic-features }
+## Pydantic के features { #pydantic-features }
 
 **FastAPI** [**Pydantic**](https://pydantic.dev/docs/) के साथ पूरी तरह compatible है (और उसी पर आधारित है)। इसलिए, आपके पास जो भी अतिरिक्त Pydantic code है, वह भी काम करेगा।
 

docs/hi/docs/index.md

@@ -40,7 +40,7 @@ include_yaml:
 
 FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्शन) web framework है जो standard Python type hints के आधार पर Python से APIs बनाने के लिए है।
 
-मुख्य विशेषताएँ:
+मुख्य features:
 
 * **तेज़**: बहुत उच्च प्रदर्शन, **NodeJS** और **Go** के समकक्ष (Starlette और Pydantic की बदौलत)। [उपलब्ध सबसे तेज़ Python frameworks में से एक](#performance)।
 * **कोड लिखने में तेज़**: features विकसित करने की गति लगभग 200% से 300% तक बढ़ाएँ। *
@@ -89,7 +89,7 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
 
 <!-- only-mkdocs -->
 <div class="fastapi-opinions" data-fastapi-opinions>
-  <div class="fastapi-opinions__tabs" role="tablist" aria-label="Companies using FastAPI">
+  <div class="fastapi-opinions__tabs" role="tablist" aria-label="FastAPI का उपयोग करने वाली कंपनियाँ">
     <button class="fastapi-opinions__tab" role="tab" type="button" id="fo-tab-microsoft" aria-controls="fo-panel-microsoft" aria-selected="true" tabindex="0">
       <span class="fastapi-opinions__mark"><img src="/img/logos/microsoft.svg" alt="Microsoft" loading="lazy"></span>
     </button>
@@ -105,7 +105,7 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
   </div>
 
   <div class="fastapi-opinions__panel" id="fo-panel-microsoft" role="tabpanel" aria-labelledby="fo-tab-microsoft" tabindex="0">
-    <blockquote class="fastapi-opinions__quote">"मैं इन दिनों <strong>FastAPI</strong> का बहुत उपयोग कर रहा/रही हूँ। वास्तव में मैं अपनी team की <strong>Microsoft में ML सेवाओं</strong> के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य <strong>Windows</strong> product और कुछ <strong>Office</strong> products में इंटीग्रेट किया जा रहा है।"</blockquote>
+    <blockquote class="fastapi-opinions__quote">"मैं इन दिनों <strong>FastAPI</strong> का बहुत उपयोग कर रहा/रही हूँ। वास्तव में मैं अपनी team की <strong>Microsoft में सभी ML सेवाओं</strong> के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य <strong>Windows</strong> product और कुछ <strong>Office</strong> products में इंटीग्रेट किया जा रहा है।"</blockquote>
     <div class="fastapi-opinions__attr">— कबीर खान, <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26">(संदर्भ)</a></div>
   </div>
   <div class="fastapi-opinions__panel" id="fo-panel-uber" role="tabpanel" aria-labelledby="fo-tab-uber" tabindex="0" hidden>
@@ -125,7 +125,7 @@ FastAPI एक आधुनिक, तेज़ (उच्च-प्रदर्
 
 <div class="only-github" markdown="1">
 
-"_[...] मैं इन दिनों **FastAPI** का बहुत उपयोग कर रहा/रही हूँ। [...] वास्तव में मैं अपनी team की **Microsoft में ML सेवाओं** के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य **Windows** product और कुछ **Office** products में इंटीग्रेट किया जा रहा है._"
+"_[...] मैं इन दिनों **FastAPI** का बहुत उपयोग कर रहा/रही हूँ। [...] वास्तव में मैं अपनी team की **Microsoft में सभी ML सेवाओं** के लिए इसे उपयोग करने की योजना बना रहा/रही हूँ। इनमें से कुछ को मुख्य **Windows** product और कुछ **Office** products में इंटीग्रेट किया जा रहा है._"
 
 <div style="text-align: right; margin-right: 10%;">कबीर खान - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(संदर्भ)</small></a></div>
 
@@ -544,7 +544,7 @@ Pydantic द्वारा उपयोग किया गया:
 
 Starlette द्वारा उपयोग किया गया:
 
-* [`httpx`](https://www.python-httpx.org) - यदि आप `TestClient` का उपयोग करना चाहते हैं तो required।
+* [`httpx2`](https://pydantic.dev/docs/httpx2/) (या `httpx`) - `TestClient` द्वारा उपयोग किया जाता है।
 * [`jinja2`](https://jinja.palletsprojects.com) - यदि आप default टेम्पलेट कॉन्फ़िगरेशन का उपयोग करना चाहते हैं तो required।
 * [`python-multipart`](https://github.com/Kludex/python-multipart) - यदि आप form <dfn title="HTTP request से आने वाली string को Python data में convert करना">"parsing"</dfn> का समर्थन करना चाहते हैं, `request.form()` के साथ, तो required।
 

docs/hi/docs/tutorial/bigger-applications.md

@@ -155,8 +155,7 @@ from app.routers import items
 
 ```Python hl_lines="1"
 @router.get("/{item_id}")
-async def read_item(item_id: str):
-    ...
+async def read_item(item_id: str): ...
 ```
 
 ...prefix में अंत में `/` शामिल नहीं होना चाहिए।

docs/hi/docs/tutorial/body-fields.md

@@ -43,13 +43,13 @@
 
 ## अतिरिक्त जानकारी जोड़ें { #add-extra-information }
 
-आप `Field`, `Query`, `Body` आदि में अतिरिक्त जानकारी घोषित कर सकते हैं। और यह जनरेट किए गए JSON Schema में शामिल होगी।
+आप `Field`, `Query`, `Body` आदि में `json_schema_extra` के साथ अतिरिक्त जानकारी घोषित कर सकते हैं। और यह जनरेट किए गए JSON Schema में शामिल होगी।
 
 आप docs में आगे examples घोषित करना सीखते समय अतिरिक्त जानकारी जोड़ने के बारे में और जानेंगे।
 
 /// warning | चेतावनी
 
-`Field` को दिए गए अतिरिक्त keys आपके application के परिणामी OpenAPI schema में भी मौजूद होंगे।
+`json_schema_extra` में दिए गए अतिरिक्त keys आपके application के परिणामी OpenAPI schema में भी मौजूद होंगे।
 क्योंकि ये keys जरूरी नहीं कि OpenAPI specification का हिस्सा हों, इसलिए कुछ OpenAPI tools, उदाहरण के लिए [OpenAPI validator](https://validator.swagger.io/), आपके जनरेट किए गए schema के साथ काम नहीं कर सकते।
 
 ///
@@ -58,4 +58,4 @@
 
 आप model attributes के लिए अतिरिक्त validations और metadata घोषित करने के लिए Pydantic के `Field` का उपयोग कर सकते हैं।
 
-आप अतिरिक्त JSON Schema metadata पास करने के लिए extra keyword arguments का भी उपयोग कर सकते हैं।
+आप अतिरिक्त JSON Schema metadata पास करने के लिए `json_schema_extra` का भी उपयोग कर सकते हैं।

docs/hi/docs/tutorial/cookie-param-models.md

@@ -71,6 +71,22 @@
 }
 ```
 
+## Parameter Models को संयोजित करें { #combine-parameter-models }
+
+आप कई cookie parameter models को अलग-अलग cookie parameters और dependencies के साथ संयोजित कर सकते हैं। हर model को स्वतंत्र रूप से extract और validate किया जाता है, जैसा कि [query parameter models](query-param-models.md#combine-parameter-models) के लिए समझाया गया है।
+
+हर model का `extra` configuration सभी cookie parameters पर लागू होता है, जिनमें अन्य models या dependencies में declare किए गए parameters भी शामिल हैं। `extra="forbid"` के साथ, उस model के बाहर की किसी भी cookie को reject कर दिया जाता है। `extra="allow"` के साथ, उन cookies को model extras के रूप में शामिल किया जाता है।
+
+## वैकल्पिक Cookie Parameter Models { #optional-cookie-parameter-models }
+
+समूह को वैकल्पिक बनाने के लिए cookie parameter model को `| None` और `None` की default value के साथ declare करें।
+
+{* ../../docs_src/cookie_param_models/tutorial003_an_py310.py hl[15] *}
+
+अगर न तो `theme` और न ही `locale` भेजा जाता है, तो `preferences` की value `None` होती है। अगर इनमें से कोई भी भेजा जाता है, तो FastAPI model को validate करता है और दोनों fields को required मानता है।
+
+defaults, extra fields और OpenAPI के लिए वही नियम लागू होते हैं जो [वैकल्पिक query parameter models](query-param-models.md#optional-query-parameter-models) के लिए लागू होते हैं।
+
 ## सारांश { #summary }
 
 आप **FastAPI** में <dfn title="जाने से पहले एक आखिरी cookie लीजिए। 🍪">**cookies**</dfn> declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/dependencies/sub-dependencies.md

@@ -58,20 +58,22 @@ query_extractor --> query_or_cookie_extractor --> read_query
 
 अगर आपकी किसी dependency को उसी *path operation* के लिए कई बार declare किया गया है, उदाहरण के लिए, कई dependencies की कोई common sub-dependency है, तो **FastAPI** जानता होगा कि उस sub-dependency को प्रति request केवल एक बार call करना है।
 
-और यह return किए गए value को एक <dfn title="computed/generated values को store करने और उन्हें फिर से compute करने के बजाय reuse करने के लिए एक utility/system">"cache"</dfn> में save करेगा और उसे उन सभी "dependants" को pass करेगा जिन्हें उस specific request में इसकी ज़रूरत है, बजाय उसी request के लिए dependency को कई बार call करने के।
+और यह return किए गए value को एक <dfn title="गणना की गई/बनाई गई values को संग्रहीत करने और उनकी दोबारा गणना करने के बजाय उनका पुनः उपयोग करने के लिए एक उपयोगिता/प्रणाली।">"कैश"</dfn> में 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)]):
+```Python hl_lines="2"
+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
+//// tab | Python 3.10+ बिना Annotated के
 
 /// tip | सुझाव
 

docs/hi/docs/tutorial/extra-models.md

@@ -54,10 +54,10 @@ print(user_dict)
 
 ```Python
 {
-    'username': 'john',
-    'password': 'secret',
-    'email': 'john.doe@example.com',
-    'full_name': None,
+    "username": "john",
+    "password": "secret",
+    "email": "john.doe@example.com",
+    "full_name": None,
 }
 ```
 
@@ -86,10 +86,10 @@ UserInDB(
 
 ```Python
 UserInDB(
-    username = user_dict["username"],
-    password = user_dict["password"],
-    email = user_dict["email"],
-    full_name = user_dict["full_name"],
+    username=user_dict["username"],
+    password=user_dict["password"],
+    email=user_dict["email"],
+    full_name=user_dict["full_name"],
 )
 ```
 
@@ -124,11 +124,11 @@ 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,
+    username=user_dict["username"],
+    password=user_dict["password"],
+    email=user_dict["email"],
+    full_name=user_dict["full_name"],
+    hashed_password=hashed_password,
 )
 ```
 

docs/hi/docs/tutorial/header-param-models.md

@@ -67,6 +67,26 @@
 
 ///
 
+## Parameter Models को संयोजित करें { #combine-parameter-models }
+
+आप कई header parameter models को अलग-अलग header parameters और dependencies के साथ संयोजित कर सकते हैं। हर model को स्वतंत्र रूप से extract और validate किया जाता है, जैसा कि [query parameter models](query-param-models.md#combine-parameter-models) के लिए समझाया गया है।
+
+हर model की `extra` configuration सभी header parameters पर लागू होती है, जिनमें दूसरे models या dependencies में declare किए गए parameters भी शामिल हैं। `extra="forbid"` के साथ, उस model के बाहर का कोई भी header अस्वीकार कर दिया जाता है। `extra="allow"` के साथ, वे headers model extras के रूप में शामिल किए जाते हैं।
+
+हर model request पढ़ते समय और OpenAPI generate करते समय अपनी खुद की `Header(convert_underscores=...)` setting का उपयोग करता है। स्पष्ट रूप से दिए गए field aliases बिना बदलाव के header names बने रहते हैं।
+
+## वैकल्पिक Header Parameter Models { #optional-header-parameter-models }
+
+पूरे समूह को वैकल्पिक बनाने के लिए header parameter model को `| None` और `None` की default value के साथ declare करें।
+
+{* ../../docs_src/header_param_models/tutorial004_an_py310.py hl[15] *}
+
+अगर न तो `x-client-name` और न ही `x-client-version` भेजा जाता है, तो `client` की value `None` होती है। अगर इनमें से कोई भी भेजा जाता है, तो FastAPI model को validate करता है और दोनों fields को required मानता है।
+
+Defaults, extra fields और OpenAPI के लिए वही नियम लागू होते हैं जो [वैकल्पिक query parameter models](query-param-models.md#optional-query-parameter-models) के लिए हैं।
+
+`Host` जैसे headers भी model की `extra` configuration का पालन करते हैं। `extra="allow"` के साथ, उनकी वजह से model मौजूद माना जाता है, भले ही declare किए गए दोनों fields में से कोई भी न दिया गया हो।
+
 ## सारांश { #summary }
 
 आप **FastAPI** में **headers** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/path-params-numeric-validations.md

@@ -28,7 +28,7 @@ FastAPI ने version 0.95.0 में `Annotated` के लिए support ज
 
 /// note | नोट
 
-एक path parameter हमेशा required होता है क्योंकि उसे path का हिस्सा होना होता है। भले ही आपने इसे `None` के साथ घोषित किया हो या कोई default value सेट की हो, इससे कुछ भी प्रभावित नहीं होगा, यह फिर भी हमेशा required रहेगा।
+एक path parameter हमेशा required होता है क्योंकि उसे URL path का हिस्सा होना होता है। उसके type में `None` जोड़ने से वह वैकल्पिक नहीं हो जाता। `Path` के साथ घोषित parameter की कोई default value नहीं हो सकती।
 
 ///
 
@@ -81,7 +81,7 @@ FastAPI ने version 0.95.0 में `Annotated` के लिए support ज
 
 function के पहले parameter के रूप में `*` पास करें।
 
-Python उस `*` के साथ कुछ नहीं करेगा, लेकिन उसे पता चल जाएगा कि उसके बाद आने वाले सभी parameters को keyword arguments (key-value pairs) के रूप में call किया जाना चाहिए, जिन्हें <abbr title="From: K-ey W-ord Arg-uments - से: K-ey W-ord Arg-uments"><code>kwargs</code></abbr> भी कहा जाता है। भले ही उनके पास default value न हो।
+Python उस `*` के साथ कुछ नहीं करेगा, लेकिन उसे पता चल जाएगा कि उसके बाद आने वाले सभी parameters को keyword arguments (key-value pairs) के रूप में call किया जाना चाहिए, जिन्हें <abbr title="से: K-ey W-ord Arg-uments - कीवर्ड आर्ग्युमेंट्स"><code>kwargs</code></abbr> भी कहा जाता है। भले ही उनके पास default value न हो।
 
 {* ../../docs_src/path_params_numeric_validations/tutorial003_py310.py hl[7] *}
 

docs/hi/docs/tutorial/query-param-models.md

@@ -57,6 +57,42 @@ https://example.com/items/?limit=10&tool=plumbus
 }
 ```
 
+## Parameter Models को साथ में उपयोग करें { #combine-parameter-models }
+
+आप कई query parameter models declare कर सकते हैं, और उन्हें अलग-अलग query parameters या dependencies के साथ उपयोग कर सकते हैं।
+
+{* ../../docs_src/query_param_models/tutorial003_an_py310.py hl[9:15,20:22] *}
+
+request parameters एक ही स्तर पर रहते हैं।
+
+```http
+https://example.com/items/?limit=5&offset=10&tags=red&tags=blue&search=shirt
+```
+
+query string में `pagination` या `filters` keys नहीं होती हैं। हर model अपने default values, field validators और model validators के साथ query parameters को स्वतंत्र रूप से validate करता है। यही बात तब भी लागू होती है जब models या अलग-अलग parameters dependencies में declare किए जाते हैं।
+
+अगर models किसी parameter नाम या alias को साझा करते हैं, तो हर model उस request parameter को स्वतंत्र रूप से validate करता है। स्वतंत्र values के लिए अलग-अलग नाम या aliases का उपयोग करें। OpenAPI साझा parameter को एक बार सूचीबद्ध करता है, जैसे वह dependencies के साथ साझा किए गए parameters के लिए करता है, इसलिए साझा declarations में एक ही type और constraints का वर्णन होना चाहिए।
+
+हर model की `extra` configuration सभी query parameters पर लागू होती है, जिनमें अन्य models या dependencies में declare किए गए parameters भी शामिल हैं। `extra="forbid"` के साथ, उस model के बाहर का कोई भी parameter अस्वीकार कर दिया जाता है। `extra="allow"` के साथ, वे parameters model extras के रूप में शामिल किए जाते हैं।
+
+यह `Header` और `Cookie` models के लिए भी काम करता है।
+
+## वैकल्पिक Query Parameter Models { #optional-query-parameter-models }
+
+समूह को वैकल्पिक बनाने के लिए query parameter model को `| None` और `None` की default value के साथ declare करें।
+
+{* ../../docs_src/query_param_models/tutorial004_an_py310.py hl[18] *}
+
+अगर न तो `start` और न ही `end` भेजा जाता है, तो `date_range` की value `None` होती है। अगर इनमें से कोई भी भेजा जाता है, तो FastAPI model को validate करता है और दोनों fields को required मानता है।
+
+default के बिना `| None` का उपयोग करने पर parameter फिर भी required रहता है।
+
+अतिरिक्त parameters model की `extra` configuration का पालन करते हैं। अनदेखा किए गए अतिरिक्त parameters से model को मौजूद नहीं माना जाता।
+
+OpenAPI समूह के fields को अलग-अलग सूचीबद्ध करता है और उन्हें वैकल्पिक के रूप में चिह्नित करता है।
+
+आप वैकल्पिक [header parameter models](header-param-models.md#optional-header-parameter-models) और [cookie parameter models](cookie-param-models.md#optional-cookie-parameter-models) भी declare कर सकते हैं।
+
 ## सारांश { #summary }
 
 आप **FastAPI** में **query parameters** declare करने के लिए **Pydantic models** का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/query-params-str-validations.md

@@ -220,14 +220,22 @@ q: Annotated[str | None, Query(min_length=3)] = None
 
 {* ../../docs_src/query_params_str_validations/tutorial006_an_py310.py hl[9] *}
 
-### Required, `None` हो सकता है { #required-can-be-none }
+### Required parameters और `None` { #required-parameters-and-none }
 
-आप declare कर सकते हैं कि parameter `None` accept कर सकता है, लेकिन फिर भी यह required है। यह clients को value भेजने के लिए मजबूर करेगा, भले ही value `None` हो।
-
-ऐसा करने के लिए, आप declare कर सकते हैं कि `None` एक valid type है लेकिन बस default value declare न करें:
+type `str | None` Python value के रूप में `None` की अनुमति देता है, लेकिन यह query parameter को optional नहीं बनाता। default value के बिना, parameter अभी भी required है:
 
 {* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
 
+query parameter की values strings के रूप में आती हैं और उनमें `None` के लिए कोई built-in representation नहीं होता। `?q=None` या `?q=null` भेजने पर क्रमशः strings `"None"` और `"null"` भेजी जाती हैं। `?q=` भेजने पर एक खाली string भेजी जाती है, जो इस example में `min_length=3` validation में fail होती है।
+
+clients को `q` न भेजने और उसकी value के रूप में `None` use करने की अनुमति देने के लिए, उसकी default value `None` रखें:
+
+```Python
+q: Annotated[str | None, Query(min_length=3)] = None
+```
+
+query parameters के विपरीत, JSON request bodies में स्पष्ट रूप से `null` value हो सकती है।
+
 ## Query parameter list / multiple values { #query-parameter-list-multiple-values }
 
 जब आप query parameter को स्पष्ट रूप से `Query` के साथ define करते हैं तो आप इसे values की list receive करने के लिए भी declare कर सकते हैं, या दूसरे शब्दों में, multiple values receive करने के लिए।

docs/hi/docs/tutorial/query-params.md

@@ -107,7 +107,13 @@ 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` के रूप में।
+या कोई भी दूसरी case variation (uppercase, पहले अक्षर को uppercase, आदि), आपका function parameter `short` को `True` के `bool` value के साथ देखेगा।
+
+`0`, `false`, `off`, और `no` जैसी values (case variations सहित) `False` में convert की जाती हैं।
+
+अगर `short` नहीं दिया जाता है, तो **FastAPI** उसकी default value का उपयोग करता है, जो इस उदाहरण में `False` है।
+
+खाली value (`?short=`) या कोई अपरिचित value (उदाहरण के लिए, `?short=maybe`) से `422` validation error आती है।
 
 
 ## कई path और query parameters { #multiple-path-and-query-parameters }

docs/hi/docs/tutorial/request-form-models.md

@@ -28,6 +28,8 @@ $ uv add python-multipart
 
 **FastAPI** request में मौजूद **form data** से **हर field** के लिए data **extract** करेगा और आपको वह Pydantic model देगा जिसे आपने define किया है।
 
+[HTML checkboxes](request-forms.md#boolean-form-fields) के लिए, boolean fields को `False` की default value के साथ declare करें।
+
 ## Docs जाँचें { #check-the-docs }
 
 आप इसे `/docs` पर docs UI में verify कर सकते हैं:
@@ -73,6 +75,58 @@ $ uv add python-multipart
 }
 ```
 
+## Form Models को संयोजित करें { #combine-form-models }
+
+आप कई form models को अलग-अलग `Form` parameters के साथ संयोजित कर सकते हैं।
+
+{* ../../docs_src/request_form_models/tutorial003_an_py310.py hl[9:14,19:21] *}
+
+client `name`, `tags`, और `token` को form fields के रूप में भेजता है। हर model form fields को स्वतंत्र रूप से validate करता है।
+
+हर model की `extra` configuration सभी form fields पर लागू होती है, जिनमें अन्य parameters या dependencies में declare किए गए fields और files भी शामिल हैं। `extra="forbid"` के साथ, उस model से बाहर का कोई भी field अस्वीकार कर दिया जाता है। `extra="allow"` के साथ, वे fields model extras के रूप में शामिल किए जाते हैं।
+
+अगर कई declarations एक ही form field नाम का उपयोग करते हैं, तो हर declaration उस field की value को validate करता है। साझा fields के लिए संगत types और constraints का उपयोग करें ताकि OpenAPI schema उनका सुसंगत रूप से वर्णन कर सके।
+
+## वैकल्पिक Form Models { #optional-form-models }
+
+समूह को वैकल्पिक बनाने के लिए, form model को `| None` और `None` की default value के साथ declare करें।
+
+{* ../../docs_src/request_form_models/tutorial005_an_py310.py hl[17] *}
+
+अगर न तो `name` और न ही `age` भेजा जाता है, तो `profile` की value `None` होती है। अगर इनमें से कोई भी भेजा जाता है, तो FastAPI model को validate करता है और दोनों fields को required मानता है। खाली value सबमिट करना भी field प्रदान करना माना जाता है।
+
+default value के बिना `| None` का उपयोग करने पर भी parameter required रहता है।
+
+Extra fields model की `extra` configuration का पालन करते हैं। अनदेखा किए गए extras से model को मौजूद नहीं माना जाता।
+
+केवल unchecked checkboxes वाला वैकल्पिक model छोड़ दिया जाता है। इसे स्पष्ट रूप से प्रदान करने के लिए `enabled=false` जैसी value भेजें।
+
+## Form Models के वैकल्पिक Unions { #optional-unions-of-form-models }
+
+आप models के वैकल्पिक union का भी उपयोग कर सकते हैं।
+
+{* ../../docs_src/request_form_models/tutorial006_an_py310.py hl[9:16,21] *}
+
+अगर कोई form fields नहीं भेजे जाते हैं, तो `contact` की value `None` होती है। `name` के साथ `kind=person`, या `company_name` के साथ `kind=company` भेजें। discriminator चुनता है कि किस model को validate करना है।
+
+## Form Models के Unions को संयोजित करें { #combine-unions-of-form-models }
+
+आप unions को अन्य form models, अलग-अलग `Form` parameters, और `File` parameters के साथ संयोजित कर सकते हैं। हर union को स्वतंत्र रूप से validate किया जाता है।
+
+{* ../../docs_src/request_form_models/tutorial007_an_py310.py hl[31:35] *}
+
+सभी fields एक ही form में भेजें। उदाहरण के लिए, `contact_type=person`, `name=Rick`, `notification_type=email`, `email=rick@example.com`, और `token=secret` भेजें।
+
+`notification` की value `None` रखने के लिए notification fields छोड़ दें।
+
+## Form Models और Files { #form-models-and-files }
+
+आप form model को [file parameters](request-files.md) के साथ भी संयोजित कर सकते हैं।
+
+{* ../../docs_src/request_form_models/tutorial004_an_py310.py hl[14] *}
+
+यहाँ client `multipart/form-data` का उपयोग करके `name` field और `avatar` file भेजता है।
+
 ## सारांश { #summary }
 
 आप FastAPI में form fields declare करने के लिए Pydantic models का उपयोग कर सकते हैं। 😎

docs/hi/docs/tutorial/request-forms.md

@@ -44,6 +44,14 @@ form bodies declare करने के लिए, आपको स्पष्
 
 ///
 
+## Boolean Form Fields { #boolean-form-fields }
+
+HTML forms submit करते समय browsers unchecked checkboxes को छोड़ देते हैं। unchecked होने पर `False` प्राप्त करने के लिए `False` default वाला boolean form parameter declare करें:
+
+{* ../../docs_src/request_forms/tutorial002_an_py310.py hl[9] *}
+
+एक checked checkbox अपनी value भेजता है, जो default रूप से `"on"` होती है। **FastAPI** `"on"` को `True` के रूप में स्वीकार करता है।
+
 ## "Form Fields" के बारे में { #about-form-fields }
 
 HTML forms (`<form></form>`) आमतौर पर data को server पर भेजने के लिए उस data के लिए एक "special" encoding का उपयोग करते हैं, यह JSON से अलग होता है।
@@ -56,6 +64,8 @@ forms से आने वाला data आमतौर पर "media type" `ap
 
 लेकिन जब form में files शामिल होती हैं, तो इसे `multipart/form-data` के रूप में encoded किया जाता है। files को handle करने के बारे में आप अगले chapter में पढ़ेंगे।
 
+OpenAPI में multipart form का वर्णन करने के लिए आप `Form(media_type="multipart/form-data")` का उपयोग कर सकते हैं। form parameters या models को मिलाते समय इसे एक parameter पर सेट करना पर्याप्त है।
+
 अगर आप इन encodings और form fields के बारे में अधिक पढ़ना चाहते हैं, तो [`POST` के लिए <abbr title="Mozilla Developer Network - मोज़िला डेवलपर नेटवर्क">MDN</abbr> web docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST) देखें।
 
 ///

docs/hi/docs/tutorial/response-model.md

@@ -266,6 +266,7 @@ FastAPI internally Pydantic के साथ कई चीज़ें करत
 
 लेकिन अगर आपके data में model के default values वाले fields के लिए values हैं, जैसे ID `bar` वाला item:
 
+<!-- fmt:off -->
 ```Python hl_lines="3  5"
 {
     "name": "Bar",
@@ -274,6 +275,7 @@ FastAPI internally Pydantic के साथ कई चीज़ें करत
     "tax": 20.2
 }
 ```
+<!-- fmt:on -->
 
 तो वे response में शामिल होंगे।
 
@@ -281,6 +283,7 @@ FastAPI internally Pydantic के साथ कई चीज़ें करत
 
 अगर data में default values जैसे ही values हैं, जैसे ID `baz` वाला item:
 
+<!-- fmt:off -->
 ```Python hl_lines="3  5-6"
 {
     "name": "Baz",
@@ -290,6 +293,7 @@ FastAPI internally Pydantic के साथ कई चीज़ें करत
     "tags": []
 }
 ```
+<!-- fmt:on -->
 
 FastAPI इतना smart है (दरअसल, Pydantic इतना smart है) कि यह समझ सके कि, भले ही `description`, `tax`, और `tags` के values defaults जैसे ही हैं, उन्हें explicitly set किया गया था (defaults से लिए जाने के बजाय)।
 

docs/hi/docs/tutorial/security/simple-oauth2.md

@@ -136,11 +136,11 @@ Error के लिए, हम exception `HTTPException` का उपयोग
 
 ```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"],
+    username=user_dict["username"],
+    email=user_dict["email"],
+    full_name=user_dict["full_name"],
+    disabled=user_dict["disabled"],
+    hashed_password=user_dict["hashed_password"],
 )
 ```