+lt
+* XWT
+* PSGI
+
+### abbr مکمل جملہ اور وضاحت دیتا ہے { #the-abbr-gives-a-full-phrase-and-an-explanation }
+
+* MDN
+* I/O.
+
+////
+
+//// tab | Info
+
+"abbr" عناصر کی "title" attributes کا مخصوص ہدایات کے مطابق ترجمہ کیا جاتا ہے۔
+
+تراجم اپنے "abbr" عناصر شامل کر سکتے ہیں جنہیں LLM نہیں ہٹانا چاہیے۔ مثلاً انگریزی الفاظ کی وضاحت کے لیے۔
+
+`scripts/translate.py` میں عمومی prompt کا سیکشن `### HTML abbr elements` دیکھیں۔
+
+////
+
+## HTML "dfn" عناصر { #html-dfn-elements }
+
+* cluster
+* Deep Learning
+
+## عنوانات { #headings }
+
+//// tab | Test
+
+### ایک webapp تیار کریں - ایک tutorial { #develop-a-webapp-a-tutorial }
+
+ہیلو۔
+
+### Type hints اور -annotations { #type-hints-and-annotations }
+
+دوبارہ ہیلو۔
+
+### Super- اور subclasses { #super-and-subclasses }
+
+دوبارہ ہیلو۔
+
+////
+
+//// tab | Info
+
+عنوانات کے لیے واحد سخت قاعدہ یہ ہے کہ LLM گھنگھریالے قوسین کے اندر hash حصے کو تبدیل نہ کرے، جو یقینی بناتا ہے کہ لنکس نہ ٹوٹیں۔
+
+`scripts/translate.py` میں عمومی prompt کا سیکشن `### Headings` دیکھیں۔
+
+کچھ زبان کے مخصوص ہدایات کے لیے، مثلاً `docs/de/llm-prompt.md` میں سیکشن `### Headings` دیکھیں۔
+
+////
+
+## Docs میں استعمال ہونے والی اصطلاحات { #terms-used-in-the-docs }
+
+//// tab | Test
+
+* you
+* your
+
+* e.g.
+* etc.
+
+* `foo` as an `int`
+* `bar` as a `str`
+* `baz` as a `list`
+
+* the Tutorial - User guide
+* the Advanced User Guide
+* the SQLModel docs
+* the API docs
+* the automatic docs
+
+* Data Science
+* Deep Learning
+* Machine Learning
+* Dependency Injection
+* HTTP Basic authentication
+* HTTP Digest
+* ISO format
+* the JSON Schema standard
+* the JSON schema
+* the schema definition
+* Password Flow
+* Mobile
+
+* deprecated
+* designed
+* invalid
+* on the fly
+* standard
+* default
+* case-sensitive
+* case-insensitive
+
+* to serve the application
+* to serve the page
+
+* the app
+* the application
+
+* the request
+* the response
+* the error response
+
+* the path operation
+* the path operation decorator
+* the path operation function
+
+* the body
+* the request body
+* the response body
+* the JSON body
+* the form body
+* the file body
+* the function body
+
+* the parameter
+* the body parameter
+* the path parameter
+* the query parameter
+* the cookie parameter
+* the header parameter
+* the form parameter
+* the function parameter
+
+* the event
+* the startup event
+* the startup of the server
+* the shutdown event
+* the lifespan event
+
+* the handler
+* the event handler
+* the exception handler
+* to handle
+
+* the model
+* the Pydantic model
+* the data model
+* the database model
+* the form model
+* the model object
+
+* the class
+* the base class
+* the parent class
+* the subclass
+* the child class
+* the sibling class
+* the class method
+
+* the header
+* the headers
+* the authorization header
+* the `Authorization` header
+* the forwarded header
+
+* the dependency injection system
+* the dependency
+* the dependable
+* the dependant
+
+* I/O bound
+* CPU bound
+* concurrency
+* parallelism
+* multiprocessing
+
+* the env var
+* the environment variable
+* the `PATH`
+* the `PATH` variable
+
+* the authentication
+* the authentication provider
+* the authorization
+* the authorization form
+* the authorization provider
+* the user authenticates
+* the system authenticates the user
+
+* the CLI
+* the command line interface
+
+* the server
+* the client
+
+* the cloud provider
+* the cloud service
+
+* the development
+* the development stages
+
+* the dict
+* the dictionary
+* the enumeration
+* the enum
+* the enum member
+
+* the encoder
+* the decoder
+* to encode
+* to decode
+
+* the exception
+* to raise
+
+* the expression
+* the statement
+
+* the frontend
+* the backend
+
+* the GitHub discussion
+* the GitHub issue
+
+* the performance
+* the performance optimization
+
+* the return type
+* the return value
+
+* the security
+* the security scheme
+
+* the task
+* the background task
+* the task function
+
+* the template
+* the template engine
+
+* the type annotation
+* the type hint
+
+* the server worker
+* the Uvicorn worker
+* the Gunicorn Worker
+* the worker process
+* the worker class
+* the workload
+
+* the deployment
+* to deploy
+
+* the SDK
+* the software development kit
+
+* the `APIRouter`
+* the `requirements.txt`
+* the Bearer Token
+* the breaking change
+* the bug
+* the button
+* the callable
+* the code
+* the commit
+* the context manager
+* the coroutine
+* the database session
+* the disk
+* the domain
+* the engine
+* the fake X
+* the HTTP GET method
+* the item
+* the library
+* the lifespan
+* the lock
+* the middleware
+* the mobile application
+* the module
+* the mounting
+* the network
+* the origin
+* the override
+* the payload
+* the processor
+* the property
+* the proxy
+* the pull request
+* the query
+* the RAM
+* the remote machine
+* the status code
+* the string
+* the tag
+* the web framework
+* the wildcard
+* to return
+* to validate
+
+////
+
+//// tab | Info
+
+یہ docs میں نظر آنے والی (زیادہ تر) تکنیکی اصطلاحات کی ایک نامکمل اور غیر حتمی فہرست ہے۔ یہ prompt ڈیزائنر کے لیے مفید ہو سکتی ہے تاکہ معلوم ہو کہ کن اصطلاحات کے لیے LLM کو مدد کی ضرورت ہے۔ مثلاً جب یہ اچھے ترجمے کو بار بار کسی کمتر ترجمے میں واپس لے آئے۔ یا جب اسے آپ کی زبان میں کسی اصطلاح کو conjugate/declinate کرنے میں مسائل ہوں۔
+
+مثال کے طور پر `docs/de/llm-prompt.md` میں سیکشن `### List of English terms and their preferred German translations` دیکھیں۔
+
+////
diff --git a/docs/ur/docs/about/index.md b/docs/ur/docs/about/index.md
new file mode 100644
index 000000000..3dcf347a7
--- /dev/null
+++ b/docs/ur/docs/about/index.md
@@ -0,0 +1,3 @@
+# کے بارے میں { #about }
+
+FastAPI کے بارے میں، اس کی ڈیزائن، الہام اور مزید۔ 🤓
diff --git a/docs/ur/docs/advanced/additional-responses.md b/docs/ur/docs/advanced/additional-responses.md
new file mode 100644
index 000000000..0c1483502
--- /dev/null
+++ b/docs/ur/docs/advanced/additional-responses.md
@@ -0,0 +1,247 @@
+# OpenAPI میں اضافی Responses { #additional-responses-in-openapi }
+
+/// warning | انتباہ
+
+یہ ایک کافی ایڈوانسڈ موضوع ہے۔
+
+اگر آپ **FastAPI** کے ساتھ شروعات کر رہے ہیں تو آپ کو شاید اس کی ضرورت نہ ہو۔
+
+///
+
+آپ اضافی responses کا اعلان کر سکتے ہیں، اضافی status codes، media types، وضاحتوں وغیرہ کے ساتھ۔
+
+یہ اضافی responses OpenAPI schema میں شامل کیے جائیں گے، لہذا وہ API docs میں بھی ظاہر ہوں گے۔
+
+لیکن ان اضافی responses کے لیے آپ کو یقینی بنانا ہوگا کہ آپ براہ راست `Response` جیسے `JSONResponse` واپس کریں، اپنے status code اور مواد کے ساتھ۔
+
+## `model` کے ساتھ اضافی Response { #additional-response-with-model }
+
+آپ اپنے *path operation decorators* کو ایک parameter `responses` دے سکتے ہیں۔
+
+یہ ایک `dict` وصول کرتا ہے: کلیدیں ہر response کے لیے status codes ہیں (جیسے `200`)، اور قدریں دوسری `dict` ہیں جن میں ہر ایک کی معلومات ہوتی ہیں۔
+
+ان response `dict` میں سے ہر ایک میں `model` نامی ایک کلید ہو سکتی ہے، جس میں Pydantic model ہوتا ہے، بالکل `response_model` کی طرح۔
+
+**FastAPI** اس model کو لے گا، اس کا JSON Schema تیار کرے گا اور اسے OpenAPI میں صحیح جگہ شامل کرے گا۔
+
+مثال کے طور پر، status code `404` اور Pydantic model `Message` کے ساتھ ایک اور response کا اعلان کرنے کے لیے، آپ یہ لکھ سکتے ہیں:
+
+{* ../../docs_src/additional_responses/tutorial001_py310.py hl[18,22] *}
+
+/// note | نوٹ
+
+ذہن میں رکھیں کہ آپ کو `JSONResponse` براہ راست واپس کرنا ہوگا۔
+
+///
+
+/// info | معلومات
+
+`model` کلید OpenAPI کا حصہ نہیں ہے۔
+
+**FastAPI** وہاں سے Pydantic model لے گا، JSON Schema تیار کرے گا، اور اسے صحیح جگہ رکھے گا۔
+
+صحیح جگہ یہ ہے:
+
+* کلید `content` میں، جس کی قدر ایک اور JSON object (`dict`) ہے جس میں شامل ہے:
+ * media type والی ایک کلید، مثلاً `application/json`، جس کی قدر ایک اور JSON object ہے، جس میں شامل ہے:
+ * ایک کلید `schema`، جس کی قدر model سے JSON Schema ہے، یہ ہے صحیح جگہ۔
+ * **FastAPI** یہاں عالمی JSON Schemas کا حوالہ شامل کرتا ہے جو آپ کے OpenAPI میں کسی اور جگہ ہوتے ہیں بجائے اسے براہ راست شامل کرنے کے۔ اس طرح، دوسری ایپلیکیشنز اور clients ان JSON Schemas کو براہ راست استعمال کر سکتے ہیں، بہتر code generation ٹولز فراہم کر سکتے ہیں وغیرہ۔
+
+///
+
+اس *path operation* کے لیے OpenAPI میں تیار شدہ responses یہ ہوں گے:
+
+```JSON hl_lines="3-12"
+{
+ "responses": {
+ "404": {
+ "description": "Additional Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Message"
+ }
+ }
+ }
+ },
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Item"
+ }
+ }
+ }
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/HTTPValidationError"
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+Schemas کا حوالہ OpenAPI schema کے اندر کسی اور جگہ دیا گیا ہے:
+
+```JSON hl_lines="4-16"
+{
+ "components": {
+ "schemas": {
+ "Message": {
+ "title": "Message",
+ "required": [
+ "message"
+ ],
+ "type": "object",
+ "properties": {
+ "message": {
+ "title": "Message",
+ "type": "string"
+ }
+ }
+ },
+ "Item": {
+ "title": "Item",
+ "required": [
+ "id",
+ "value"
+ ],
+ "type": "object",
+ "properties": {
+ "id": {
+ "title": "Id",
+ "type": "string"
+ },
+ "value": {
+ "title": "Value",
+ "type": "string"
+ }
+ }
+ },
+ "ValidationError": {
+ "title": "ValidationError",
+ "required": [
+ "loc",
+ "msg",
+ "type"
+ ],
+ "type": "object",
+ "properties": {
+ "loc": {
+ "title": "Location",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "msg": {
+ "title": "Message",
+ "type": "string"
+ },
+ "type": {
+ "title": "Error Type",
+ "type": "string"
+ }
+ }
+ },
+ "HTTPValidationError": {
+ "title": "HTTPValidationError",
+ "type": "object",
+ "properties": {
+ "detail": {
+ "title": "Detail",
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/ValidationError"
+ }
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+## بنیادی response کے لیے اضافی media types { #additional-media-types-for-the-main-response }
+
+آپ اسی `responses` parameter کو استعمال کر کے بنیادی response میں مختلف media types شامل کر سکتے ہیں۔
+
+مثال کے طور پر، آپ `image/png` کی اضافی media type شامل کر سکتے ہیں، یہ اعلان کرتے ہوئے کہ آپ کا *path operation* ایک JSON object (media type `application/json` کے ساتھ) یا PNG تصویر واپس کر سکتا ہے:
+
+{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
+
+/// note | نوٹ
+
+دھیان دیں کہ آپ کو تصویر براہ راست `FileResponse` استعمال کر کے واپس کرنی ہوگی۔
+
+///
+
+/// info | معلومات
+
+جب تک آپ اپنے `responses` parameter میں واضح طور پر کوئی مختلف media type بیان نہیں کرتے، FastAPI فرض کرے گا کہ response کی media type بنیادی response class جیسی ہی ہے (پہلے سے طے شدہ `application/json`)۔
+
+لیکن اگر آپ نے `None` کو اس کی media type کے طور پر اپنی مرضی کی response class بیان کی ہے، تو FastAPI کسی بھی اضافی response کے لیے `application/json` استعمال کرے گا جس کے ساتھ ایک model منسلک ہے۔
+
+///
+
+## معلومات کو یکجا کرنا { #combining-information }
+
+آپ متعدد جگہوں سے response کی معلومات کو بھی یکجا کر سکتے ہیں، بشمول `response_model`، `status_code`، اور `responses` parameters۔
+
+آپ `response_model` کا اعلان کر سکتے ہیں، پہلے سے طے شدہ status code `200` (یا ضرورت کے مطابق کوئی اور) استعمال کرتے ہوئے، اور پھر اسی response کے لیے `responses` میں اضافی معلومات کا اعلان کر سکتے ہیں، براہ راست OpenAPI schema میں۔
+
+**FastAPI** `responses` سے اضافی معلومات رکھے گا، اور اسے آپ کے model سے JSON Schema کے ساتھ ملا دے گا۔
+
+مثال کے طور پر، آپ status code `404` والا response اعلان کر سکتے ہیں جو Pydantic model استعمال کرتا ہے اور اپنی مرضی کی `description` رکھتا ہے۔
+
+اور status code `200` والا response جو آپ کا `response_model` استعمال کرتا ہے، لیکن اپنی مرضی کی `example` شامل کرتا ہے:
+
+{* ../../docs_src/additional_responses/tutorial003_py310.py hl[20:31] *}
+
+یہ سب یکجا ہو کر آپ کے OpenAPI میں شامل ہو جائے گا، اور API docs میں دکھایا جائے گا:
+
+
+
+## پہلے سے طے شدہ اور اپنی مرضی کے responses کو ملانا { #combine-predefined-responses-and-custom-ones }
+
+ہو سکتا ہے آپ چاہیں کہ کچھ پہلے سے طے شدہ responses ہوں جو بہت سے *path operations* پر لاگو ہوں، لیکن آپ انہیں ہر *path operation* کے لیے درکار اپنی مرضی کے responses کے ساتھ ملانا چاہتے ہیں۔
+
+ان صورتوں میں، آپ Python کی `dict` کو `**dict_to_unpack` کے ساتھ "unpack" کرنے کی تکنیک استعمال کر سکتے ہیں:
+
+```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 جوڑے اور نیا key-value جوڑا شامل ہوگا:
+
+```Python
+{
+ "old key": "old value",
+ "second old key": "second old value",
+ "new key": "new value",
+}
+```
+
+آپ اس تکنیک کو اپنے *path operations* میں پہلے سے طے شدہ responses کو دوبارہ استعمال کرنے اور انہیں اضافی اپنی مرضی کے responses کے ساتھ ملانے کے لیے استعمال کر سکتے ہیں۔
+
+مثال کے طور پر:
+
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
+
+## OpenAPI responses کے بارے میں مزید معلومات { #more-information-about-openapi-responses }
+
+یہ دیکھنے کے لیے کہ آپ responses میں بالکل کیا شامل کر سکتے ہیں، آپ OpenAPI specification میں یہ حصے دیکھ سکتے ہیں:
+
+* [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/ur/docs/advanced/additional-status-codes.md b/docs/ur/docs/advanced/additional-status-codes.md
new file mode 100644
index 000000000..323488415
--- /dev/null
+++ b/docs/ur/docs/advanced/additional-status-codes.md
@@ -0,0 +1,41 @@
+# اضافی Status Codes { #additional-status-codes }
+
+پہلے سے طے شدہ طور پر، **FastAPI** responses کو `JSONResponse` استعمال کر کے واپس کرے گا، آپ کے *path operation* سے واپس آنے والے مواد کو اس `JSONResponse` میں ڈال کر۔
+
+یہ پہلے سے طے شدہ status code یا وہ استعمال کرے گا جو آپ نے اپنے *path operation* میں مقرر کیا ہے۔
+
+## اضافی status codes { #additional-status-codes_1 }
+
+اگر آپ بنیادی status code کے علاوہ اضافی status codes واپس کرنا چاہتے ہیں، تو آپ براہ راست `Response` واپس کر کے ایسا کر سکتے ہیں، جیسے `JSONResponse`، اور اضافی status code براہ راست مقرر کر سکتے ہیں۔
+
+مثال کے طور پر، فرض کریں کہ آپ ایک *path operation* چاہتے ہیں جو آئٹمز کو اپ ڈیٹ کرنے کی اجازت دے، اور کامیاب ہونے پر HTTP status code 200 "OK" واپس کرے۔
+
+لیکن آپ یہ بھی چاہتے ہیں کہ یہ نئے آئٹمز قبول کرے۔ اور جب آئٹمز پہلے سے موجود نہیں تھے، تو یہ انہیں بنائے اور HTTP status code 201 "Created" واپس کرے۔
+
+اس کے لیے، `JSONResponse` import کریں، اور اپنا مواد وہاں براہ راست واپس کریں، جو `status_code` آپ چاہتے ہیں وہ مقرر کرتے ہوئے:
+
+{* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
+
+/// warning | انتباہ
+
+جب آپ براہ راست `Response` واپس کرتے ہیں، جیسا کہ اوپر کی مثال میں، تو یہ براہ راست واپس کیا جائے گا۔
+
+اسے model وغیرہ کے ساتھ serialize نہیں کیا جائے گا۔
+
+یقینی بنائیں کہ اس میں وہ ڈیٹا ہے جو آپ چاہتے ہیں، اور قدریں درست JSON ہیں (اگر آپ `JSONResponse` استعمال کر رہے ہیں)۔
+
+///
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import JSONResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** وہی `starlette.responses` فراہم کرتا ہے جو `fastapi.responses` کے طور پر، بس آپ یعنی developer کی سہولت کے لیے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔ `status` کے ساتھ بھی یہی ہے۔
+
+///
+
+## OpenAPI اور API docs { #openapi-and-api-docs }
+
+اگر آپ اضافی status codes اور responses براہ راست واپس کرتے ہیں، تو وہ OpenAPI schema (API docs) میں شامل نہیں ہوں گے، کیونکہ FastAPI کے پاس پہلے سے یہ جاننے کا کوئی طریقہ نہیں ہے کہ آپ کیا واپس کرنے والے ہیں۔
+
+لیکن آپ اپنے کوڈ میں اسے دستاویزی شکل دے سکتے ہیں، استعمال کرتے ہوئے: [OpenAPI میں اضافی Responses](additional-responses.md)۔
diff --git a/docs/ur/docs/advanced/advanced-dependencies.md b/docs/ur/docs/advanced/advanced-dependencies.md
new file mode 100644
index 000000000..347f68461
--- /dev/null
+++ b/docs/ur/docs/advanced/advanced-dependencies.md
@@ -0,0 +1,163 @@
+# ایڈوانسڈ Dependencies { #advanced-dependencies }
+
+## پیرامیٹرائزڈ dependencies { #parameterized-dependencies }
+
+ہم نے اب تک جتنی بھی dependencies دیکھی ہیں وہ ایک مقررہ function یا class ہیں۔
+
+لیکن ایسے مواقع ہو سکتے ہیں جہاں آپ dependency پر parameters سیٹ کرنا چاہیں، بغیر بہت سے مختلف functions یا classes بنائے۔
+
+آئیے تصور کریں کہ ہم ایک ایسی dependency چاہتے ہیں جو چیک کرے کہ query parameter `q` میں کوئی مقررہ مواد موجود ہے یا نہیں۔
+
+لیکن ہم اس مقررہ مواد کو پیرامیٹرائز کرنا چاہتے ہیں۔
+
+## ایک "callable" instance { #a-callable-instance }
+
+Python میں کسی class کے instance کو "callable" بنانے کا ایک طریقہ ہے۔
+
+خود class نہیں (جو پہلے سے ہی callable ہے)، بلکہ اس class کا ایک instance۔
+
+اس کے لیے ہم `__call__` method بیان کرتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[12] *}
+
+اس صورت میں، یہ `__call__` وہ ہے جسے **FastAPI** اضافی parameters اور sub-dependencies چیک کرنے کے لیے استعمال کرے گا، اور بعد میں آپ کے *path operation function* میں parameter کو قدر دینے کے لیے یہی call کیا جائے گا۔
+
+## Instance کو پیرامیٹرائز کریں { #parameterize-the-instance }
+
+اب ہم `__init__` استعمال کر کے instance کے parameters بیان کر سکتے ہیں جنہیں ہم dependency کو "پیرامیٹرائز" کرنے کے لیے استعمال کر سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[9] *}
+
+اس صورت میں، **FastAPI** کبھی `__init__` کو چھوئے گا نہ اس کی فکر کرے گا، ہم اسے براہ راست اپنے کوڈ میں استعمال کریں گے۔
+
+## ایک instance بنائیں { #create-an-instance }
+
+ہم اس class کا ایک instance اس طرح بنا سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[18] *}
+
+اور اس طرح ہم اپنی dependency کو "پیرامیٹرائز" کر سکتے ہیں، جس میں اب `"bar"` موجود ہے، بطور attribute `checker.fixed_content`۔
+
+## Instance کو dependency کے طور پر استعمال کریں { #use-the-instance-as-a-dependency }
+
+پھر ہم اس `checker` کو `Depends(checker)` میں استعمال کر سکتے ہیں، `Depends(FixedContentQueryChecker)` کی بجائے، کیونکہ dependency خود instance ہے، `checker`، نہ کہ class۔
+
+اور dependency حل کرتے وقت، **FastAPI** اس `checker` کو اس طرح call کرے گا:
+
+```Python
+checker(q="somequery")
+```
+
+...اور جو بھی یہ واپس کرے اسے ہمارے *path operation function* میں dependency کی قدر کے طور پر parameter `fixed_content_included` میں دے گا:
+
+{* ../../docs_src/dependencies/tutorial011_an_py310.py hl[22] *}
+
+/// tip | مشورہ
+
+یہ سب کچھ پیچیدہ لگ سکتا ہے۔ اور ابھی شاید یہ واضح نہ ہو کہ یہ کتنا مفید ہے۔
+
+یہ مثالیں جان بوجھ کر سادہ ہیں، لیکن دکھاتی ہیں کہ یہ سب کیسے کام کرتا ہے۔
+
+Security کے ابواب میں، ایسے utility functions ہیں جو بالکل اسی طرح بنائے گئے ہیں۔
+
+اگر آپ نے یہ سب سمجھ لیا، تو آپ پہلے سے جانتے ہیں کہ security کے لیے وہ utility tools اندرونی طور پر کیسے کام کرتے ہیں۔
+
+///
+
+## `yield`، `HTTPException`، `except` اور Background Tasks کے ساتھ Dependencies { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+/// warning | انتباہ
+
+آپ کو شاید ان تکنیکی تفصیلات کی ضرورت نہیں ہے۔
+
+یہ تفصیلات بنیادی طور پر اس وقت مفید ہیں جب آپ کی FastAPI ایپلیکیشن 0.121.0 سے پرانی ہو اور آپ کو `yield` والی dependencies کے ساتھ مسائل درپیش ہوں۔
+
+///
+
+`yield` والی Dependencies وقت کے ساتھ مختلف استعمال کے مواقع کے لیے اور کچھ مسائل حل کرنے کے لیے بدلتی رہی ہیں، یہاں تبدیلیوں کا خلاصہ ہے۔
+
+### `yield` اور `scope` والی Dependencies { #dependencies-with-yield-and-scope }
+
+ورژن 0.121.0 میں، FastAPI نے `yield` والی dependencies کے لیے `Depends(scope="function")` کی سہولت شامل کی۔
+
+`Depends(scope="function")` استعمال کرنے سے، `yield` کے بعد والا exit کوڈ *path operation function* ختم ہونے کے فوراً بعد چلتا ہے، response کلائنٹ کو واپس بھیجنے سے پہلے۔
+
+اور `Depends(scope="request")` (جو کہ default ہے) استعمال کرنے سے، `yield` کے بعد والا exit کوڈ response بھیجنے کے بعد چلتا ہے۔
+
+آپ اس کے بارے میں مزید [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 استعمال کرتے، تو exit کوڈ *path operation function* کے واپس آنے کے بعد لیکن response بھیجنے سے پہلے چلتا تھا۔
+
+اس کا مقصد وسائل کو ضرورت سے زیادہ دیر تک نہ رکھنا تھا، response کے نیٹ ورک پر سفر کرنے کا انتظار کرتے ہوئے۔
+
+اس تبدیلی کا یہ بھی مطلب تھا کہ اگر آپ `StreamingResponse` واپس کرتے، تو `yield` والی dependency کا exit کوڈ پہلے ہی چل چکا ہوتا۔
+
+مثال کے طور پر، اگر آپ کے پاس `yield` والی dependency میں database session ہو، تو `StreamingResponse` ڈیٹا stream کرتے وقت اس session کو استعمال نہیں کر سکتا کیونکہ `yield` کے بعد exit کوڈ میں session پہلے ہی بند ہو چکا ہوتا۔
+
+یہ رویہ 0.118.0 میں واپس بدل دیا گیا، تاکہ `yield` کے بعد والا exit کوڈ response بھیجنے کے بعد چلے۔
+
+/// info | معلومات
+
+جیسا کہ آپ نیچے دیکھیں گے، یہ ورژن 0.106.0 سے پہلے کے رویے سے بہت ملتا جلتا ہے، لیکن کئی بہتریوں اور خاص صورتوں میں bug fixes کے ساتھ۔
+
+///
+
+#### ابتدائی Exit کوڈ کے ساتھ استعمال کے مواقع { #use-cases-with-early-exit-code }
+
+کچھ مخصوص شرائط کے ساتھ استعمال کے مواقع ہیں جو `yield` والی dependencies کے exit کوڈ کو response بھیجنے سے پہلے چلانے کے پرانے رویے سے فائدہ اٹھا سکتے ہیں۔
+
+مثال کے طور پر، تصور کریں کہ آپ کے پاس ایسا کوڈ ہے جو `yield` والی dependency میں database session صرف صارف کی تصدیق کے لیے استعمال کرتا ہے، لیکن database session کبھی *path operation function* میں دوبارہ استعمال نہیں ہوتا، صرف dependency میں، **اور** response بھیجنے میں بہت وقت لگتا ہے، جیسے `StreamingResponse` جو آہستہ آہستہ ڈیٹا بھیجتا ہے، لیکن کسی وجہ سے database استعمال نہیں کرتا۔
+
+اس صورت میں، database session response مکمل ہونے تک رکھا جائے گا، لیکن اگر آپ اسے استعمال نہیں کرتے، تو اسے رکھنا ضروری نہیں ہوگا۔
+
+یہ کچھ اس طرح نظر آ سکتا ہے:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py *}
+
+Exit کوڈ، `Session` کی خودکار بندش:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
+
+...سست ڈیٹا بھیجنے کے بعد response مکمل ہونے پر چلے گا:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
+
+لیکن چونکہ `generate_stream()` database session استعمال نہیں کرتا، اس لیے response بھیجتے وقت session کھلا رکھنا واقعی ضروری نہیں ہے۔
+
+اگر آپ کے پاس SQLModel (یا SQLAlchemy) استعمال کرنے والا یہ مخصوص معاملہ ہے، تو آپ ضرورت نہ رہنے پر session کو واضح طور پر بند کر سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial014_an_py310.py ln[24:28] hl[28] *}
+
+اس طرح session database connection چھوڑ دے گا، تاکہ دوسری requests اسے استعمال کر سکیں۔
+
+اگر آپ کے پاس کوئی مختلف استعمال کا موقع ہے جس میں `yield` والی dependency سے جلد باہر نکلنے کی ضرورت ہو، تو براہ کرم اپنے مخصوص استعمال کے ساتھ ایک [GitHub Discussion Question](https://github.com/fastapi/fastapi/discussions/new?category=questions) بنائیں اور بتائیں کہ آپ کو `yield` والی dependencies کے لیے جلد بند ہونے سے کیا فائدہ ہوگا۔
+
+اگر `yield` والی dependencies میں جلد بند ہونے کے لیے قابل ذکر استعمال کے مواقع ہوں، تو میں جلد بند ہونے کا اختیار دینے کا ایک نیا طریقہ شامل کرنے پر غور کروں گا۔
+
+### `yield` اور `except` والی Dependencies، تکنیکی تفصیلات { #dependencies-with-yield-and-except-technical-details }
+
+FastAPI 0.110.0 سے پہلے، اگر آپ `yield` والی dependency استعمال کرتے، اور پھر اس dependency میں `except` سے کوئی exception پکڑتے، اور آپ exception دوبارہ raise نہیں کرتے تھے، تو exception خودکار طور پر کسی بھی exception handlers یا internal server error handler کو raise/forward کر دیا جاتا تھا۔
+
+یہ ورژن 0.110.0 میں تبدیل کیا گیا تاکہ بغیر handler کے forward کیے گئے exceptions سے غیر منظم memory consumption (internal server errors) کو ٹھیک کیا جا سکے، اور اسے عام Python کوڈ کے رویے سے ہم آہنگ بنایا جا سکے۔
+
+### Background Tasks اور `yield` والی Dependencies، تکنیکی تفصیلات { #background-tasks-and-dependencies-with-yield-technical-details }
+
+FastAPI 0.106.0 سے پہلے، `yield` کے بعد exceptions raise کرنا ممکن نہیں تھا، `yield` والی dependencies میں exit کوڈ response بھیجنے کے *بعد* چلتا تھا، اس لیے [Exception Handlers](../tutorial/handling-errors.md#install-custom-exception-handlers) پہلے ہی چل چکے ہوتے تھے۔
+
+یہ بنیادی طور پر اس لیے ڈیزائن کیا گیا تھا تاکہ dependencies سے "yield" کیے گئے اشیاء کو background tasks کے اندر استعمال کیا جا سکے، کیونکہ exit کوڈ background tasks مکمل ہونے کے بعد چلتا تھا۔
+
+یہ FastAPI 0.106.0 میں اس ارادے سے تبدیل کیا گیا کہ response کے نیٹ ورک پر سفر کرنے کا انتظار کرتے ہوئے وسائل کو نہ رکھا جائے۔
+
+/// tip | مشورہ
+
+مزید برآں، ایک background task عام طور پر منطق کا ایک آزاد حصہ ہوتا ہے جسے الگ سے، اپنے وسائل کے ساتھ (مثلاً اپنا database connection) سنبھالا جانا چاہیے۔
+
+اس طرح آپ کا کوڈ شاید زیادہ صاف ہوگا۔
+
+///
+
+اگر آپ پہلے اس رویے پر انحصار کرتے تھے، تو اب آپ کو background task کے اندر ہی background tasks کے لیے وسائل بنانے چاہئیں، اور اندرونی طور پر صرف وہ ڈیٹا استعمال کرنا چاہیے جو `yield` والی dependencies کے وسائل پر منحصر نہ ہو۔
+
+مثال کے طور پر، ایک ہی database session استعمال کرنے کی بجائے، آپ background task کے اندر ایک نیا database session بنائیں گے، اور اس نئے session سے database سے اشیاء حاصل کریں گے۔ اور پھر background task function کو parameter کے طور پر database سے آبجیکٹ دینے کی بجائے، آپ اس آبجیکٹ کی ID دیں گے اور پھر background task function کے اندر دوبارہ آبجیکٹ حاصل کریں گے۔
diff --git a/docs/ur/docs/advanced/advanced-python-types.md b/docs/ur/docs/advanced/advanced-python-types.md
new file mode 100644
index 000000000..4d885845b
--- /dev/null
+++ b/docs/ur/docs/advanced/advanced-python-types.md
@@ -0,0 +1,61 @@
+# ایڈوانسڈ Python Types { #advanced-python-types }
+
+یہاں کچھ اضافی خیالات ہیں جو Python types کے ساتھ کام کرتے وقت مفید ہو سکتے ہیں۔
+
+## `Union` یا `Optional` کا استعمال { #using-union-or-optional }
+
+اگر آپ کا کوڈ کسی وجہ سے `|` استعمال نہیں کر سکتا، مثلاً اگر یہ type annotation میں نہیں بلکہ `response_model=` جیسی کسی چیز میں ہے، تو عمودی بار (`|`) استعمال کرنے کی بجائے آپ `typing` سے `Union` استعمال کر سکتے ہیں۔
+
+مثال کے طور پر، آپ بیان کر سکتے ہیں کہ کچھ `str` یا `None` ہو سکتا ہے:
+
+```python
+from typing import Union
+
+
+def say_hi(name: Union[str, None]):
+ print(f"Hi {name}!")
+```
+
+`typing` میں `None` بیان کرنے کا ایک شارٹ کٹ بھی ہے، `Optional` کے ساتھ۔
+
+یہاں میرے بہت **ذاتی** نقطہ نظر سے ایک مشورہ:
+
+* `Optional[SomeType]` استعمال کرنے سے بچیں
+* اس کی بجائے **`Union[SomeType, None]`** استعمال کریں۔
+
+دونوں ایک جیسے ہیں اور اندرونی طور پر وہی ہیں، لیکن میں `Optional` کی بجائے `Union` تجویز کروں گا کیونکہ لفظ "**optional**" یہ تاثر دے سکتا ہے کہ قدر اختیاری ہے، اور اس کا اصل مطلب ہے "یہ `None` ہو سکتا ہے"، چاہے یہ اختیاری نہ ہو اور پھر بھی ضروری ہو۔
+
+مجھے لگتا ہے کہ `Union[SomeType, None]` زیادہ واضح طور پر بتاتا ہے کہ اس کا مطلب کیا ہے۔
+
+یہ صرف الفاظ اور ناموں کے بارے میں ہے۔ لیکن یہ الفاظ اثر ڈال سکتے ہیں کہ آپ اور آپ کے ساتھی کوڈ کے بارے میں کیسے سوچتے ہیں۔
+
+بطور مثال، یہ function لیں:
+
+```python
+from typing import Optional
+
+
+def say_hi(name: Optional[str]):
+ print(f"Hey {name}!")
+```
+
+parameter `name` کو `Optional[str]` بیان کیا گیا ہے، لیکن یہ **اختیاری نہیں** ہے، آپ function کو بغیر parameter کے نہیں بلا سکتے:
+
+```Python
+say_hi() # اوہ نہیں، یہ غلطی دے گا!
+```
+
+`name` parameter پھر بھی **ضروری** ہے (نہ کہ *اختیاری*) کیونکہ اس کی ڈیفالٹ قدر نہیں ہے۔ پھر بھی، `name` قدر کے طور پر `None` قبول کرتا ہے:
+
+```Python
+say_hi(name=None) # یہ کام کرتا ہے، None درست ہے
+```
+
+خوشخبری یہ ہے کہ زیادہ تر صورتوں میں، آپ آسانی سے types کی unions بیان کرنے کے لیے `|` استعمال کر سکتے ہیں:
+
+```python
+def say_hi(name: str | None):
+ print(f"Hey {name}!")
+```
+
+تو، عام طور پر آپ کو `Optional` اور `Union` جیسے ناموں کی فکر کرنے کی ضرورت نہیں ہے۔
diff --git a/docs/ur/docs/advanced/async-tests.md b/docs/ur/docs/advanced/async-tests.md
new file mode 100644
index 000000000..8a6a2ba91
--- /dev/null
+++ b/docs/ur/docs/advanced/async-tests.md
@@ -0,0 +1,99 @@
+# Async Tests { #async-tests }
+
+آپ پہلے ہی دیکھ چکے ہیں کہ فراہم کیے گئے `TestClient` کا استعمال کرتے ہوئے اپنی **FastAPI** ایپلیکیشنز کی جانچ کیسے کی جائے۔ اب تک آپ نے صرف synchronous ٹیسٹ لکھنا دیکھا ہے، بغیر `async` functions کے استعمال کے۔
+
+اپنے ٹیسٹوں میں asynchronous functions استعمال کر سکنا مفید ہو سکتا ہے، مثال کے طور پر، جب آپ اپنے database سے asynchronously query کر رہے ہوں۔ تصور کریں کہ آپ اپنی FastAPI ایپلیکیشن کو requests بھیجنا چاہتے ہیں اور پھر تصدیق کرنا چاہتے ہیں کہ آپ کے backend نے database میں درست ڈیٹا لکھا ہے، ایک async database library استعمال کرتے ہوئے۔
+
+آئیے دیکھتے ہیں کہ ہم یہ کیسے کر سکتے ہیں۔
+
+## pytest.mark.anyio { #pytest-mark-anyio }
+
+اگر ہم اپنے ٹیسٹوں میں asynchronous functions call کرنا چاہتے ہیں، تو ہمارے test functions کو asynchronous ہونا ہوگا۔ AnyIO اس کے لیے ایک عمدہ plugin فراہم کرتا ہے، جو ہمیں یہ بتانے دیتا ہے کہ کچھ test functions asynchronously call کیے جائیں۔
+
+## HTTPX { #httpx }
+
+اگر آپ کی **FastAPI** ایپلیکیشن `async def` کی بجائے عام `def` functions استعمال کرتی ہے، تب بھی یہ اندرونی طور پر ایک `async` ایپلیکیشن ہے۔
+
+`TestClient` اندرونی طور پر کچھ خاص عمل کرتا ہے تاکہ آپ کے عام `def` test functions میں asynchronous FastAPI ایپلیکیشن کو call کیا جا سکے، معیاری pytest استعمال کرتے ہوئے۔ لیکن وہ خاص عمل asynchronous functions کے اندر استعمال ہونے پر مزید کام نہیں کرتا۔ اپنے ٹیسٹ asynchronously چلانے سے، ہم اپنے test functions کے اندر `TestClient` مزید استعمال نہیں کر سکتے۔
+
+`TestClient` [HTTPX](https://www.python-httpx.org) پر مبنی ہے، اور خوش قسمتی سے، ہم اسے براہ راست API کی جانچ کے لیے استعمال کر سکتے ہیں۔
+
+## مثال { #example }
+
+ایک سادہ مثال کے لیے، آئیے ایسا فائل ڈھانچہ لیتے ہیں جو [Bigger Applications](../tutorial/bigger-applications.md) اور [Testing](../tutorial/testing.md) میں بیان کیے گئے سے ملتا جلتا ہو:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+│ └── test_main.py
+```
+
+`main.py` فائل میں ہوگا:
+
+{* ../../docs_src/async_tests/app_a_py310/main.py *}
+
+`test_main.py` فائل میں `main.py` کے ٹیسٹ ہوں گے، یہ اب کچھ اس طرح نظر آ سکتی ہے:
+
+{* ../../docs_src/async_tests/app_a_py310/test_main.py *}
+
+## اسے چلائیں { #run-it }
+
+آپ اپنے ٹیسٹ حسب معمول اس طرح چلا سکتے ہیں:
+
+
+
+لیکن اگر ہم "سرکاری" URL سے proxy کے ذریعے port `9999` پر docs UI رسائی کریں، `/api/v1/docs` پر، تو یہ درست طریقے سے کام کرتا ہے!
+
+آپ اسے [http://127.0.0.1:9999/api/v1/docs](http://127.0.0.1:9999/api/v1/docs) پر چیک کر سکتے ہیں:
+
+
+
+بالکل جیسا ہم چاہتے تھے۔
+
+اس کی وجہ یہ ہے کہ FastAPI اس `root_path` کو استعمال کرکے OpenAPI میں `root_path` کے فراہم کردہ URL کے ساتھ ڈیفالٹ `server` بناتا ہے۔
+
+## اضافی servers { #additional-servers }
+
+/// warning | انتباہ
+
+یہ ایک زیادہ ایڈوانسڈ استعمال ہے۔ اسے چھوڑ دینے میں کوئی حرج نہیں۔
+
+///
+
+بطور ڈیفالٹ، **FastAPI** OpenAPI schema میں `root_path` کے URL کے ساتھ ایک `server` بنائے گا۔
+
+لیکن آپ دیگر متبادل `servers` بھی فراہم کر سکتے ہیں، مثال کے طور پر اگر آپ چاہتے ہیں کہ *وہی* docs UI staging اور production دونوں ماحول کے ساتھ بات چیت کرے۔
+
+اگر آپ `servers` کی حسب ضرورت فہرست پاس کریں اور `root_path` موجود ہو (کیونکہ آپ کا API proxy کے پیچھے ہے)، تو **FastAPI** فہرست کے شروع میں اس `root_path` کے ساتھ ایک "server" داخل کرے گا۔
+
+مثال کے طور پر:
+
+{* ../../docs_src/behind_a_proxy/tutorial003_py310.py hl[4:7] *}
+
+یہ اس طرح کا OpenAPI schema بنائے گا:
+
+```JSON hl_lines="5-7"
+{
+ "openapi": "3.1.0",
+ // More stuff here
+ "servers": [
+ {
+ "url": "/api/v1"
+ },
+ {
+ "url": "https://stag.example.com",
+ "description": "Staging environment"
+ },
+ {
+ "url": "https://prod.example.com",
+ "description": "Production environment"
+ }
+ ],
+ "paths": {
+ // More stuff here
+ }
+}
+```
+
+/// tip | مشورہ
+
+غور کریں خود بخود بنایا گیا server جس کی `url` ویلیو `/api/v1` ہے، جو `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 کے ساتھ بات چیت کرے گا جسے آپ منتخب کریں۔
+
+///
+
+/// note | تکنیکی تفصیلات
+
+OpenAPI specification میں `servers` خاصیت اختیاری ہے۔
+
+اگر آپ `servers` parameter بیان نہ کریں اور `root_path` `/` کے برابر ہو، تو بنائے گئے OpenAPI schema میں `servers` خاصیت مکمل طور پر چھوڑ دی جائے گی، جو بطور ڈیفالٹ `url` ویلیو `/` والے ایک واحد server کے برابر ہے۔
+
+///
+
+### `root_path` سے خودکار server غیر فعال کرنا { #disable-automatic-server-from-root-path }
+
+اگر آپ نہیں چاہتے کہ **FastAPI** `root_path` استعمال کرتے ہوئے خودکار server شامل کرے، تو آپ `root_path_in_servers=False` parameter استعمال کر سکتے ہیں:
+
+{* ../../docs_src/behind_a_proxy/tutorial004_py310.py hl[9] *}
+
+اور پھر اسے OpenAPI schema میں شامل نہیں کیا جائے گا۔
+
+## Sub-application mount کرنا { #mounting-a-sub-application }
+
+اگر آپ کو sub-application mount کرنی ہو (جیسا کہ [Sub Applications - Mounts](sub-applications.md) میں بیان ہے) جبکہ `root_path` کے ساتھ proxy بھی استعمال ہو رہا ہو، تو آپ اسے عام طور پر کر سکتے ہیں، جیسا کہ آپ توقع کریں گے۔
+
+FastAPI اندرونی طور پر `root_path` کو سمجھداری سے استعمال کرے گا، تو یہ بس کام کر جائے گا۔
diff --git a/docs/ur/docs/advanced/custom-response.md b/docs/ur/docs/advanced/custom-response.md
new file mode 100644
index 000000000..38927a556
--- /dev/null
+++ b/docs/ur/docs/advanced/custom-response.md
@@ -0,0 +1,272 @@
+# حسب ضرورت Response - HTML, Stream, File, اور دیگر { #custom-response-html-stream-file-others }
+
+پہلے سے طے شدہ طور پر، **FastAPI** JSON responses واپس کرے گا۔
+
+آپ اسے براہ راست `Response` واپس کر کے تبدیل کر سکتے ہیں جیسا کہ [براہ راست Response واپس کریں](response-directly.md) میں بتایا گیا ہے۔
+
+لیکن اگر آپ براہ راست `Response` واپس کرتے ہیں (یا کوئی بھی subclass، جیسے `JSONResponse`)، تو ڈیٹا خود بخود تبدیل نہیں ہوگا (چاہے آپ نے `response_model` کا اعلان کیا ہو)، اور دستاویزات خود بخود تیار نہیں ہوں گی (مثال کے طور پر، مخصوص "media type" شامل کرنا، HTTP header `Content-Type` میں، تیار شدہ OpenAPI کے حصے کے طور پر)۔
+
+لیکن آپ وہ `Response` بھی اعلان کر سکتے ہیں جو آپ استعمال کرنا چاہتے ہیں (مثلاً کوئی بھی `Response` subclass)، *path operation decorator* میں `response_class` parameter استعمال کر کے۔
+
+آپ کے *path operation function* سے واپس آنے والا مواد اس `Response` میں ڈالا جائے گا۔
+
+/// note | نوٹ
+
+اگر آپ بغیر media type والی response class استعمال کرتے ہیں، تو FastAPI توقع کرے گا کہ آپ کے response میں کوئی مواد نہیں ہے، لہذا یہ تیار شدہ OpenAPI docs میں response format کو دستاویزی شکل نہیں دے گا۔
+
+///
+
+## JSON Responses { #json-responses }
+
+پہلے سے طے شدہ طور پر FastAPI JSON responses واپس کرتا ہے۔
+
+اگر آپ [Response Model](../tutorial/response-model.md) کا اعلان کرتے ہیں تو FastAPI اسے Pydantic استعمال کر کے ڈیٹا کو JSON میں serialize کرنے کے لیے استعمال کرے گا۔
+
+اگر آپ response model کا اعلان نہیں کرتے، تو FastAPI [JSON Compatible Encoder](../tutorial/encoder.md) میں بیان کردہ `jsonable_encoder` استعمال کرے گا اور اسے `JSONResponse` میں ڈالے گا۔
+
+اگر آپ JSON media type (`application/json`) والی `response_class` کا اعلان کرتے ہیں، جیسا کہ `JSONResponse` کے معاملے میں ہے، تو آپ کا واپس کردہ ڈیٹا خود بخود Pydantic `response_model` کے ساتھ تبدیل (اور فلٹر) ہوگا جو آپ نے *path operation decorator* میں اعلان کیا تھا۔ لیکن ڈیٹا کو Pydantic کے ذریعے JSON bytes میں serialize نہیں کیا جائے گا، بلکہ اسے `jsonable_encoder` سے تبدیل کیا جائے گا اور پھر `JSONResponse` class کو دیا جائے گا، جو اسے Python کی معیاری JSON library استعمال کر کے bytes میں serialize کرے گی۔
+
+### JSON کارکردگی { #json-performance }
+
+مختصراً، اگر آپ زیادہ سے زیادہ کارکردگی چاہتے ہیں تو [Response Model](../tutorial/response-model.md) استعمال کریں اور *path operation decorator* میں `response_class` کا اعلان نہ کریں۔
+
+{* ../../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` دیں۔
+
+{* ../../docs_src/custom_response/tutorial002_py310.py hl[2,7] *}
+
+/// info | معلومات
+
+parameter `response_class` کو response کی "media type" کی تعریف کے لیے بھی استعمال کیا جائے گا۔
+
+اس صورت میں، HTTP header `Content-Type` کو `text/html` پر مقرر کیا جائے گا۔
+
+اور اسے OpenAPI میں اسی طرح دستاویزی شکل دی جائے گی۔
+
+///
+
+### `Response` واپس کریں { #return-a-response }
+
+جیسا کہ [براہ راست Response واپس کریں](response-directly.md) میں بتایا گیا ہے، آپ اپنے *path operation* میں response کو براہ راست واپس کر کے بھی تبدیل کر سکتے ہیں۔
+
+اوپر والی مثال، `HTMLResponse` واپس کرتے ہوئے، اس طرح دکھ سکتی ہے:
+
+{* ../../docs_src/custom_response/tutorial003_py310.py hl[2,7,19] *}
+
+/// warning | انتباہ
+
+آپ کے *path operation function* سے براہ راست واپس کیا گیا `Response` OpenAPI میں دستاویزی شکل نہیں دیا جائے گا (مثال کے طور پر، `Content-Type` دستاویزی نہیں ہوگا) اور خودکار انٹرایکٹو docs میں نظر نہیں آئے گا۔
+
+///
+
+/// info | معلومات
+
+یقیناً، اصل `Content-Type` header، status code وغیرہ آپ کے واپس کردہ `Response` آبجیکٹ سے آئیں گے۔
+
+///
+
+### OpenAPI میں دستاویز بنائیں اور `Response` کو تبدیل کریں { #document-in-openapi-and-override-response }
+
+اگر آپ function کے اندر سے response کو تبدیل کرنا چاہتے ہیں لیکن ساتھ ہی OpenAPI میں "media type" کو دستاویزی شکل دینا چاہتے ہیں، تو آپ `response_class` parameter استعمال کر سکتے ہیں اور ساتھ ہی `Response` آبجیکٹ واپس کر سکتے ہیں۔
+
+`response_class` پھر صرف OpenAPI *path operation* کی دستاویز بنانے کے لیے استعمال ہوگی، لیکن آپ کا `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_html_response()` کو کال کرنے کا نتیجہ واپس کر کے، آپ پہلے سے ہی ایک `Response` واپس کر رہے ہیں جو **FastAPI** کے پہلے سے طے شدہ رویے کو تبدیل کر دے گا۔
+
+لیکن چونکہ آپ نے `HTMLResponse` کو `response_class` میں بھی دیا ہے، **FastAPI** جانے گا کہ اسے OpenAPI اور انٹرایکٹو docs میں HTML کے طور پر `text/html` کے ساتھ دستاویزی شکل کیسے دینی ہے:
+
+
+
+## دستیاب responses { #available-responses }
+
+یہاں کچھ دستیاب responses ہیں۔
+
+ذہن میں رکھیں کہ آپ `Response` استعمال کر کے کچھ بھی واپس کر سکتے ہیں، یا حتی کہ اپنی مرضی کی sub-class بنا سکتے ہیں۔
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import HTMLResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** وہی `starlette.responses` فراہم کرتا ہے جو `fastapi.responses` کے طور پر، بس آپ یعنی developer کی سہولت کے لیے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+///
+
+### `Response` { #response }
+
+بنیادی `Response` class، باقی تمام responses اس سے وراثت میں ملتے ہیں۔
+
+آپ اسے براہ راست واپس کر سکتے ہیں۔
+
+یہ درج ذیل parameters قبول کرتا ہے:
+
+* `content` - ایک `str` یا `bytes`۔
+* `status_code` - ایک `int` HTTP status code۔
+* `headers` - strings کی ایک `dict`۔
+* `media_type` - media type دینے والی ایک `str`۔ مثلاً `"text/html"`۔
+
+FastAPI (دراصل Starlette) خود بخود Content-Length header شامل کرے گا۔ یہ Content-Type header بھی شامل کرے گا، `media_type` کی بنیاد پر اور متنی اقسام کے لیے charset شامل کرے گا۔
+
+{* ../../docs_src/response_directly/tutorial002_py310.py hl[1,18] *}
+
+### `HTMLResponse` { #htmlresponse }
+
+کچھ متن یا bytes لیتا ہے اور HTML response واپس کرتا ہے، جیسا کہ آپ نے اوپر پڑھا۔
+
+### `PlainTextResponse` { #plaintextresponse }
+
+کچھ متن یا bytes لیتا ہے اور سادہ متنی response واپس کرتا ہے۔
+
+{* ../../docs_src/custom_response/tutorial005_py310.py hl[2,7,9] *}
+
+### `JSONResponse` { #jsonresponse }
+
+کچھ ڈیٹا لیتا ہے اور `application/json` encoded response واپس کرتا ہے۔
+
+یہ **FastAPI** میں استعمال ہونے والا پہلے سے طے شدہ response ہے، جیسا کہ آپ نے اوپر پڑھا۔
+
+/// note | تکنیکی تفصیلات
+
+لیکن اگر آپ response model یا return type کا اعلان کرتے ہیں، تو اسے ڈیٹا کو JSON میں براہ راست serialize کرنے کے لیے استعمال کیا جائے گا، اور JSON کے لیے صحیح media type والا response براہ راست واپس کیا جائے گا، `JSONResponse` class استعمال کیے بغیر۔
+
+یہ بہترین کارکردگی حاصل کرنے کا مثالی طریقہ ہے۔
+
+///
+
+### `RedirectResponse` { #redirectresponse }
+
+HTTP redirect واپس کرتا ہے۔ پہلے سے طے شدہ طور پر 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` کا پہلے سے طے شدہ ہوگا، جو `307` ہے۔
+
+---
+
+آپ `status_code` parameter کو `response_class` parameter کے ساتھ بھی استعمال کر سکتے ہیں:
+
+{* ../../docs_src/custom_response/tutorial006c_py310.py hl[2,7,9] *}
+
+### `StreamingResponse` { #streamingresponse }
+
+ایک async generator یا عام generator/iterator (ایک function جس میں `yield` ہو) لیتا ہے اور response body کو stream کرتا ہے۔
+
+{* ../../docs_src/custom_response/tutorial007_py310.py hl[3,16] *}
+
+/// note | تکنیکی تفصیلات
+
+ایک `async` task صرف اس وقت منسوخ ہو سکتا ہے جب یہ `await` پر پہنچتا ہے۔ اگر `await` نہیں ہے، تو generator (function جس میں `yield` ہو) صحیح طریقے سے منسوخ نہیں ہو سکتا اور منسوخی کی درخواست کے بعد بھی چلتا رہ سکتا ہے۔
+
+چونکہ اس چھوٹی مثال کو کسی `await` statement کی ضرورت نہیں ہے، ہم `await anyio.sleep(0)` شامل کرتے ہیں تاکہ event loop کو منسوخی سنبھالنے کا موقع مل سکے۔
+
+بڑے یا لامحدود streams کے ساتھ یہ اور بھی اہم ہوگا۔
+
+///
+
+/// tip | مشورہ
+
+براہ راست `StreamingResponse` واپس کرنے کی بجائے، آپ کو شاید [Stream Data](./stream-data.md) میں دیے گئے طریقے پر عمل کرنا چاہیے، یہ بہت زیادہ آسان ہے اور پس پردہ منسوخی کو آپ کے لیے سنبھالتا ہے۔
+
+اگر آپ JSON Lines stream کر رہے ہیں، تو [Stream JSON Lines](../tutorial/stream-json-lines.md) ٹیوٹوریل دیکھیں۔
+
+///
+
+### `FileResponse` { #fileresponse }
+
+فائل کو غیر ہم وقتی (asynchronously) response کے طور پر stream کرتا ہے۔
+
+دوسری response اقسام سے مختلف arguments لیتا ہے:
+
+* `path` - فائل کا path جو stream کرنی ہے۔
+* `headers` - شامل کرنے کے لیے کوئی بھی حسب ضرورت headers، بطور dictionary۔
+* `media_type` - media type دینے والی ایک string۔ اگر مقرر نہ ہو تو فائل نام یا path سے media type کا اندازہ لگایا جائے گا۔
+* `filename` - اگر مقرر ہو تو یہ 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 سے براہ راست فائل کا path واپس کر سکتے ہیں۔
+
+## حسب ضرورت response class { #custom-response-class }
+
+آپ `Response` سے وراثت میں لے کر اپنی مرضی کی response class بنا سکتے ہیں اور اسے استعمال کر سکتے ہیں۔
+
+مثال کے طور پر، فرض کریں کہ آپ [`orjson`](https://github.com/ijl/orjson) کو کچھ ترتیبات کے ساتھ استعمال کرنا چاہتے ہیں۔
+
+فرض کریں آپ چاہتے ہیں کہ یہ indented اور formatted JSON واپس کرے، لہذا آپ orjson آپشن `orjson.OPT_INDENT_2` استعمال کرنا چاہتے ہیں۔
+
+آپ `CustomORJSONResponse` بنا سکتے ہیں۔ سب سے اہم بات یہ ہے کہ آپ کو ایک `Response.render(content)` method بنانا ہے جو مواد کو `bytes` کے طور پر واپس کرے:
+
+{* ../../docs_src/custom_response/tutorial009c_py310.py hl[9:14,17] *}
+
+اب واپس کرنے کی بجائے:
+
+```json
+{"message": "Hello World"}
+```
+
+...یہ response واپس کرے گا:
+
+```json
+{
+ "message": "Hello World"
+}
+```
+
+یقیناً، آپ کو JSON فارمیٹنگ سے کہیں بہتر طریقے مل جائیں گے اس سے فائدہ اٹھانے کے لیے۔
+
+### `orjson` یا Response Model { #orjson-or-response-model }
+
+اگر آپ کارکردگی کی تلاش میں ہیں تو شاید `orjson` response سے بہتر یہ ہے کہ آپ [Response Model](../tutorial/response-model.md) استعمال کریں۔
+
+Response model کے ساتھ، FastAPI ڈیٹا کو JSON میں serialize کرنے کے لیے Pydantic استعمال کرے گا، بغیر درمیانی مراحل کے، جیسے اسے `jsonable_encoder` سے تبدیل کرنا، جو کسی بھی اور صورت میں ہوتا۔
+
+اور پس پردہ، Pydantic JSON میں serialize کرنے کے لیے `orjson` جیسے ہی بنیادی Rust میکانزم استعمال کرتا ہے، لہذا response model کے ساتھ آپ کو پہلے سے ہی بہترین کارکردگی مل جائے گی۔
+
+## پہلے سے طے شدہ response class { #default-response-class }
+
+**FastAPI** class instance یا `APIRouter` بناتے وقت آپ بتا سکتے ہیں کہ پہلے سے طے شدہ طور پر کون سی response class استعمال ہو۔
+
+اسے بیان کرنے والا parameter `default_response_class` ہے۔
+
+نیچے دی گئی مثال میں، **FastAPI** تمام *path operations* میں JSON کی بجائے پہلے سے طے شدہ طور پر `HTMLResponse` استعمال کرے گا۔
+
+{* ../../docs_src/custom_response/tutorial010_py310.py hl[2,4] *}
+
+/// tip | مشورہ
+
+آپ پہلے کی طرح *path operations* میں `response_class` کو تبدیل کر سکتے ہیں۔
+
+///
+
+## اضافی دستاویزات { #additional-documentation }
+
+آپ OpenAPI میں media type اور بہت سی دوسری تفصیلات کا بھی `responses` استعمال کر کے اعلان کر سکتے ہیں: [OpenAPI میں اضافی Responses](additional-responses.md)۔
diff --git a/docs/ur/docs/advanced/dataclasses.md b/docs/ur/docs/advanced/dataclasses.md
new file mode 100644
index 000000000..d88a22d3b
--- /dev/null
+++ b/docs/ur/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) استعمال کرنے کی بھی اسی طرح سپورٹ کرتا ہے:
+
+{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
+
+یہ **Pydantic** کی بدولت اب بھی سپورٹ ہے، کیونکہ اس میں [`dataclasses` کی اندرونی سپورٹ](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel) موجود ہے۔
+
+تو، اوپر والے کوڈ میں بھی جو واضح طور پر Pydantic استعمال نہیں کرتا، FastAPI ان معیاری dataclasses کو Pydantic کے اپنے مخصوص dataclasses میں تبدیل کرنے کے لیے Pydantic استعمال کر رہا ہے۔
+
+اور یقیناً، یہ وہی سب سپورٹ کرتا ہے:
+
+* ڈیٹا validation
+* ڈیٹا serialization
+* ڈیٹا دستاویزات، وغیرہ۔
+
+یہ Pydantic models کی طرح ہی کام کرتا ہے۔ اور یہ دراصل اندرونی طور پر اسی طرح حاصل کیا جاتا ہے، Pydantic استعمال کرتے ہوئے۔
+
+/// info | معلومات
+
+یاد رکھیں کہ dataclasses وہ سب کچھ نہیں کر سکتیں جو Pydantic models کر سکتے ہیں۔
+
+تو، آپ کو پھر بھی Pydantic models استعمال کرنے کی ضرورت پڑ سکتی ہے۔
+
+لیکن اگر آپ کے پاس بہت سی dataclasses پڑی ہیں تو FastAPI استعمال کر کے web API بنانے کے لیے انہیں استعمال کرنا ایک اچھی تدبیر ہے۔
+
+///
+
+## `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 میں نظر آئے گا:
+
+
+
+## نیسٹڈ ڈیٹا ڈھانچوں میں Dataclasses { #dataclasses-in-nested-data-structures }
+
+آپ `dataclasses` کو دوسری type annotations کے ساتھ ملا کر نیسٹڈ ڈیٹا ڈھانچے بنا سکتے ہیں۔
+
+بعض صورتوں میں، آپ کو پھر بھی Pydantic کے ورژن کی `dataclasses` استعمال کرنی ہو سکتی ہیں۔ مثال کے طور پر، اگر خود بخود بنائی گئی API دستاویزات میں غلطیاں ہوں۔
+
+اس صورت میں، آپ معیاری `dataclasses` کو `pydantic.dataclasses` سے بدل سکتے ہیں، جو ایک متبادل ہے:
+
+{* ../../docs_src/dataclasses_/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
+
+1. ہم پھر بھی معیاری `dataclasses` سے `field` import کرتے ہیں۔
+
+2. `pydantic.dataclasses` `dataclasses` کا متبادل ہے۔
+
+3. `Author` dataclass میں `Item` dataclasses کی فہرست شامل ہے۔
+
+4. `Author` dataclass `response_model` parameter کے طور پر استعمال ہوتی ہے۔
+
+5. آپ dataclasses کے ساتھ دیگر معیاری type annotations کو request body کے طور پر استعمال کر سکتے ہیں۔
+
+ اس صورت میں، یہ `Item` dataclasses کی فہرست ہے۔
+
+6. یہاں ہم dictionary واپس کر رہے ہیں جس میں `items` ہے جو dataclasses کی فہرست ہے۔
+
+ FastAPI پھر بھی ڈیٹا کو JSON میں serialize کرنے کے قابل ہے۔
+
+7. یہاں `response_model` `Author` dataclasses کی فہرست کی type annotation استعمال کر رہا ہے۔
+
+ دوبارہ، آپ `dataclasses` کو معیاری type annotations کے ساتھ ملا سکتے ہیں۔
+
+8. غور کریں کہ یہ *path operation function* `async def` کی بجائے عام `def` استعمال کرتا ہے۔
+
+ ہمیشہ کی طرح، FastAPI میں آپ `def` اور `async def` کو ضرورت کے مطابق ملا سکتے ہیں۔
+
+ اگر آپ کو یاد دہانی چاہیے کہ کب کون سا استعمال کریں، تو [`async` اور `await`](../async.md#in-a-hurry) کی دستاویزات میں _"جلدی میں ہیں؟"_ سیکشن دیکھیں۔
+
+9. یہ *path operation function* dataclasses واپس نہیں کر رہا (حالانکہ کر سکتا ہے)، بلکہ اندرونی ڈیٹا کے ساتھ dictionaries کی فہرست واپس کر رہا ہے۔
+
+ FastAPI `response_model` parameter (جس میں dataclasses شامل ہیں) استعمال کرکے response تبدیل کرے گا۔
+
+آپ `dataclasses` کو دیگر type annotations کے ساتھ بہت سے مختلف مجموعوں میں ملا کر پیچیدہ ڈیٹا ڈھانچے بنا سکتے ہیں۔
+
+مزید مخصوص تفصیلات دیکھنے کے لیے اوپر کوڈ میں موجود annotation مشورے دیکھیں۔
+
+## مزید جانیں { #learn-more }
+
+آپ `dataclasses` کو دیگر Pydantic models کے ساتھ بھی ملا سکتے ہیں، ان سے inherit کر سکتے ہیں، انہیں اپنے models میں شامل کر سکتے ہیں، وغیرہ۔
+
+مزید جاننے کے لیے، [dataclasses کے بارے میں Pydantic دستاویزات](https://docs.pydantic.dev/latest/concepts/dataclasses/) دیکھیں۔
+
+## ورژن { #version }
+
+یہ FastAPI ورژن `0.67.0` سے دستیاب ہے۔
diff --git a/docs/ur/docs/advanced/events.md b/docs/ur/docs/advanced/events.md
new file mode 100644
index 000000000..497fd0d58
--- /dev/null
+++ b/docs/ur/docs/advanced/events.md
@@ -0,0 +1,165 @@
+# Lifespan Events { #lifespan-events }
+
+آپ ایسی منطق (کوڈ) بیان کر سکتے ہیں جو ایپلیکیشن **شروع ہونے** سے پہلے عمل میں آئے۔ اس کا مطلب ہے کہ یہ کوڈ ایپلیکیشن کے **requests وصول کرنا شروع** کرنے سے **پہلے**، **ایک بار** عمل میں آئے گا۔
+
+اسی طرح، آپ ایسی منطق (کوڈ) بیان کر سکتے ہیں جو ایپلیکیشن کے **بند ہونے** کے وقت عمل میں آئے۔ اس صورت میں، یہ کوڈ ممکنہ طور پر **بہت سی requests** ہینڈل کرنے کے **بعد**، **ایک بار** عمل میں آئے گا۔
+
+چونکہ یہ کوڈ ایپلیکیشن کے requests لینا **شروع** کرنے سے پہلے عمل میں آتا ہے، اور requests ہینڈل کرنا **ختم** کرنے کے فوراً بعد، یہ پوری ایپلیکیشن کی **lifespan** کا احاطہ کرتا ہے (لفظ "lifespan" ایک لمحے میں اہم ہوگا)۔
+
+یہ ایسے **وسائل** سیٹ اپ کرنے کے لیے بہت مفید ہو سکتا ہے جو آپ کو پوری ایپ میں استعمال کرنے ہیں، اور جو requests کے درمیان **مشترک** ہیں، اور/یا جنہیں آپ کو بعد میں **صاف** کرنا ہے۔ مثال کے طور پر، database connection pool، یا مشترکہ machine learning model لوڈ کرنا۔
+
+## استعمال کی صورت { #use-case }
+
+آئیے ایک مثال **استعمال کی صورت** سے شروع کریں اور پھر دیکھیں کہ اسے کیسے حل کیا جائے۔
+
+فرض کریں کہ آپ کے پاس کچھ **machine learning models** ہیں جو آپ requests ہینڈل کرنے کے لیے استعمال کرنا چاہتے ہیں۔
+
+وہی models requests کے درمیان مشترک ہیں، تو یہ ہر request کے لیے ایک model نہیں، یا ہر صارف کے لیے ایک یا اس جیسی کوئی بات نہیں۔
+
+فرض کریں کہ model لوڈ کرنے میں **کافی وقت** لگ سکتا ہے، کیونکہ اسے **ڈسک سے بہت سا ڈیٹا** پڑھنا ہوتا ہے۔ تو آپ ہر request پر یہ نہیں کرنا چاہتے۔
+
+آپ اسے module/فائل کی اعلیٰ سطح پر لوڈ کر سکتے ہیں، لیکن اس کا مطلب یہ بھی ہوگا کہ اگر آپ صرف ایک سادہ خودکار ٹیسٹ چلا رہے ہیں تو بھی یہ **model لوڈ** کرے گا، پھر وہ ٹیسٹ **سست** ہوگا کیونکہ اسے کوڈ کا آزاد حصہ چلانے سے پہلے model لوڈ ہونے کا انتظار کرنا ہوگا۔
+
+یہی ہم حل کریں گے، requests ہینڈل ہونے سے پہلے model لوڈ کریں، لیکن صرف ایپلیکیشن کے requests وصول کرنا شروع کرنے سے ٹھیک پہلے، نہ کہ جب کوڈ لوڈ ہو رہا ہو۔
+
+## Lifespan { #lifespan }
+
+آپ `FastAPI` ایپ کے `lifespan` parameter اور ایک "context manager" استعمال کرکے یہ *startup* اور *shutdown* منطق بیان کر سکتے ہیں (میں آپ کو ایک لمحے میں بتاؤں گا کہ یہ کیا ہے)۔
+
+آئیے ایک مثال سے شروع کریں اور پھر تفصیل سے دیکھیں۔
+
+ہم `yield` کے ساتھ ایک async function `lifespan()` اس طرح بناتے ہیں:
+
+{* ../../docs_src/events/tutorial003_py310.py hl[16,19] *}
+
+یہاں ہم model لوڈ کرنے کے مہنگے *startup* عمل کی نقل کر رہے ہیں (جعلی) model function کو `yield` سے پہلے machine learning models کی dictionary میں رکھ کر۔ یہ کوڈ ایپلیکیشن کے **requests لینا شروع** کرنے سے **پہلے**، *startup* کے دوران عمل میں آئے گا۔
+
+اور پھر، `yield` کے فوراً بعد، ہم model کو unload کرتے ہیں۔ یہ کوڈ ایپلیکیشن کے **requests ہینڈل کرنا ختم** کرنے کے **بعد**، *shutdown* سے ٹھیک پہلے عمل میں آئے گا۔ یہ مثال کے طور پر، memory یا GPU جیسے وسائل آزاد کر سکتا ہے۔
+
+/// tip | مشورہ
+
+`shutdown` تب ہوگا جب آپ ایپلیکیشن **بند** کر رہے ہوں۔
+
+شاید آپ کو نیا ورژن شروع کرنا ہو، یا آپ بس اسے چلاتے چلاتے تھک گئے ہوں۔
+
+///
+
+### Lifespan function { #lifespan-function }
+
+سب سے پہلے غور کریں کہ ہم `yield` کے ساتھ ایک async function بیان کر رہے ہیں۔ یہ `yield` والی Dependencies سے بہت ملتا جلتا ہے۔
+
+{* ../../docs_src/events/tutorial003_py310.py hl[14:19] *}
+
+function کا پہلا حصہ، `yield` سے پہلے، ایپلیکیشن شروع ہونے سے **پہلے** عمل میں آئے گا۔
+
+اور `yield` کے بعد والا حصہ ایپلیکیشن ختم ہونے کے **بعد** عمل میں آئے گا۔
+
+### Async Context Manager { #async-context-manager }
+
+اگر آپ دیکھیں، تو function کو `@asynccontextmanager` سے decorate کیا گیا ہے۔
+
+یہ function کو "**async context manager**" نامی چیز میں تبدیل کرتا ہے۔
+
+{* ../../docs_src/events/tutorial003_py310.py hl[1,13] *}
+
+Python میں **context manager** وہ چیز ہے جسے آپ `with` statement میں استعمال کر سکتے ہیں، مثال کے طور پر، `open()` context manager کے طور پر استعمال ہو سکتا ہے:
+
+```Python
+with open("file.txt") as file:
+ file.read()
+```
+
+Python کے حالیہ ورژنز میں، ایک **async context manager** بھی ہے۔ آپ اسے `async with` کے ساتھ استعمال کریں گے:
+
+```Python
+async with lifespan(app):
+ await do_stuff()
+```
+
+جب آپ اوپر کی طرح context manager یا async context manager بناتے ہیں، تو یہ `with` بلاک میں داخل ہونے سے پہلے `yield` سے پہلے والا کوڈ عمل میں لائے گا، اور `with` بلاک سے باہر نکلنے کے بعد `yield` کے بعد والا کوڈ عمل میں لائے گا۔
+
+ہماری اوپر والی کوڈ مثال میں، ہم اسے براہ راست استعمال نہیں کرتے، بلکہ FastAPI کو استعمال کرنے کے لیے پاس کرتے ہیں۔
+
+`FastAPI` ایپ کا `lifespan` parameter ایک **async context manager** لیتا ہے، تو ہم اپنا نیا `lifespan` async context manager اسے پاس کر سکتے ہیں۔
+
+{* ../../docs_src/events/tutorial003_py310.py hl[22] *}
+
+## متبادل Events (deprecated) { #alternative-events-deprecated }
+
+/// warning | انتباہ
+
+*startup* اور *shutdown* کو ہینڈل کرنے کا تجویز کردہ طریقہ اوپر بیان کردہ `FastAPI` ایپ کا `lifespan` parameter استعمال کرنا ہے۔ اگر آپ `lifespan` parameter فراہم کریں تو `startup` اور `shutdown` event handlers مزید نہیں بلائے جائیں گے۔ یہ یا تو سب `lifespan` ہے یا سب events، دونوں نہیں۔
+
+آپ شاید اس حصے کو چھوڑ سکتے ہیں۔
+
+///
+
+*startup* اور *shutdown* کے دوران عمل میں آنے والی منطق بیان کرنے کا ایک متبادل طریقہ ہے۔
+
+آپ ایسے event handler functions بیان کر سکتے ہیں جو ایپلیکیشن شروع ہونے سے پہلے، یا بند ہوتے وقت عمل میں آنے چاہییں۔
+
+یہ functions `async def` یا عام `def` کے ساتھ بیان کیے جا سکتے ہیں۔
+
+### `startup` event { #startup-event }
+
+ایسا function شامل کرنے کے لیے جو ایپلیکیشن شروع ہونے سے پہلے چلے، اسے `"startup"` event کے ساتھ بیان کریں:
+
+{* ../../docs_src/events/tutorial001_py310.py hl[8] *}
+
+اس صورت میں، `startup` event handler function آئٹمز کے "database" (صرف ایک `dict`) کو کچھ اقدار سے شروع کرے گا۔
+
+آپ ایک سے زیادہ event handler functions شامل کر سکتے ہیں۔
+
+اور آپ کی ایپلیکیشن تب تک requests وصول کرنا شروع نہیں کرے گی جب تک تمام `startup` event handlers مکمل نہیں ہو جاتے۔
+
+### `shutdown` event { #shutdown-event }
+
+ایسا function شامل کرنے کے لیے جو ایپلیکیشن بند ہوتے وقت چلے، اسے `"shutdown"` event کے ساتھ بیان کریں:
+
+{* ../../docs_src/events/tutorial002_py310.py hl[6] *}
+
+یہاں، `shutdown` event handler function `log.txt` فائل میں ایک ٹیکسٹ لائن `"Application shutdown"` لکھے گا۔
+
+/// info | معلومات
+
+`open()` function میں، `mode="a"` کا مطلب "append" ہے، تو لائن فائل میں پہلے سے موجود مواد کو مٹائے بغیر آخر میں شامل ہوگی۔
+
+///
+
+/// tip | مشورہ
+
+غور کریں کہ اس صورت میں ہم معیاری Python `open()` function استعمال کر رہے ہیں جو فائل کے ساتھ بات چیت کرتا ہے۔
+
+تو، اس میں I/O (input/output) شامل ہے، جس کے لیے ڈسک پر لکھے جانے کا "انتظار" کرنا ہوتا ہے۔
+
+لیکن `open()` `async` اور `await` استعمال نہیں کرتا۔
+
+تو، ہم event handler function کو `async def` کی بجائے معیاری `def` کے ساتھ بیان کرتے ہیں۔
+
+///
+
+### `startup` اور `shutdown` ایک ساتھ { #startup-and-shutdown-together }
+
+بہت زیادہ امکان ہے کہ آپ کی *startup* اور *shutdown* منطق آپس میں جڑی ہوئی ہے، آپ شاید کچھ شروع کرنا اور پھر ختم کرنا چاہیں، کوئی وسیلہ حاصل کرنا اور پھر آزاد کرنا چاہیں وغیرہ۔
+
+یہ الگ functions میں کرنا جو منطق یا متغیرات شیئر نہیں کرتے، زیادہ مشکل ہے کیونکہ آپ کو اقدار global variables یا اسی طرح کی تدبیروں میں محفوظ کرنی ہوں گی۔
+
+اسی لیے، اب تجویز یہ ہے کہ اوپر بیان کردہ `lifespan` استعمال کریں۔
+
+## تکنیکی تفصیلات { #technical-details }
+
+متجسس لوگوں کے لیے صرف ایک تکنیکی تفصیل۔
+
+اندرونی طور پر، ASGI تکنیکی specification میں، یہ [Lifespan Protocol](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) کا حصہ ہے، اور یہ `startup` اور `shutdown` نامی events بیان کرتا ہے۔
+
+/// info | معلومات
+
+آپ Starlette کے `lifespan` handlers کے بارے میں مزید [Starlette کی Lifespan دستاویزات](https://www.starlette.dev/lifespan/) میں پڑھ سکتے ہیں۔
+
+بشمول یہ کہ lifespan state کو کیسے ہینڈل کریں جو آپ کے کوڈ کے دوسرے حصوں میں استعمال ہو سکتا ہے۔
+
+///
+
+## Sub Applications { #sub-applications }
+
+یاد رکھیں کہ یہ lifespan events (startup اور shutdown) صرف مرکزی ایپلیکیشن کے لیے عمل میں آئیں گے، [Sub Applications - Mounts](sub-applications.md) کے لیے نہیں۔
diff --git a/docs/ur/docs/advanced/generate-clients.md b/docs/ur/docs/advanced/generate-clients.md
new file mode 100644
index 000000000..3a301aef8
--- /dev/null
+++ b/docs/ur/docs/advanced/generate-clients.md
@@ -0,0 +1,208 @@
+# SDKs بنانا { #generating-sdks }
+
+چونکہ **FastAPI** **OpenAPI** specification پر مبنی ہے، اس کے APIs کو ایک معیاری فارمیٹ میں بیان کیا جا سکتا ہے جسے بہت سے ٹولز سمجھتے ہیں۔
+
+اس سے تازہ ترین **دستاویزات**، متعدد زبانوں میں client لائبریریاں (**SDKs**)، اور **testing** یا **automation workflows** بنانا آسان ہو جاتا ہے جو آپ کے کوڈ کے ساتھ ہم آہنگ رہتے ہیں۔
+
+اس گائیڈ میں، آپ سیکھیں گے کہ اپنے FastAPI backend کے لیے **TypeScript SDK** کیسے بنائیں۔
+
+## اوپن سورس SDK Generators { #open-source-sdk-generators }
+
+ایک ورسٹائل آپشن [OpenAPI Generator](https://openapi-generator.tech/) ہے، جو **بہت سی پروگرامنگ زبانوں** کو سپورٹ کرتا ہے اور آپ کی OpenAPI specification سے SDKs بنا سکتا ہے۔
+
+**TypeScript clients** کے لیے، [Hey API](https://heyapi.dev/) ایک مقصد کے لیے بنایا گیا حل ہے، جو TypeScript ایکو سسٹم کے لیے بہترین تجربہ فراہم کرتا ہے۔
+
+آپ [OpenAPI.Tools](https://openapi.tools/#sdk) پر مزید SDK generators دریافت کر سکتے ہیں۔
+
+/// tip | مشورہ
+
+FastAPI خود بخود **OpenAPI 3.1** specifications بناتا ہے، لہذا آپ جو بھی ٹول استعمال کریں اسے اس ورژن کو سپورٹ کرنا ضروری ہے۔
+
+///
+
+## FastAPI کے اسپانسرز سے SDK Generators { #sdk-generators-from-fastapi-sponsors }
+
+یہ سیکشن FastAPI کے اسپانسر کمپنیوں کے **وینچر بیکڈ** اور **کمپنی سپورٹ یافتہ** حل نمایاں کرتا ہے۔ یہ پروڈکٹس اعلیٰ معیار کی بنائی گئی SDKs کے ساتھ **اضافی خصوصیات** اور **integrations** فراہم کرتے ہیں۔
+
+**FastAPI** کو ✨ [**اسپانسر**](../help-fastapi.md#sponsor-the-author) ✨ کرکے، یہ کمپنیاں framework اور اس کے **ایکو سسٹم** کو صحت مند اور **پائیدار** رکھنے میں مدد کرتی ہیں۔
+
+ان کی اسپانسرشپ FastAPI **کمیونٹی** (آپ) کے ساتھ مضبوط وابستگی بھی ظاہر کرتی ہے، یہ دکھاتے ہوئے کہ وہ نہ صرف **بہترین سروس** فراہم کرنے بلکہ ایک **مضبوط اور ترقی پذیر framework**، FastAPI، کو سپورٹ کرنے میں بھی دلچسپی رکھتے ہیں۔
+
+مثال کے طور پر، آپ آزما سکتے ہیں:
+
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
+
+ان میں سے کچھ حل اوپن سورس بھی ہو سکتے ہیں یا مفت درجے پیش کر سکتے ہیں، تو آپ انہیں بغیر مالی وابستگی کے آزما سکتے ہیں۔ دیگر تجارتی SDK generators بھی دستیاب ہیں اور آن لائن مل سکتے ہیں۔
+
+## TypeScript SDK بنائیں { #create-a-typescript-sdk }
+
+آئیے ایک سادہ FastAPI ایپلیکیشن سے شروع کریں:
+
+{* ../../docs_src/generate_clients/tutorial001_py310.py hl[7:9,12:13,16:17,21] *}
+
+غور کریں کہ *path operations* اپنے استعمال شدہ models کو request payload اور response payload کے لیے بیان کرتے ہیں، `Item` اور `ResponseMessage` models استعمال کرتے ہوئے۔
+
+### API Docs { #api-docs }
+
+اگر آپ `/docs` پر جائیں تو آپ دیکھیں گے کہ اس میں requests میں بھیجے جانے والے اور responses میں وصول ہونے والے ڈیٹا کے **schemas** موجود ہیں:
+
+
+
+آپ وہ schemas اس لیے دیکھ سکتے ہیں کیونکہ وہ ایپ میں models کے ساتھ بیان کیے گئے تھے۔
+
+وہ معلومات ایپ کے **OpenAPI schema** میں دستیاب ہیں، اور پھر API docs میں دکھائی جاتی ہیں۔
+
+OpenAPI میں شامل models کی وہی معلومات **client کوڈ بنانے** کے لیے استعمال ہو سکتی ہیں۔
+
+### Hey API { #hey-api }
+
+جب ہمارے پاس models والی FastAPI ایپ ہو تو ہم TypeScript client بنانے کے لیے Hey API استعمال کر سکتے ہیں۔ اس کا سب سے تیز طریقہ npx کے ذریعے ہے۔
+
+```sh
+npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
+```
+
+یہ `./src/client` میں TypeScript SDK بنائے گا۔
+
+آپ [`@hey-api/openapi-ts` انسٹال کرنے](https://heyapi.dev/openapi-ts/get-started) اور [بنائے گئے output](https://heyapi.dev/openapi-ts/output) کے بارے میں ان کی ویب سائٹ پر پڑھ سکتے ہیں۔
+
+### SDK استعمال کرنا { #using-the-sdk }
+
+اب آپ client کوڈ import اور استعمال کر سکتے ہیں۔ یہ کچھ اس طرح نظر آ سکتا ہے، غور کریں کہ آپ کو methods کے لیے autocompletion ملتا ہے:
+
+
+
+آپ کو بھیجے جانے والے payload کے لیے بھی autocompletion ملے گا:
+
+
+
+/// tip | مشورہ
+
+`name` اور `price` کے لیے autocompletion غور کریں، جو FastAPI ایپلیکیشن میں `Item` model میں بیان کیے گئے تھے۔
+
+///
+
+آپ کو بھیجے جانے والے ڈیٹا کے لیے inline errors بھی ملیں گے:
+
+
+
+response آبجیکٹ میں بھی autocompletion ہوگا:
+
+
+
+## Tags کے ساتھ FastAPI ایپ { #fastapi-app-with-tags }
+
+بہت سے معاملات میں، آپ کی FastAPI ایپ بڑی ہوگی، اور آپ شاید *path operations* کے مختلف گروپس الگ کرنے کے لیے tags استعمال کریں گے۔
+
+مثال کے طور پر، آپ کے پاس **items** کا سیکشن اور **users** کا الگ سیکشن ہو سکتا ہے، اور وہ tags سے الگ ہو سکتے ہیں:
+
+{* ../../docs_src/generate_clients/tutorial002_py310.py hl[21,26,34] *}
+
+### Tags کے ساتھ TypeScript Client بنائیں { #generate-a-typescript-client-with-tags }
+
+اگر آپ tags استعمال کرنے والی FastAPI ایپ کے لیے client بنائیں، تو یہ عام طور پر tags کی بنیاد پر client کوڈ کو الگ بھی کرے گا۔
+
+اس طریقے سے، آپ کو client کوڈ میں چیزیں درست ترتیب اور گروپنگ میں ملیں گی:
+
+
+
+اس صورت میں، آپ کے پاس ہیں:
+
+* `ItemsService`
+* `UsersService`
+
+### Client Method کے نام { #client-method-names }
+
+اس وقت، بنائے گئے method کے نام جیسے `createItemItemsPost` بہت صاف نہیں لگتے:
+
+```TypeScript
+ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
+```
+
+...اس کی وجہ یہ ہے کہ client generator ہر *path operation* کے لیے OpenAPI کا اندرونی **operation ID** استعمال کرتا ہے۔
+
+OpenAPI تقاضا کرتا ہے کہ ہر operation ID تمام *path operations* میں منفرد ہو، اس لیے FastAPI اس operation ID کو بنانے کے لیے **function کا نام**، **path**، اور **HTTP method/operation** استعمال کرتا ہے، کیونکہ اس طرح یہ یقینی بنا سکتا ہے کہ operation IDs منفرد ہیں۔
+
+لیکن میں آپ کو اگلے حصے میں دکھاؤں گا کہ اسے کیسے بہتر بنائیں۔
+
+## حسب ضرورت Operation IDs اور بہتر Method نام { #custom-operation-ids-and-better-method-names }
+
+آپ ان operation IDs کی **بنانے کے طریقے کو تبدیل** کر سکتے ہیں تاکہ وہ آسان ہوں اور clients میں **آسان method نام** ہوں۔
+
+اس صورت میں، آپ کو یقینی بنانا ہوگا کہ ہر operation ID کسی اور طریقے سے **منفرد** ہو۔
+
+مثال کے طور پر، آپ یقینی بنا سکتے ہیں کہ ہر *path operation* میں ایک tag ہو، اور پھر **tag** اور *path operation* کے **نام** (function نام) کی بنیاد پر operation ID بنائیں۔
+
+### حسب ضرورت Unique ID Function بنائیں { #custom-generate-unique-id-function }
+
+FastAPI ہر *path operation* کے لیے ایک **unique ID** استعمال کرتا ہے، جو **operation ID** کے لیے اور requests یا responses کے لیے کسی ضروری حسب ضرورت models کے ناموں کے لیے بھی استعمال ہوتا ہے۔
+
+آپ اس function کو حسب ضرورت بنا سکتے ہیں۔ یہ ایک `APIRoute` لیتا ہے اور string واپس کرتا ہے۔
+
+مثال کے طور پر، یہاں یہ پہلا tag (آپ کے پاس شاید صرف ایک tag ہوگا) اور *path operation* کا نام (function نام) استعمال کر رہا ہے۔
+
+پھر آپ اس حسب ضرورت function کو **FastAPI** کو `generate_unique_id_function` parameter کے طور پر پاس کر سکتے ہیں:
+
+{* ../../docs_src/generate_clients/tutorial003_py310.py hl[6:7,10] *}
+
+### حسب ضرورت Operation IDs کے ساتھ TypeScript Client بنائیں { #generate-a-typescript-client-with-custom-operation-ids }
+
+اب، اگر آپ دوبارہ client بنائیں تو آپ دیکھیں گے کہ اس میں بہتر method نام ہیں:
+
+
+
+جیسا کہ آپ دیکھ سکتے ہیں، method ناموں میں اب tag اور پھر function نام ہے، اب ان میں URL path اور HTTP operation کی معلومات شامل نہیں ہیں۔
+
+### Client Generator کے لیے OpenAPI Specification پری پروسیس کریں { #preprocess-the-openapi-specification-for-the-client-generator }
+
+بنائے گئے کوڈ میں ابھی بھی کچھ **دہرائی ہوئی معلومات** ہیں۔
+
+ہم پہلے ہی جانتے ہیں کہ یہ method **items** سے متعلق ہے کیونکہ وہ لفظ `ItemsService` (tag سے لیا گیا) میں ہے، لیکن method نام میں بھی tag نام prefix ہے۔
+
+ہم شاید اسے عام طور پر OpenAPI کے لیے رکھنا چاہیں گے، کیونکہ یہ یقینی بنائے گا کہ operation IDs **منفرد** ہیں۔
+
+لیکن بنائے گئے client کے لیے، ہم clients بنانے سے بالکل پہلے OpenAPI operation IDs **تبدیل** کر سکتے ہیں، تاکہ وہ method نام بہتر اور **صاف** ہوں۔
+
+ہم OpenAPI JSON کو `openapi.json` فائل میں ڈاؤن لوڈ کر سکتے ہیں اور پھر اس script سے **وہ prefix tag ہٹا** سکتے ہیں:
+
+{* ../../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 نام بنا سکتا ہے۔
+
+### پری پروسیس شدہ OpenAPI کے ساتھ TypeScript Client بنائیں { #generate-a-typescript-client-with-the-preprocessed-openapi }
+
+چونکہ آخری نتیجہ اب `openapi.json` فائل میں ہے، آپ کو اپنی input location اپ ڈیٹ کرنی ہوگی:
+
+```sh
+npx @hey-api/openapi-ts -i ./openapi.json -o src/client
+```
+
+نیا client بنانے کے بعد، آپ کے پاس اب **صاف method نام** ہوں گے، تمام **autocompletion**، **inline errors** وغیرہ کے ساتھ:
+
+
+
+## فوائد { #benefits }
+
+خود بخود بنائے گئے clients استعمال کرتے وقت آپ کو **autocompletion** ملے گا:
+
+* Methods کے لیے۔
+* Body میں Request payloads، query parameters وغیرہ کے لیے۔
+* Response payloads کے لیے۔
+
+آپ کو ہر چیز کے لیے **inline errors** بھی ملیں گے۔
+
+اور جب بھی آپ backend کوڈ اپ ڈیٹ کریں، اور frontend **دوبارہ بنائیں**، اس میں تمام نئی *path operations* methods کے طور پر دستیاب ہوں گی، پرانی ہٹ جائیں گی، اور کوئی بھی تبدیلی بنائے گئے کوڈ میں ظاہر ہوگی۔
+
+اس کا مطلب یہ بھی ہے کہ اگر کچھ بدلا تو یہ خود بخود client کوڈ میں **ظاہر** ہوگا۔ اور اگر آپ client **بلڈ** کریں تو اگر استعمال شدہ ڈیٹا میں کوئی **مماثلت نہ ہو** تو غلطی آئے گی۔
+
+تو، آپ ترقیاتی عمل میں بہت جلد **بہت سی غلطیاں پکڑ** لیں گے بجائے اس کے کہ غلطیاں پروڈکشن میں آپ کے آخری صارفین کو نظر آئیں اور پھر آپ مسئلے کی تشخیص کرنے کی کوشش کریں۔
diff --git a/docs/ur/docs/advanced/index.md b/docs/ur/docs/advanced/index.md
new file mode 100644
index 000000000..da83935d3
--- /dev/null
+++ b/docs/ur/docs/advanced/index.md
@@ -0,0 +1,21 @@
+# ایڈوانسڈ صارف گائیڈ { #advanced-user-guide }
+
+## اضافی خصوصیات { #additional-features }
+
+بنیادی [ٹیوٹوریل - صارف گائیڈ](../tutorial/index.md) آپ کو **FastAPI** کی تمام اہم خصوصیات کا مکمل جائزہ دینے کے لیے کافی ہونا چاہیے۔
+
+آنے والے حصوں میں آپ مزید اختیارات، ترتیبات اور اضافی خصوصیات دیکھیں گے۔
+
+/// tip | مشورہ
+
+آنے والے حصے **ضروری نہیں کہ "ایڈوانسڈ" ہوں**۔
+
+اور یہ ممکن ہے کہ آپ کے استعمال کے لیے حل انہیں میں سے کسی ایک میں ہو۔
+
+///
+
+## پہلے ٹیوٹوریل پڑھیں { #read-the-tutorial-first }
+
+آپ بنیادی [ٹیوٹوریل - صارف گائیڈ](../tutorial/index.md) کے علم سے **FastAPI** کی زیادہ تر خصوصیات استعمال کر سکتے ہیں۔
+
+اور آنے والے حصے فرض کرتے ہیں کہ آپ نے اسے پہلے ہی پڑھ لیا ہے، اور یہ فرض کرتے ہیں کہ آپ ان بنیادی تصورات سے واقف ہیں۔
diff --git a/docs/ur/docs/advanced/json-base64-bytes.md b/docs/ur/docs/advanced/json-base64-bytes.md
new file mode 100644
index 000000000..7ab76e174
--- /dev/null
+++ b/docs/ur/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# Base64 کے طور پر Bytes کے ساتھ JSON { #json-with-bytes-as-base64 }
+
+اگر آپ کی ایپ کو JSON ڈیٹا وصول اور بھیجنا ہے، لیکن اس میں binary ڈیٹا بھی شامل کرنا ہے، تو آپ اسے base64 کے طور پر encode کر سکتے ہیں۔
+
+## Base64 بمقابلہ فائلیں { #base64-vs-files }
+
+پہلے غور کریں کہ کیا آپ binary ڈیٹا اپ لوڈ کرنے کے لیے [Request Files](../tutorial/request-files.md) اور binary ڈیٹا بھیجنے کے لیے [Custom Response - FileResponse](./custom-response.md#fileresponse--fileresponse-) استعمال کر سکتے ہیں، JSON میں encode کرنے کی بجائے۔
+
+JSON صرف UTF-8 encoded strings رکھ سکتا ہے، اس لیے اس میں خام bytes نہیں ہو سکتے۔
+
+Base64 binary ڈیٹا کو strings میں encode کر سکتا ہے، لیکن ایسا کرنے کے لیے اسے اصل binary ڈیٹا سے زیادہ characters استعمال کرنے ہوتے ہیں، اس لیے یہ عام طور پر عام فائلوں سے کم موثر ہوتا ہے۔
+
+Base64 صرف اسی وقت استعمال کریں جب آپ کو یقینی طور پر JSON میں binary ڈیٹا شامل کرنا ہو، اور آپ اس کے لیے فائلیں استعمال نہیں کر سکتے۔
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+آپ `bytes` fields کے ساتھ Pydantic model بیان کر سکتے ہیں، اور پھر model config میں `val_json_bytes` استعمال کر کے بتا سکتے ہیں کہ input JSON ڈیٹا کو *validate* کرنے کے لیے base64 استعمال کرے، اس validation کے حصے کے طور پر یہ base64 string کو bytes میں decode کرے گا۔
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+اگر آپ `/docs` چیک کریں، تو وہ دکھائیں گے کہ `data` field base64 encoded bytes کی توقع رکھتا ہے:
+
+
+
diff --git a/docs/ur/docs/advanced/openapi-webhooks.md b/docs/ur/docs/advanced/openapi-webhooks.md
new file mode 100644
index 000000000..a09901fad
--- /dev/null
+++ b/docs/ur/docs/advanced/openapi-webhooks.md
@@ -0,0 +1,55 @@
+# OpenAPI Webhooks { #openapi-webhooks }
+
+ایسی صورتیں ہوتی ہیں جہاں آپ اپنے API **صارفین** کو بتانا چاہتے ہیں کہ آپ کی ایپ *ان کی* ایپ کو (request بھیج کر) کچھ ڈیٹا بھیج سکتی ہے، عام طور پر کسی قسم کے **واقعے** کی **اطلاع** دینے کے لیے۔
+
+اس کا مطلب ہے کہ عام عمل کی بجائے جہاں آپ کے صارفین آپ کے API کو requests بھیجتے ہیں، یہاں **آپ کا API** (یا آپ کی ایپ) **ان کے سسٹم** (ان کے API، ان کی ایپ) کو **requests بھیج** سکتا ہے۔
+
+اسے عام طور پر **webhook** کہتے ہیں۔
+
+## Webhooks کے مراحل { #webhooks-steps }
+
+عمل عام طور پر یہ ہوتا ہے کہ **آپ بیان کرتے ہیں** اپنے کوڈ میں کہ وہ پیغام کیا ہوگا جو آپ بھیجیں گے، request کی **body**۔
+
+آپ کسی طریقے سے یہ بھی بیان کرتے ہیں کہ آپ کی ایپ وہ requests یا events **کن لمحات** پر بھیجے گی۔
+
+اور **آپ کے صارفین** کسی طریقے سے (مثلاً کہیں ویب dashboard میں) وہ **URL** بیان کرتے ہیں جہاں آپ کی ایپ کو وہ requests بھیجنی چاہییں۔
+
+webhooks کے لیے URLs رجسٹر کرنے کی **منطق** اور requests بھیجنے کا اصل کوڈ آپ پر ہے۔ آپ اسے اپنے **کوڈ** میں جیسے چاہیں لکھتے ہیں۔
+
+## **FastAPI** اور OpenAPI کے ساتھ webhooks دستاویز کرنا { #documenting-webhooks-with-fastapi-and-openapi }
+
+**FastAPI** کے ساتھ، OpenAPI استعمال کرتے ہوئے، آپ ان webhooks کے نام، HTTP operations کی اقسام جو آپ کی ایپ بھیج سکتی ہے (مثلاً `POST`، `PUT` وغیرہ) اور request **bodies** جو آپ کی ایپ بھیجے گی، بیان کر سکتے ہیں۔
+
+اس سے آپ کے صارفین کے لیے آپ کی **webhook** requests وصول کرنے کے لیے **اپنے APIs بنانا** بہت آسان ہو سکتا ہے، وہ شاید اپنا API کوڈ خود بخود بنانے کے بھی قابل ہوں۔
+
+/// info | معلومات
+
+Webhooks OpenAPI 3.1.0 اور اس سے اوپر میں دستیاب ہیں، FastAPI `0.99.0` اور اس سے اوپر میں سپورٹ ہوتے ہیں۔
+
+///
+
+## Webhooks والی ایپ { #an-app-with-webhooks }
+
+جب آپ **FastAPI** ایپلیکیشن بناتے ہیں، تو ایک `webhooks` attribute ہوتا ہے جسے آپ *webhooks* بیان کرنے کے لیے استعمال کر سکتے ہیں، بالکل اسی طرح جیسے آپ *path operations* بیان کرتے ہیں، مثلاً `@app.webhooks.post()` کے ساتھ۔
+
+{* ../../docs_src/openapi_webhooks/tutorial001_py310.py hl[9:12,15:20] *}
+
+آپ جو webhooks بیان کریں گے وہ **OpenAPI** schema اور خودکار **docs UI** میں نظر آئیں گے۔
+
+/// info | معلومات
+
+`app.webhooks` آبجیکٹ دراصل ایک `APIRouter` ہے، وہی قسم جو آپ اپنی ایپ کو متعدد فائلوں سے ترتیب دیتے وقت استعمال کرتے ہیں۔
+
+///
+
+غور کریں کہ webhooks کے ساتھ آپ دراصل *path* (جیسے `/items/`) بیان نہیں کر رہے، وہاں جو ٹیکسٹ آپ پاس کرتے ہیں وہ صرف webhook کا **شناختی نام** (event کا نام) ہے، مثلاً `@app.webhooks.post("new-subscription")` میں، webhook کا نام `new-subscription` ہے۔
+
+اس کی وجہ یہ ہے کہ یہ توقع کی جاتی ہے کہ **آپ کے صارفین** اصل **URL path** کسی اور طریقے سے بیان کریں گے جہاں وہ webhook request وصول کرنا چاہتے ہیں (مثلاً ویب dashboard)۔
+
+### Docs چیک کریں { #check-the-docs }
+
+اب آپ اپنی ایپ شروع کر سکتے ہیں اور [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) پر جائیں۔
+
+آپ دیکھیں گے کہ آپ کے docs میں عام *path operations* اور کچھ **webhooks** بھی ہیں:
+
+
diff --git a/docs/ur/docs/advanced/path-operation-advanced-configuration.md b/docs/ur/docs/advanced/path-operation-advanced-configuration.md
new file mode 100644
index 000000000..d505acff8
--- /dev/null
+++ b/docs/ur/docs/advanced/path-operation-advanced-configuration.md
@@ -0,0 +1,172 @@
+# Path Operation ایڈوانسڈ ترتیب { #path-operation-advanced-configuration }
+
+## OpenAPI operationId { #openapi-operationid }
+
+/// warning | انتباہ
+
+اگر آپ OpenAPI میں "ماہر" نہیں ہیں، تو آپ کو شاید اس کی ضرورت نہ ہو۔
+
+///
+
+آپ اپنے *path operation* میں `operation_id` parameter استعمال کر کے OpenAPI `operationId` مقرر کر سکتے ہیں۔
+
+آپ کو یقینی بنانا ہوگا کہ یہ ہر operation کے لیے منفرد ہو۔
+
+{* ../../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` کے طور پر استعمال کرنا چاہتے ہیں، تو آپ ان سب پر iterate کر سکتے ہیں اور ہر *path operation* کے `operation_id` کو ان کے `APIRoute.name` سے تبدیل کر سکتے ہیں۔
+
+آپ کو یہ اپنے تمام *path operations* شامل کرنے کے بعد کرنا چاہیے۔
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py310.py hl[2, 12:21, 24] *}
+
+/// tip | مشورہ
+
+اگر آپ دستی طور پر `app.openapi()` کال کرتے ہیں، تو آپ کو اس سے پہلے `operationId` اپ ڈیٹ کرنے چاہئیں۔
+
+///
+
+/// warning | انتباہ
+
+اگر آپ ایسا کرتے ہیں، تو آپ کو یقینی بنانا ہوگا کہ آپ کے ہر *path operation function* کا نام منفرد ہو۔
+
+چاہے وہ مختلف modules (Python فائلوں) میں ہوں۔
+
+///
+
+## OpenAPI سے خارج کریں { #exclude-from-openapi }
+
+کسی *path operation* کو تیار شدہ OpenAPI schema سے (اور اس طرح خودکار دستاویزی نظاموں سے) خارج کرنے کے لیے، parameter `include_in_schema` استعمال کریں اور اسے `False` پر مقرر کریں:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py310.py hl[6] *}
+
+## docstring سے ایڈوانسڈ وضاحت { #advanced-description-from-docstring }
+
+آپ *path operation function* کے docstring سے OpenAPI کے لیے استعمال ہونے والی سطروں کو محدود کر سکتے ہیں۔
+
+`\f` (ایک escaped "form feed" حرف) شامل کرنے سے **FastAPI** اس مقام پر OpenAPI کے لیے استعمال ہونے والی آؤٹ پٹ کو تراش دے گا۔
+
+یہ دستاویزات میں نظر نہیں آئے گا، لیکن دوسرے ٹولز (جیسے Sphinx) باقی حصہ استعمال کر سکیں گے۔
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
+
+## اضافی Responses { #additional-responses }
+
+آپ نے شاید دیکھا ہوگا کہ *path operation* کے لیے `response_model` اور `status_code` کا اعلان کیسے کیا جاتا ہے۔
+
+یہ *path operation* کے بنیادی response کے بارے میں metadata بیان کرتا ہے۔
+
+آپ اضافی responses بھی اعلان کر سکتے ہیں ان کے models، status codes وغیرہ کے ساتھ۔
+
+دستاویزات میں اس بارے میں ایک مکمل باب ہے، آپ اسے [OpenAPI میں اضافی Responses](additional-responses.md) پر پڑھ سکتے ہیں۔
+
+## OpenAPI Extra { #openapi-extra }
+
+جب آپ اپنی ایپلیکیشن میں *path operation* کا اعلان کرتے ہیں، **FastAPI** خود بخود اس *path operation* کے بارے میں متعلقہ metadata تیار کرتا ہے تاکہ اسے OpenAPI schema میں شامل کیا جا سکے۔
+
+/// note | تکنیکی تفصیلات
+
+OpenAPI specification میں اسے [Operation Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object) کہا جاتا ہے۔
+
+///
+
+اس میں *path operation* کے بارے میں تمام معلومات ہوتی ہیں اور اسے خودکار دستاویزات تیار کرنے کے لیے استعمال کیا جاتا ہے۔
+
+اس میں `tags`، `parameters`، `requestBody`، `responses` وغیرہ شامل ہیں۔
+
+یہ *path operation* مخصوص OpenAPI schema عام طور پر **FastAPI** کی طرف سے خود بخود تیار ہوتا ہے، لیکن آپ اسے بڑھا بھی سکتے ہیں۔
+
+/// tip | مشورہ
+
+یہ ایک نچلی سطح کا extension point ہے۔
+
+اگر آپ کو صرف اضافی responses کا اعلان کرنا ہے، تو اس کا ایک زیادہ آسان طریقہ [OpenAPI میں اضافی Responses](additional-responses.md) ہے۔
+
+///
+
+آپ `openapi_extra` parameter استعمال کر کے *path operation* کے OpenAPI schema کو بڑھا سکتے ہیں۔
+
+### OpenAPI Extensions { #openapi-extensions }
+
+یہ `openapi_extra` مفید ہو سکتا ہے، مثال کے طور پر، [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) کا اعلان کرنے کے لیے:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial005_py310.py hl[6] *}
+
+اگر آپ خودکار API docs کھولتے ہیں، تو آپ کی extension مخصوص *path operation* کے نیچے ظاہر ہوگی۔
+
+
+
+اور اگر آپ نتیجے میں آنے والا OpenAPI دیکھتے ہیں (آپ کے API میں `/openapi.json` پر)، تو آپ اپنی extension مخصوص *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"
+ }
+ }
+ }
+}
+```
+
+### حسب ضرورت OpenAPI *path operation* schema { #custom-openapi-path-operation-schema }
+
+`openapi_extra` میں موجود dictionary کو *path operation* کے خود بخود تیار شدہ OpenAPI schema کے ساتھ گہرائی سے merge کیا جائے گا۔
+
+لہذا، آپ خود بخود تیار شدہ schema میں اضافی ڈیٹا شامل کر سکتے ہیں۔
+
+مثال کے طور پر، آپ فیصلہ کر سکتے ہیں کہ request کو اپنے کوڈ سے پڑھیں اور توثیق کریں، Pydantic کے ساتھ FastAPI کی خودکار خصوصیات استعمال کیے بغیر، لیکن آپ پھر بھی OpenAPI schema میں request کی تعریف کرنا چاہیں۔
+
+آپ یہ `openapi_extra` کے ساتھ کر سکتے ہیں:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py310.py hl[19:36, 39:40] *}
+
+اس مثال میں، ہم نے کوئی Pydantic model اعلان نہیں کیا۔ دراصل، request body کو JSON کے طور پر parse بھی نہیں کیا گیا، اسے براہ راست `bytes` کے طور پر پڑھا گیا ہے، اور function `magic_data_reader()` اسے کسی طرح parse کرنے کا ذمہ دار ہوگا۔
+
+بہرحال، ہم request body کے لیے متوقع schema کا اعلان کر سکتے ہیں۔
+
+### حسب ضرورت OpenAPI content type { #custom-openapi-content-type }
+
+اسی چال کا استعمال کرتے ہوئے، آپ Pydantic model استعمال کر کے JSON Schema بیان کر سکتے ہیں جو پھر *path operation* کے حسب ضرورت OpenAPI schema حصے میں شامل ہوتا ہے۔
+
+اور آپ یہ اس صورت میں بھی کر سکتے ہیں جب request میں ڈیٹا کی قسم JSON نہ ہو۔
+
+مثال کے طور پر، اس ایپلیکیشن میں ہم FastAPI کی مربوط فعالیت استعمال نہیں کرتے Pydantic models سے JSON Schema نکالنے یا JSON کے لیے خودکار توثیق کے لیے۔ دراصل، ہم request content type کو JSON کی بجائے YAML بیان کر رہے ہیں:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py310.py hl[15:20, 22] *}
+
+بہرحال، اگرچہ ہم پہلے سے طے شدہ مربوط فعالیت استعمال نہیں کر رہے، ہم پھر بھی Pydantic model استعمال کر رہے ہیں تاکہ دستی طور پر اس ڈیٹا کے لیے JSON Schema تیار کیا جا سکے جو ہم YAML میں وصول کرنا چاہتے ہیں۔
+
+پھر ہم request کو براہ راست استعمال کرتے ہیں، اور body کو `bytes` کے طور پر نکالتے ہیں۔ اس کا مطلب ہے کہ FastAPI request payload کو JSON کے طور پر parse کرنے کی کوشش بھی نہیں کرے گا۔
+
+اور پھر اپنے کوڈ میں، ہم اس YAML مواد کو براہ راست parse کرتے ہیں، اور پھر ہم دوبارہ وہی Pydantic model استعمال کر کے YAML مواد کی توثیق کرتے ہیں:
+
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py310.py hl[24:31] *}
+
+/// tip | مشورہ
+
+یہاں ہم وہی Pydantic model دوبارہ استعمال کر رہے ہیں۔
+
+لیکن اسی طرح، ہم اسے کسی اور طریقے سے بھی توثیق کر سکتے تھے۔
+
+///
diff --git a/docs/ur/docs/advanced/response-change-status-code.md b/docs/ur/docs/advanced/response-change-status-code.md
new file mode 100644
index 000000000..2388dcc44
--- /dev/null
+++ b/docs/ur/docs/advanced/response-change-status-code.md
@@ -0,0 +1,31 @@
+# Response - Status Code تبدیل کریں { #response-change-status-code }
+
+آپ نے شاید پہلے پڑھا ہوگا کہ آپ پہلے سے طے شدہ [Response Status Code](../tutorial/response-status-code.md) مقرر کر سکتے ہیں۔
+
+لیکن بعض صورتوں میں آپ کو پہلے سے طے شدہ status code سے مختلف status code واپس کرنے کی ضرورت ہوتی ہے۔
+
+## استعمال کی صورت { #use-case }
+
+مثال کے طور پر، تصور کریں کہ آپ پہلے سے طے شدہ طور پر HTTP status code "OK" `200` واپس کرنا چاہتے ہیں۔
+
+لیکن اگر ڈیٹا موجود نہیں تھا، تو آپ اسے بنانا چاہتے ہیں، اور HTTP status code "CREATED" `201` واپس کرنا چاہتے ہیں۔
+
+لیکن آپ پھر بھی `response_model` کے ساتھ واپس کیے گئے ڈیٹا کو فلٹر اور تبدیل کرنے کے قابل رہنا چاہتے ہیں۔
+
+ان صورتوں میں، آپ `Response` parameter استعمال کر سکتے ہیں۔
+
+## `Response` parameter استعمال کریں { #use-a-response-parameter }
+
+آپ اپنے *path operation function* میں `Response` قسم کا parameter اعلان کر سکتے ہیں (جیسا کہ آپ cookies اور headers کے لیے کر سکتے ہیں)۔
+
+اور پھر آپ اس *عارضی* response آبجیکٹ میں `status_code` مقرر کر سکتے ہیں۔
+
+{* ../../docs_src/response_change_status_code/tutorial001_py310.py hl[1,9,12] *}
+
+اور پھر آپ جیسے عام طور پر کرتے ہیں، کوئی بھی آبجیکٹ واپس کر سکتے ہیں (ایک `dict`، database model وغیرہ)۔
+
+اور اگر آپ نے `response_model` کا اعلان کیا ہے، تو اسے پھر بھی آپ کے واپس کردہ آبجیکٹ کو فلٹر اور تبدیل کرنے کے لیے استعمال کیا جائے گا۔
+
+**FastAPI** اس *عارضی* response کو status code (نیز cookies اور headers) نکالنے کے لیے استعمال کرے گا، اور انہیں حتمی response میں ڈالے گا جس میں آپ کی واپس کردہ قدر ہوگی، کسی بھی `response_model` سے فلٹر شدہ۔
+
+آپ dependencies میں بھی `Response` parameter کا اعلان کر سکتے ہیں، اور ان میں status code مقرر کر سکتے ہیں۔ لیکن ذہن میں رکھیں کہ آخری مقرر کیا گیا غالب آئے گا۔
diff --git a/docs/ur/docs/advanced/response-cookies.md b/docs/ur/docs/advanced/response-cookies.md
new file mode 100644
index 000000000..e5d6755cc
--- /dev/null
+++ b/docs/ur/docs/advanced/response-cookies.md
@@ -0,0 +1,51 @@
+# Response Cookies { #response-cookies }
+
+## `Response` parameter استعمال کریں { #use-a-response-parameter }
+
+آپ اپنے *path operation function* میں `Response` قسم کا parameter اعلان کر سکتے ہیں۔
+
+اور پھر آپ اس *عارضی* response آبجیکٹ میں cookies مقرر کر سکتے ہیں۔
+
+{* ../../docs_src/response_cookies/tutorial002_py310.py hl[1, 8:9] *}
+
+اور پھر آپ جیسے عام طور پر کرتے ہیں، کوئی بھی آبجیکٹ واپس کر سکتے ہیں (ایک `dict`، database model وغیرہ)۔
+
+اور اگر آپ نے `response_model` کا اعلان کیا ہے، تو اسے پھر بھی آپ کے واپس کردہ آبجیکٹ کو فلٹر اور تبدیل کرنے کے لیے استعمال کیا جائے گا۔
+
+**FastAPI** اس *عارضی* response کو cookies (نیز headers اور status code) نکالنے کے لیے استعمال کرے گا، اور انہیں حتمی response میں ڈالے گا جس میں آپ کی واپس کردہ قدر ہوگی، کسی بھی `response_model` سے فلٹر شدہ۔
+
+آپ dependencies میں بھی `Response` parameter کا اعلان کر سکتے ہیں، اور ان میں cookies (اور headers) مقرر کر سکتے ہیں۔
+
+## براہ راست `Response` واپس کریں { #return-a-response-directly }
+
+آپ اپنے کوڈ میں براہ راست `Response` واپس کرتے وقت بھی cookies بنا سکتے ہیں۔
+
+ایسا کرنے کے لیے، آپ [براہ راست Response واپس کریں](response-directly.md) میں بیان کردہ طریقے سے response بنا سکتے ہیں۔
+
+پھر اس میں Cookies مقرر کریں، اور پھر اسے واپس کریں:
+
+{* ../../docs_src/response_cookies/tutorial001_py310.py hl[10:12] *}
+
+/// tip | مشورہ
+
+ذہن میں رکھیں کہ اگر آپ `Response` parameter استعمال کرنے کی بجائے براہ راست response واپس کرتے ہیں، تو FastAPI اسے براہ راست واپس کرے گا۔
+
+لہذا، آپ کو یقینی بنانا ہوگا کہ آپ کا ڈیٹا صحیح قسم کا ہے۔ مثلاً اگر آپ `JSONResponse` واپس کر رہے ہیں تو یہ JSON کے موافق ہو۔
+
+اور یہ بھی کہ آپ ایسا کوئی ڈیٹا نہیں بھیج رہے جو `response_model` سے فلٹر ہونا چاہیے تھا۔
+
+///
+
+### مزید معلومات { #more-info }
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import Response` یا `from starlette.responses import JSONResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** وہی `starlette.responses` فراہم کرتا ہے جو `fastapi.responses` کے طور پر، بس آپ یعنی developer کی سہولت کے لیے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+اور چونکہ `Response` اکثر headers اور cookies مقرر کرنے کے لیے استعمال ہوتا ہے، **FastAPI** اسے `fastapi.Response` پر بھی فراہم کرتا ہے۔
+
+///
+
+تمام دستیاب parameters اور اختیارات دیکھنے کے لیے، [Starlette کی دستاویزات](https://www.starlette.dev/responses/#set-cookie) دیکھیں۔
diff --git a/docs/ur/docs/advanced/response-directly.md b/docs/ur/docs/advanced/response-directly.md
new file mode 100644
index 000000000..0dcd3fbe1
--- /dev/null
+++ b/docs/ur/docs/advanced/response-directly.md
@@ -0,0 +1,83 @@
+# براہ راست Response واپس کریں { #return-a-response-directly }
+
+جب آپ **FastAPI** *path operation* بناتے ہیں تو آپ عام طور پر اس سے کوئی بھی ڈیٹا واپس کر سکتے ہیں: ایک `dict`، ایک `list`، ایک Pydantic model، database model وغیرہ۔
+
+اگر آپ [Response Model](../tutorial/response-model.md) کا اعلان کرتے ہیں تو FastAPI اسے Pydantic استعمال کر کے ڈیٹا کو JSON میں serialize کرنے کے لیے استعمال کرے گا۔
+
+اگر آپ response model کا اعلان نہیں کرتے، تو FastAPI [JSON Compatible Encoder](../tutorial/encoder.md) میں بیان کردہ `jsonable_encoder` استعمال کرے گا اور اسے `JSONResponse` میں ڈالے گا۔
+
+آپ براہ راست `JSONResponse` بنا کر بھی واپس کر سکتے ہیں۔
+
+/// tip | مشورہ
+
+`JSONResponse` براہ راست واپس کرنے کی بجائے [Response Model](../tutorial/response-model.md) استعمال کرنے سے آپ کو عام طور پر بہت بہتر کارکردگی ملے گی، کیونکہ اس طرح یہ Pydantic کا استعمال کرتے ہوئے Rust میں ڈیٹا کو serialize کرتا ہے۔
+
+///
+
+## `Response` واپس کریں { #return-a-response }
+
+آپ `Response` یا اس کی کوئی بھی sub-class واپس کر سکتے ہیں۔
+
+/// info | معلومات
+
+`JSONResponse` خود `Response` کی ایک sub-class ہے۔
+
+///
+
+اور جب آپ `Response` واپس کرتے ہیں، **FastAPI** اسے براہ راست منتقل کرے گا۔
+
+یہ Pydantic models کے ساتھ کوئی ڈیٹا تبدیلی نہیں کرے گا، مواد کو کسی قسم میں تبدیل نہیں کرے گا وغیرہ۔
+
+یہ آپ کو بہت زیادہ **لچک** دیتا ہے۔ آپ کسی بھی ڈیٹا قسم کو واپس کر سکتے ہیں، کسی بھی ڈیٹا اعلان یا توثیق کو تبدیل کر سکتے ہیں وغیرہ۔
+
+یہ آپ کو بہت زیادہ **ذمہ داری** بھی دیتا ہے۔ آپ کو یقینی بنانا ہوگا کہ آپ جو ڈیٹا واپس کر رہے ہیں وہ درست ہے، صحیح فارمیٹ میں ہے، serialize ہو سکتا ہے وغیرہ۔
+
+## `Response` میں `jsonable_encoder` استعمال کرنا { #using-the-jsonable-encoder-in-a-response }
+
+چونکہ **FastAPI** آپ کے واپس کردہ `Response` میں کوئی تبدیلی نہیں کرتا، آپ کو یقینی بنانا ہوگا کہ اس کا مواد اس کے لیے تیار ہے۔
+
+مثال کے طور پر، آپ Pydantic model کو `JSONResponse` میں پہلے اسے `dict` میں تبدیل کیے بغیر نہیں ڈال سکتے، جس میں تمام ڈیٹا اقسام (جیسے `datetime`، `UUID` وغیرہ) JSON کے موافق اقسام میں تبدیل ہوں۔
+
+ان صورتوں میں، آپ `jsonable_encoder` استعمال کر سکتے ہیں اپنے ڈیٹا کو response میں دینے سے پہلے تبدیل کرنے کے لیے:
+
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import JSONResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** وہی `starlette.responses` فراہم کرتا ہے جو `fastapi.responses` کے طور پر، بس آپ یعنی developer کی سہولت کے لیے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+///
+
+## حسب ضرورت `Response` واپس کرنا { #returning-a-custom-response }
+
+اوپر کی مثال تمام ضروری حصے دکھاتی ہے، لیکن ابھی بہت مفید نہیں ہے، کیونکہ آپ صرف `item` براہ راست واپس کر سکتے تھے، اور **FastAPI** اسے آپ کے لیے `JSONResponse` میں ڈال دیتا، اسے `dict` میں تبدیل کر دیتا وغیرہ۔ یہ سب پہلے سے طے شدہ طور پر ہوتا ہے۔
+
+اب، آئیں دیکھتے ہیں کہ آپ اسے حسب ضرورت response واپس کرنے کے لیے کیسے استعمال کر سکتے ہیں۔
+
+فرض کریں کہ آپ [XML](https://en.wikipedia.org/wiki/XML) response واپس کرنا چاہتے ہیں۔
+
+آپ اپنا XML مواد ایک 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) کا اعلان کرتے ہیں، **FastAPI** اسے Pydantic استعمال کر کے ڈیٹا کو JSON میں serialize کرنے کے لیے استعمال کرے گا۔
+
+{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
+
+چونکہ یہ Rust کی طرف ہوگا، کارکردگی عام Python اور `JSONResponse` class سے بہت بہتر ہوگی۔
+
+`response_model` یا return type استعمال کرتے وقت، FastAPI ڈیٹا کو تبدیل کرنے کے لیے `jsonable_encoder` (جو سست ہوتا) اور نہ `JSONResponse` class استعمال کرے گا۔
+
+اس کی بجائے یہ response model (یا return type) استعمال کر کے Pydantic سے تیار شدہ JSON bytes لیتا ہے اور JSON کے لیے صحیح media type (`application/json`) کے ساتھ براہ راست `Response` واپس کرتا ہے۔
+
+## نوٹس { #notes }
+
+جب آپ براہ راست `Response` واپس کرتے ہیں تو اس کا ڈیٹا خود بخود توثیق، تبدیل (serialize) یا دستاویزی نہیں ہوتا۔
+
+لیکن آپ پھر بھی اسے دستاویزی شکل دے سکتے ہیں جیسا کہ [OpenAPI میں اضافی Responses](additional-responses.md) میں بیان کیا گیا ہے۔
+
+آنے والے حصوں میں آپ دیکھ سکتے ہیں کہ خودکار ڈیٹا تبدیلی، دستاویزات وغیرہ رکھتے ہوئے ان حسب ضرورت `Response` کو کیسے استعمال/اعلان کیا جائے۔
diff --git a/docs/ur/docs/advanced/response-headers.md b/docs/ur/docs/advanced/response-headers.md
new file mode 100644
index 000000000..24e0efc0c
--- /dev/null
+++ b/docs/ur/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 آبجیکٹ میں headers مقرر کر سکتے ہیں۔
+
+{* ../../docs_src/response_headers/tutorial002_py310.py hl[1, 7:8] *}
+
+اور پھر آپ جیسے عام طور پر کرتے ہیں، کوئی بھی آبجیکٹ واپس کر سکتے ہیں (ایک `dict`، database model وغیرہ)۔
+
+اور اگر آپ نے `response_model` کا اعلان کیا ہے، تو اسے پھر بھی آپ کے واپس کردہ آبجیکٹ کو فلٹر اور تبدیل کرنے کے لیے استعمال کیا جائے گا۔
+
+**FastAPI** اس *عارضی* response کو headers (نیز cookies اور status code) نکالنے کے لیے استعمال کرے گا، اور انہیں حتمی response میں ڈالے گا جس میں آپ کی واپس کردہ قدر ہوگی، کسی بھی `response_model` سے فلٹر شدہ۔
+
+آپ dependencies میں بھی `Response` parameter کا اعلان کر سکتے ہیں، اور ان میں headers (اور cookies) مقرر کر سکتے ہیں۔
+
+## براہ راست `Response` واپس کریں { #return-a-response-directly }
+
+آپ براہ راست `Response` واپس کرتے وقت بھی headers شامل کر سکتے ہیں۔
+
+[براہ راست Response واپس کریں](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** وہی `starlette.responses` فراہم کرتا ہے جو `fastapi.responses` کے طور پر، بس آپ یعنی developer کی سہولت کے لیے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+اور چونکہ `Response` اکثر headers اور cookies مقرر کرنے کے لیے استعمال ہوتا ہے، **FastAPI** اسے `fastapi.Response` پر بھی فراہم کرتا ہے۔
+
+///
+
+## حسب ضرورت Headers { #custom-headers }
+
+ذہن میں رکھیں کہ حسب ضرورت ملکیتی headers [`X-` سابقہ استعمال کر کے](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) شامل کیے جا سکتے ہیں۔
+
+لیکن اگر آپ کے پاس حسب ضرورت headers ہیں جو آپ چاہتے ہیں کہ براؤزر میں ایک client انہیں دیکھ سکے، تو آپ کو انہیں اپنی CORS ترتیبات میں شامل کرنا ہوگا ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md) میں مزید پڑھیں)، [Starlette کی CORS دستاویزات](https://www.starlette.dev/middleware/#corsmiddleware) میں بیان کردہ `expose_headers` parameter استعمال کرتے ہوئے۔
diff --git a/docs/ur/docs/advanced/security/http-basic-auth.md b/docs/ur/docs/advanced/security/http-basic-auth.md
new file mode 100644
index 000000000..611d7db5d
--- /dev/null
+++ b/docs/ur/docs/advanced/security/http-basic-auth.md
@@ -0,0 +1,107 @@
+# HTTP Basic Auth { #http-basic-auth }
+
+سب سے سادہ صورتوں کے لیے، آپ HTTP Basic Auth استعمال کر سکتے ہیں۔
+
+HTTP Basic Auth میں، ایپلیکیشن ایک ایسا header توقع کرتی ہے جس میں username اور password ہو۔
+
+اگر اسے یہ نہیں ملتا، تو یہ HTTP 401 "Unauthorized" error واپس کرتی ہے۔
+
+اور `WWW-Authenticate` header واپس کرتی ہے جس کی قدر `Basic` ہوتی ہے، اور ایک اختیاری `realm` parameter۔
+
+اس سے browser کو username اور password کے لیے پہلے سے موجود prompt دکھانے کا اشارہ ملتا ہے۔
+
+پھر جب آپ وہ username اور password ٹائپ کرتے ہیں، تو browser انہیں خودکار طور پر header میں بھیجتا ہے۔
+
+## سادہ HTTP Basic Auth { #simple-http-basic-auth }
+
+* `HTTPBasic` اور `HTTPBasicCredentials` import کریں۔
+* `HTTPBasic` استعمال کر کے ایک "`security` scheme" بنائیں۔
+* اس `security` کو اپنے *path operation* میں dependency کے ساتھ استعمال کریں۔
+* یہ `HTTPBasicCredentials` قسم کا ایک object واپس کرتا ہے:
+ * اس میں بھیجے گئے `username` اور `password` ہوتے ہیں۔
+
+{* ../../docs_src/security/tutorial006_an_py310.py hl[4,8,12] *}
+
+جب آپ پہلی بار URL کھولنے کی کوشش کریں گے (یا docs میں "Execute" بٹن پر کلک کریں گے) تو browser آپ سے username اور password پوچھے گا:
+
+
+
+## Username چیک کریں { #check-the-username }
+
+یہاں ایک زیادہ مکمل مثال ہے۔
+
+username اور password درست ہیں یا نہیں یہ چیک کرنے کے لیے dependency استعمال کریں۔
+
+اس کے لیے Python کا معیاری module [`secrets`](https://docs.python.org/3/library/secrets.html) استعمال کریں تاکہ username اور password چیک کیے جا سکیں۔
+
+`secrets.compare_digest()` کو `bytes` یا ایسی `str` لینی ہوتی ہے جس میں صرف ASCII حروف ہوں (انگریزی والے)، اس کا مطلب ہے کہ یہ `á` جیسے حروف کے ساتھ کام نہیں کرے گا، جیسے `Sebastián` میں۔
+
+اسے سنبھالنے کے لیے، ہم پہلے `username` اور `password` کو UTF-8 سے encode کر کے `bytes` میں تبدیل کرتے ہیں۔
+
+پھر ہم `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"):
+ # Return some error
+ ...
+```
+
+لیکن `secrets.compare_digest()` استعمال کرنے سے یہ "timing attacks" نامی حملوں سے محفوظ رہے گا۔
+
+### Timing Attacks { #timing-attacks }
+
+لیکن "timing attack" کیا ہے؟
+
+تصور کریں کہ کچھ حملہ آور username اور password کا اندازہ لگانے کی کوشش کر رہے ہیں۔
+
+اور وہ username `johndoe` اور password `love123` کے ساتھ ایک request بھیجتے ہیں۔
+
+پھر آپ کی ایپلیکیشن میں Python کوڈ کچھ اس طرح ہوگا:
+
+```Python
+if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
+ ...
+```
+
+لیکن جس لمحے Python `johndoe` کے پہلے `j` کا `stanleyjobson` کے پہلے `s` سے موازنہ کرتا ہے، یہ `False` واپس کر دے گا، کیونکہ اسے پہلے سے معلوم ہو جاتا ہے کہ یہ دونوں strings ایک جیسی نہیں ہیں، یہ سوچتے ہوئے کہ "باقی حروف کا موازنہ کرنے میں مزید وقت ضائع کرنے کی ضرورت نہیں"۔ اور آپ کی ایپلیکیشن کہے گی "غلط username یا password"۔
+
+لیکن پھر حملہ آور username `stanleyjobsox` اور password `love123` کے ساتھ کوشش کرتے ہیں۔
+
+اور آپ کی ایپلیکیشن کا کوڈ کچھ ایسا کرتا ہے:
+
+```Python
+if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
+ ...
+```
+
+Python کو `stanleyjobsox` اور `stanleyjobson` دونوں میں پورا `stanleyjobso` موازنہ کرنا ہوگا اس سے پہلے کہ اسے پتا چلے کہ دونوں strings ایک جیسی نہیں ہیں۔ تو "غلط username یا password" جواب دینے میں کچھ اضافی مائیکرو سیکنڈز لگیں گے۔
+
+#### جواب دینے کا وقت حملہ آوروں کی مدد کرتا ہے { #the-time-to-answer-helps-the-attackers }
+
+اس مقام پر، یہ دیکھ کر کہ server نے "غلط username یا password" جواب بھیجنے میں کچھ مائیکرو سیکنڈز زیادہ لگائے، حملہ آوروں کو معلوم ہو جائے گا کہ انہوں نے _کچھ_ درست کیا، ابتدائی حروف میں سے کچھ صحیح تھے۔
+
+اور پھر وہ دوبارہ کوشش کر سکتے ہیں یہ جانتے ہوئے کہ یہ شاید `johndoe` سے زیادہ `stanleyjobsox` سے ملتا جلتا ہے۔
+
+#### ایک "پیشہ ورانہ" حملہ { #a-professional-attack }
+
+یقیناً، حملہ آور یہ سب ہاتھ سے نہیں کریں گے، وہ ایک پروگرام لکھیں گے جو ممکنہ طور پر فی سیکنڈ ہزاروں یا لاکھوں ٹیسٹ کرے۔ اور وہ ایک وقت میں صرف ایک اضافی درست حرف حاصل کریں گے۔
+
+لیکن ایسا کرنے سے، کچھ منٹوں یا گھنٹوں میں حملہ آوروں نے ہماری ایپلیکیشن کی "مدد" سے، صرف جواب دینے کا وقت استعمال کر کے، صحیح username اور password کا اندازہ لگا لیا ہوگا۔
+
+#### `secrets.compare_digest()` سے ٹھیک کریں { #fix-it-with-secrets-compare-digest }
+
+لیکن ہمارے کوڈ میں ہم دراصل `secrets.compare_digest()` استعمال کر رہے ہیں۔
+
+مختصراً، `stanleyjobsox` کا `stanleyjobson` سے موازنہ کرنے میں اتنا ہی وقت لگے گا جتنا `johndoe` کا `stanleyjobson` سے موازنہ میں لگتا ہے۔ اور password کے لیے بھی ایسا ہی ہے۔
+
+اس طرح، اپنی ایپلیکیشن کے کوڈ میں `secrets.compare_digest()` استعمال کرنے سے، یہ security حملوں کی اس پوری قسم سے محفوظ رہے گا۔
+
+### Error واپس کریں { #return-the-error }
+
+credentials غلط ہونے کا پتا لگنے کے بعد، status code 401 کے ساتھ ایک `HTTPException` واپس کریں (وہی جو credentials فراہم نہ ہونے پر واپس آتا ہے) اور `WWW-Authenticate` header شامل کریں تاکہ browser دوبارہ login prompt دکھائے:
+
+{* ../../docs_src/security/tutorial007_an_py310.py hl[26:30] *}
diff --git a/docs/ur/docs/advanced/security/index.md b/docs/ur/docs/advanced/security/index.md
new file mode 100644
index 000000000..cd91742aa
--- /dev/null
+++ b/docs/ur/docs/advanced/security/index.md
@@ -0,0 +1,19 @@
+# ایڈوانسڈ Security { #advanced-security }
+
+## اضافی خصوصیات { #additional-features }
+
+[ٹیوٹوریل - صارف گائیڈ: Security](../../tutorial/security/index.md) میں شامل خصوصیات کے علاوہ security کو سنبھالنے کے لیے کچھ اضافی خصوصیات موجود ہیں۔
+
+/// tip | مشورہ
+
+اگلے حصے **ضروری نہیں کہ "ایڈوانسڈ" ہوں**۔
+
+اور یہ ممکن ہے کہ آپ کے استعمال کے لیے حل انہی میں سے کسی ایک میں ہو۔
+
+///
+
+## پہلے ٹیوٹوریل پڑھیں { #read-the-tutorial-first }
+
+اگلے حصے یہ فرض کرتے ہیں کہ آپ پہلے سے مرکزی [ٹیوٹوریل - صارف گائیڈ: Security](../../tutorial/security/index.md) پڑھ چکے ہیں۔
+
+یہ سب انہی تصورات پر مبنی ہیں، لیکن کچھ اضافی فعالیت فراہم کرتے ہیں۔
diff --git a/docs/ur/docs/advanced/security/oauth2-scopes.md b/docs/ur/docs/advanced/security/oauth2-scopes.md
new file mode 100644
index 000000000..b8e55860a
--- /dev/null
+++ b/docs/ur/docs/advanced/security/oauth2-scopes.md
@@ -0,0 +1,274 @@
+# OAuth2 scopes { #oauth2-scopes }
+
+آپ **FastAPI** کے ساتھ براہ راست OAuth2 scopes استعمال کر سکتے ہیں، یہ بغیر کسی رکاوٹ کے کام کرنے کے لیے مربوط ہیں۔
+
+یہ آپ کو OAuth2 معیار کے مطابق، آپ کی OpenAPI ایپلیکیشن (اور API docs) میں مربوط، ایک زیادہ باریک بینی سے اجازتوں کا نظام رکھنے کی سہولت دے گا۔
+
+OAuth2 with scopes وہ طریقہ کار ہے جو بہت سے بڑے authentication فراہم کنندگان استعمال کرتے ہیں، جیسے Facebook، Google، GitHub، Microsoft، X (Twitter) وغیرہ۔ وہ اسے صارفین اور ایپلیکیشنز کو مخصوص اجازتیں دینے کے لیے استعمال کرتے ہیں۔
+
+جب بھی آپ Facebook، Google، GitHub، Microsoft، X (Twitter) کے ساتھ "log in" کرتے ہیں، وہ ایپلیکیشن OAuth2 with scopes استعمال کر رہی ہوتی ہے۔
+
+اس حصے میں آپ دیکھیں گے کہ اپنی **FastAPI** ایپلیکیشن میں اسی OAuth2 with scopes کے ساتھ authentication اور authorization کیسے منظم کی جائے۔
+
+/// warning | انتباہ
+
+یہ ایک کم و بیش ایڈوانسڈ حصہ ہے۔ اگر آپ ابھی شروع کر رہے ہیں، تو آپ اسے چھوڑ سکتے ہیں۔
+
+آپ کو لازمی طور پر OAuth2 scopes کی ضرورت نہیں، اور آپ authentication اور authorization جیسے چاہیں سنبھال سکتے ہیں۔
+
+لیکن OAuth2 with scopes آپ کی API (OpenAPI کے ساتھ) اور آپ کے API docs میں اچھی طرح مربوط ہو سکتا ہے۔
+
+بہرحال، آپ ان scopes، یا کسی بھی دوسری security/authorization ضرورت کو، اپنے کوڈ میں جیسے چاہیں نافذ کرتے ہیں۔
+
+بہت سی صورتوں میں، OAuth2 with scopes ضرورت سے زیادہ ہو سکتا ہے۔
+
+لیکن اگر آپ جانتے ہیں کہ آپ کو اس کی ضرورت ہے، یا آپ متجسس ہیں، تو پڑھتے رہیں۔
+
+///
+
+## OAuth2 scopes اور OpenAPI { #oauth2-scopes-and-openapi }
+
+OAuth2 specification "scopes" کو خالی جگہوں سے الگ کیے گئے strings کی فہرست کے طور پر بیان کرتی ہے۔
+
+ہر ایک string کا مواد کسی بھی شکل میں ہو سکتا ہے، لیکن اس میں خالی جگہیں نہیں ہونی چاہئیں۔
+
+یہ scopes "اجازتوں" کی نمائندگی کرتے ہیں۔
+
+OpenAPI (مثلاً API docs) میں، آپ "security schemes" بیان کر سکتے ہیں۔
+
+جب ان میں سے کوئی security scheme OAuth2 استعمال کرے، تو آپ scopes بھی بیان اور استعمال کر سکتے ہیں۔
+
+ہر "scope" بس ایک string ہے (بغیر خالی جگہوں کے)۔
+
+یہ عام طور پر مخصوص security اجازتیں بیان کرنے کے لیے استعمال ہوتے ہیں، مثال کے طور پر:
+
+* `users:read` یا `users:write` عام مثالیں ہیں۔
+* `instagram_basic` Facebook / Instagram استعمال کرتا ہے۔
+* `https://www.googleapis.com/auth/drive` Google استعمال کرتا ہے۔
+
+/// info | معلومات
+
+OAuth2 میں "scope" صرف ایک string ہے جو ایک مخصوص مطلوبہ اجازت بیان کرتی ہے۔
+
+اس سے کوئی فرق نہیں پڑتا کہ اس میں `:` جیسے دوسرے حروف ہیں یا یہ URL ہے۔
+
+یہ تفصیلات عمل درآمد کے لحاظ سے مخصوص ہیں۔
+
+OAuth2 کے لیے یہ بس strings ہیں۔
+
+///
+
+## مجموعی نظارہ { #global-view }
+
+پہلے آئیے جلدی سے ان حصوں کو دیکھیں جو مرکزی **ٹیوٹوریل - صارف گائیڈ** کی [OAuth2 with Password (and hashing), Bearer with JWT tokens](../../tutorial/security/oauth2-jwt.md) مثالوں سے تبدیل ہوتے ہیں۔ اب OAuth2 scopes استعمال کرتے ہوئے:
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
+
+اب آئیے ان تبدیلیوں کا قدم بہ قدم جائزہ لیتے ہیں۔
+
+## OAuth2 Security scheme { #oauth2-security-scheme }
+
+پہلی تبدیلی یہ ہے کہ اب ہم OAuth2 security scheme کو دو دستیاب scopes، `me` اور `items` کے ساتھ بیان کر رہے ہیں۔
+
+`scopes` parameter ایک `dict` لیتا ہے جس میں ہر scope بطور key اور وضاحت بطور value ہوتی ہے:
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *}
+
+چونکہ ہم اب ان scopes کو بیان کر رہے ہیں، یہ API docs میں جب آپ log-in/authorize کریں گے تو دکھائی دیں گے۔
+
+اور آپ منتخب کر سکیں گے کہ آپ کون سے scopes تک رسائی دینا چاہتے ہیں: `me` اور `items`۔
+
+یہ وہی طریقہ کار ہے جو Facebook، Google، GitHub وغیرہ کے ساتھ login کرتے وقت اجازتیں دیتے وقت استعمال ہوتا ہے:
+
+
+
+## Scopes کے ساتھ JWT token { #jwt-token-with-scopes }
+
+اب token *path operation* میں تبدیلی کریں تاکہ درخواست کیے گئے scopes واپس کیے جائیں۔
+
+ہم ابھی بھی وہی `OAuth2PasswordRequestForm` استعمال کر رہے ہیں۔ اس میں `scopes` property شامل ہے جس میں `str` کی `list` ہوتی ہے، request میں موصول ہونے والے ہر scope کے ساتھ۔
+
+اور ہم scopes کو JWT token کے حصے کے طور پر واپس کرتے ہیں۔
+
+/// danger
+
+سادگی کے لیے، یہاں ہم موصول ہونے والے scopes کو براہ راست token میں شامل کر رہے ہیں۔
+
+لیکن آپ کی ایپلیکیشن میں، security کے لیے، آپ کو یقینی بنانا چاہیے کہ آپ صرف وہ scopes شامل کریں جو صارف واقعی رکھ سکتا ہے، یا جو آپ نے پہلے سے مقرر کیے ہیں۔
+
+///
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[157] *}
+
+## *path operations* اور dependencies میں scopes بیان کریں { #declare-scopes-in-path-operations-and-dependencies }
+
+اب ہم بیان کرتے ہیں کہ `/users/me/items/` کے *path operation* کو scope `items` درکار ہے۔
+
+اس کے لیے ہم `fastapi` سے `Security` import اور استعمال کرتے ہیں۔
+
+آپ `Security` استعمال کر کے dependencies بیان کر سکتے ہیں (بالکل `Depends` کی طرح)، لیکن `Security` ایک اضافی parameter `scopes` بھی لیتا ہے جس میں scopes (strings) کی فہرست ہوتی ہے۔
+
+اس صورت میں، ہم dependency function `get_current_active_user` کو `Security` میں دیتے ہیں (اسی طرح جیسے ہم `Depends` کے ساتھ کرتے)۔
+
+لیکن ہم scopes کی ایک `list` بھی دیتے ہیں، اس صورت میں صرف ایک scope: `items` (اس میں مزید بھی ہو سکتے ہیں)۔
+
+اور dependency function `get_current_active_user` بھی sub-dependencies بیان کر سکتا ہے، نہ صرف `Depends` کے ساتھ بلکہ `Security` کے ساتھ بھی۔ اپنا sub-dependency function (`get_current_user`) بیان کرتے ہوئے، اور مزید scope کی ضروریات۔
+
+اس صورت میں، اسے scope `me` درکار ہے (اسے ایک سے زیادہ scopes بھی درکار ہو سکتے ہیں)۔
+
+/// note | نوٹ
+
+آپ کو لازمی طور پر مختلف جگہوں پر مختلف scopes شامل کرنے کی ضرورت نہیں۔
+
+ہم یہاں یہ دکھانے کے لیے کر رہے ہیں کہ **FastAPI** مختلف سطحوں پر بیان کیے گئے scopes کو کیسے سنبھالتا ہے۔
+
+///
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}
+
+/// info | تکنیکی تفصیلات
+
+`Security` دراصل `Depends` کی ایک subclass ہے، اور اس میں صرف ایک اضافی parameter ہے جو ہم بعد میں دیکھیں گے۔
+
+لیکن `Depends` کی بجائے `Security` استعمال کرنے سے، **FastAPI** جان لے گا کہ وہ security scopes بیان کر سکتا ہے، انہیں اندرونی طور پر استعمال کر سکتا ہے، اور API کو OpenAPI کے ساتھ دستاویز بنا سکتا ہے۔
+
+لیکن جب آپ `fastapi` سے `Query`، `Path`، `Depends`، `Security` اور دیگر import کرتے ہیں، تو یہ دراصل ایسے functions ہیں جو خصوصی classes واپس کرتے ہیں۔
+
+///
+
+## `SecurityScopes` استعمال کریں { #use-securityscopes }
+
+اب dependency `get_current_user` کو اپ ڈیٹ کریں۔
+
+یہ وہی ہے جسے اوپر کی dependencies استعمال کرتی ہیں۔
+
+یہاں ہم وہی OAuth2 scheme استعمال کر رہے ہیں جو ہم نے پہلے بنایا تھا، اسے dependency کے طور پر بیان کرتے ہوئے: `oauth2_scheme`۔
+
+چونکہ اس dependency function کو خود کسی scope کی ضرورت نہیں، ہم `Depends` کو `oauth2_scheme` کے ساتھ استعمال کر سکتے ہیں، جب ہمیں security scopes بیان کرنے کی ضرورت نہ ہو تو `Security` استعمال کرنا ضروری نہیں۔
+
+ہم `fastapi.security` سے import کیا ہوا `SecurityScopes` قسم کا ایک خصوصی parameter بھی بیان کرتے ہیں۔
+
+یہ `SecurityScopes` class `Request` سے ملتی جلتی ہے (`Request` براہ راست request object حاصل کرنے کے لیے استعمال ہوتا تھا)۔
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *}
+
+## `scopes` استعمال کریں { #use-the-scopes }
+
+`security_scopes` parameter کی قسم `SecurityScopes` ہوگی۔
+
+اس میں `scopes` property ہوگی جس میں خود اور تمام dependencies جو اسے sub-dependency کے طور پر استعمال کرتی ہیں، کے درکار تمام scopes کی فہرست ہوگی۔ یعنی تمام "dependants"... یہ الجھا دینے والا لگ سکتا ہے، نیچے اسے دوبارہ سمجھایا گیا ہے۔
+
+`security_scopes` object (`SecurityScopes` class کا) ایک `scope_str` attribute بھی فراہم کرتا ہے جس میں ان scopes پر مشتمل ایک واحد string ہوتی ہے، خالی جگہوں سے الگ (ہم اسے استعمال کریں گے)۔
+
+ہم ایک `HTTPException` بناتے ہیں جسے ہم بعد میں کئی مقامات پر دوبارہ استعمال (`raise`) کر سکتے ہیں۔
+
+اس exception میں، ہم درکار scopes (اگر کوئی ہوں) خالی جگہوں سے الگ string کے طور پر (`scope_str` استعمال کرتے ہوئے) شامل کرتے ہیں۔ ہم scopes پر مشتمل وہ string `WWW-Authenticate` header میں ڈالتے ہیں (یہ specification کا حصہ ہے)۔
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *}
+
+## `username` اور ڈیٹا کی شکل کی تصدیق کریں { #verify-the-username-and-data-shape }
+
+ہم تصدیق کرتے ہیں کہ ہمیں `username` ملا ہے، اور scopes نکالتے ہیں۔
+
+اور پھر ہم اس ڈیٹا کی Pydantic model سے تصدیق کرتے ہیں (`ValidationError` exception پکڑتے ہوئے)، اور اگر JWT token پڑھنے یا Pydantic سے ڈیٹا کی تصدیق کرنے میں کوئی error آئے، تو ہم وہ `HTTPException` raise کرتے ہیں جو ہم نے پہلے بنایا تھا۔
+
+اس کے لیے، ہم Pydantic model `TokenData` کو ایک نئی property `scopes` کے ساتھ اپ ڈیٹ کرتے ہیں۔
+
+Pydantic سے ڈیٹا کی تصدیق کر کے ہم یقینی بنا سکتے ہیں کہ ہمارے پاس، مثال کے طور پر، scopes کے ساتھ بالکل `str` کی `list` ہے اور `username` کے ساتھ ایک `str`۔
+
+مثال کے طور پر، `dict` یا کچھ اور کی بجائے، کیونکہ یہ بعد میں کسی مقام پر ایپلیکیشن کو توڑ سکتا ہے، جو اسے security کا خطرہ بنا دے گا۔
+
+ہم یہ بھی تصدیق کرتے ہیں کہ اس username کا صارف موجود ہے، اور اگر نہیں، تو وہی exception raise کرتے ہیں جو ہم نے پہلے بنایا تھا۔
+
+{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:129] *}
+
+## `scopes` کی تصدیق کریں { #verify-the-scopes }
+
+اب ہم تصدیق کرتے ہیں کہ اس dependency اور تمام dependants (بشمول *path operations*) کے لیے درکار تمام scopes، موصول ہونے والے token میں فراہم کیے گئے 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 کا دوبارہ جائزہ لیتے ہیں۔
+
+چونکہ `get_current_active_user` dependency کی `get_current_user` پر sub-dependency ہے، اس لیے `get_current_active_user` میں بیان کیا گیا scope `"me"` `get_current_user` کو دیے گئے `security_scopes.scopes` میں درکار scopes کی فہرست میں شامل ہوگا۔
+
+*path operation* خود بھی ایک scope بیان کرتا ہے، `"items"`، تو یہ بھی `get_current_user` کو دیے گئے `security_scopes.scopes` کی فہرست میں ہوگا۔
+
+یہاں dependencies اور scopes کا درجہ بندی کا نظارہ ہے:
+
+* *path operation* `read_own_items` میں ہے:
+ * درکار scopes `["items"]` dependency کے ساتھ:
+ * `get_current_active_user`:
+ * dependency function `get_current_active_user` میں ہے:
+ * درکار scopes `["me"]` dependency کے ساتھ:
+ * `get_current_user`:
+ * dependency function `get_current_user` میں ہے:
+ * خود کوئی scopes درکار نہیں۔
+ * `oauth2_scheme` استعمال کرنے والی dependency۔
+ * `SecurityScopes` قسم کا `security_scopes` parameter:
+ * اس `security_scopes` parameter میں `scopes` property ہے جس میں اوپر بیان کیے گئے تمام scopes کی `list` ہے، تو:
+ * `security_scopes.scopes` *path operation* `read_own_items` کے لیے `["me", "items"]` ہوگا۔
+ * `security_scopes.scopes` *path operation* `read_users_me` کے لیے `["me"]` ہوگا، کیونکہ یہ dependency `get_current_active_user` میں بیان کیا گیا ہے۔
+ * `security_scopes.scopes` *path operation* `read_system_status` کے لیے `[]` (خالی) ہوگا، کیونکہ اس نے `scopes` کے ساتھ کوئی `Security` بیان نہیں کیا، اور اس کی dependency `get_current_user` بھی کوئی `scopes` بیان نہیں کرتی۔
+
+/// tip | مشورہ
+
+یہاں اہم اور "جادوئی" بات یہ ہے کہ `get_current_user` ہر *path operation* کے لیے چیک کرنے کے لیے scopes کی مختلف فہرست رکھے گا۔
+
+سب کا انحصار ہر *path operation* میں اور اس مخصوص *path operation* کے لیے dependency tree میں ہر dependency میں بیان کیے گئے `scopes` پر ہے۔
+
+///
+
+## `SecurityScopes` کے بارے میں مزید تفصیلات { #more-details-about-securityscopes }
+
+آپ `SecurityScopes` کسی بھی مقام پر، اور متعدد جگہوں پر استعمال کر سکتے ہیں، یہ ضروری نہیں کہ "root" dependency پر ہو۔
+
+اس میں ہمیشہ موجودہ `Security` dependencies اور **اس مخصوص** *path operation* اور **اس مخصوص** dependency tree کے تمام dependants میں بیان کیے گئے security scopes ہوں گے۔
+
+چونکہ `SecurityScopes` میں dependants کی طرف سے بیان کیے گئے تمام scopes ہوں گے، آپ اسے ایک مرکزی dependency function میں استعمال کر سکتے ہیں تاکہ تصدیق کی جا سکے کہ token میں درکار scopes موجود ہیں، اور پھر مختلف *path operations* میں مختلف scope کی ضروریات بیان کریں۔
+
+ہر *path operation* کے لیے آزادانہ طور پر چیک کیے جائیں گے۔
+
+## اسے چیک کریں { #check-it }
+
+اگر آپ API docs کھولیں، تو آپ authenticate کر سکتے ہیں اور بتا سکتے ہیں کہ آپ کون سے scopes authorize کرنا چاہتے ہیں۔
+
+
+
+اگر آپ کوئی scope منتخب نہیں کرتے، تو آپ "authenticated" ہوں گے، لیکن جب آپ `/users/me/` یا `/users/me/items/` تک رسائی حاصل کرنے کی کوشش کریں گے تو آپ کو ایک error ملے گا کہ آپ کے پاس کافی اجازتیں نہیں ہیں۔ آپ پھر بھی `/status/` تک رسائی حاصل کر سکیں گے۔
+
+اور اگر آپ scope `me` منتخب کرتے ہیں لیکن scope `items` نہیں، تو آپ `/users/me/` تک رسائی حاصل کر سکیں گے لیکن `/users/me/items/` تک نہیں۔
+
+یہ وہی ہوگا جو کسی تیسرے فریق کی ایپلیکیشن کے ساتھ ہوتا جو صارف کی طرف سے فراہم کیے گئے token کے ساتھ ان *path operations* میں سے کسی تک رسائی حاصل کرنے کی کوشش کرتی، اس پر منحصر کہ صارف نے ایپلیکیشن کو کتنی اجازتیں دیں۔
+
+## تیسرے فریق کی integrations کے بارے میں { #about-third-party-integrations }
+
+اس مثال میں ہم OAuth2 "password" flow استعمال کر رہے ہیں۔
+
+یہ اس وقت مناسب ہے جب ہم اپنی خود کی ایپلیکیشن میں login کر رہے ہوں، شاید اپنے خود کے frontend کے ساتھ۔
+
+کیونکہ ہم `username` اور `password` وصول کرنے پر اعتماد کر سکتے ہیں، کیونکہ ہم اسے کنٹرول کرتے ہیں۔
+
+لیکن اگر آپ ایسی OAuth2 ایپلیکیشن بنا رہے ہیں جس سے دوسرے جڑیں گے (یعنی اگر آپ Facebook، Google، GitHub وغیرہ کے مساوی authentication فراہم کنندہ بنا رہے ہیں) تو آپ کو دوسرے flows میں سے کوئی استعمال کرنا چاہیے۔
+
+سب سے عام implicit flow ہے۔
+
+سب سے محفوظ code flow ہے، لیکن اسے عمل میں لانا زیادہ پیچیدہ ہے کیونکہ اس میں مزید مراحل درکار ہیں۔ چونکہ یہ زیادہ پیچیدہ ہے، بہت سے فراہم کنندگان implicit flow تجویز کرتے ہیں۔
+
+/// note | نوٹ
+
+یہ عام ہے کہ ہر authentication فراہم کنندہ اپنے flows کو مختلف ناموں سے پکارتا ہے، تاکہ اسے اپنے برانڈ کا حصہ بنا سکے۔
+
+لیکن آخر میں، وہ وہی OAuth2 معیار نافذ کر رہے ہیں۔
+
+///
+
+**FastAPI** ان تمام OAuth2 authentication flows کے لیے `fastapi.security.oauth2` میں utilities شامل کرتا ہے۔
+
+## Decorator `dependencies` میں `Security` { #security-in-decorator-dependencies }
+
+جس طرح آپ decorator کے `dependencies` parameter میں `Depends` کی `list` بیان کر سکتے ہیں (جیسا کہ [Dependencies in path operation decorators](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md) میں سمجھایا گیا ہے)، اسی طرح آپ وہاں `scopes` کے ساتھ `Security` بھی استعمال کر سکتے ہیں۔
diff --git a/docs/ur/docs/advanced/settings.md b/docs/ur/docs/advanced/settings.md
new file mode 100644
index 000000000..72e472def
--- /dev/null
+++ b/docs/ur/docs/advanced/settings.md
@@ -0,0 +1,302 @@
+# Settings اور Environment Variables { #settings-and-environment-variables }
+
+بہت سے معاملات میں آپ کی ایپلیکیشن کو کچھ بیرونی settings یا configurations کی ضرورت ہو سکتی ہے، مثال کے طور پر خفیہ کلیدیں، database credentials، ای میل سروسز کے credentials وغیرہ۔
+
+ان میں سے زیادہ تر settings متغیر ہیں (تبدیل ہو سکتی ہیں)، جیسے database URLs۔ اور بہت سی حساس ہو سکتی ہیں، جیسے خفیہ معلومات۔
+
+اسی لیے انہیں environment variables میں فراہم کرنا عام ہے جنہیں ایپلیکیشن پڑھتی ہے۔
+
+/// tip | مشورہ
+
+Environment variables کو سمجھنے کے لیے آپ [Environment Variables](../environment-variables.md) پڑھ سکتے ہیں۔
+
+///
+
+## اقسام اور validation { #types-and-validation }
+
+یہ environment variables صرف text strings ہینڈل کر سکتے ہیں، کیونکہ یہ Python سے باہر ہیں اور دوسرے پروگراموں اور باقی سسٹم (اور مختلف آپریٹنگ سسٹمز، جیسے Linux، Windows، macOS) کے ساتھ مطابقت رکھنی ہوتی ہے۔
+
+اس کا مطلب ہے کہ Python میں environment variable سے پڑھی گئی ہر قدر `str` ہوگی، اور کسی مختلف قسم میں تبدیلی یا کوئی validation کوڈ میں کرنی ہوگی۔
+
+## Pydantic `Settings` { #pydantic-settings }
+
+خوش قسمتی سے، Pydantic environment variables سے آنے والی ان settings کو ہینڈل کرنے کے لیے ایک بہترین utility فراہم کرتا ہے [Pydantic: Settings management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) کے ساتھ۔
+
+### `pydantic-settings` انسٹال کریں { #install-pydantic-settings }
+
+سب سے پہلے، یقینی بنائیں کہ آپ اپنا [virtual environment](../virtual-environments.md) بنائیں، اسے فعال کریں، اور پھر `pydantic-settings` پیکیج انسٹال کریں:
+
+
+
+اور پھر، sub-application کی docs [http://127.0.0.1:8000/subapi/docs](http://127.0.0.1:8000/subapi/docs) پر کھولیں۔
+
+آپ sub-application کی خودکار API docs دیکھیں گے، جس میں صرف اس کی اپنی _path operations_ شامل ہوں گی، سب درست sub-path prefix `/subapi` کے نیچے:
+
+
+
+اگر آپ دونوں user interfaces میں سے کسی کے ساتھ بات چیت کرنے کی کوشش کریں، تو وہ درست طریقے سے کام کریں گے، کیونکہ browser ہر مخصوص ایپ یا sub-app سے بات کر سکے گا۔
+
+### تکنیکی تفصیلات: `root_path` { #technical-details-root-path }
+
+جب آپ اوپر بیان کردہ طریقے سے sub-application mount کرتے ہیں، FastAPI ASGI specification کے ایک مکینزم جسے `root_path` کہتے ہیں، استعمال کرکے sub-application کے mount path کو منتقل کرنے کا خیال رکھتا ہے۔
+
+اس طریقے سے، sub-application کو docs UI کے لیے اس path prefix کو استعمال کرنے کا علم ہوگا۔
+
+اور sub-application کی اپنی بھی mount شدہ sub-applications ہو سکتی ہیں اور سب کچھ درست طریقے سے کام کرے گا، کیونکہ FastAPI ان تمام `root_path`s کو خود بخود ہینڈل کرتا ہے۔
+
+آپ `root_path` اور اسے واضح طور پر استعمال کرنے کے بارے میں مزید [Proxy کے پیچھے](behind-a-proxy.md) سیکشن میں جانیں گے۔
diff --git a/docs/ur/docs/advanced/templates.md b/docs/ur/docs/advanced/templates.md
new file mode 100644
index 000000000..d0fba521c
--- /dev/null
+++ b/docs/ur/docs/advanced/templates.md
@@ -0,0 +1,126 @@
+# Templates { #templates }
+
+آپ **FastAPI** کے ساتھ کوئی بھی template engine استعمال کر سکتے ہیں۔
+
+ایک عام انتخاب Jinja2 ہے، وہی جو Flask اور دیگر ٹولز میں استعمال ہوتا ہے۔
+
+اسے آسانی سے ترتیب دینے کے لیے utilities موجود ہیں جو آپ اپنی **FastAPI** ایپلیکیشن میں براہ راست استعمال کر سکتے ہیں (Starlette کی فراہم کردہ)۔
+
+## Dependencies انسٹال کریں { #install-dependencies }
+
+یقینی بنائیں کہ آپ [virtual environment](../virtual-environments.md) بنائیں، اسے فعال کریں، اور `jinja2` انسٹال کریں:
+
+
+
+آپ input باکس میں پیغامات ٹائپ کر کے بھیج سکتے ہیں:
+
+
+
+اور آپ کی WebSockets والی **FastAPI** ایپلیکیشن واپس جواب دے گی:
+
+
+
+آپ بہت سے پیغامات بھیج (اور وصول کر) سکتے ہیں:
+
+
+
+اور یہ سب ایک ہی 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] *}
+
+/// info | معلومات
+
+چونکہ یہ WebSocket ہے تو `HTTPException` raise کرنا واقعی مناسب نہیں ہے، اس کی بجائے ہم `WebSocketException` raise کرتے ہیں۔
+
+آپ [specification میں بیان کردہ درست codes](https://tools.ietf.org/html/rfc6455#section-7.4.1) سے closing code استعمال کر سکتے ہیں۔
+
+///
+
+### Dependencies کے ساتھ WebSockets آزمائیں { #try-the-websockets-with-dependencies }
+
+اپنی ایپلیکیشن چلائیں:
+
+
+
+## منقطع ہونے اور متعدد clients کو سنبھالنا { #handling-disconnections-and-multiple-clients }
+
+جب WebSocket connection بند ہوتا ہے تو `await websocket.receive_text()` ایک `WebSocketDisconnect` exception raise کرتا ہے، جسے آپ اس مثال کی طرح پکڑ کر ہینڈل کر سکتے ہیں۔
+
+{* ../../docs_src/websockets_/tutorial003_py310.py hl[79:81] *}
+
+آزمانے کے لیے:
+
+* ایپ کو کئی browser tabs میں کھولیں۔
+* ان سے پیغامات لکھیں۔
+* پھر ان میں سے ایک tab بند کریں۔
+
+اس سے `WebSocketDisconnect` exception raise ہوگا، اور باقی تمام clients کو اس طرح کا پیغام ملے گا:
+
+```
+Client #1596980209979 left the chat
+```
+
+/// tip | مشورہ
+
+اوپر والی ایپ ایک کم سے کم اور سادہ مثال ہے جو یہ ظاہر کرتی ہے کہ کئی WebSocket connections پر پیغامات کیسے ہینڈل اور broadcast کیے جائیں۔
+
+لیکن یاد رکھیں کہ، چونکہ سب کچھ memory میں ایک واحد فہرست میں ہینڈل ہو رہا ہے، یہ صرف اس وقت تک کام کرے گا جب تک process چل رہا ہے، اور صرف ایک واحد process کے ساتھ کام کرے گا۔
+
+اگر آپ کو کچھ ایسا چاہیے جو FastAPI کے ساتھ آسانی سے integrate ہو لیکن زیادہ مضبوط ہو، Redis، PostgreSQL یا دیگر کی سپورٹ رکھتا ہو، تو [encode/broadcaster](https://github.com/encode/broadcaster) دیکھیں۔
+
+///
+
+## مزید معلومات { #more-info }
+
+آپشنز کے بارے میں مزید جاننے کے لیے، Starlette کی دستاویزات دیکھیں:
+
+* [`WebSocket` class](https://www.starlette.dev/websockets/)
+* [Class پر مبنی WebSocket ہینڈلنگ](https://www.starlette.dev/endpoints/#websocketendpoint)
diff --git a/docs/ur/docs/advanced/wsgi.md b/docs/ur/docs/advanced/wsgi.md
new file mode 100644
index 000000000..6ab49f47f
--- /dev/null
+++ b/docs/ur/docs/advanced/wsgi.md
@@ -0,0 +1,51 @@
+# WSGI شامل کرنا - Flask, Django, اور دیگر { #including-wsgi-flask-django-others }
+
+آپ WSGI ایپلیکیشنز کو mount کر سکتے ہیں جیسا کہ آپ نے [Sub Applications - Mounts](sub-applications.md) اور [Proxy کے پیچھے](behind-a-proxy.md) میں دیکھا۔
+
+اس کے لیے، آپ `WSGIMiddleware` استعمال کر سکتے ہیں اور اسے اپنی WSGI ایپلیکیشن، مثلاً Flask، Django وغیرہ کو wrap کرنے کے لیے استعمال کر سکتے ہیں۔
+
+## `WSGIMiddleware` استعمال کرنا { #using-wsgimiddleware }
+
+/// info | معلومات
+
+اس کے لیے `a2wsgi` انسٹال کرنا ضروری ہے، مثال کے طور پر `pip install a2wsgi` سے۔
+
+///
+
+آپ کو `a2wsgi` سے `WSGIMiddleware` import کرنا ہوگا۔
+
+پھر WSGI (مثلاً Flask) ایپ کو middleware کے ساتھ wrap کریں۔
+
+اور پھر اسے ایک path کے نیچے mount کریں۔
+
+{* ../../docs_src/wsgi/tutorial001_py310.py hl[1,3,23] *}
+
+/// note | نوٹ
+
+پہلے، `fastapi.middleware.wsgi` سے `WSGIMiddleware` استعمال کرنے کی سفارش کی جاتی تھی، لیکن اب یہ deprecated ہے۔
+
+اس کی بجائے `a2wsgi` پیکیج استعمال کرنے کی تجویز دی جاتی ہے۔ استعمال کا طریقہ وہی رہتا ہے۔
+
+بس یقینی بنائیں کہ `a2wsgi` پیکیج انسٹال ہے اور `WSGIMiddleware` کو `a2wsgi` سے درست طریقے سے import کریں۔
+
+///
+
+## چیک کریں { #check-it }
+
+اب، `/v1/` path کے نیچے ہر request Flask ایپلیکیشن کے ذریعے ہینڈل ہوگی۔
+
+اور باقی **FastAPI** کے ذریعے ہینڈل ہوں گی۔
+
+اگر آپ اسے چلائیں اور [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/ur/docs/alternatives.md b/docs/ur/docs/alternatives.md
new file mode 100644
index 000000000..9af47c362
--- /dev/null
+++ b/docs/ur/docs/alternatives.md
@@ -0,0 +1,485 @@
+# متبادل، تحریک اور موازنے { #alternatives-inspiration-and-comparisons }
+
+**FastAPI** کو کس چیز نے تحریک دی، یہ متبادل سے کیسے موازنہ کرتا ہے اور اس نے ان سے کیا سیکھا۔
+
+## تعارف { #intro }
+
+**FastAPI** موجود نہ ہوتا اگر دوسروں کا پچھلا کام نہ ہوتا۔
+
+پہلے بہت سے tools بنائے گئے ہیں جنہوں نے اس کی تخلیق کی تحریک دی۔
+
+میں کئی سالوں سے نیا framework بنانے سے گریز کرتا رہا۔ پہلے میں نے **FastAPI** کی تمام features کو بہت سے مختلف frameworks، plug-ins، اور tools استعمال کرکے حل کرنے کی کوشش کی۔
+
+لیکن کسی وقت، کوئی اور راستہ نہیں تھا سوائے اس کے کہ کچھ ایسا بنایا جائے جو یہ تمام features فراہم کرے، پچھلے tools سے بہترین آئیڈیاز لے کر، اور انہیں بہترین ممکنہ طریقے سے ملا کر، زبان کی ان features کو استعمال کرتے ہوئے جو پہلے دستیاب نہیں تھیں (Python 3.6+ type hints)۔
+
+## پچھلے tools { #previous-tools }
+
+### [Django](https://www.djangoproject.com/) { #django }
+
+یہ سب سے مقبول Python framework ہے اور وسیع پیمانے پر قابل اعتماد ہے۔ اسے Instagram جیسے systems بنانے کے لیے استعمال کیا جاتا ہے۔
+
+یہ relational databases (جیسے MySQL یا PostgreSQL) کے ساتھ نسبتاً مضبوطی سے جڑا ہوا ہے، تو NoSQL database (جیسے Couchbase، MongoDB، Cassandra وغیرہ) کو بنیادی storage engine کے طور پر رکھنا بہت آسان نہیں ہے۔
+
+یہ backend میں HTML بنانے کے لیے بنایا گیا تھا، نہ کہ جدید frontend (جیسے React، Vue.js اور Angular) یا دوسرے systems (جیسے IoT devices) کے ذریعے استعمال ہونے والی APIs بنانے کے لیے۔
+
+### [Django REST Framework](https://www.django-rest-framework.org/) { #django-rest-framework }
+
+Django REST framework اس لیے بنایا گیا تاکہ Django کے نیچے استعمال کرتے ہوئے Web APIs بنانے کا ایک لچکدار toolkit فراہم کیا جائے، تاکہ اس کی API صلاحیتوں کو بہتر بنایا جا سکے۔
+
+اسے Mozilla، Red Hat اور Eventbrite سمیت بہت سی کمپنیاں استعمال کرتی ہیں۔
+
+یہ **خودکار API documentation** کی پہلی مثالوں میں سے ایک تھا، اور یہ خاص طور پر ان پہلے آئیڈیاز میں سے ایک تھا جنہوں نے **FastAPI** کی "تلاش" کی تحریک دی۔
+
+/// note | نوٹ
+
+Django REST Framework Tom Christie نے بنایا تھا۔ Starlette اور Uvicorn کے وہی بانی، جن پر **FastAPI** مبنی ہے۔
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+خودکار API documentation web user interface رکھنے کی۔
+
+///
+
+### [Flask](https://flask.palletsprojects.com) { #flask }
+
+Flask ایک "microframework" ہے، اس میں database integrations یا وہ بہت سی چیزیں شامل نہیں ہیں جو Django میں بطور default آتی ہیں۔
+
+اس سادگی اور لچک کی وجہ سے NoSQL databases کو بنیادی data storage system کے طور پر استعمال کرنا ممکن ہوتا ہے۔
+
+چونکہ یہ بہت سادہ ہے، سیکھنا نسبتاً بدیہی ہے، حالانکہ documentation کچھ مقامات پر تکنیکی ہو جاتی ہے۔
+
+اسے عام طور پر ان applications کے لیے بھی استعمال کیا جاتا ہے جن کو ضروری نہیں کہ database، user management، یا Django میں پہلے سے بنی بہت سی features کی ضرورت ہو۔ حالانکہ ان میں سے بہت سی features plug-ins کے ساتھ شامل کی جا سکتی ہیں۔
+
+حصوں کی یہ علیحدگی، اور ایک "microframework" ہونا جسے بالکل ضرورت کے مطابق بڑھایا جا سکے، ایک اہم خصوصیت تھی جسے میں برقرار رکھنا چاہتا تھا۔
+
+Flask کی سادگی کو دیکھتے ہوئے، یہ APIs بنانے کے لیے اچھا انتخاب لگا۔ اگلی چیز Flask کے لیے ایک "Django REST Framework" تلاش کرنا تھی۔
+
+/// check | **FastAPI** کو تحریک دی
+
+ایک micro-framework ہونے کی۔ ضرورت کے مطابق tools اور حصوں کو ملانا آسان بنانے کی۔
+
+سادہ اور استعمال میں آسان routing system رکھنے کی۔
+
+///
+
+### [Requests](https://requests.readthedocs.io) { #requests }
+
+**FastAPI** دراصل **Requests** کا متبادل نہیں ہے۔ ان کا دائرہ کار بہت مختلف ہے۔
+
+درحقیقت FastAPI application کے *اندر* Requests استعمال کرنا عام ہوگا۔
+
+لیکن پھر بھی، FastAPI نے Requests سے کافی تحریک لی۔
+
+**Requests** APIs کے ساتھ *تعامل* کرنے (بطور client) کی library ہے، جبکہ **FastAPI** APIs *بنانے* (بطور server) کی library ہے۔
+
+وہ کم و بیش مخالف سروں پر ہیں، ایک دوسرے کی تکمیل کرتے ہیں۔
+
+Requests کا بہت سادہ اور بدیہی ڈیزائن ہے، یہ استعمال میں بہت آسان ہے، معقول defaults کے ساتھ۔ لیکن ساتھ ہی، یہ بہت طاقتور اور حسب ضرورت بنانے کے قابل ہے۔
+
+اسی لیے، جیسا کہ سرکاری ویب سائٹ پر کہا گیا ہے:
+
+> Requests ہر وقت کے سب سے زیادہ download کیے جانے والے Python packages میں سے ایک ہے
+
+اسے استعمال کرنے کا طریقہ بہت سادہ ہے۔ مثال کے طور پر، `GET` request کرنے کے لیے، آپ یہ لکھیں گے:
+
+```Python
+response = requests.get("http://example.com/some/url")
+```
+
+FastAPI کا مساوی API *path operation* اس طرح نظر آ سکتا ہے:
+
+```Python hl_lines="1"
+@app.get("/some/url")
+def read_url():
+ return {"message": "Hello World"}
+```
+
+`requests.get(...)` اور `@app.get(...)` میں مماثلت دیکھیں۔
+
+/// check | **FastAPI** کو تحریک دی
+
+* سادہ اور بدیہی API رکھنے کی۔
+* HTTP method names (operations) کو براہ راست، سیدھے اور بدیہی طریقے سے استعمال کرنے کی۔
+* معقول defaults رکھنے کی، لیکن طاقتور customizations کے ساتھ۔
+
+///
+
+### [Swagger](https://swagger.io/) / [OpenAPI](https://github.com/OAI/OpenAPI-Specification/) { #swagger-openapi }
+
+Django REST Framework سے مجھے جو بنیادی feature چاہیے تھا وہ خودکار API documentation تھا۔
+
+پھر مجھے پتا چلا کہ JSON (یا YAML، JSON کی ایک extension) استعمال کرکے APIs کو document کرنے کا ایک standard ہے جسے Swagger کہتے ہیں۔
+
+اور Swagger APIs کے لیے ایک web user interface پہلے سے بنایا گیا تھا۔ تو، کسی API کے لیے Swagger documentation بنا سکنے سے اس web user interface کو خودکار طور پر استعمال کرنا ممکن ہو جائے گا۔
+
+کسی وقت، Swagger کو Linux Foundation کو دے دیا گیا، اور اس کا نام OpenAPI رکھا گیا۔
+
+اسی لیے ورژن 2.0 کے بارے میں بات کرتے وقت عام طور پر "Swagger" کہا جاتا ہے، اور ورژن 3+ کے لیے "OpenAPI"۔
+
+/// check | **FastAPI** کو تحریک دی
+
+API specifications کے لیے ایک کھلا standard اپنانے اور استعمال کرنے کی، حسب ضرورت schema کی بجائے۔
+
+اور standards پر مبنی user interface tools کو مربوط کرنے کی:
+
+* [Swagger UI](https://github.com/swagger-api/swagger-ui)
+* [ReDoc](https://github.com/Rebilly/ReDoc)
+
+یہ دونوں کافی مقبول اور مستحکم ہونے کی وجہ سے منتخب کیے گئے، لیکن تیز تلاش سے آپ OpenAPI کے لیے درجنوں متبادل user interfaces تلاش کر سکتے ہیں (جنہیں آپ **FastAPI** کے ساتھ استعمال کر سکتے ہیں)۔
+
+///
+
+### Flask REST frameworks { #flask-rest-frameworks }
+
+کئی Flask REST frameworks ہیں، لیکن ان کی تحقیق میں وقت اور محنت لگانے کے بعد، میں نے پایا کہ بہت سے بند یا ترک کر دیے گئے ہیں، کئی کھڑے مسائل کے ساتھ جو انہیں ناموزوں بناتے ہیں۔
+
+### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }
+
+API systems کی ایک بنیادی ضرورت data "serialization" ہے جو code (Python) سے data لے کر اسے network پر بھیجی جا سکنے والی چیز میں تبدیل کرتی ہے۔ مثلاً، database سے data رکھنے والے object کو JSON object میں تبدیل کرنا۔ `datetime` objects کو strings میں تبدیل کرنا، وغیرہ۔
+
+APIs کی ایک اور بڑی ضرورت data validation ہے، یہ یقینی بنانا کہ data درست ہے مخصوص parameters کے مطابق۔ مثلاً، کوئی field `int` ہے نہ کہ کوئی random string۔ یہ آنے والے data کے لیے خاص طور پر مفید ہے۔
+
+Data validation system کے بغیر، آپ کو code میں تمام checks خود کرنے ہوں گے۔
+
+یہی features ہیں جو Marshmallow فراہم کرنے کے لیے بنایا گیا تھا۔ یہ ایک بہترین library ہے، اور میں نے اسے پہلے بہت استعمال کیا ہے۔
+
+لیکن یہ Python type hints سے پہلے بنایا گیا تھا۔ تو ہر schema define کرنے کے لیے Marshmallow کی فراہم کردہ مخصوص utils اور classes استعمال کرنی ہوتی ہیں۔
+
+/// check | **FastAPI** کو تحریک دی
+
+Data types اور validation فراہم کرنے والے "schemas" define کرنے کے لیے code استعمال کرنے کی، خودکار طور پر۔
+
+///
+
+### [Webargs](https://webargs.readthedocs.io/en/latest/) { #webargs }
+
+APIs کی ایک اور بڑی ضرورت آنے والی requests سے data parsing ہے۔
+
+Webargs ایک tool ہے جو کئی frameworks بشمول Flask کے اوپر یہ سہولت فراہم کرنے کے لیے بنایا گیا تھا۔
+
+یہ data validation کے لیے Marshmallow استعمال کرتا ہے۔ اور اسے انہی developers نے بنایا تھا۔
+
+یہ ایک بہترین tool ہے اور میں نے اسے بھی **FastAPI** سے پہلے بہت استعمال کیا ہے۔
+
+/// info | معلومات
+
+Webargs وہی Marshmallow developers نے بنایا تھا۔
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+آنے والے request data کی خودکار validation رکھنے کی۔
+
+///
+
+### [APISpec](https://apispec.readthedocs.io/en/stable/) { #apispec }
+
+Marshmallow اور Webargs plug-ins کے طور پر validation، parsing اور serialization فراہم کرتے ہیں۔
+
+لیکن documentation ابھی بھی نہیں تھی۔ پھر APISpec بنایا گیا۔
+
+یہ بہت سے frameworks کے لیے plug-in ہے (اور Starlette کے لیے بھی ایک plug-in ہے)۔
+
+یہ اس طرح کام کرتا ہے کہ آپ route handle کرنے والے ہر function کی docstring میں YAML فارمیٹ استعمال کرکے schema کی definition لکھتے ہیں۔
+
+اور یہ OpenAPI schemas بناتا ہے۔
+
+Flask، Starlette، Responder وغیرہ میں یہی طریقہ ہے۔
+
+لیکن پھر، ہمارے پاس دوبارہ Python string (ایک بڑا YAML) کے اندر ایک micro-syntax کا مسئلہ ہے۔
+
+Editor اس میں زیادہ مدد نہیں کر سکتا۔ اور اگر ہم parameters یا Marshmallow schemas تبدیل کریں اور وہ YAML docstring بھی اپڈیٹ کرنا بھول جائیں، تو بنایا گیا schema متروک ہو جائے گا۔
+
+/// info | معلومات
+
+APISpec وہی Marshmallow developers نے بنایا تھا۔
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+APIs کے لیے کھلے standard، OpenAPI، کی حمایت کرنے کی۔
+
+///
+
+### [Flask-apispec](https://flask-apispec.readthedocs.io/en/latest/) { #flask-apispec }
+
+یہ ایک Flask plug-in ہے، جو Webargs، Marshmallow اور APISpec کو جوڑتا ہے۔
+
+یہ Webargs اور Marshmallow سے معلومات استعمال کرکے APISpec کے ذریعے خودکار OpenAPI schemas بناتا ہے۔
+
+یہ ایک بہترین tool ہے، بہت کم قدردانی حاصل۔ اسے وہاں بہت سے Flask plug-ins سے زیادہ مقبول ہونا چاہیے۔ اس کی وجہ شاید اس کی documentation کا بہت مختصر اور تجریدی ہونا ہے۔
+
+اس نے Python docstrings کے اندر YAML (ایک اور syntax) لکھنے کا مسئلہ حل کیا۔
+
+Flask، Flask-apispec بمع Marshmallow اور Webargs کا یہ مجموعہ **FastAPI** بنانے تک میرا پسندیدہ backend stack تھا۔
+
+اسے استعمال کرنے سے کئی Flask full-stack generators بنے۔ یہ وہ بنیادی stacks ہیں جو میں (اور کئی بیرونی ٹیمیں) اب تک استعمال کرتے رہے ہیں:
+
+* [https://github.com/tiangolo/full-stack](https://github.com/tiangolo/full-stack)
+* [https://github.com/tiangolo/full-stack-flask-couchbase](https://github.com/tiangolo/full-stack-flask-couchbase)
+* [https://github.com/tiangolo/full-stack-flask-couchdb](https://github.com/tiangolo/full-stack-flask-couchdb)
+
+اور یہی full-stack generators [**FastAPI** Project Generators](project-generation.md) کی بنیاد تھے۔
+
+/// info | معلومات
+
+Flask-apispec وہی Marshmallow developers نے بنایا تھا۔
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+اسی code سے جو serialization اور validation define کرتا ہے، خودکار طور پر OpenAPI schema بنانے کی۔
+
+///
+
+### [NestJS](https://nestjs.com/) (اور [Angular](https://angular.io/)) { #nestjs-and-angular }
+
+یہ Python بھی نہیں ہے، NestJS ایک JavaScript (TypeScript) NodeJS framework ہے جو Angular سے تحریک یافتہ ہے۔
+
+یہ کچھ حد تک ایسا ہی حاصل کرتا ہے جو Flask-apispec سے کیا جا سکتا ہے۔
+
+اس میں Angular 2 سے تحریک یافتہ ایک مربوط dependency injection system ہے۔ اسے "injectables" کو پہلے سے register کرنا ضروری ہے (جیسے میں جانتا ہوں تمام dependency injection systems)، تو یہ طوالت اور code کی تکرار میں اضافہ کرتا ہے۔
+
+چونکہ parameters TypeScript types سے بیان کیے جاتے ہیں (Python type hints کی طرح)، editor support کافی اچھا ہے۔
+
+لیکن چونکہ TypeScript data JavaScript میں compile ہونے کے بعد محفوظ نہیں رہتا، یہ validation، serialization اور documentation ایک ساتھ define کرنے کے لیے types پر انحصار نہیں کر سکتا۔ اس اور کچھ design فیصلوں کی وجہ سے، validation، serialization اور خودکار schema generation حاصل کرنے کے لیے بہت سی جگہوں پر decorators شامل کرنے ہوتے ہیں۔ تو یہ کافی طویل ہو جاتا ہے۔
+
+یہ nested models کو بہت اچھی طرح سنبھال نہیں سکتا۔ تو اگر request میں JSON body ایک JSON object ہے جس میں اندر کے fields بدلے میں nested JSON objects ہیں، تو اسے ٹھیک سے document اور validate نہیں کیا جا سکتا۔
+
+/// check | **FastAPI** کو تحریک دی
+
+بہترین editor support حاصل کرنے کے لیے Python types استعمال کرنے کی۔
+
+طاقتور dependency injection system رکھنے کی۔ Code کی تکرار کم کرنے کا طریقہ ڈھونڈنے کی۔
+
+///
+
+### [Sanic](https://sanic.readthedocs.io/en/latest/) { #sanic }
+
+یہ `asyncio` پر مبنی انتہائی تیز Python frameworks میں سے پہلے تھا۔ اسے Flask سے بہت ملتا جلتا بنایا گیا تھا۔
+
+/// note | تکنیکی تفصیلات
+
+اس نے default Python `asyncio` loop کی بجائے [`uvloop`](https://github.com/MagicStack/uvloop) استعمال کیا۔ یہی اسے اتنا تیز بنایا۔
+
+اس نے واضح طور پر Uvicorn اور Starlette کو تحریک دی، جو فی الحال کھلے benchmarks میں Sanic سے تیز ہیں۔
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+زبردست performance حاصل کرنے کا طریقہ ڈھونڈنے کی۔
+
+اسی لیے **FastAPI** Starlette پر مبنی ہے، کیونکہ یہ دستیاب تیز ترین framework ہے (third-party benchmarks سے ٹیسٹ شدہ)۔
+
+///
+
+### [Falcon](https://falconframework.org/) { #falcon }
+
+Falcon ایک اور اعلیٰ performance Python framework ہے، اسے کم سے کم ہونے کے لیے ڈیزائن کیا گیا ہے، اور دوسرے frameworks جیسے Hug کی بنیاد کے طور پر کام کرنے کے لیے۔
+
+اسے ایسے functions رکھنے کے لیے ڈیزائن کیا گیا ہے جو دو parameters وصول کرتے ہیں، ایک "request" اور ایک "response"۔ پھر آپ request سے حصے "پڑھتے" ہیں، اور response میں حصے "لکھتے" ہیں۔ اس ڈیزائن کی وجہ سے، function parameters کے طور پر standard Python type hints کے ساتھ request parameters اور bodies declare کرنا ممکن نہیں ہے۔
+
+تو data validation، serialization، اور documentation code میں کرنی ہوتی ہے، خودکار طور پر نہیں۔ یا انہیں Falcon کے اوپر framework کے طور پر implement کرنا ہوتا ہے، جیسے Hug۔ یہی فرق ان دوسرے frameworks میں ہوتا ہے جو Falcon کے ڈیزائن سے تحریک یافتہ ہیں، ایک request object اور ایک response object بطور parameters رکھنے کا۔
+
+/// check | **FastAPI** کو تحریک دی
+
+بہترین performance حاصل کرنے کے طریقے ڈھونڈنے کی۔
+
+Hug کے ساتھ مل کر (چونکہ Hug، Falcon پر مبنی ہے) **FastAPI** کو functions میں `response` parameter declare کرنے کی تحریک دی۔
+
+حالانکہ FastAPI میں یہ اختیاری ہے، اور بنیادی طور پر headers، cookies، اور متبادل status codes سیٹ کرنے کے لیے استعمال ہوتا ہے۔
+
+///
+
+### [Molten](https://moltenframework.com/) { #molten }
+
+میں نے **FastAPI** بنانے کے ابتدائی مراحل میں Molten دریافت کیا۔ اور اس کے کافی ملتے جلتے آئیڈیاز ہیں:
+
+* Python type hints پر مبنی۔
+* ان types سے validation اور documentation۔
+* Dependency Injection system۔
+
+یہ Pydantic جیسی data validation، serialization اور documentation third-party library استعمال نہیں کرتا، بلکہ اس کی اپنی ہے۔ تو یہ data type definitions آسانی سے دوبارہ استعمال نہیں ہوتیں۔
+
+اسے تھوڑی زیادہ verbose configurations کی ضرورت ہے۔ اور چونکہ یہ WSGI (ASGI کی بجائے) پر مبنی ہے، اسے Uvicorn، Starlette اور Sanic جیسے tools کی اعلیٰ performance کا فائدہ اٹھانے کے لیے ڈیزائن نہیں کیا گیا۔
+
+Dependency injection system dependencies کو پہلے سے register کرنے اور declare کیے گئے types کی بنیاد پر resolve کرنے کی ضرورت ہے۔ تو ایک مخصوص type فراہم کرنے والے ایک سے زیادہ "component" declare کرنا ممکن نہیں ہے۔
+
+Routes ایک ہی جگہ declare کیے جاتے ہیں، دوسری جگہوں پر declare کیے گئے functions کا استعمال کرتے ہوئے (endpoint handle کرنے والے function کے بالکل اوپر رکھے جا سکنے والے decorators استعمال کرنے کی بجائے)۔ یہ Django کے طریقے سے زیادہ قریب ہے بنسبت Flask (اور Starlette) کے۔ یہ code میں ان چیزوں کو الگ کرتا ہے جو نسبتاً مضبوطی سے جڑی ہوتی ہیں۔
+
+/// check | **FastAPI** کو تحریک دی
+
+Model attributes کی "default" value استعمال کرکے data types کے لیے اضافی validations define کرنے کی۔ اس سے editor support بہتر ہوا، اور یہ پہلے Pydantic میں دستیاب نہیں تھا۔
+
+اس نے دراصل Pydantic کے حصے اپڈیٹ کرنے کی تحریک دی، تاکہ وہی validation declaration style سہولت فراہم ہو (یہ ساری functionality اب پہلے سے Pydantic میں دستیاب ہے)۔
+
+///
+
+### [Hug](https://github.com/hugapi/hug) { #hug }
+
+Hug ان پہلے frameworks میں سے ایک تھا جنہوں نے Python type hints استعمال کرکے API parameter types declare کرنا implement کیا۔ یہ ایک زبردست آئیڈیا تھا جس نے دوسرے tools کو بھی ایسا کرنے کی تحریک دی۔
+
+اس نے اپنی declarations میں standard Python types کی بجائے custom types استعمال کیے، لیکن یہ پھر بھی آگے کی طرف ایک بڑا قدم تھا۔
+
+یہ JSON میں API کی پوری declaration کا ایک custom schema بنانے والے پہلے frameworks میں سے بھی تھا۔
+
+یہ OpenAPI اور JSON Schema جیسے standard پر مبنی نہیں تھا۔ تو اسے Swagger UI جیسے دوسرے tools کے ساتھ مربوط کرنا سیدھا نہیں ہوتا۔ لیکن پھر بھی، یہ ایک بہت اختراعی آئیڈیا تھا۔
+
+اس میں ایک دلچسپ، غیر معمولی feature ہے: ایک ہی framework استعمال کرکے APIs اور CLIs دونوں بنانا ممکن ہے۔
+
+چونکہ یہ synchronous Python web frameworks کے پچھلے standard (WSGI) پر مبنی ہے، یہ Websockets اور دوسری چیزیں سنبھال نہیں سکتا، حالانکہ اس کی performance بھی اعلیٰ ہے۔
+
+/// info | معلومات
+
+Hug Timothy Crosley نے بنایا تھا، [`isort`](https://github.com/timothycrosley/isort) کے وہی بانی، Python فائلوں میں imports کو خودکار ترتیب دینے کا ایک بہترین tool۔
+
+///
+
+/// check | **FastAPI** کو تحریک دینے والے آئیڈیاز
+
+Hug نے APIStar کے حصوں کی تحریک دی، اور وہ tools میں سے ایک تھا جو مجھے APIStar کے ساتھ سب سے زیادہ امید افزا لگا۔
+
+Hug نے **FastAPI** کو Python type hints استعمال کرکے parameters declare کرنے، اور API define کرنے والا schema خودکار بنانے کی تحریک دی۔
+
+Hug نے **FastAPI** کو functions میں `response` parameter declare کرنے کی تحریک دی تاکہ headers اور cookies سیٹ کیے جا سکیں۔
+
+///
+
+### [APIStar](https://github.com/encode/apistar) (<= 0.5) { #apistar-0-5 }
+
+**FastAPI** بنانے کا فیصلہ کرنے سے ٹھیک پہلے مجھے **APIStar** server ملا۔ اس میں تقریباً وہ سب کچھ تھا جو میں تلاش کر رہا تھا اور اس کا ایک بہترین ڈیزائن تھا۔
+
+یہ parameters اور requests declare کرنے کے لیے Python type hints استعمال کرنے والے framework کے پہلے implementations میں سے ایک تھا جو میں نے کبھی دیکھا (NestJS اور Molten سے پہلے)۔ مجھے یہ تقریباً Hug کے ساتھ ہی ملا۔ لیکن APIStar نے OpenAPI standard استعمال کیا۔
+
+اس میں کئی جگہوں پر ایک ہی type hints کی بنیاد پر خودکار data validation، data serialization اور OpenAPI schema generation تھی۔
+
+Body schema definitions Pydantic کی طرح وہی Python type hints استعمال نہیں کرتی تھیں، یہ Marshmallow سے زیادہ ملتی جلتی تھیں، تو editor support اتنا اچھا نہ ہوتا، لیکن پھر بھی APIStar دستیاب بہترین آپشن تھا۔
+
+اس وقت اس کے بہترین performance benchmarks تھے (صرف Starlette سے پیچھے)۔
+
+شروع میں، اس کے پاس خودکار API documentation web UI نہیں تھا، لیکن مجھے معلوم تھا کہ میں اس میں Swagger UI شامل کر سکتا ہوں۔
+
+اس کا dependency injection system تھا۔ اسے components کو پہلے سے register کرنا ضروری تھا، جیسے اوپر بیان کیے گئے دوسرے tools۔ لیکن پھر بھی، یہ ایک بہترین feature تھا۔
+
+میں اسے کسی مکمل project میں استعمال نہیں کر سکا، کیونکہ اس میں security integration نہیں تھا، تو میں Flask-apispec پر مبنی full-stack generators کی تمام features کو replace نہیں کر سکتا تھا۔ میرے projects کے backlog میں وہ functionality شامل کرنے والی pull request بنانا تھا۔
+
+لیکن پھر، project کی توجہ بدل گئی۔
+
+یہ اب API web framework نہیں رہا، کیونکہ بانی کو Starlette پر توجہ مرکوز کرنی تھی۔
+
+اب APIStar OpenAPI specifications کو validate کرنے والے tools کا مجموعہ ہے، web framework نہیں۔
+
+/// info | معلومات
+
+APIStar Tom Christie نے بنایا تھا۔ وہی شخص جس نے بنایا:
+
+* Django REST Framework
+* Starlette (جس پر **FastAPI** مبنی ہے)
+* Uvicorn (جو Starlette اور **FastAPI** استعمال کرتے ہیں)
+
+///
+
+/// check | **FastAPI** کو تحریک دی
+
+موجود ہونے کی۔
+
+ایک ہی Python types کے ساتھ متعدد چیزیں (data validation، serialization اور documentation) declare کرنے کا آئیڈیا، جو ساتھ ہی بہترین editor support بھی فراہم کرے، ایک شاندار آئیڈیا تھا۔
+
+اور لمبے عرصے تک ملتا جلتا framework تلاش کرنے اور بہت سے مختلف متبادل ٹیسٹ کرنے کے بعد، APIStar دستیاب بہترین آپشن تھا۔
+
+پھر APIStar ایک server کے طور پر بند ہو گیا اور Starlette بنایا گیا، اور ایسے system کے لیے ایک نئی بہتر بنیاد تھا۔ یہ **FastAPI** بنانے کی حتمی تحریک تھی۔
+
+میں **FastAPI** کو APIStar کا "روحانی جانشین" سمجھتا ہوں، جبکہ ان تمام پچھلے tools سے سیکھے گئے سبق کی بنیاد پر features، typing system، اور دوسرے حصوں کو بہتر اور بڑھاتے ہوئے۔
+
+///
+
+## **FastAPI** کے ذریعے استعمال شدہ { #used-by-fastapi }
+
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }
+
+Pydantic ایک library ہے جو Python type hints کی بنیاد پر data validation، serialization اور documentation (JSON Schema استعمال کرتے ہوئے) define کرتی ہے۔
+
+یہ اسے انتہائی بدیہی بناتا ہے۔
+
+یہ Marshmallow سے قابل موازنہ ہے۔ حالانکہ benchmarks میں یہ Marshmallow سے تیز ہے۔ اور چونکہ یہ وہی Python type hints پر مبنی ہے، editor support بہترین ہے۔
+
+/// check | **FastAPI** اسے استعمال کرتا ہے
+
+تمام data validation، data serialization اور خودکار model documentation (JSON Schema پر مبنی) سنبھالنے کے لیے۔
+
+**FastAPI** پھر وہ JSON Schema data لے کر OpenAPI میں ڈالتا ہے، اس کے علاوہ جو کچھ اور یہ کرتا ہے۔
+
+///
+
+### [Starlette](https://www.starlette.dev/) { #starlette }
+
+Starlette ایک ہلکا پھلکا ASGI framework/toolkit ہے، جو اعلیٰ performance asyncio services بنانے کے لیے مثالی ہے۔
+
+یہ بہت سادہ اور بدیہی ہے۔ اسے آسانی سے قابل توسیع، اور ماڈیولر اجزاء کے ساتھ ڈیزائن کیا گیا ہے۔
+
+اس کے پاس ہے:
+
+* سنجیدگی سے شاندار performance۔
+* WebSocket support۔
+* In-process background tasks۔
+* Startup اور shutdown events۔
+* HTTPX پر مبنی Test client۔
+* CORS، GZip، Static Files، Streaming responses۔
+* Session اور Cookie support۔
+* 100% test coverage۔
+* 100% type annotated codebase۔
+* بہت کم hard dependencies۔
+
+Starlette فی الحال ٹیسٹ شدہ تیز ترین Python framework ہے۔ صرف Uvicorn سے پیچھے، جو framework نہیں بلکہ server ہے۔
+
+Starlette تمام بنیادی web microframework functionality فراہم کرتا ہے۔
+
+لیکن یہ خودکار data validation، serialization یا documentation فراہم نہیں کرتا۔
+
+یہ ان بنیادی چیزوں میں سے ایک ہے جو **FastAPI** اوپر سے شامل کرتا ہے، سب Python type hints پر مبنی (Pydantic استعمال کرتے ہوئے)۔ یہ، اور dependency injection system، security utilities، OpenAPI schema generation وغیرہ۔
+
+/// note | تکنیکی تفصیلات
+
+ASGI ایک نیا "standard" ہے جو Django core ٹیم کے ممبران develop کر رہے ہیں۔ یہ ابھی تک "Python standard" (PEP) نہیں ہے، حالانکہ وہ اس کے عمل میں ہیں۔
+
+تاہم، یہ پہلے سے کئی tools کے ذریعے "standard" کے طور پر استعمال ہو رہا ہے۔ یہ interoperability کو بہت بہتر بناتا ہے، کیونکہ آپ Uvicorn کو کسی بھی دوسرے ASGI server (جیسے Daphne یا Hypercorn) سے بدل سکتے ہیں، یا ASGI compatible tools شامل کر سکتے ہیں، جیسے `python-socketio`۔
+
+///
+
+/// check | **FastAPI** اسے استعمال کرتا ہے
+
+تمام بنیادی web حصوں کو سنبھالنے کے لیے۔ اوپر features شامل کرتے ہوئے۔
+
+`FastAPI` class خود براہ راست `Starlette` class سے inherit کرتی ہے۔
+
+تو جو کچھ بھی آپ Starlette کے ساتھ کر سکتے ہیں، آپ براہ راست **FastAPI** کے ساتھ کر سکتے ہیں، کیونکہ یہ بنیادی طور پر Starlette ہے مگر طاقتور۔
+
+///
+
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }
+
+Uvicorn ایک بجلی کی رفتار والا ASGI server ہے، uvloop اور httptools پر مبنی۔
+
+یہ web framework نہیں بلکہ server ہے۔ مثلاً، یہ paths سے routing کے tools فراہم نہیں کرتا۔ یہ وہ چیز ہے جو Starlette (یا **FastAPI**) جیسا framework اوپر فراہم کرتا ہے۔
+
+یہ Starlette اور **FastAPI** کے لیے تجویز کردہ server ہے۔
+
+/// check | **FastAPI** اسے تجویز کرتا ہے بطور
+
+**FastAPI** applications چلانے کا بنیادی web server۔
+
+آپ `--workers` command line option بھی استعمال کر سکتے ہیں تاکہ asynchronous multi-process server ہو۔
+
+مزید تفصیلات [Deployment](deployment/index.md) سیکشن میں دیکھیں۔
+
+///
+
+## Benchmarks اور رفتار { #benchmarks-and-speed }
+
+Uvicorn، Starlette اور FastAPI کے درمیان فرق سمجھنے، موازنہ کرنے اور دیکھنے کے لیے [Benchmarks](benchmarks.md) کا سیکشن دیکھیں۔
diff --git a/docs/ur/docs/async.md b/docs/ur/docs/async.md
new file mode 100644
index 000000000..3c1d04494
--- /dev/null
+++ b/docs/ur/docs/async.md
@@ -0,0 +1,444 @@
+# Concurrency اور async / await { #concurrency-and-async-await }
+
+*path operation functions* کے لیے `async def` syntax کے بارے میں تفصیلات اور asynchronous code، concurrency، اور parallelism کا پس منظر۔
+
+## جلدی میں ہیں؟ { #in-a-hurry }
+
+TL;DR:
+
+اگر آپ third party libraries استعمال کر رہے ہیں جو آپ سے `await` کے ساتھ call کرنے کو کہتی ہیں، جیسے:
+
+```Python
+results = await some_library()
+```
+
+تو اپنے *path operation functions* کو `async def` کے ساتھ declare کریں جیسے:
+
+```Python hl_lines="2"
+@app.get('/')
+async def read_results():
+ results = await some_library()
+ return results
+```
+
+/// note | نوٹ
+
+آپ `await` صرف `async def` سے بنائے گئے functions کے اندر استعمال کر سکتے ہیں۔
+
+///
+
+---
+
+اگر آپ کوئی third party library استعمال کر رہے ہیں جو کسی چیز سے communicate کرتی ہے (database، API، file system وغیرہ) اور `await` کے استعمال کی سہولت نہیں رکھتی (فی الحال زیادہ تر database libraries کے ساتھ یہی صورتحال ہے)، تو اپنے *path operation functions* کو عام طریقے سے صرف `def` کے ساتھ declare کریں، جیسے:
+
+```Python hl_lines="2"
+@app.get('/')
+def results():
+ results = some_library()
+ return results
+```
+
+---
+
+اگر آپ کی application کو (کسی بھی طرح) کسی اور چیز سے communicate کرکے اس کے جواب کا انتظار نہیں کرنا ہے، تو `async def` استعمال کریں، چاہے آپ کو اندر `await` استعمال کرنے کی ضرورت نہ ہو۔
+
+---
+
+اگر آپ کو نہیں معلوم، تو عام `def` استعمال کریں۔
+
+---
+
+**نوٹ**: آپ اپنے *path operation functions* میں `def` اور `async def` کو جتنا چاہیں ملا جلا کر استعمال کر سکتے ہیں اور ہر ایک کو اپنی بہترین ضرورت کے مطابق define کر سکتے ہیں۔ FastAPI ان کے ساتھ صحیح طریقے سے کام کرے گا۔
+
+بہرحال، اوپر کے کسی بھی معاملے میں، FastAPI پھر بھی asynchronously کام کرے گا اور انتہائی تیز ہوگا۔
+
+لیکن اوپر دیے گئے اقدامات پر عمل کرنے سے، یہ کچھ performance optimizations کر سکے گا۔
+
+## تکنیکی تفصیلات { #technical-details }
+
+Python کے جدید ورژنز **"asynchronous code"** کی سہولت فراہم کرتے ہیں جسے **"coroutines"** کہتے ہیں، **`async` اور `await`** syntax کے ساتھ۔
+
+آئیے اس جملے کو نیچے دیے گئے حصوں میں تفصیل سے دیکھتے ہیں:
+
+* **Asynchronous Code**
+* **`async` اور `await`**
+* **Coroutines**
+
+## Asynchronous Code { #asynchronous-code }
+
+Asynchronous code کا مطلب صرف یہ ہے کہ زبان 💬 کے پاس computer / program 🤖 کو یہ بتانے کا ایک طریقہ ہے کہ code میں کسی مقام پر، اسے 🤖 کسی اور جگہ *کچھ اور* مکمل ہونے کا انتظار کرنا ہوگا۔ فرض کریں کہ وہ *کچھ اور* "slow-file" 📝 کہلاتا ہے۔
+
+تو اس وقت کے دوران، computer جا کر کوئی اور کام کر سکتا ہے، جب تک "slow-file" 📝 مکمل ہوتا ہے۔
+
+پھر computer / program 🤖 ہر بار واپس آئے گا جب اسے موقع ملے کیونکہ وہ دوبارہ انتظار میں ہے، یا جب بھی اس 🤖 نے اس وقت تک کا سارا کام مکمل کر لیا ہو۔ اور یہ 🤖 دیکھے گا کہ جن tasks کا انتظار تھا ان میں سے کوئی مکمل ہو چکا ہے، اور جو کچھ اسے کرنا تھا وہ کرے گا۔
+
+پھر، یہ 🤖 مکمل ہونے والا پہلا task لیتا ہے (فرض کریں ہمارا "slow-file" 📝) اور جو کچھ اسے اس کے ساتھ کرنا تھا وہ جاری رکھتا ہے۔
+
+وہ "کسی اور چیز کا انتظار" عام طور پر I/O operations کی طرف اشارہ کرتا ہے جو نسبتاً "سست" ہوتے ہیں (processor اور RAM memory کی رفتار کے مقابلے میں)، جیسے انتظار کرنا:
+
+* client کے ذریعے network سے بھیجے جانے والے data کا
+* آپ کے program کے ذریعے بھیجے گئے data کا client تک network سے پہنچنے کا
+* disk پر فائل کے مواد کو system کے ذریعے پڑھ کر آپ کے program کو دینے کا
+* آپ کے program نے system کو جو مواد دیا اسے disk پر لکھنے کا
+* ایک remote API operation کا
+* ایک database operation مکمل ہونے کا
+* ایک database query کے نتائج واپس آنے کا
+* وغیرہ۔
+
+چونکہ execution time زیادہ تر I/O operations کے انتظار میں صرف ہوتا ہے، انہیں "I/O bound" operations کہتے ہیں۔
+
+اسے "asynchronous" اس لیے کہتے ہیں کیونکہ computer / program کو سست task کے ساتھ "synchronized" نہیں رہنا پڑتا، task مکمل ہونے کے صحیح لمحے کا انتظار کرتے ہوئے کچھ نہ کرتے ہوئے، تاکہ task کا نتیجہ لے کر کام جاری رکھ سکے۔
+
+اس کی بجائے، ایک "asynchronous" system ہونے کی وجہ سے، ایک بار مکمل ہونے کے بعد، task تھوڑی دیر (کچھ microseconds) قطار میں انتظار کر سکتا ہے جب تک computer / program جو بھی کام کر رہا تھا وہ مکمل کرے، اور پھر واپس آ کر نتائج لے اور ان کے ساتھ کام جاری رکھے۔
+
+"Synchronous" ("asynchronous" کے برعکس) کے لیے عام طور پر "sequential" کی اصطلاح بھی استعمال ہوتی ہے، کیونکہ computer / program تمام مراحل کو ترتیب سے follow کرتا ہے کسی مختلف task پر جانے سے پہلے، چاہے ان مراحل میں انتظار شامل ہو۔
+
+### Concurrency اور برگرز { #concurrency-and-burgers }
+
+اوپر بیان کردہ **asynchronous** code کے اس تصور کو بعض اوقات **"concurrency"** بھی کہا جاتا ہے۔ یہ **"parallelism"** سے مختلف ہے۔
+
+**Concurrency** اور **parallelism** دونوں کا تعلق "مختلف چیزوں کا کم و بیش ایک ہی وقت میں ہونا" سے ہے۔
+
+لیکن *concurrency* اور *parallelism* کے درمیان تفصیلات کافی مختلف ہیں۔
+
+فرق سمجھنے کے لیے، برگرز کے بارے میں یہ کہانی تصور کریں:
+
+### Concurrent برگرز { #concurrent-burgers }
+
+آپ اپنے ساتھی کے ساتھ fast food لینے جاتے ہیں، آپ قطار میں کھڑے ہوتے ہیں جب کہ cashier آپ سے پہلے والے لوگوں کے آرڈرز لے رہا ہوتا ہے۔ 😍
+
+
+
+پھر آپ کی باری آتی ہے، آپ اپنے ساتھی اور اپنے لیے 2 بہت عمدہ برگرز کا آرڈر دیتے ہیں۔ 🍔🍔
+
+
+
+Cashier کچن میں باورچی کو کچھ کہتا ہے تاکہ انہیں معلوم ہو کہ آپ کے برگرز تیار کرنے ہیں (حالانکہ وہ ابھی پہلے والے گاہکوں کے برگرز تیار کر رہے ہیں)۔
+
+
+
+آپ ادائیگی کرتے ہیں۔ 💸
+
+Cashier آپ کو آپ کی باری کا نمبر دیتا ہے۔
+
+
+
+جب آپ انتظار کر رہے ہوتے ہیں، آپ اپنے ساتھی کے ساتھ جا کر ایک میز چنتے ہیں، بیٹھتے ہیں اور کافی دیر تک بات کرتے ہیں (کیونکہ آپ کے برگرز بہت عمدہ ہیں اور تیار ہونے میں وقت لگتا ہے)۔
+
+جب آپ اپنے ساتھی کے ساتھ میز پر بیٹھے برگرز کا انتظار کر رہے ہوتے ہیں، آپ اس وقت کو یہ دیکھنے میں صرف کر سکتے ہیں کہ آپ کا ساتھی کتنا زبردست، خوبصورت اور ذہین ہے ✨😍✨۔
+
+
+
+انتظار کرتے ہوئے اور اپنے ساتھی سے بات کرتے ہوئے، وقتاً فوقتاً آپ کاؤنٹر پر دکھائے جانے والے نمبر کو چیک کرتے ہیں کہ کیا آپ کی باری آ گئی ہے۔
+
+پھر کسی وقت، آخرکار آپ کی باری آتی ہے۔ آپ کاؤنٹر پر جاتے ہیں، اپنے برگرز لیتے ہیں اور واپس میز پر آتے ہیں۔
+
+
+
+آپ اور آپ کا ساتھی برگرز کھاتے ہیں اور اچھا وقت گزارتے ہیں۔ ✨
+
+
+
+/// info | معلومات
+
+خوبصورت تصاویر بنانے والی [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot)۔ 🎨
+
+///
+
+---
+
+تصور کریں کہ آپ اس کہانی میں computer / program 🤖 ہیں۔
+
+جب آپ قطار میں ہوتے ہیں، آپ بس خالی بیٹھے 😴 اپنی باری کا انتظار کر رہے ہوتے ہیں، کوئی خاص "productive" کام نہیں کر رہے۔ لیکن قطار تیز ہے کیونکہ cashier صرف آرڈرز لے رہا ہے (تیار نہیں کر رہا)، تو یہ ٹھیک ہے۔
+
+پھر جب آپ کی باری آتی ہے، آپ حقیقی "productive" کام کرتے ہیں، مینو پر غور کرتے ہیں، فیصلہ کرتے ہیں کہ آپ کیا چاہتے ہیں، اپنے ساتھی کی پسند لیتے ہیں، ادائیگی کرتے ہیں، چیک کرتے ہیں کہ آپ نے صحیح بل یا کارڈ دیا ہے، چیک کرتے ہیں کہ آپ سے صحیح رقم لی گئی ہے، چیک کرتے ہیں کہ آرڈر میں صحیح آئٹمز ہیں، وغیرہ۔
+
+لیکن پھر، حالانکہ آپ کے پاس ابھی تک برگرز نہیں ہیں، cashier کے ساتھ آپ کا کام "روک" ⏸ پر ہے، کیونکہ آپ کو اپنے برگرز تیار ہونے کا انتظار 🕙 کرنا ہے۔
+
+لیکن جیسے ہی آپ کاؤنٹر سے ہٹ کر اپنی باری کے نمبر کے ساتھ میز پر بیٹھتے ہیں، آپ اپنی توجہ 🔀 اپنے ساتھی کی طرف کر سکتے ہیں، اور اس پر "کام" ⏯ 🤓 کر سکتے ہیں۔ پھر آپ دوبارہ کچھ بہت "productive" کر رہے ہیں جیسے اپنے ساتھی سے فلرٹ کرنا 😍۔
+
+پھر cashier 💁 کہتا ہے "میں نے برگرز تیار کر دیے" آپ کا نمبر کاؤنٹر کی display پر لگا کر، لیکن آپ پاگلوں کی طرح فوراً نہیں کودتے جب display نمبر آپ کی باری کے نمبر پر بدلتا ہے۔ آپ جانتے ہیں کہ کوئی آپ کے برگرز نہیں چرائے گا کیونکہ آپ کے پاس آپ کی باری کا نمبر ہے، اور ان کے پاس ان کا۔
+
+تو آپ اپنے ساتھی کی کہانی مکمل ہونے کا انتظار کرتے ہیں (موجودہ کام ⏯ / task مکمل ہونا 🤓)، نرمی سے مسکراتے ہیں اور کہتے ہیں کہ آپ برگرز لینے جا رہے ہیں ⏸۔
+
+پھر آپ کاؤنٹر 🔀 پر جاتے ہیں، اس ابتدائی task کی طرف جو اب مکمل ہو چکا ہے ⏯، برگرز لیتے ہیں، شکریہ کہتے ہیں اور انہیں میز پر لے آتے ہیں۔ یہ کاؤنٹر کے ساتھ تعامل کا وہ مرحلہ / task ختم کرتا ہے ⏹۔ یہ بدلے میں ایک نیا task شروع کرتا ہے، "برگرز کھانا" 🔀 ⏯، لیکن پچھلا "برگرز لینا" مکمل ہو چکا ہے ⏹۔
+
+### Parallel برگرز { #parallel-burgers }
+
+اب تصور کریں کہ یہ "Concurrent برگرز" نہیں بلکہ "Parallel برگرز" ہیں۔
+
+آپ اپنے ساتھی کے ساتھ parallel fast food لینے جاتے ہیں۔
+
+آپ قطار میں کھڑے ہوتے ہیں جب کہ کئی (فرض کریں 8) cashiers جو بیک وقت باورچی بھی ہیں، آپ سے پہلے والے لوگوں کے آرڈرز لے رہے ہیں۔
+
+آپ سے پہلے ہر شخص کاؤنٹر چھوڑنے سے پہلے اپنے برگرز تیار ہونے کا انتظار کر رہا ہے کیونکہ 8 cashiers میں سے ہر ایک اگلا آرڈر لینے سے پہلے برگر فوراً تیار کرتا ہے۔
+
+
+
+پھر آخرکار آپ کی باری آتی ہے، آپ اپنے ساتھی اور اپنے لیے 2 بہت عمدہ برگرز کا آرڈر دیتے ہیں۔
+
+آپ ادائیگی کرتے ہیں 💸۔
+
+
+
+Cashier کچن میں جاتا ہے۔
+
+آپ کاؤنٹر کے سامنے کھڑے رہتے ہیں 🕙، تاکہ کوئی اور آپ سے پہلے آپ کے برگرز نہ لے لے، کیونکہ باری کے نمبر نہیں ہیں۔
+
+
+
+چونکہ آپ اور آپ کا ساتھی کسی کو اپنے سامنے آنے اور جب بھی وہ آئیں آپ کے برگرز لینے سے روکنے میں مصروف ہیں، آپ اپنے ساتھی پر توجہ نہیں دے سکتے۔ 😞
+
+یہ "synchronous" کام ہے، آپ cashier/باورچی 👨🍳 کے ساتھ "synchronized" ہیں۔ آپ کو انتظار 🕙 کرنا ہے اور بالکل اس لمحے وہاں موجود ہونا ہے جب cashier/باورچی 👨🍳 برگرز مکمل کرے اور آپ کو دے، ورنہ کوئی اور لے سکتا ہے۔
+
+
+
+پھر آپ کا cashier/باورچی 👨🍳 آخرکار آپ کے برگرز لے کر واپس آتا ہے، کاؤنٹر کے سامنے لمبے انتظار 🕙 کے بعد۔
+
+
+
+آپ اپنے برگرز لیتے ہیں اور اپنے ساتھی کے ساتھ میز پر جاتے ہیں۔
+
+آپ بس انہیں کھاتے ہیں، اور ہو گیا۔ ⏹
+
+
+
+زیادہ بات چیت یا فلرٹنگ نہیں ہوئی کیونکہ زیادہ تر وقت کاؤنٹر کے سامنے انتظار 🕙 میں صرف ہوا۔ 😞
+
+/// info | معلومات
+
+خوبصورت تصاویر بنانے والی [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot)۔ 🎨
+
+///
+
+---
+
+Parallel برگرز کے اس منظرنامے میں، آپ ایک computer / program 🤖 ہیں جس کے دو processors ہیں (آپ اور آپ کا ساتھی)، دونوں انتظار 🕙 کر رہے ہیں اور اپنی توجہ ⏯ "کاؤنٹر پر انتظار" 🕙 میں لمبے عرصے تک لگائے ہوئے ہیں۔
+
+Fast food store کے 8 processors (cashiers/باورچی) ہیں۔ جبکہ concurrent برگرز والے store میں شاید صرف 2 ہوں (ایک cashier اور ایک باورچی)۔
+
+لیکن پھر بھی، حتمی تجربہ بہترین نہیں ہے۔ 😞
+
+---
+
+یہ برگرز کی parallel مساوی کہانی ہوگی۔ 🍔
+
+"حقیقی زندگی" کی مزید مثال کے لیے، ایک بینک تصور کریں۔
+
+حال ہی تک، زیادہ تر بینکوں میں متعدد cashiers 👨💼👨💼👨💼👨💼 ہوتے تھے اور ایک بڑی قطار 🕙🕙🕙🕙🕙🕙🕙🕙۔
+
+تمام cashiers ایک کے بعد ایک client کے ساتھ سارا کام کرتے 👨💼⏯۔
+
+اور آپ کو قطار میں لمبا انتظار 🕙 کرنا ہوتا ہے ورنہ آپ اپنی باری کھو دیتے ہیں۔
+
+آپ شاید اپنے ساتھی 😍 کو اپنے ساتھ بینک 🏦 میں کام کرانے نہیں لے جانا چاہیں گے۔
+
+### برگرز کا نتیجہ { #burger-conclusion }
+
+"اپنے ساتھی کے ساتھ fast food برگرز" کے اس منظرنامے میں، چونکہ بہت زیادہ انتظار 🕙 ہے، concurrent system ⏸🔀⏯ رکھنا بہت زیادہ معنی رکھتا ہے۔
+
+زیادہ تر web applications کے ساتھ یہی معاملہ ہے۔
+
+بہت سارے، بہت سارے users، لیکن آپ کا server ان کے اتنے اچھے نہ ہونے والے connection سے requests بھیجنے کا انتظار 🕙 کر رہا ہے۔
+
+اور پھر دوبارہ responses واپس آنے کا انتظار 🕙۔
+
+یہ "انتظار" 🕙 microseconds میں ماپا جاتا ہے، لیکن پھر بھی، سب کو جمع کریں تو آخر میں بہت زیادہ انتظار ہوتا ہے۔
+
+اسی لیے web APIs کے لیے asynchronous ⏸🔀⏯ code استعمال کرنا بہت معنی رکھتا ہے۔
+
+اسی قسم کی asynchronicity نے NodeJS کو مقبول بنایا (حالانکہ NodeJS parallel نہیں ہے) اور یہی Go کی بطور programming language طاقت ہے۔
+
+اور یہ وہی سطح کی performance ہے جو آپ کو **FastAPI** کے ساتھ ملتی ہے۔
+
+اور چونکہ آپ parallelism اور asynchronicity دونوں بیک وقت حاصل کر سکتے ہیں، آپ کو زیادہ تر tested NodeJS frameworks سے زیادہ اور Go کے برابر performance ملتی ہے، جو C کے قریب ایک compiled language ہے [(یہ سب Starlette کی بدولت ہے)](https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1)۔
+
+### کیا concurrency، parallelism سے بہتر ہے؟ { #is-concurrency-better-than-parallelism }
+
+نہیں! یہ کہانی کا سبق نہیں ہے۔
+
+Concurrency، parallelism سے مختلف ہے۔ اور یہ ان **مخصوص** منظرناموں میں بہتر ہے جن میں بہت زیادہ انتظار شامل ہو۔ اس وجہ سے، یہ عام طور پر web application development کے لیے parallelism سے بہت بہتر ہے۔ لیکن ہر چیز کے لیے نہیں۔
+
+تو اسے متوازن کرنے کے لیے، یہ مختصر کہانی تصور کریں:
+
+> آپ کو ایک بڑا، گندا گھر صاف کرنا ہے۔
+
+*ہاں، یہی پوری کہانی ہے*۔
+
+---
+
+کہیں بھی انتظار 🕙 نہیں ہے، بس گھر کی مختلف جگہوں پر بہت سارا کام کرنا ہے۔
+
+آپ برگرز کی مثال کی طرح باریاں لے سکتے ہیں، پہلے بیٹھک، پھر کچن، لیکن چونکہ آپ کسی چیز کا انتظار 🕙 نہیں کر رہے، بس صفائی اور صفائی، تو باریاں کسی چیز پر اثر نہیں ڈالیں گی۔
+
+باریوں (concurrency) کے ساتھ یا بغیر مکمل ہونے میں اتنا ہی وقت لگے گا اور آپ نے اتنا ہی کام کیا ہوگا۔
+
+لیکن اس صورت میں، اگر آپ 8 سابقہ cashier/باورچی/اب صفائی والے لا سکتے، اور ہر ایک (آپ سمیت) گھر کا ایک حصہ صاف کر سکتا، تو آپ سارا کام **parallel** میں، اضافی مدد سے، بہت جلد مکمل کر سکتے تھے۔
+
+اس منظرنامے میں، ہر صفائی کرنے والا (آپ سمیت) ایک processor ہوگا، جو اپنے حصے کا کام کر رہا ہوگا۔
+
+اور چونکہ زیادہ تر execution time حقیقی کام میں صرف ہوتا ہے (انتظار کی بجائے)، اور computer میں کام ایک CPU کے ذریعے ہوتا ہے، وہ ان مسائل کو "CPU bound" کہتے ہیں۔
+
+---
+
+CPU bound operations کی عام مثالیں وہ چیزیں ہیں جنہیں پیچیدہ ریاضیاتی processing کی ضرورت ہوتی ہے۔
+
+مثال کے طور پر:
+
+* **Audio** یا **image processing**۔
+* **Computer vision**: ایک تصویر لاکھوں pixels پر مشتمل ہوتی ہے، ہر pixel میں 3 values / رنگ ہوتے ہیں، ان کی processing میں عام طور پر ان pixels پر بیک وقت کوئی حساب لگانا ہوتا ہے۔
+* **Machine Learning**: عام طور پر بہت سی "matrix" اور "vector" multiplications کی ضرورت ہوتی ہے۔ نمبروں سے بھری ایک بڑی spreadsheet کا تصور کریں اور ان سب کو بیک وقت ضرب دینا۔
+* **Deep Learning**: یہ Machine Learning کا ایک ذیلی شعبہ ہے، تو وہی اصول لاگو ہوتے ہیں۔ بس اتنا ہے کہ ضرب دینے کے لیے نمبروں کی ایک ہی spreadsheet نہیں بلکہ ایک بہت بڑا مجموعہ ہوتا ہے، اور بہت سے معاملات میں آپ ان models کو بنانے اور/یا استعمال کرنے کے لیے ایک خاص processor استعمال کرتے ہیں۔
+
+### Concurrency + Parallelism: Web + Machine Learning { #concurrency-parallelism-web-machine-learning }
+
+**FastAPI** کے ساتھ آپ concurrency کا فائدہ اٹھا سکتے ہیں جو web development کے لیے بہت عام ہے (NodeJS کی وہی بنیادی کشش)۔
+
+لیکن آپ parallelism اور multiprocessing (متعدد processes بیک وقت چلنا) کے فوائد کو بھی **CPU bound** workloads کے لیے استعمال کر سکتے ہیں جیسے Machine Learning systems۔
+
+یہ، اور اس سادہ حقیقت کے ساتھ کہ Python **Data Science**، Machine Learning اور خاص طور پر Deep Learning کی بنیادی زبان ہے، FastAPI کو Data Science / Machine Learning web APIs اور applications کے لیے ایک بہت اچھا انتخاب بناتے ہیں (بہت سی دوسری چیزوں کے علاوہ)۔
+
+production میں یہ parallelism کیسے حاصل کریں یہ جاننے کے لیے [Deployment](deployment/index.md) کا سیکشن دیکھیں۔
+
+## `async` اور `await` { #async-and-await }
+
+Python کے جدید ورژنز میں asynchronous code define کرنے کا ایک بہت بدیہی طریقہ ہے۔ یہ اسے عام "sequential" code جیسا بناتا ہے اور صحیح لمحات پر آپ کے لیے "awaiting" کرتا ہے۔
+
+جب کوئی operation ہو جو نتائج دینے سے پہلے انتظار کی ضرورت رکھتا ہو اور Python کی ان نئی features کی سہولت رکھتا ہو، آپ اسے اس طرح code کر سکتے ہیں:
+
+```Python
+burgers = await get_burgers(2)
+```
+
+یہاں کلید `await` ہے۔ یہ Python کو بتاتا ہے کہ اسے `get_burgers(2)` کا اپنا کام 🕙 مکمل کرنے تک انتظار ⏸ کرنا ہے `burgers` میں نتائج محفوظ کرنے سے پہلے۔ اس کے ساتھ، Python جان لے گا کہ وہ اس دوران 🔀 ⏯ کچھ اور کام کر سکتا ہے (جیسے کوئی اور request وصول کرنا)۔
+
+`await` کام کرنے کے لیے، اسے ایک ایسے function کے اندر ہونا ضروری ہے جو اس asynchronicity کی سہولت رکھتا ہو۔ ایسا کرنے کے لیے، بس اسے `async def` کے ساتھ declare کریں:
+
+```Python hl_lines="1"
+async def get_burgers(number: int):
+ # Do some asynchronous stuff to create the burgers
+ return burgers
+```
+
+...`def` کی بجائے:
+
+```Python hl_lines="2"
+# This is not asynchronous
+def get_sequential_burgers(number: int):
+ # Do some sequential stuff to create the burgers
+ return burgers
+```
+
+`async def` کے ساتھ، Python جانتا ہے کہ اس function کے اندر اسے `await` expressions کا خیال رکھنا ہے، اور یہ کہ وہ اس function کی execution کو "روک" ⏸ کر واپس آنے سے پہلے 🔀 کچھ اور کام کر سکتا ہے۔
+
+جب آپ کسی `async def` function کو call کرنا چاہیں، تو آپ کو اسے "await" کرنا ہوگا۔ تو یہ کام نہیں کرے گا:
+
+```Python
+# This won't work, because get_burgers was defined with: async def
+burgers = get_burgers(2)
+```
+
+---
+
+تو اگر آپ کوئی library استعمال کر رہے ہیں جو آپ سے `await` کے ساتھ call کرنے کو کہتی ہے، تو آپ کو اسے استعمال کرنے والے *path operation functions* کو `async def` کے ساتھ بنانا ہوگا، جیسے:
+
+```Python hl_lines="2-3"
+@app.get('/burgers')
+async def read_burgers():
+ burgers = await get_burgers(2)
+ return burgers
+```
+
+### مزید تکنیکی تفصیلات { #more-technical-details }
+
+آپ نے غور کیا ہوگا کہ `await` صرف `async def` سے define کیے گئے functions کے اندر استعمال ہو سکتا ہے۔
+
+لیکن ساتھ ہی، `async def` سے define کیے گئے functions کو "await" کرنا ضروری ہے۔ تو `async def` والے functions صرف `async def` سے define کیے گئے functions کے اندر ہی call ہو سکتے ہیں۔
+
+تو انڈے اور مرغی کے بارے میں، آپ پہلا `async` function کیسے call کریں؟
+
+اگر آپ **FastAPI** کے ساتھ کام کر رہے ہیں تو آپ کو اس کی فکر نہیں کرنی، کیونکہ وہ "پہلا" function آپ کا *path operation function* ہوگا، اور FastAPI جانے گا کہ صحیح کام کیسے کرنا ہے۔
+
+لیکن اگر آپ FastAPI کے بغیر `async` / `await` استعمال کرنا چاہیں، تو آپ ایسا بھی کر سکتے ہیں۔
+
+### اپنا async code لکھیں { #write-your-own-async-code }
+
+Starlette (اور **FastAPI**) [AnyIO](https://anyio.readthedocs.io/en/stable/) پر مبنی ہیں، جو اسے Python کی standard library [asyncio](https://docs.python.org/3/library/asyncio-task.html) اور [Trio](https://trio.readthedocs.io/en/stable/) دونوں کے ساتھ compatible بناتا ہے۔
+
+خاص طور پر، آپ اپنے advanced concurrency use cases کے لیے براہ راست [AnyIO](https://anyio.readthedocs.io/en/stable/) استعمال کر سکتے ہیں جنہیں آپ کے اپنے code میں مزید advanced patterns کی ضرورت ہو۔
+
+اور اگر آپ FastAPI استعمال نہیں بھی کر رہے ہوتے، تو بھی آپ [AnyIO](https://anyio.readthedocs.io/en/stable/) کے ساتھ اپنی async applications لکھ سکتے تھے جو بہت compatible ہوں اور اس کے فوائد حاصل کریں (مثلاً *structured concurrency*)۔
+
+میں نے AnyIO کے اوپر ایک اور library بنائی ہے، ایک پتلی layer کے طور پر، type annotations کو تھوڑا بہتر بنانے اور بہتر **autocompletion**، **inline errors** وغیرہ حاصل کرنے کے لیے۔ اس میں ایک دوستانہ تعارف اور tutorial بھی ہے جو آپ کو **سمجھنے** اور **اپنا async code** لکھنے میں مدد کرے: [Asyncer](https://asyncer.tiangolo.com/)۔ یہ خاص طور پر مفید ہوگا اگر آپ کو **async code کو regular** (blocking/synchronous) code کے ساتھ ملانے کی ضرورت ہو۔
+
+### Asynchronous code کی دوسری شکلیں { #other-forms-of-asynchronous-code }
+
+`async` اور `await` استعمال کرنے کا یہ انداز زبان میں نسبتاً نیا ہے۔
+
+لیکن یہ asynchronous code کے ساتھ کام کرنا بہت آسان بناتا ہے۔
+
+یہی syntax (یا تقریباً ایک جیسا) حال ہی میں JavaScript کے جدید ورژنز (Browser اور NodeJS میں) میں بھی شامل کیا گیا۔
+
+لیکن اس سے پہلے، asynchronous code کو سنبھالنا کافی زیادہ پیچیدہ اور مشکل تھا۔
+
+Python کے پچھلے ورژنز میں، آپ threads یا [Gevent](https://www.gevent.org/) استعمال کر سکتے تھے۔ لیکن code سمجھنے، debug کرنے، اور سوچنے میں بہت زیادہ پیچیدہ ہوتا ہے۔
+
+NodeJS / Browser JavaScript کے پچھلے ورژنز میں، آپ "callbacks" استعمال کرتے۔ جو "callback hell" کی طرف لے جاتا ہے۔
+
+## Coroutines { #coroutines }
+
+**Coroutine** بس اس چیز کے لیے ایک بہت فینسی اصطلاح ہے جو `async def` function واپس کرتا ہے۔ Python جانتا ہے کہ یہ ایک function جیسی چیز ہے، جو شروع ہو سکتی ہے اور کسی وقت ختم ہوگی، لیکن یہ اندرونی طور پر بھی ⏸ روکی جا سکتی ہے، جب بھی اس کے اندر `await` ہو۔
+
+لیکن `async` اور `await` کے ساتھ asynchronous code استعمال کرنے کی یہ ساری functionality اکثر "coroutines" استعمال کرنا کہہ کر خلاصہ کی جاتی ہے۔ یہ Go کی بنیادی خصوصیت "Goroutines" سے قابل موازنہ ہے۔
+
+## نتیجہ { #conclusion }
+
+آئیے اوپر والا وہی جملہ دوبارہ دیکھتے ہیں:
+
+> Python کے جدید ورژنز **"asynchronous code"** کی سہولت فراہم کرتے ہیں جسے **"coroutines"** کہتے ہیں، **`async` اور `await`** syntax کے ساتھ۔
+
+اب یہ زیادہ سمجھ آنا چاہیے۔ ✨
+
+یہی سب **FastAPI** کو (Starlette کے ذریعے) طاقت دیتا ہے اور اسے اتنی شاندار performance دیتا ہے۔
+
+## انتہائی تکنیکی تفصیلات { #very-technical-details }
+
+/// warning | انتباہ
+
+آپ شاید اسے چھوڑ سکتے ہیں۔
+
+یہ بہت تکنیکی تفصیلات ہیں کہ **FastAPI** اندرونی طور پر کیسے کام کرتا ہے۔
+
+اگر آپ کے پاس کافی تکنیکی علم ہے (coroutines، threads، blocking وغیرہ) اور آپ جاننا چاہتے ہیں کہ FastAPI `async def` بمقابلہ عام `def` کو کیسے سنبھالتا ہے، تو آگے بڑھیں۔
+
+///
+
+### Path operation functions { #path-operation-functions }
+
+جب آپ *path operation function* کو `async def` کی بجائے عام `def` کے ساتھ declare کرتے ہیں، تو اسے ایک بیرونی threadpool میں چلایا جاتا ہے جس کا پھر await کیا جاتا ہے، براہ راست call کرنے کی بجائے (کیونکہ یہ server کو block کر دے گا)۔
+
+اگر آپ کسی اور async framework سے آ رہے ہیں جو اوپر بیان کردہ طریقے سے کام نہیں کرتا اور آپ عام `def` کے ساتھ معمولی compute-only *path operation functions* define کرنے کے عادی ہیں تھوڑی سی performance بہتری (تقریباً 100 nanoseconds) کے لیے، تو براہ کرم نوٹ کریں کہ **FastAPI** میں اثر بالکل الٹا ہوگا۔ ان صورتوں میں، `async def` استعمال کرنا بہتر ہے جب تک کہ آپ کے *path operation functions* ایسا code استعمال نہ کریں جو blocking I/O کرتا ہو۔
+
+پھر بھی، دونوں صورتوں میں، امکان ہے کہ **FastAPI** آپ کے پچھلے framework سے [پھر بھی تیز](index.md#performance) ہوگا (یا کم از کم اس کے برابر)۔
+
+### Dependencies { #dependencies }
+
+یہی [dependencies](tutorial/dependencies/index.md) پر بھی لاگو ہوتا ہے۔ اگر dependency ایک عام `def` function ہے `async def` کی بجائے، تو اسے بیرونی threadpool میں چلایا جاتا ہے۔
+
+### Sub-dependencies { #sub-dependencies }
+
+آپ کے متعدد dependencies اور [sub-dependencies](tutorial/dependencies/sub-dependencies.md) ہو سکتے ہیں جو ایک دوسرے کی ضرورت رکھتے ہوں (function definitions کے parameters کے طور پر)، ان میں سے کچھ `async def` سے بنائے جا سکتے ہیں اور کچھ عام `def` سے۔ یہ پھر بھی کام کرے گا، اور عام `def` سے بنائے گئے ایک بیرونی thread (threadpool سے) پر call کیے جائیں گے "await" کیے جانے کی بجائے۔
+
+### دوسرے utility functions { #other-utility-functions }
+
+کوئی بھی دوسرا utility function جسے آپ براہ راست call کرتے ہیں، عام `def` یا `async def` سے بنایا جا سکتا ہے اور FastAPI اس پر اثر نہیں ڈالے گا جس طرح آپ اسے call کرتے ہیں۔
+
+یہ ان functions کے برعکس ہے جو FastAPI آپ کے لیے call کرتا ہے: *path operation functions* اور dependencies۔
+
+اگر آپ کا utility function ایک عام `def` والا function ہے، تو اسے براہ راست call کیا جائے گا (جیسا کہ آپ اسے اپنے code میں لکھتے ہیں)، threadpool میں نہیں، اگر function `async def` سے بنایا گیا ہے تو آپ کو اس function کو اپنے code میں call کرتے وقت `await` کرنا چاہیے۔
+
+---
+
+دوبارہ، یہ بہت تکنیکی تفصیلات ہیں جو شاید مفید ہوں اگر آپ انہیں تلاش کرتے ہوئے آئے ہیں۔
+
+ورنہ، آپ اوپر والے سیکشن کی ہدایات سے ٹھیک ہونے چاہئیں: جلدی میں ہیں؟
diff --git a/docs/ur/docs/benchmarks.md b/docs/ur/docs/benchmarks.md
new file mode 100644
index 000000000..279d55706
--- /dev/null
+++ b/docs/ur/docs/benchmarks.md
@@ -0,0 +1,34 @@
+# Benchmarks { #benchmarks }
+
+آزاد TechEmpower benchmarks ظاہر کرتے ہیں کہ Uvicorn کے تحت چلنے والی **FastAPI** applications [دستیاب تیز ترین Python frameworks میں سے ایک](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7) ہیں، صرف Starlette اور Uvicorn سے پیچھے (جو FastAPI اندرونی طور پر استعمال کرتا ہے)۔
+
+لیکن benchmarks اور موازنے دیکھتے وقت آپ کو درج ذیل باتیں ذہن میں رکھنی چاہئیں۔
+
+## Benchmarks اور رفتار { #benchmarks-and-speed }
+
+جب آپ benchmarks دیکھتے ہیں، تو عام طور پر مختلف اقسام کے کئی tools کو مساوی کے طور پر موازنہ کیا جاتا ہے۔
+
+خاص طور پر، Uvicorn، Starlette اور FastAPI کو ایک ساتھ (بہت سے دوسرے tools کے درمیان) موازنے میں دیکھنا۔
+
+tool جتنا آسان مسئلہ حل کرتا ہے، اتنی بہتر performance دیتا ہے۔ اور زیادہ تر benchmarks tool کی فراہم کردہ اضافی features کو ٹیسٹ نہیں کرتے۔
+
+درجہ بندی اس طرح ہے:
+
+* **Uvicorn**: ایک ASGI server
+ * **Starlette**: (Uvicorn استعمال کرتا ہے) ایک web microframework
+ * **FastAPI**: (Starlette استعمال کرتا ہے) ایک API microframework جس میں APIs بنانے کے لیے کئی اضافی features ہیں، data validation وغیرہ کے ساتھ۔
+
+* **Uvicorn**:
+ * سب سے بہترین performance ہوگی، کیونکہ server کے علاوہ اس میں زیادہ اضافی code نہیں ہے۔
+ * آپ براہ راست Uvicorn میں application نہیں لکھیں گے۔ اس کا مطلب ہوگا کہ آپ کے code میں کم از کم وہ سارا code شامل ہو جو Starlette (یا **FastAPI**) فراہم کرتا ہے۔ اور اگر آپ ایسا کریں، تو آپ کی حتمی application میں بھی وہی overhead ہوگا جیسا framework استعمال کرنے اور app code اور bugs کو کم سے کم رکھنے میں ہوتا۔
+ * اگر آپ Uvicorn کا موازنہ کر رہے ہیں، تو اسے Daphne، Hypercorn، uWSGI وغیرہ سے موازنہ کریں۔ Application servers۔
+* **Starlette**:
+ * Uvicorn کے بعد اگلی بہترین performance ہوگی۔ درحقیقت، Starlette چلنے کے لیے Uvicorn استعمال کرتا ہے۔ تو یہ شاید صرف مزید code execute کرنے کی وجہ سے Uvicorn سے "سست" ہو سکتا ہے۔
+ * لیکن یہ آپ کو سادہ web applications بنانے کے tools فراہم کرتا ہے، paths پر مبنی routing وغیرہ کے ساتھ۔
+ * اگر آپ Starlette کا موازنہ کر رہے ہیں، تو اسے Sanic، Flask، Django وغیرہ سے موازنہ کریں۔ Web frameworks (یا microframeworks)۔
+* **FastAPI**:
+ * جس طرح Starlette، Uvicorn استعمال کرتا ہے اور اس سے تیز نہیں ہو سکتا، **FastAPI** Starlette استعمال کرتا ہے، تو یہ اس سے تیز نہیں ہو سکتا۔
+ * FastAPI، Starlette کے اوپر مزید features فراہم کرتا ہے۔ وہ features جن کی آپ کو APIs بناتے وقت تقریباً ہمیشہ ضرورت ہوتی ہے، جیسے data validation اور serialization۔ اور اسے استعمال کرنے سے آپ کو خودکار documentation مفت میں ملتی ہے (خودکار documentation چلتی applications میں overhead بھی نہیں ڈالتی، یہ startup پر generate ہوتی ہے)۔
+ * اگر آپ نے FastAPI استعمال نہ کیا ہوتا اور براہ راست Starlette (یا کوئی اور tool جیسے Sanic، Flask، Responder وغیرہ) استعمال کیا ہوتا تو آپ کو ساری data validation اور serialization خود implement کرنی ہوتی۔ تو آپ کی حتمی application میں پھر بھی وہی overhead ہوتا جیسا FastAPI استعمال کرنے میں ہوتا۔ اور بہت سے معاملات میں، یہ data validation اور serialization applications میں لکھے جانے والے code کا سب سے بڑا حصہ ہوتی ہے۔
+ * تو FastAPI استعمال کرکے آپ development time، bugs، code کی لائنیں بچا رہے ہیں، اور شاید آپ کو وہی performance (یا بہتر) ملے گی جو آپ کو اسے استعمال نہ کرنے پر ملتی (کیونکہ آپ کو یہ سب اپنے code میں implement کرنا ہوتا)۔
+ * اگر آپ FastAPI کا موازنہ کر رہے ہیں، تو اسے کسی web application framework (یا tools کے مجموعے) سے موازنہ کریں جو data validation، serialization اور documentation فراہم کرتا ہو، جیسے Flask-apispec، NestJS، Molten وغیرہ۔ وہ frameworks جن میں مربوط خودکار data validation، serialization اور documentation شامل ہو۔
diff --git a/docs/ur/docs/contributing.md b/docs/ur/docs/contributing.md
new file mode 100644
index 000000000..4a39c2daf
--- /dev/null
+++ b/docs/ur/docs/contributing.md
@@ -0,0 +1,261 @@
+# ترقی - تعاون
+
+پہلے، آپ [FastAPI کی مدد کریں اور مدد حاصل کریں](help-fastapi.md) کے بنیادی طریقے دیکھنا چاہیں گے۔
+
+## ترقی
+
+اگر آپ نے پہلے ہی [fastapi repository](https://github.com/fastapi/fastapi) clone کر لیا ہے اور code میں گہرائی سے جانا چاہتے ہیں، تو یہاں آپ کا ماحول ترتیب دینے کی کچھ ہدایات ہیں۔
+
+### ضروریات install کریں
+
+Virtual environment بنائیں اور [`uv`](https://github.com/astral-sh/uv) کے ساتھ درکار packages install کریں:
+
++بڑی+ +نادانستہ طور پر نقصان پہنچانے سے بچیں۔ + +آپ کے پاس حیرت انگیز tools ہیں، انہیں سمجھداری سے مؤثر طریقے سے مدد کرنے کے لیے استعمال کریں۔ diff --git a/docs/ur/docs/deployment/cloud.md b/docs/ur/docs/deployment/cloud.md new file mode 100644 index 000000000..1f293c2d9 --- /dev/null +++ b/docs/ur/docs/deployment/cloud.md @@ -0,0 +1,24 @@ +# Cloud Providers پر FastAPI Deploy کریں { #deploy-fastapi-on-cloud-providers } + +آپ اپنی FastAPI ایپلیکیشن deploy کرنے کے لیے عملی طور پر **کوئی بھی cloud provider** استعمال کر سکتے ہیں۔ + +زیادہ تر معاملات میں، بڑے cloud providers کے پاس FastAPI کو ان کے ساتھ deploy کرنے کی رہنما دستاویزات موجود ہیں۔ + +## FastAPI Cloud { #fastapi-cloud } + +**[FastAPI Cloud](https://fastapicloud.com)** اسی مصنف اور ٹیم نے بنایا ہے جو **FastAPI** کے پیچھے ہے۔ + +یہ کم سے کم محنت کے ساتھ API **بنانے**، **deploy کرنے**، اور **رسائی حاصل کرنے** کے عمل کو آسان بناتا ہے۔ + +یہ FastAPI کے ساتھ apps بنانے کا وہی **developer experience** cloud پر **deploy** کرنے میں لاتا ہے۔ 🎉 + +FastAPI Cloud *FastAPI اور دوستوں* کے اوپن سورس منصوبوں کا بنیادی کفیل اور فنڈنگ فراہم کنندہ ہے۔ ✨ + +## Cloud Providers - کفیل { #cloud-providers-sponsors } + +کچھ اور cloud providers ✨ [**FastAPI کی کفالت**](../help-fastapi.md#sponsor-the-author) ✨ بھی کرتے ہیں۔ 🙇 + +آپ ان کی رہنما دستاویزات کی پیروی اور ان کی خدمات آزمانے پر بھی غور کر سکتے ہیں: + +* [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/ur/docs/deployment/concepts.md b/docs/ur/docs/deployment/concepts.md new file mode 100644 index 000000000..1a87f1921 --- /dev/null +++ b/docs/ur/docs/deployment/concepts.md @@ -0,0 +1,321 @@ +# Deployment کے تصورات { #deployments-concepts } + +**FastAPI** ایپلیکیشن، یا درحقیقت کسی بھی قسم کی web API deploy کرتے وقت، کئی تصورات ہیں جن کی آپ کو فکر ہوتی ہے، اور ان کا استعمال کرتے ہوئے آپ اپنی **ایپلیکیشن deploy کرنے** کا **سب سے موزوں** طریقہ تلاش کر سکتے ہیں۔ + +کچھ اہم تصورات یہ ہیں: + +* سیکیورٹی - HTTPS +* شروع ہونے پر چلنا +* دوبارہ شروع ہونا +* نقل (چلنے والے processes کی تعداد) +* میموری +* شروع ہونے سے پہلے کے مراحل + +ہم دیکھیں گے کہ یہ **deployments** کو کیسے متاثر کرتے ہیں۔ + +آخر میں، حتمی مقصد یہ ہے کہ آپ اپنے **API صارفین کو** ایسے طریقے سے خدمت فراہم کر سکیں جو **محفوظ** ہو، **رکاوٹوں سے بچے**، اور **compute resources** (مثلاً remote servers/virtual machines) کو زیادہ سے زیادہ مؤثر طریقے سے استعمال کرے۔ 🚀 + +میں آپ کو یہاں ان **تصورات** کے بارے میں کچھ اور بتاؤں گا، اور اس سے امید ہے کہ آپ کو وہ **سمجھ** ملے گی جس کی آپ کو بہت مختلف ماحول میں اپنی API deploy کرنے کے فیصلے کے لیے ضرورت ہوگی، حتیٰ کہ ممکنہ طور پر **مستقبل** کے ایسے ماحول میں بھی جو ابھی موجود نہیں ہیں۔ + +ان تصورات پر غور کر کے، آپ اپنی **APIs** کو deploy کرنے کا بہترین طریقہ **جانچنے اور ڈیزائن** کرنے کے قابل ہوں گے۔ + +اگلے ابواب میں، میں آپ کو FastAPI ایپلیکیشنز deploy کرنے کی مزید **عملی ترکیبیں** دوں گا۔ + +لیکن ابھی کے لیے، آئیے ان اہم **تصوراتی خیالات** کو دیکھتے ہیں۔ یہ تصورات کسی بھی دوسری قسم کی web API پر بھی لاگو ہوتے ہیں۔ 💡 + +## سیکیورٹی - HTTPS { #security-https } + +[HTTPS کے بارے میں پچھلے باب](https.md) میں ہم نے سیکھا کہ HTTPS آپ کی API کے لیے کس طرح encryption فراہم کرتا ہے۔ + +ہم نے یہ بھی دیکھا کہ HTTPS عام طور پر آپ کے application server سے **بیرونی** جزو، ایک **TLS Termination Proxy** کے ذریعے فراہم کیا جاتا ہے۔ + +اور **HTTPS certificates کی تجدید** کے ذمہ دار کسی چیز کا ہونا ضروری ہے، یہ وہی جزو ہو سکتا ہے یا کوئی مختلف چیز ہو سکتی ہے۔ + +### HTTPS کے لیے ٹولز کی مثالیں { #example-tools-for-https } + +TLS Termination Proxy کے طور پر آپ جو ٹولز استعمال کر سکتے ہیں ان میں سے کچھ یہ ہیں: + +* Traefik + * خود بخود certificates کی تجدید سنبھالتا ہے ✨ +* Caddy + * خود بخود certificates کی تجدید سنبھالتا ہے ✨ +* Nginx + * certificate کی تجدید کے لیے Certbot جیسے بیرونی جزو کے ساتھ +* HAProxy + * certificate کی تجدید کے لیے Certbot جیسے بیرونی جزو کے ساتھ +* Kubernetes ایک Ingress Controller جیسے Nginx کے ساتھ + * certificate کی تجدید کے لیے cert-manager جیسے بیرونی جزو کے ساتھ +* cloud provider کے ذریعے ان کی خدمات کے حصے کے طور پر اندرونی طور پر سنبھالا جاتا ہے (نیچے پڑھیں 👇) + +ایک اور اختیار یہ ہے کہ آپ ایک **cloud service** استعمال کر سکتے ہیں جو HTTPS ترتیب دینے سمیت زیادہ کام کرے۔ اس میں کچھ پابندیاں ہو سکتی ہیں یا آپ سے زیادہ معاوضہ لیا جا سکتا ہے، وغیرہ۔ لیکن اس صورت میں، آپ کو خود TLS Termination Proxy ترتیب دینے کی ضرورت نہیں ہوگی۔ + +میں آپ کو اگلے ابواب میں کچھ ٹھوس مثالیں دکھاؤں گا۔ + +--- + +پھر غور کرنے والے اگلے تصورات سب آپ کی اصل API چلانے والے پروگرام (مثلاً Uvicorn) کے بارے میں ہیں۔ + +## پروگرام اور Process { #program-and-process } + +ہم چلنے والے "**process**" کے بارے میں بہت بات کریں گے، اس لیے اس بارے میں واضح ہونا مفید ہے کہ اس کا مطلب کیا ہے، اور "**program**" کے لفظ سے کیا فرق ہے۔ + +### پروگرام کیا ہے { #what-is-a-program } + +**پروگرام** کا لفظ عام طور پر بہت سی چیزوں کے لیے استعمال ہوتا ہے: + +* وہ **کوڈ** جو آپ لکھتے ہیں، **Python فائلیں**۔ +* وہ **فائل** جسے آپریٹنگ سسٹم **چلا** سکتا ہے، مثلاً: `python`، `python.exe` یا `uvicorn`۔ +* ایک مخصوص پروگرام جب یہ آپریٹنگ سسٹم پر **چل** رہا ہو، CPU استعمال کر رہا ہو، اور چیزیں میموری میں محفوظ کر رہا ہو۔ اسے **process** بھی کہتے ہیں۔ + +### Process کیا ہے { #what-is-a-process } + +**Process** کا لفظ عام طور پر زیادہ مخصوص انداز میں استعمال ہوتا ہے، صرف اس چیز کا حوالہ دیتے ہوئے جو آپریٹنگ سسٹم میں چل رہی ہے (جیسا کہ اوپر آخری نکتے میں بتایا گیا): + +* ایک مخصوص پروگرام جب یہ آپریٹنگ سسٹم پر **چل** رہا ہو۔ + * یہ فائل کا حوالہ نہیں دیتا، نہ ہی کوڈ کا، یہ **خاص طور پر** اس چیز کا حوالہ دیتا ہے جو آپریٹنگ سسٹم کے ذریعے **چلائی** اور منظم کی جا رہی ہے۔ +* کوئی بھی پروگرام، کوئی بھی کوڈ، **صرف تبھی کچھ کر سکتا ہے** جب یہ **چلایا** جا رہا ہو۔ تو، جب ایک **process چل** رہا ہو۔ +* process کو آپ یا آپریٹنگ سسٹم **ختم** (یا "kill") کر سکتا ہے۔ اس وقت، یہ چلنا/عمل درآمد ہونا بند ہو جاتا ہے، اور یہ **مزید کچھ نہیں کر سکتا**۔ +* آپ کے کمپیوٹر پر چلنے والی ہر ایپلیکیشن کے پیچھے کوئی process ہوتا ہے، ہر چلنے والا پروگرام، ہر ونڈو، وغیرہ۔ اور عام طور پر کمپیوٹر آن ہونے پر **ایک ہی وقت میں** بہت سے processes چل رہے ہوتے ہیں۔ +* **ایک ہی پروگرام** کے **متعدد processes** ایک ہی وقت میں چل سکتے ہیں۔ + +اگر آپ اپنے آپریٹنگ سسٹم میں "task manager" یا "system monitor" (یا اسی طرح کے ٹولز) دیکھیں، تو آپ ان میں سے بہت سے processes چلتے ہوئے دیکھ سکیں گے۔ + +اور، مثال کے طور پر، آپ شاید دیکھیں گے کہ ایک ہی browser پروگرام (Firefox، Chrome، Edge، وغیرہ) کے متعدد processes چل رہے ہیں۔ وہ عام طور پر ہر ٹیب کے لیے ایک process چلاتے ہیں، اس کے علاوہ کچھ اضافی processes بھی۔ + +طاقتtools کے ساتھ بڑی ذمہ داری آتی ہے۔ +
+
+---
+
+اب جب ہم **process** اور **program** کی اصطلاحات کے درمیان فرق جان گئے ہیں، تو آئیے deployments کے بارے میں بات جاری رکھیں۔
+
+## شروع ہونے پر چلنا { #running-on-startup }
+
+زیادہ تر معاملات میں، جب آپ web API بناتے ہیں، تو آپ چاہتے ہیں کہ یہ **ہمیشہ چلتی** رہے، بلا رکاوٹ، تاکہ آپ کے صارفین ہمیشہ اس تک رسائی حاصل کر سکیں۔ یہ یقیناً اس صورت میں ہے جب تک کہ آپ کے پاس کوئی خاص وجہ نہ ہو کہ آپ اسے صرف مخصوص حالات میں چلانا چاہتے ہیں، لیکن زیادہ تر وقت آپ چاہتے ہیں کہ یہ مسلسل چلتی رہے اور **دستیاب** ہو۔
+
+### Remote Server میں { #in-a-remote-server }
+
+جب آپ remote server (cloud server، virtual machine وغیرہ) ترتیب دیتے ہیں تو سب سے آسان کام جو آپ کر سکتے ہیں وہ ہے `fastapi run` (جو Uvicorn استعمال کرتا ہے) یا کچھ ایسا ہی دستی طور پر استعمال کرنا، بالکل اسی طرح جیسے آپ مقامی طور پر development کے دوران کرتے ہیں۔
+
+اور یہ کام کرے گا اور **development کے دوران** مفید ہوگا۔
+
+لیکن اگر server سے آپ کا کنکشن ٹوٹ جائے، تو **چلنے والا process** شاید ختم ہو جائے گا۔
+
+اور اگر server دوبارہ شروع ہوتا ہے (مثلاً updates یا cloud provider کی migrations کے بعد) تو آپ کو شاید **اس کا پتا بھی نہیں چلے گا**۔ اور اس وجہ سے، آپ کو یہ بھی معلوم نہیں ہوگا کہ آپ کو process دستی طور پر دوبارہ شروع کرنا ہے۔ تو، آپ کی API بس بند رہے گی۔ 😱
+
+### شروع ہونے پر خود بخود چلنا { #run-automatically-on-startup }
+
+عام طور پر، آپ شاید چاہیں گے کہ server پروگرام (مثلاً Uvicorn) server شروع ہونے پر خود بخود شروع ہو جائے، اور بغیر کسی **انسانی مداخلت** کے، تاکہ آپ کی API کے ساتھ ہمیشہ ایک process چلتا رہے (مثلاً Uvicorn آپ کی FastAPI app چلا رہا ہو)۔
+
+### الگ پروگرام { #separate-program }
+
+اسے حاصل کرنے کے لیے، آپ کے پاس عام طور پر ایک **الگ پروگرام** ہوگا جو اس بات کو یقینی بنائے گا کہ آپ کی ایپلیکیشن شروع ہونے پر چلے۔ اور بہت سے معاملات میں، یہ دوسرے اجزاء یا ایپلیکیشنز بھی چلانے کو یقینی بنائے گا، مثلاً ایک ڈیٹابیس۔
+
+### شروع ہونے پر چلانے کے لیے ٹولز کی مثالیں { #example-tools-to-run-at-startup }
+
+یہ کام کرنے والے کچھ ٹولز کی مثالیں یہ ہیں:
+
+* Docker
+* Kubernetes
+* Docker Compose
+* Docker in Swarm Mode
+* Systemd
+* Supervisor
+* cloud provider کے ذریعے ان کی خدمات کے حصے کے طور پر اندرونی طور پر سنبھالا جاتا ہے
+* دیگر...
+
+میں آپ کو اگلے ابواب میں مزید ٹھوس مثالیں دوں گا۔
+
+## دوبارہ شروع ہونا { #restarts }
+
+شروع ہونے پر اپنی ایپلیکیشن چلنے کو یقینی بنانے کی طرح، آپ شاید یہ بھی یقینی بنانا چاہیں گے کہ ناکامیوں کے بعد یہ **دوبارہ شروع** ہو جائے۔
+
+### ہم سے غلطیاں ہوتی ہیں { #we-make-mistakes }
+
+ہم، بحیثیت انسان، ہر وقت **غلطیاں** کرتے ہیں۔ سافٹ ویئر میں تقریباً *ہمیشہ* مختلف جگہوں پر **bugs** چھپے ہوتے ہیں۔ 🐛
+
+اور ہم بحیثیت developers جب ان bugs تلاش کرتے ہیں اور نئے فیچرز شامل کرتے ہیں تو کوڈ کو بہتر بناتے رہتے ہیں (شاید نئے bugs بھی شامل کرتے ہوئے 😅)۔
+
+### چھوٹی خرابیاں خود بخود سنبھالی جاتی ہیں { #small-errors-automatically-handled }
+
+FastAPI کے ساتھ web APIs بناتے وقت، اگر ہمارے کوڈ میں کوئی خرابی ہو، تو FastAPI عام طور پر اسے اس واحد request تک محدود رکھے گی جس نے خرابی کو متحرک کیا۔ 🛡
+
+صارف کو اس request کے لیے **500 Internal Server Error** ملے گی، لیکن ایپلیکیشن مکمل طور پر بند ہونے کے بجائے اگلی requests کے لیے کام کرتی رہے گی۔
+
+### بڑی خرابیاں - بند ہو جانا { #bigger-errors-crashes }
+
+تاہم، ایسے معاملات ہو سکتے ہیں جہاں ہم ایسا کوڈ لکھتے ہیں جو **پوری ایپلیکیشن کو بند کر دیتا ہے** جس سے Uvicorn اور Python بند ہو جاتے ہیں۔ 💥
+
+اور پھر بھی، آپ شاید نہیں چاہیں گے کہ ایپلیکیشن اس لیے بند رہے کہ ایک جگہ خرابی تھی، آپ شاید چاہیں گے کہ یہ کم از کم ان *path operations* کے لیے **چلتی رہے** جو خراب نہیں ہیں۔
+
+### بند ہونے کے بعد دوبارہ شروع { #restart-after-crash }
+
+لیکن ان معاملات میں جہاں واقعی بری خرابیاں چلتے ہوئے **process** کو بند کر دیتی ہیں، آپ ایک بیرونی جزو چاہیں گے جو process کو **دوبارہ شروع** کرنے کا ذمہ دار ہو، کم از کم چند بار...
+
+/// tip | مشورہ
+
+...اگرچہ اگر پوری ایپلیکیشن **فوری طور پر بند ہو رہی ہے** تو شاید اسے ہمیشہ کے لیے دوبارہ شروع کرتے رہنا معقول نہیں ہے۔ لیکن ان معاملات میں، آپ کو شاید development کے دوران، یا کم از کم deployment کے فوراً بعد اس کا پتا چل جائے گا۔
+
+تو آئیے ان اصل معاملات پر توجہ مرکوز کریں، جہاں یہ **مستقبل میں** کچھ خاص معاملات میں مکمل طور پر بند ہو سکتا ہے، اور اسے دوبارہ شروع کرنا معقول ہے۔
+
+///
+
+آپ شاید اپنی ایپلیکیشن دوبارہ شروع کرنے کے ذمہ دار کو ایک **بیرونی جزو** کے طور پر رکھنا چاہیں گے، کیونکہ اس وقت، Uvicorn اور Python کے ساتھ وہی ایپلیکیشن پہلے ہی بند ہو چکی ہوتی ہے، تو اسی app کے اسی کوڈ میں کچھ بھی نہیں ہے جو اس کے بارے میں کچھ کر سکے۔
+
+### خود بخود دوبارہ شروع کرنے کے لیے ٹولز کی مثالیں { #example-tools-to-restart-automatically }
+
+زیادہ تر معاملات میں، وہی ٹول جو **پروگرام کو شروع ہونے پر چلانے** کے لیے استعمال ہوتا ہے، خود بخود **دوبارہ شروع** کرنے کو سنبھالنے کے لیے بھی استعمال ہوتا ہے۔
+
+مثال کے طور پر، یہ ان کے ذریعے سنبھالا جا سکتا ہے:
+
+* Docker
+* Kubernetes
+* Docker Compose
+* Docker in Swarm Mode
+* Systemd
+* Supervisor
+* cloud provider کے ذریعے ان کی خدمات کے حصے کے طور پر اندرونی طور پر سنبھالا جاتا ہے
+* دیگر...
+
+## نقل - Processes اور میموری { #replication-processes-and-memory }
+
+FastAPI ایپلیکیشن کے ساتھ، `fastapi` command جیسے server پروگرام کا استعمال کرتے ہوئے جو Uvicorn چلاتا ہے، اسے ایک بار **ایک process** میں چلانے سے متعدد صارفین کو بیک وقت خدمت فراہم کی جا سکتی ہے۔
+
+لیکن بہت سے معاملات میں، آپ ایک ہی وقت میں کئی worker processes چلانا چاہیں گے۔
+
+### متعدد Processes - Workers { #multiple-processes-workers }
+
+اگر آپ کے پاس ایک process سے زیادہ صارفین ہیں (مثلاً اگر virtual machine بہت بڑی نہیں ہے) اور server کے CPU میں **متعدد cores** ہیں، تو آپ ایک ہی وقت میں ایک ہی ایپلیکیشن کے **متعدد processes** چلا سکتے ہیں، اور تمام requests ان میں تقسیم کر سکتے ہیں۔
+
+جب آپ ایک ہی API پروگرام کے **متعدد processes** چلاتے ہیں، تو انہیں عام طور پر **workers** کہا جاتا ہے۔
+
+### Worker Processes اور Ports { #worker-processes-and-ports }
+
+[HTTPS کے بارے میں](https.md) دستاویزات سے یاد ہے کہ server میں ایک port اور IP ایڈریس کے مجموعے پر صرف ایک process سن سکتا ہے؟
+
+یہ ابھی بھی درست ہے۔
+
+تو، ایک ہی وقت میں **متعدد processes** رکھنے کے لیے، ایک **واحد process کا port پر سننا** ضروری ہے جو پھر ہر worker process کو کسی طرح سے مواصلت منتقل کرے۔
+
+### فی Process میموری { #memory-per-process }
+
+اب، جب پروگرام چیزیں میموری میں لوڈ کرتا ہے، مثلاً ایک machine learning ماڈل کسی variable میں، یا کسی بڑی فائل کا مواد کسی variable میں، تو یہ سب server کی **میموری (RAM) کا کچھ حصہ استعمال** کرتا ہے۔
+
+اور متعدد processes عام طور پر **کوئی میموری شیئر نہیں کرتے**۔ اس کا مطلب ہے کہ ہر چلنے والے process کی اپنی چیزیں، variables اور میموری ہوتی ہے۔ اور اگر آپ اپنے کوڈ میں بڑی مقدار میں میموری استعمال کر رہے ہیں، تو **ہر process** اتنی ہی میموری استعمال کرے گا۔
+
+### Server کی میموری { #server-memory }
+
+مثال کے طور پر، اگر آپ کا کوڈ **1 GB سائز** کا Machine Learning ماڈل لوڈ کرتا ہے، جب آپ اپنی API کے ساتھ ایک process چلاتے ہیں، تو یہ کم از کم 1 GB RAM استعمال کرے گا۔ اور اگر آپ **4 processes** (4 workers) شروع کرتے ہیں، تو ہر ایک 1 GB RAM استعمال کرے گا۔ تو مجموعی طور پر، آپ کی API **4 GB RAM** استعمال کرے گی۔
+
+اور اگر آپ کے remote server یا virtual machine میں صرف 3 GB RAM ہے، تو 4 GB سے زیادہ RAM لوڈ کرنے کی کوشش مسائل پیدا کرے گی۔ 🚨
+
+### متعدد Processes - ایک مثال { #multiple-processes-an-example }
+
+اس مثال میں، ایک **Manager Process** ہے جو دو **Worker Processes** کو شروع اور کنٹرول کرتا ہے۔
+
+یہ Manager Process شاید وہ ہوگا جو IP میں **port** پر سن رہا ہو۔ اور یہ تمام مواصلت worker processes کو منتقل کرے گا۔
+
+وہ worker processes وہ ہوں گے جو آپ کی ایپلیکیشن چلا رہے ہوں گے، وہ **request** وصول کرنے اور **response** واپس کرنے کے لیے اصل حسابات انجام دیں گے، اور وہ آپ کی variables میں ڈالی گئی کوئی بھی چیز RAM میں لوڈ کریں گے۔
+
+
+
+اور یقیناً، اسی مشین پر آپ کی ایپلیکیشن کے علاوہ شاید **دوسرے processes** بھی چل رہے ہوں گے۔
+
+ایک دلچسپ بات یہ ہے کہ ہر process کی **CPU استعمال** کی فیصد وقت کے ساتھ **بہت زیادہ تبدیل** ہو سکتی ہے، لیکن **میموری (RAM)** عام طور پر کم و بیش **مستحکم** رہتی ہے۔
+
+اگر آپ کے پاس ایسی API ہے جو ہر بار تقریباً یکساں مقدار میں حسابات کرتی ہے اور آپ کے بہت سے صارفین ہیں، تو **CPU کا استعمال** شاید *بھی مستحکم* ہوگا (مسلسل اوپر نیچے جانے کے بجائے)۔
+
+### نقل کے ٹولز اور حکمت عملیوں کی مثالیں { #examples-of-replication-tools-and-strategies }
+
+اسے حاصل کرنے کے کئی طریقے ہو سکتے ہیں، اور میں آپ کو اگلے ابواب میں مخصوص حکمت عملیوں کے بارے میں مزید بتاؤں گا، مثلاً Docker اور containers کے بارے میں بات کرتے وقت۔
+
+غور کرنے کی بنیادی پابندی یہ ہے کہ **عوامی IP** میں **port** سنبھالنے والا ایک **واحد** جزو ہونا ضروری ہے۔ اور پھر اس کے پاس نقل شدہ **processes/workers** کو مواصلت **منتقل** کرنے کا کوئی طریقہ ہونا ضروری ہے۔
+
+یہاں کچھ ممکنہ مجموعے اور حکمت عملیاں ہیں:
+
+* **Uvicorn** `--workers` کے ساتھ
+ * ایک Uvicorn **process manager** **IP** اور **port** پر سنے گا، اور یہ **متعدد Uvicorn worker processes** شروع کرے گا۔
+* **Kubernetes** اور دوسرے تقسیم شدہ **container systems**
+ * **Kubernetes** پرت میں کوئی چیز **IP** اور **port** پر سنے گی۔ نقل **متعدد containers** رکھ کر ہوگی، ہر ایک میں **ایک Uvicorn process** چل رہا ہوگا۔
+* **Cloud services** جو یہ آپ کے لیے سنبھالتی ہیں
+ * cloud service شاید **آپ کے لیے نقل سنبھالے گی**۔ یہ ممکنہ طور پر آپ کو **چلانے کے لیے ایک process** یا استعمال کرنے کے لیے ایک **container image** تعین کرنے دے گی، کسی بھی صورت میں، یہ شاید **ایک واحد Uvicorn process** ہوگا، اور cloud service اس کی نقل کی ذمہ دار ہوگی۔
+
+/// tip | مشورہ
+
+اگر **containers**، Docker، یا Kubernetes کے بارے میں ان میں سے کچھ آئٹمز ابھی زیادہ واضح نہیں ہیں تو فکر نہ کریں۔
+
+میں آپ کو container images، Docker، Kubernetes وغیرہ کے بارے میں ایک آئندہ باب میں مزید بتاؤں گا: [FastAPI in Containers - Docker](docker.md)۔
+
+///
+
+## شروع ہونے سے پہلے کے مراحل { #previous-steps-before-starting }
+
+بہت سے معاملات ہیں جہاں آپ اپنی ایپلیکیشن **شروع ہونے سے پہلے** کچھ مراحل انجام دینا چاہتے ہیں۔
+
+مثال کے طور پر، آپ شاید **database migrations** چلانا چاہیں۔
+
+لیکن زیادہ تر معاملات میں، آپ یہ مراحل صرف **ایک بار** انجام دینا چاہیں گے۔
+
+تو، ایپلیکیشن شروع کرنے سے پہلے ان **پچھلے مراحل** کو انجام دینے کے لیے آپ ایک **واحد process** رکھنا چاہیں گے۔
+
+اور آپ کو اس بات کو یقینی بنانا ہوگا کہ یہ واحد process ان پچھلے مراحل کو چلائے *چاہے* بعد میں آپ خود ایپلیکیشن کے لیے **متعدد processes** (متعدد workers) شروع کریں۔ اگر یہ مراحل **متعدد processes** کے ذریعے چلائے جائیں، تو وہ **متوازی** طور پر چلا کر کام کی **نقل** کریں گے، اور اگر مراحل کوئی نازک چیز ہوں جیسے database migration، تو وہ ایک دوسرے سے ٹکراؤ پیدا کر سکتے ہیں۔
+
+یقیناً، کچھ معاملات ایسے ہیں جہاں پچھلے مراحل کو کئی بار چلانے میں کوئی مسئلہ نہیں ہے، اس صورت میں اسے سنبھالنا بہت آسان ہے۔
+
+/// tip | مشورہ
+
+اس بات کو بھی ذہن میں رکھیں کہ آپ کے سیٹ اپ پر منحصر ہے، کچھ معاملات میں آپ کو اپنی ایپلیکیشن شروع کرنے سے پہلے **کسی پچھلے مرحلے کی ضرورت ہی نہ ہو**۔
+
+اس صورت میں، آپ کو اس میں سے کسی کے بارے میں فکر کرنے کی ضرورت نہیں ہوگی۔ 🤷
+
+///
+
+### پچھلے مراحل کی حکمت عملیوں کی مثالیں { #examples-of-previous-steps-strategies }
+
+یہ بہت زیادہ اس بات پر **منحصر** ہوگا کہ آپ **اپنا سسٹم کیسے deploy** کرتے ہیں، اور یہ شاید پروگرامز شروع کرنے، دوبارہ شروع کرنے وغیرہ کے طریقے سے جڑا ہوگا۔
+
+یہاں کچھ ممکنہ خیالات ہیں:
+
+* Kubernetes میں "Init Container" جو آپ کے app container سے پہلے چلے
+* ایک bash script جو پچھلے مراحل چلائے اور پھر آپ کی ایپلیکیشن شروع کرے
+ * آپ کو پھر بھی *اس* bash script کو شروع/دوبارہ شروع کرنے، خرابیوں کا پتا لگانے وغیرہ کا طریقہ درکار ہوگا۔
+
+/// tip | مشورہ
+
+میں آپ کو containers کے ساتھ ایسا کرنے کی مزید ٹھوس مثالیں ایک آئندہ باب میں دوں گا: [FastAPI in Containers - Docker](docker.md)۔
+
+///
+
+## وسائل کا استعمال { #resource-utilization }
+
+آپ کا/کے server(s) ایک **وسیلہ** ہے/ہیں، آپ اپنے پروگراموں سے استعمال کر سکتے ہیں، CPUs پر حساب کا وقت، اور دستیاب RAM میموری۔
+
+آپ سسٹم کے کتنے وسائل استعمال کرنا چاہتے ہیں؟ یہ سوچنا آسان ہو سکتا ہے "زیادہ نہیں"، لیکن حقیقت میں، آپ شاید **بند ہوئے بغیر زیادہ سے زیادہ** استعمال کرنا چاہیں گے۔
+
+اگر آپ 3 servers کے لیے ادائیگی کر رہے ہیں لیکن ان کی RAM اور CPU کا صرف تھوڑا سا استعمال کر رہے ہیں، تو آپ شاید **پیسے ضائع کر رہے ہیں** 💸، اور شاید **server کی بجلی بھی ضائع کر رہے ہیں** 🌎، وغیرہ۔
+
+اس صورت میں، صرف 2 servers رکھنا اور ان کے وسائل (CPU، میموری، ڈسک، نیٹ ورک bandwidth وغیرہ) کا زیادہ فیصد استعمال کرنا بہتر ہو سکتا ہے۔
+
+دوسری طرف، اگر آپ کے پاس 2 servers ہیں اور آپ ان کی **CPU اور RAM کا 100%** استعمال کر رہے ہیں، تو کسی وقت ایک process مزید میموری مانگے گا، اور server کو ڈسک کو "میموری" کے طور پر استعمال کرنا پڑے گا (جو ہزاروں گنا سست ہو سکتا ہے)، یا حتیٰ کہ **بند ہو سکتا ہے**۔ یا ایک process کو کچھ حساب کرنے کی ضرورت ہوگی اور اسے CPU دوبارہ خالی ہونے تک انتظار کرنا پڑے گا۔
+
+اس صورت میں، **ایک اضافی server** لینا اور اس پر کچھ processes چلانا بہتر ہوگا تاکہ سب کے پاس **کافی RAM اور CPU وقت** ہو۔
+
+یہ بھی ممکن ہے کہ کسی وجہ سے آپ کی API کے استعمال میں **اچانک اضافہ** ہو جائے۔ شاید یہ وائرل ہو گئی، یا شاید کچھ دوسری خدمات یا bots اسے استعمال کرنا شروع کر دیں۔ اور آپ ان حالات میں محفوظ رہنے کے لیے اضافی وسائل رکھنا چاہ سکتے ہیں۔
+
+آپ ہدف کے لیے ایک **من مانی تعداد** مقرر کر سکتے ہیں، مثلاً وسائل کے استعمال کے **50% سے 90% کے درمیان** کچھ۔ بات یہ ہے کہ شاید یہ وہ اصل چیزیں ہیں جو آپ ناپنا اور اپنے deployments کو بہتر بنانے کے لیے استعمال کرنا چاہیں گے۔
+
+آپ اپنے server میں CPU اور RAM کا استعمال یا ہر process کے ذریعے استعمال ہونے والی مقدار دیکھنے کے لیے `htop` جیسے آسان ٹولز استعمال کر سکتے ہیں۔ یا آپ زیادہ پیچیدہ مانیٹرنگ ٹولز استعمال کر سکتے ہیں، جو servers پر تقسیم شدہ ہو سکتے ہیں، وغیرہ۔
+
+## خلاصہ { #recap }
+
+آپ نے یہاں ان اصل تصورات میں سے کچھ پڑھے ہیں جو آپ کو اپنی ایپلیکیشن deploy کرنے کا فیصلہ کرتے وقت ذہن میں رکھنے کی ضرورت ہوگی:
+
+* سیکیورٹی - HTTPS
+* شروع ہونے پر چلنا
+* دوبارہ شروع ہونا
+* نقل (چلنے والے processes کی تعداد)
+* میموری
+* شروع ہونے سے پہلے کے مراحل
+
+ان خیالات کو سمجھنا اور انہیں لاگو کرنے کا طریقہ جاننا آپ کو deployments کو ترتیب اور بہتر بنانے کے فیصلے کرنے کے لیے ضروری سمجھ فراہم کرے۔ 🤓
+
+اگلے حصوں میں، میں آپ کو ممکنہ حکمت عملیوں کی مزید ٹھوس مثالیں دوں گا۔ 🚀
diff --git a/docs/ur/docs/deployment/docker.md b/docs/ur/docs/deployment/docker.md
new file mode 100644
index 000000000..5905f0459
--- /dev/null
+++ b/docs/ur/docs/deployment/docker.md
@@ -0,0 +1,618 @@
+# FastAPI in Containers - Docker { #fastapi-in-containers-docker }
+
+FastAPI ایپلیکیشنز deploy کرتے وقت ایک عام طریقہ **Linux container image** بنانا ہے۔ یہ عام طور پر [**Docker**](https://www.docker.com/) استعمال کرتے ہوئے کیا جاتا ہے۔ پھر آپ اس container image کو کئی ممکنہ طریقوں سے deploy کر سکتے ہیں۔
+
+Linux containers استعمال کرنے کے کئی فوائد ہیں بشمول **سیکیورٹی**، **نقل پذیری**، **سادگی**، اور دیگر۔
+
+/// tip | مشورہ
+
+جلدی میں ہیں اور یہ سب پہلے سے جانتے ہیں؟ نیچے [`Dockerfile` 👇](#build-a-docker-image-for-fastapi) پر جائیں۔
+
+///
+
+
+
+### TLS Handshake کا آغاز { #tls-handshake-start }
+
+browser پھر اس IP ایڈریس سے **port 443** (HTTPS port) پر مواصلت کرے گا۔
+
+مواصلت کا پہلا حصہ صرف client اور server کے درمیان کنکشن قائم کرنا اور خفیہ keys وغیرہ کا فیصلہ کرنا ہے۔
+
+
+
+TLS کنکشن قائم کرنے کے لیے client اور server کے درمیان اس تعامل کو **TLS handshake** کہا جاتا ہے۔
+
+### SNI توسیع کے ساتھ TLS { #tls-with-sni-extension }
+
+server میں ایک مخصوص **IP ایڈریس** کے مخصوص **port** پر صرف **ایک process** سن سکتا ہے۔ اسی IP ایڈریس پر دوسرے ports پر دوسرے processes سن سکتے ہیں، لیکن ہر IP ایڈریس اور port کے مجموعے کے لیے صرف ایک۔
+
+TLS (HTTPS) بطور ڈیفالٹ مخصوص port `443` استعمال کرتا ہے۔ تو ہمیں اسی port کی ضرورت ہوگی۔
+
+چونکہ اس port پر صرف ایک process سن سکتا ہے، وہ process جو یہ کرے گا وہ **TLS Termination Proxy** ہوگا۔
+
+TLS Termination Proxy کے پاس ایک یا زیادہ **TLS certificates** (HTTPS certificates) تک رسائی ہوگی۔
+
+اوپر بحث کی گئی **SNI توسیع** کا استعمال کرتے ہوئے، TLS Termination Proxy چیک کرے گا کہ دستیاب TLS (HTTPS) certificates میں سے اسے اس کنکشن کے لیے کون سا استعمال کرنا چاہیے، وہ جو client کی متوقع domain سے مماثل ہو۔
+
+اس معاملے میں، یہ `someapp.example.com` کا certificate استعمال کرے گا۔
+
+
+
+client پہلے سے اس ادارے پر **اعتماد** کرتا ہے جس نے وہ TLS certificate تیار کیا (اس معاملے میں Let's Encrypt، لیکن ہم اس کے بارے میں بعد میں بات کریں گے)، تو یہ **تصدیق** کر سکتا ہے کہ certificate درست ہے۔
+
+پھر، certificate کا استعمال کرتے ہوئے، client اور TLS Termination Proxy باقی **TCP مواصلت کو encrypt کرنے کا طریقہ فیصلہ** کرتے ہیں۔ اس سے **TLS Handshake** کا حصہ مکمل ہو جاتا ہے۔
+
+اس کے بعد، client اور server کے پاس ایک **encrypted TCP کنکشن** ہوتا ہے، یہی وہ چیز ہے جو TLS فراہم کرتا ہے۔ اور پھر وہ اس کنکشن کو اصل **HTTP مواصلت** شروع کرنے کے لیے استعمال کر سکتے ہیں۔
+
+اور **HTTPS** یہی ہے، یہ بس سادہ **HTTP** ایک **محفوظ TLS کنکشن** کے اندر ہے خالص (غیر encrypted) TCP کنکشن کے بجائے۔
+
+/// tip | مشورہ
+
+غور کریں کہ مواصلت کی encryption **TCP سطح** پر ہوتی ہے، HTTP سطح پر نہیں۔
+
+///
+
+### HTTPS Request { #https-request }
+
+اب جب client اور server (خاص طور پر browser اور TLS Termination Proxy) کے پاس ایک **encrypted TCP کنکشن** ہے، تو وہ **HTTP مواصلت** شروع کر سکتے ہیں۔
+
+تو، client ایک **HTTPS request** بھیجتا ہے۔ یہ بس ایک encrypted TLS کنکشن کے ذریعے HTTP request ہے۔
+
+
+
+### Request کو Decrypt کرنا { #decrypt-the-request }
+
+TLS Termination Proxy طے شدہ encryption کا استعمال کرتے ہوئے **request کو decrypt** کرے گا، اور **سادہ (decrypted) HTTP request** ایپلیکیشن چلانے والے process (مثلاً FastAPI ایپلیکیشن چلانے والے Uvicorn کے ساتھ ایک process) کو منتقل کرے گا۔
+
+
+
+### HTTP Response { #http-response }
+
+ایپلیکیشن request پر عمل کرے گی اور TLS Termination Proxy کو ایک **سادہ (غیر encrypted) HTTP response** بھیجے گی۔
+
+
+
+### HTTPS Response { #https-response }
+
+TLS Termination Proxy پھر پہلے سے طے شدہ خفیہ نگاری (جو `someapp.example.com` کے certificate سے شروع ہوئی تھی) کا استعمال کرتے ہوئے **response کو encrypt** کرے گا، اور اسے واپس browser کو بھیجے گا۔
+
+اس کے بعد، browser تصدیق کرے گا کہ response درست ہے اور صحیح خفیہ key سے encrypted ہے، وغیرہ۔ پھر یہ **response کو decrypt** کرے گا اور اس پر عمل کرے گا۔
+
+
+
+client (browser) جانے گا کہ response صحیح server سے آیا ہے کیونکہ یہ وہ خفیہ نگاری استعمال کر رہا ہے جس پر انہوں نے پہلے **HTTPS certificate** استعمال کرتے ہوئے اتفاق کیا تھا۔
+
+### متعدد ایپلیکیشنز { #multiple-applications }
+
+اسی server (یا servers) میں، **متعدد ایپلیکیشنز** ہو سکتی ہیں، مثلاً دوسرے API پروگرامز یا ڈیٹابیس۔
+
+مخصوص IP اور port (ہماری مثال میں TLS Termination Proxy) صرف ایک process سنبھال سکتا ہے لیکن دوسری ایپلیکیشنز/processes بھی server(s) پر چل سکتی ہیں، جب تک کہ وہ **عوامی IP اور port کا وہی مجموعہ** استعمال کرنے کی کوشش نہ کریں۔
+
+
+
+اس طرح، TLS Termination Proxy **متعدد domains** کے لیے، متعدد ایپلیکیشنز کے لیے HTTPS اور certificates سنبھال سکتا ہے، اور پھر ہر معاملے میں requests صحیح ایپلیکیشن کو منتقل کر سکتا ہے۔
+
+### Certificate کی تجدید { #certificate-renewal }
+
+مستقبل میں کسی وقت، ہر certificate **ختم** ہو جائے گا (حاصل کرنے کے تقریباً 3 ماہ بعد)۔
+
+اور پھر، ایک اور پروگرام ہوگا (بعض اوقات یہ ایک اور پروگرام ہوتا ہے، بعض اوقات یہ وہی TLS Termination Proxy ہو سکتا ہے) جو Let's Encrypt سے بات کرے گا، اور certificate(s) کی تجدید کرے گا۔
+
+
+
+**TLS certificates** ایک **domain name سے منسلک** ہوتے ہیں، IP ایڈریس سے نہیں۔
+
+تو، certificates کی تجدید کے لیے، تجدیدی پروگرام کو اتھارٹی (Let's Encrypt) کو **ثابت** کرنا ہوگا کہ یہ واقعی اس domain کا **"مالک" ہے اور اسے کنٹرول** کرتا ہے۔
+
+ایسا کرنے کے لیے، اور مختلف ایپلیکیشن کی ضروریات کو پورا کرنے کے لیے، یہ کئی طریقوں سے کر سکتا ہے۔ کچھ مقبول طریقے یہ ہیں:
+
+* **کچھ DNS records میں ترمیم**۔
+ * اس کے لیے، تجدیدی پروگرام کو DNS provider کی APIs کی حمایت کرنی ہوگی، تو، آپ جو DNS provider استعمال کر رہے ہیں اس پر منحصر ہے، یہ اختیار ہو بھی سکتا ہے اور نہیں بھی۔
+* domain سے منسلک عوامی IP ایڈریس پر **server کے طور پر چلنا** (کم از کم certificate حصول کے عمل کے دوران)۔
+ * جیسا کہ ہم نے اوپر کہا، مخصوص IP اور port پر صرف ایک process سن سکتا ہے۔
+ * یہ ان وجوہات میں سے ایک ہے جس کی وجہ سے یہ بہت مفید ہے جب وہی TLS Termination Proxy certificate کی تجدید کے عمل کا بھی خیال رکھے۔
+ * ورنہ، آپ کو TLS Termination Proxy کو عارضی طور پر بند کرنا پڑ سکتا ہے، certificates حاصل کرنے کے لیے تجدیدی پروگرام شروع کرنا، پھر انہیں TLS Termination Proxy کے ساتھ ترتیب دینا، اور پھر TLS Termination Proxy کو دوبارہ شروع کرنا۔ یہ مثالی نہیں ہے، کیونکہ TLS Termination Proxy بند ہونے کے دوران آپ کی app(s) دستیاب نہیں ہوں گی۔
+
+یہ سارا تجدید کا عمل، جبکہ ابھی بھی app کو خدمت فراہم کر رہے ہوں، ان اصل وجوہات میں سے ایک ہے جس کی وجہ سے آپ HTTPS سنبھالنے کے لیے TLS Termination Proxy کے ساتھ **الگ نظام** رکھنا چاہیں گے بجائے اس کے کہ TLS certificates کو براہ راست application server (مثلاً Uvicorn) کے ساتھ استعمال کریں۔
+
+## Proxy Forwarded Headers { #proxy-forwarded-headers }
+
+HTTPS سنبھالنے کے لیے proxy استعمال کرتے وقت، آپ کا **application server** (مثلاً FastAPI CLI کے ذریعے Uvicorn) HTTPS کے عمل کے بارے میں کچھ نہیں جانتا، یہ **TLS Termination Proxy** کے ساتھ سادہ HTTP میں مواصلت کرتا ہے۔
+
+یہ **proxy** عام طور پر request کو **application server** کو منتقل کرنے سے پہلے فوری طور پر کچھ HTTP headers مقرر کرتا ہے، تاکہ application server کو بتائے کہ request proxy کے ذریعے **آگے بھیجی** جا رہی ہے۔
+
+/// 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** نہیں جانتا کہ یہ ایک قابل اعتماد **proxy** کے پیچھے ہے، بطور ڈیفالٹ، یہ ان headers پر اعتماد نہیں کرے گا۔
+
+لیکن آپ **application server** کو ترتیب دے سکتے ہیں کہ وہ **proxy** کی طرف سے بھیجے گئے *forwarded* headers پر اعتماد کرے۔ اگر آپ FastAPI CLI استعمال کر رہے ہیں، تو آپ *CLI Option* `--forwarded-allow-ips` استعمال کر سکتے ہیں تاکہ اسے بتائیں کہ کن IPs سے آنے والے *forwarded* headers پر اعتماد کرنا ہے۔
+
+مثال کے طور پر، اگر **application server** صرف قابل اعتماد **proxy** سے مواصلت وصول کر رہا ہے، تو آپ اسے `--forwarded-allow-ips="*"` پر سیٹ کر سکتے ہیں تاکہ یہ تمام آنے والی IPs پر اعتماد کرے، کیونکہ اسے صرف **proxy** کے IP سے requests ملیں گی۔
+
+اس طرح ایپلیکیشن جان سکے گی کہ اس کا اپنا عوامی URL کیا ہے، آیا یہ HTTPS استعمال کر رہی ہے، domain، وغیرہ۔
+
+یہ مثال کے طور پر redirects کو صحیح طریقے سے سنبھالنے کے لیے مفید ہوگا۔
+
+/// tip | مشورہ
+
+آپ اس کے بارے میں مزید [Behind a Proxy - Enable Proxy Forwarded Headers](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers) کی دستاویزات میں جان سکتے ہیں
+
+///
+
+## خلاصہ { #recap }
+
+**HTTPS** ہونا بہت اہم ہے، اور زیادہ تر معاملات میں کافی **ضروری** ہے۔ بحیثیت developer HTTPS کے حوالے سے آپ کی زیادہ تر محنت بس **ان تصورات کو سمجھنے** اور یہ جاننے میں لگتی ہے کہ یہ کیسے کام کرتے ہیں۔
+
+لیکن ایک بار جب آپ **developers کے لیے HTTPS** کی بنیادی معلومات جان لیں تو آپ آسانی سے مختلف ٹولز کو ملا اور ترتیب دے سکتے ہیں تاکہ سب کچھ آسان طریقے سے منظم ہو سکے۔
+
+اگلے چند ابواب میں، میں آپ کو **FastAPI** ایپلیکیشنز کے لیے **HTTPS** ترتیب دینے کی کئی ٹھوس مثالیں دکھاؤں گا۔ 🔒
diff --git a/docs/ur/docs/deployment/index.md b/docs/ur/docs/deployment/index.md
new file mode 100644
index 000000000..11a7e1629
--- /dev/null
+++ b/docs/ur/docs/deployment/index.md
@@ -0,0 +1,23 @@
+# Deployment { #deployment }
+
+**FastAPI** ایپلیکیشن کو deploy کرنا نسبتاً آسان ہے۔
+
+## Deployment کا مطلب کیا ہے { #what-does-deployment-mean }
+
+کسی ایپلیکیشن کو **deploy** کرنے کا مطلب ہے وہ ضروری اقدامات کرنا جن سے یہ **صارفین کے لیے دستیاب** ہو جائے۔
+
+**web API** کے لیے، اس کا عام طور پر مطلب ہے اسے ایک **remote machine** پر رکھنا، ایک ایسے **server program** کے ساتھ جو اچھی کارکردگی، استحکام وغیرہ فراہم کرے، تاکہ آپ کے **صارفین** ایپلیکیشن تک مؤثر طریقے سے اور بغیر کسی رکاوٹ یا مسائل کے **رسائی** حاصل کر سکیں۔
+
+یہ **development** کے مراحل سے مختلف ہے، جہاں آپ مسلسل کوڈ تبدیل کرتے رہتے ہیں، اسے توڑتے اور ٹھیک کرتے ہیں، development server کو بند اور دوبارہ شروع کرتے ہیں، وغیرہ۔
+
+## Deployment کی حکمت عملیاں { #deployment-strategies }
+
+آپ کے مخصوص استعمال کے معاملے اور آپ جو ٹولز استعمال کرتے ہیں ان کے لحاظ سے اسے کرنے کے کئی طریقے ہیں۔
+
+آپ خود ٹولز کے مجموعے سے **server deploy** کر سکتے ہیں، آپ **cloud service** استعمال کر سکتے ہیں جو آپ کے لیے کچھ کام کرے، یا دوسرے ممکنہ اختیارات۔
+
+مثال کے طور پر، ہم نے، FastAPI کے پیچھے کی ٹیم نے، [**FastAPI Cloud**](https://fastapicloud.com) بنایا ہے تاکہ FastAPI ایپس کو cloud پر deploy کرنا ممکنہ حد تک آسان ہو، FastAPI کے ساتھ کام کرنے جیسے developer experience کے ساتھ۔
+
+میں آپ کو کچھ اہم تصورات دکھاؤں گا جو آپ کو **FastAPI** ایپلیکیشن deploy کرتے وقت ذہن میں رکھنے چاہئیں (اگرچہ ان میں سے زیادہ تر کسی بھی دوسری قسم کی web ایپلیکیشن پر لاگو ہوتے ہیں)۔
+
+آپ اگلے حصوں میں ذہن میں رکھنے کے لیے مزید تفصیلات اور کچھ تکنیکیں دیکھیں گے۔ ✨
diff --git a/docs/ur/docs/deployment/manually.md b/docs/ur/docs/deployment/manually.md
new file mode 100644
index 000000000..cf0822c13
--- /dev/null
+++ b/docs/ur/docs/deployment/manually.md
@@ -0,0 +1,157 @@
+# Server کو دستی طور پر چلائیں { #run-a-server-manually }
+
+## `fastapi run` Command استعمال کریں { #use-the-fastapi-run-command }
+
+مختصراً، اپنی FastAPI ایپلیکیشن کو چلانے کے لیے `fastapi run` استعمال کریں:
+
++ +**FastAPI** موجود نہ ہوتا اگر دوسروں کا پچھلا کام نہ ہوتا۔ + +پہلے بہت سے tools بنائے گئے ہیں جنہوں نے اس کی تخلیق کی تحریک دی۔ + +میں کئی سالوں سے نیا framework بنانے سے گریز کرتا رہا۔ پہلے میں نے **FastAPI** کی تمام features کو بہت سے مختلف frameworks، plug-ins، اور tools استعمال کرکے حل کرنے کی کوشش کی۔ + +لیکن کسی وقت، کوئی اور راستہ نہیں تھا سوائے اس کے کہ کچھ ایسا بنایا جائے جو یہ تمام features فراہم کرے، پچھلے tools سے بہترین آئیڈیاز لے کر، اور انہیں بہترین ممکنہ طریقے سے ملا کر، زبان کی ان features کو استعمال کرتے ہوئے جو پہلے دستیاب نہیں تھیں (Python 3.6+ type hints)۔ + ++ +## تحقیق { #investigation } + +تمام پچھلے متبادل استعمال کرکے مجھے ان سب سے سیکھنے، آئیڈیاز لینے، اور انہیں بہترین طریقے سے ملانے کا موقع ملا جو میں اپنے اور اپنی ٹیموں کے لیے ڈھونڈ سکتا تھا۔ + +مثال کے طور پر، یہ واضح تھا کہ مثالی طور پر اسے standard Python type hints پر مبنی ہونا چاہیے۔ + +نیز، بہترین طریقہ یہ تھا کہ پہلے سے موجود standards استعمال کیے جائیں۔ + +تو **FastAPI** کو code کرنا شروع کرنے سے پہلے بھی، میں نے کئی مہینے OpenAPI، JSON Schema، OAuth2 وغیرہ کی specifications کا مطالعہ کرنے میں صرف کیے۔ ان کے تعلق، اوورلیپ، اور فرق کو سمجھتے ہوئے۔ + +## ڈیزائن { #design } + +پھر میں نے کچھ وقت developer "API" کو ڈیزائن کرنے میں لگایا جو میں ایک صارف (FastAPI استعمال کرنے والے developer) کے طور پر چاہتا تھا۔ + +میں نے سب سے مقبول Python editors میں کئی آئیڈیاز ٹیسٹ کیے: PyCharm، VS Code، Jedi پر مبنی editors۔ + +آخری [Python Developer Survey](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools) کے مطابق، جو تقریباً 80% صارفین کا احاطہ کرتا ہے۔ + +اس کا مطلب ہے کہ **FastAPI** خاص طور پر 80% Python developers کے استعمال کردہ editors کے ساتھ ٹیسٹ کیا گیا۔ اور چونکہ زیادہ تر دوسرے editors ملتے جلتے کام کرتے ہیں، اس کے تمام فوائد عملی طور پر تمام editors کے لیے کام کریں گے۔ + +اس طرح مجھے code duplication کو زیادہ سے زیادہ کم کرنے، ہر جگہ completion حاصل کرنے، type اور error checks وغیرہ کے بہترین طریقے مل سکے۔ + +یہ سب اس طرح جو تمام developers کو بہترین development experience فراہم کرے۔ + +## ضروریات { #requirements } + +کئی متبادل ٹیسٹ کرنے کے بعد، میں نے فیصلہ کیا کہ میں اس کے فوائد کی وجہ سے [**Pydantic**](https://docs.pydantic.dev/) استعمال کروں گا۔ + +پھر میں نے اس میں تعاون کیا، اسے JSON Schema کے ساتھ مکمل طور پر مطابق بنانے، constraint declarations define کرنے کے مختلف طریقوں کی سہولت دینے، اور کئی editors میں ٹیسٹوں کی بنیاد پر editor support (type checks، autocompletion) بہتر بنانے کے لیے۔ + +development کے دوران، میں نے [**Starlette**](https://www.starlette.dev/) میں بھی تعاون کیا، جو دوسری اہم ضرورت تھی۔ + +## ترقی { #development } + +جب میں نے **FastAPI** خود بنانا شروع کیا، زیادہ تر حصے پہلے سے اپنی جگہ تھے، ڈیزائن مقرر تھا، ضروریات اور tools تیار تھے، اور standards اور specifications کا علم واضح اور تازہ تھا۔ + +## مستقبل { #future } + +اس مقام تک، یہ پہلے سے واضح ہے کہ **FastAPI** اپنے آئیڈیاز کے ساتھ بہت سے لوگوں کے لیے مفید ہے۔ + +بہت سے use cases کے لیے اسے پچھلے متبادل پر ترجیح دی جا رہی ہے۔ + +بہت سے developers اور ٹیمیں پہلے سے اپنے projects کے لیے **FastAPI** پر انحصار کرتی ہیں (بشمول میں اور میری ٹیم)۔ + +لیکن پھر بھی، بہت سی بہتری اور features آنے والی ہیں۔ + +**FastAPI** کا مستقبل بہت روشن ہے۔ + +اور [آپ کی مدد](help-fastapi.md) کی بہت قدر کی جاتی ہے۔ diff --git a/docs/ur/docs/how-to/authentication-error-status-code.md b/docs/ur/docs/how-to/authentication-error-status-code.md new file mode 100644 index 000000000..ec9517fd0 --- /dev/null +++ b/docs/ur/docs/how-to/authentication-error-status-code.md @@ -0,0 +1,17 @@ +# پرانے 403 Authentication Error Status Codes استعمال کریں { #use-old-403-authentication-error-status-codes } + +FastAPI ورژن `0.122.0` سے پہلے، جب integrated security utilities authentication ناکام ہونے پر client کو error واپس کرتی تھیں، تو وہ HTTP status code `403 Forbidden` استعمال کرتی تھیں۔ + +FastAPI ورژن `0.122.0` سے شروع کرتے ہوئے، وہ زیادہ مناسب HTTP status code `401 Unauthorized` استعمال کرتی ہیں، اور HTTP specifications کی پیروی کرتے ہوئے response میں ایک معقول `WWW-Authenticate` header واپس کرتی ہیں، [RFC 7235](https://datatracker.ietf.org/doc/html/rfc7235#section-3.1)، [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized)۔ + +لیکن اگر کسی وجہ سے آپ کے clients پرانے رویے پر منحصر ہیں، تو آپ اپنی security classes میں `make_not_authenticated_error` method کو override کر کے واپس پرانے رویے پر جا سکتے ہیں۔ + +مثال کے طور پر، آپ `HTTPBearer` کی ایک subclass بنا سکتے ہیں جو default `401 Unauthorized` error کی بجائے `403 Forbidden` error واپس کرے: + +{* ../../docs_src/authentication_error_status_code/tutorial001_an_py310.py hl[9:13] *} + +/// tip | مشورہ + +نوٹ کریں کہ function exception instance واپس کرتا ہے، اسے raise نہیں کرتا۔ Raise کرنا باقی اندرونی کوڈ میں ہوتا ہے۔ + +/// diff --git a/docs/ur/docs/how-to/conditional-openapi.md b/docs/ur/docs/how-to/conditional-openapi.md new file mode 100644 index 000000000..71fa659b4 --- /dev/null +++ b/docs/ur/docs/how-to/conditional-openapi.md @@ -0,0 +1,56 @@ +# مشروط OpenAPI { #conditional-openapi } + +اگر آپ کو ضرورت ہو، تو آپ settings اور environment variables استعمال کر کے ماحول کے مطابق OpenAPI کو مشروط طور پر ترتیب دے سکتے ہیں، اور یہاں تک کہ اسے مکمل طور پر غیر فعال بھی کر سکتے ہیں۔ + +## سیکیورٹی، APIs، اور docs کے بارے میں { #about-security-apis-and-docs } + +اپنے documentation user interfaces کو production میں چھپانا آپ کی API کو محفوظ کرنے کا *صحیح طریقہ نہیں* ہونا چاہیے۔ + +یہ آپ کی API میں کوئی اضافی سیکیورٹی نہیں جوڑتا، *path operations* اب بھی وہیں دستیاب رہیں گی جہاں وہ ہیں۔ + +اگر آپ کے کوڈ میں کوئی سیکیورٹی خامی ہے، تو وہ پھر بھی موجود رہے گی۔ + +Documentation چھپانا صرف آپ کی API کے ساتھ تعامل کو سمجھنا مشکل بنا دیتا ہے، اور production میں اسے debug کرنا بھی مشکل ہو سکتا ہے۔ اسے سادہ طور پر [Security through obscurity](https://en.wikipedia.org/wiki/Security_through_obscurity) کی ایک شکل سمجھا جا سکتا ہے۔ + +اگر آپ اپنی API کو محفوظ کرنا چاہتے ہیں، تو کئی بہتر چیزیں ہیں جو آپ کر سکتے ہیں، مثال کے طور پر: + +* یقینی بنائیں کہ آپ کے request bodies اور responses کے لیے اچھی طرح سے defined Pydantic models ہیں۔ +* Dependencies استعمال کر کے تمام مطلوبہ permissions اور roles ترتیب دیں۔ +* کبھی بھی سادہ متن میں passwords ذخیرہ نہ کریں، صرف password hashes ذخیرہ کریں۔ +* معروف cryptographic ٹولز استعمال کریں اور لاگو کریں، جیسے pwdlib اور JWT tokens وغیرہ۔ +* جہاں ضرورت ہو OAuth2 scopes کے ساتھ مزید تفصیلی permission controls شامل کریں۔ +* ...وغیرہ۔ + +بہرحال، آپ کا کوئی بہت مخصوص استعمال کا معاملہ ہو سکتا ہے جہاں آپ کو واقعی کسی ماحول (مثلاً production) کے لیے یا environment variables کی ترتیبات کے مطابق API docs کو غیر فعال کرنا ہو۔ + +## Settings اور env vars سے مشروط OpenAPI { #conditional-openapi-from-settings-and-env-vars } + +آپ آسانی سے وہی Pydantic settings استعمال کر سکتے ہیں اپنے تیار کردہ OpenAPI اور docs UIs کو ترتیب دینے کے لیے۔ + +مثال کے طور پر: + +{* ../../docs_src/conditional_openapi/tutorial001_py310.py hl[6,11] *} + +یہاں ہم `openapi_url` setting کو `"/openapi.json"` کی اسی default قدر کے ساتھ declare کرتے ہیں۔ + +اور پھر ہم اسے `FastAPI` app بناتے وقت استعمال کرتے ہیں۔ + +پھر آپ `OPENAPI_URL` environment variable کو خالی string پر سیٹ کر کے OpenAPI (بشمول UI docs) کو غیر فعال کر سکتے ہیں، اس طرح: + +
+
+لیکن آپ `syntaxHighlight` کو `False` سیٹ کر کے اسے غیر فعال کر سکتے ہیں:
+
+{* ../../docs_src/configure_swagger_ui/tutorial001_py310.py hl[3] *}
+
+...اور پھر Swagger UI مزید syntax highlighting نہیں دکھائے گا:
+
+
+
+## Theme تبدیل کریں { #change-the-theme }
+
+اسی طرح آپ `"syntaxHighlight.theme"` key کے ساتھ syntax highlighting theme سیٹ کر سکتے ہیں (نوٹ کریں کہ اس میں درمیان میں ایک dot ہے):
+
+{* ../../docs_src/configure_swagger_ui/tutorial002_py310.py hl[3] *}
+
+یہ ترتیب syntax highlighting کی رنگ theme تبدیل کرے گی:
+
+
+
+## Default Swagger UI Parameters تبدیل کریں { #change-default-swagger-ui-parameters }
+
+FastAPI میں زیادہ تر استعمال کے معاملات کے لیے کچھ default ترتیبی parameters شامل ہیں۔
+
+اس میں یہ default ترتیبات شامل ہیں:
+
+{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
+
+آپ `swagger_ui_parameters` argument میں مختلف قدر سیٹ کر کے ان میں سے کسی کو بھی override کر سکتے ہیں۔
+
+مثال کے طور پر، `deepLinking` کو غیر فعال کرنے کے لیے آپ یہ settings `swagger_ui_parameters` میں پاس کر سکتے ہیں:
+
+{* ../../docs_src/configure_swagger_ui/tutorial003_py310.py hl[3] *}
+
+## دیگر Swagger UI Parameters { #other-swagger-ui-parameters }
+
+تمام ممکنہ ترتیبات دیکھنے کے لیے جو آپ استعمال کر سکتے ہیں، سرکاری [Swagger UI parameters کی دستاویزات](https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/) پڑھیں۔
+
+## صرف JavaScript والی settings { #javascript-only-settings }
+
+Swagger UI دیگر ترتیبات کی بھی اجازت دیتا ہے جو **صرف JavaScript** objects ہیں (مثال کے طور پر، JavaScript functions)۔
+
+FastAPI میں یہ صرف JavaScript والی `presets` settings بھی شامل ہیں:
+
+```JavaScript
+presets: [
+ SwaggerUIBundle.presets.apis,
+ SwaggerUIBundle.SwaggerUIStandalonePreset
+]
+```
+
+یہ **JavaScript** objects ہیں، strings نہیں، اس لیے آپ انہیں Python کوڈ سے براہ راست پاس نہیں کر سکتے۔
+
+اگر آپ کو اس طرح کی صرف JavaScript والی ترتیبات استعمال کرنے کی ضرورت ہے، تو آپ اوپر بیان کردہ طریقوں میں سے کوئی ایک استعمال کر سکتے ہیں۔ تمام Swagger UI *path operation* کو override کریں اور جو بھی JavaScript آپ کو چاہیے دستی طور پر لکھیں۔
diff --git a/docs/ur/docs/how-to/custom-docs-ui-assets.md b/docs/ur/docs/how-to/custom-docs-ui-assets.md
new file mode 100644
index 000000000..104c529c0
--- /dev/null
+++ b/docs/ur/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 فائلوں کی ضرورت ہوتی ہے۔
+
+بطور default، وہ فائلیں ایک CDN سے فراہم کی جاتی ہیں۔
+
+لیکن اسے اپنی مرضی کے مطابق بنانا ممکن ہے، آپ کوئی مخصوص CDN سیٹ کر سکتے ہیں، یا فائلیں خود فراہم کر سکتے ہیں۔
+
+## JavaScript اور CSS کے لیے حسب ضرورت CDN { #custom-cdn-for-javascript-and-css }
+
+فرض کریں کہ آپ ایک مختلف CDN استعمال کرنا چاہتے ہیں، مثال کے طور پر آپ `https://unpkg.com/` استعمال کرنا چاہتے ہیں۔
+
+یہ مفید ہو سکتا ہے اگر مثلاً آپ کسی ایسے ملک میں رہتے ہیں جو کچھ URLs پر پابندی لگاتا ہے۔
+
+### خود کار docs غیر فعال کریں { #disable-the-automatic-docs }
+
+پہلا مرحلہ خود کار docs کو غیر فعال کرنا ہے، کیونکہ بطور default، وہ default CDN استعمال کرتے ہیں۔
+
+انہیں غیر فعال کرنے کے لیے، اپنی `FastAPI` app بناتے وقت ان کے URLs کو `None` پر سیٹ کریں:
+
+{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[8] *}
+
+### حسب ضرورت docs شامل کریں { #include-the-custom-docs }
+
+اب آپ حسب ضرورت docs کے لیے *path operations* بنا سکتے ہیں۔
+
+آپ docs کے لیے HTML صفحات بنانے کے لیے FastAPI کے اندرونی functions دوبارہ استعمال کر سکتے ہیں، اور انہیں مطلوبہ arguments پاس کر سکتے ہیں:
+
+* `openapi_url`: وہ URL جہاں سے docs کا HTML صفحہ آپ کی API کا OpenAPI schema حاصل کر سکتا ہے۔ آپ یہاں `app.openapi_url` attribute استعمال کر سکتے ہیں۔
+* `title`: آپ کی API کا عنوان۔
+* `oauth2_redirect_url`: آپ default استعمال کرنے کے لیے یہاں `app.swagger_ui_oauth2_redirect_url` استعمال کر سکتے ہیں۔
+* `swagger_js_url`: وہ URL جہاں سے آپ کے Swagger UI docs کا HTML **JavaScript** فائل حاصل کر سکتا ہے۔ یہ حسب ضرورت CDN URL ہے۔
+* `swagger_css_url`: وہ URL جہاں سے آپ کے Swagger UI docs کا HTML **CSS** فائل حاصل کر سکتا ہے۔ یہ حسب ضرورت 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* اس وقت کام آتا ہے جب آپ OAuth2 استعمال کرتے ہیں۔
+
+اگر آپ اپنی API کو کسی OAuth2 provider کے ساتھ integrate کرتے ہیں، تو آپ authenticate ہو کر حاصل کردہ credentials کے ساتھ API docs پر واپس آ سکیں گے۔ اور حقیقی OAuth2 authentication کا استعمال کرتے ہوئے اس کے ساتھ تعامل کر سکیں گے۔
+
+Swagger UI پردے کے پیچھے آپ کے لیے اسے سنبھالے گا، لیکن اسے اس "redirect" helper کی ضرورت ہے۔
+
+///
+
+### جانچ کے لیے *path operation* بنائیں { #create-a-path-operation-to-test-it }
+
+اب، سب کچھ کام کر رہا ہے یہ جانچنے کے لیے، ایک *path operation* بنائیں:
+
+{* ../../docs_src/custom_docs_ui/tutorial001_py310.py hl[36:38] *}
+
+### جانچ کریں { #test-it }
+
+اب، آپ اپنے docs پر [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) جا کر صفحہ دوبارہ load کر سکتے ہیں، یہ نئے CDN سے assets load کرے گا۔
+
+## Docs کے لیے JavaScript اور CSS خود host کریں { #self-hosting-javascript-and-css-for-docs }
+
+JavaScript اور CSS خود host کرنا مفید ہو سکتا ہے اگر، مثال کے طور پر، آپ کو اپنی app کو آف لائن بھی کام کرتے رہنے کی ضرورت ہے، بغیر کسی Internet رسائی کے، یا مقامی network میں۔
+
+یہاں آپ دیکھیں گے کہ ان فائلوں کو اسی FastAPI app میں خود کیسے فراہم کیا جائے، اور docs کو ان کا استعمال کرنے کے لیے کیسے ترتیب دیا جائے۔
+
+### پروجیکٹ کی فائل ساخت { #project-file-structure }
+
+فرض کریں آپ کے پروجیکٹ کی فائل ساخت اس طرح نظر آتی ہے:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+```
+
+اب ان static فائلوں کو ذخیرہ کرنے کے لیے ایک directory بنائیں۔
+
+آپ کی نئی فائل ساخت اس طرح نظر آ سکتی ہے:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+└── static/
+```
+
+### فائلیں ڈاؤن لوڈ کریں { #download-the-files }
+
+Docs کے لیے ضروری static فائلیں ڈاؤن لوڈ کریں اور انہیں اس `static/` directory میں رکھیں۔
+
+آپ غالباً ہر لنک پر right-click کر کے "Save link as..." جیسا آپشن منتخب کر سکتے ہیں۔
+
+**Swagger UI** یہ فائلیں استعمال کرتا ہے:
+
+* [`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** یہ فائل استعمال کرتا ہے:
+
+* [`redoc.standalone.js`](https://cdn.jsdelivr.net/npm/redoc@2/bundles/redoc.standalone.js)
+
+اس کے بعد، آپ کی فائل ساخت اس طرح نظر آ سکتی ہے:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+└── static
+ ├── redoc.standalone.js
+ ├── swagger-ui-bundle.js
+ └── swagger-ui.css
+```
+
+### Static فائلیں فراہم کریں { #serve-the-static-files }
+
+* `StaticFiles` import کریں۔
+* ایک مخصوص path پر `StaticFiles()` instance "Mount" کریں۔
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[7,11] *}
+
+### Static فائلوں کی جانچ کریں { #test-the-static-files }
+
+اپنی application شروع کریں اور [http://127.0.0.1:8000/static/redoc.standalone.js](http://127.0.0.1:8000/static/redoc.standalone.js) پر جائیں۔
+
+آپ کو **ReDoc** کے لیے ایک بہت لمبی JavaScript فائل نظر آنی چاہیے۔
+
+یہ کچھ اس طرح شروع ہو سکتی ہے:
+
+```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")):
+...
+```
+
+یہ تصدیق کرتا ہے کہ آپ اپنی app سے static فائلیں فراہم کر سکتے ہیں، اور آپ نے docs کی static فائلیں صحیح جگہ رکھی ہیں۔
+
+اب ہم app کو ان static فائلوں کو docs کے لیے استعمال کرنے کے لیے ترتیب دے سکتے ہیں۔
+
+### Static فائلوں کے لیے خود کار docs غیر فعال کریں { #disable-the-automatic-docs-for-static-files }
+
+حسب ضرورت CDN استعمال کرنے کی طرح، پہلا مرحلہ خود کار docs کو غیر فعال کرنا ہے، کیونکہ وہ بطور default CDN استعمال کرتے ہیں۔
+
+انہیں غیر فعال کرنے کے لیے، اپنی `FastAPI` app بناتے وقت ان کے URLs کو `None` پر سیٹ کریں:
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[9] *}
+
+### Static فائلوں کے لیے حسب ضرورت docs شامل کریں { #include-the-custom-docs-for-static-files }
+
+اور حسب ضرورت CDN کی طرح، اب آپ حسب ضرورت docs کے لیے *path operations* بنا سکتے ہیں۔
+
+دوبارہ، آپ docs کے لیے HTML صفحات بنانے کے لیے FastAPI کے اندرونی functions دوبارہ استعمال کر سکتے ہیں، اور انہیں مطلوبہ arguments پاس کر سکتے ہیں:
+
+* `openapi_url`: وہ URL جہاں سے docs کا HTML صفحہ آپ کی API کا OpenAPI schema حاصل کر سکتا ہے۔ آپ یہاں `app.openapi_url` attribute استعمال کر سکتے ہیں۔
+* `title`: آپ کی API کا عنوان۔
+* `oauth2_redirect_url`: آپ default استعمال کرنے کے لیے یہاں `app.swagger_ui_oauth2_redirect_url` استعمال کر سکتے ہیں۔
+* `swagger_js_url`: وہ URL جہاں سے آپ کے Swagger UI docs کا HTML **JavaScript** فائل حاصل کر سکتا ہے۔ **یہ وہی ہے جو آپ کی اپنی app اب فراہم کر رہی ہے**۔
+* `swagger_css_url`: وہ URL جہاں سے آپ کے Swagger UI docs کا HTML **CSS** فائل حاصل کر سکتا ہے۔ **یہ وہی ہے جو آپ کی اپنی app اب فراہم کر رہی ہے**۔
+
+اور اسی طرح ReDoc کے لیے...
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[2:6,14:22,25:27,30:36] *}
+
+/// tip | مشورہ
+
+`swagger_ui_redirect` کے لیے *path operation* اس وقت کام آتا ہے جب آپ OAuth2 استعمال کرتے ہیں۔
+
+اگر آپ اپنی API کو کسی OAuth2 provider کے ساتھ integrate کرتے ہیں، تو آپ authenticate ہو کر حاصل کردہ credentials کے ساتھ API docs پر واپس آ سکیں گے۔ اور حقیقی OAuth2 authentication کا استعمال کرتے ہوئے اس کے ساتھ تعامل کر سکیں گے۔
+
+Swagger UI پردے کے پیچھے آپ کے لیے اسے سنبھالے گا، لیکن اسے اس "redirect" helper کی ضرورت ہے۔
+
+///
+
+### Static فائلوں کی جانچ کے لیے *path operation* بنائیں { #create-a-path-operation-to-test-static-files }
+
+اب، سب کچھ کام کر رہا ہے یہ جانچنے کے لیے، ایک *path operation* بنائیں:
+
+{* ../../docs_src/custom_docs_ui/tutorial002_py310.py hl[39:41] *}
+
+### Static فائلوں کے UI کی جانچ { #test-static-files-ui }
+
+اب، آپ اپنا WiFi بند کر کے اپنے docs پر [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) جا سکتے ہیں اور صفحہ دوبارہ load کر سکتے ہیں۔
+
+اور Internet کے بغیر بھی، آپ اپنی API کے docs دیکھ سکیں گے اور اس کے ساتھ تعامل کر سکیں گے۔
diff --git a/docs/ur/docs/how-to/custom-request-and-route.md b/docs/ur/docs/how-to/custom-request-and-route.md
new file mode 100644
index 000000000..accf5b585
--- /dev/null
+++ b/docs/ur/docs/how-to/custom-request-and-route.md
@@ -0,0 +1,109 @@
+# حسب ضرورت Request اور APIRoute class { #custom-request-and-apiroute-class }
+
+بعض صورتوں میں، آپ `Request` اور `APIRoute` classes کی منطق کو override کرنا چاہ سکتے ہیں۔
+
+خاص طور پر، یہ middleware میں منطق رکھنے کا ایک اچھا متبادل ہو سکتا ہے۔
+
+مثال کے طور پر، اگر آپ request body کو آپ کی application کی طرف سے process ہونے سے پہلے پڑھنا یا تبدیل کرنا چاہتے ہیں۔
+
+/// danger
+
+یہ ایک "advanced" خصوصیت ہے۔
+
+اگر آپ ابھی **FastAPI** شروع کر رہے ہیں تو شاید آپ اس حصے کو چھوڑنا چاہیں گے۔
+
+///
+
+## استعمال کے معاملات { #use-cases }
+
+کچھ استعمال کے معاملات میں شامل ہیں:
+
+* غیر JSON request bodies کو JSON میں تبدیل کرنا (مثلاً [`msgpack`](https://msgpack.org/index.html))۔
+* gzip سے compress شدہ request bodies کو decompress کرنا۔
+* تمام request bodies کو خود کار طریقے سے log کرنا۔
+
+## حسب ضرورت request body encodings کو سنبھالنا { #handling-custom-request-body-encodings }
+
+آئیے دیکھتے ہیں کہ gzip requests کو decompress کرنے کے لیے حسب ضرورت `Request` subclass کیسے استعمال کی جائے۔
+
+اور اس حسب ضرورت request class کو استعمال کرنے کے لیے `APIRoute` subclass کیسے بنائی جائے۔
+
+### حسب ضرورت `GzipRequest` class بنائیں { #create-a-custom-gziprequest-class }
+
+/// tip | مشورہ
+
+یہ ایک مثال ہے جو دکھاتی ہے کہ یہ کیسے کام کرتا ہے، اگر آپ کو Gzip سپورٹ کی ضرورت ہے، تو آپ فراہم کردہ [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware) استعمال کر سکتے ہیں۔
+
+///
+
+سب سے پہلے، ہم ایک `GzipRequest` class بناتے ہیں، جو مناسب header کی موجودگی میں body کو decompress کرنے کے لیے `Request.body()` method کو overwrite کرے گی۔
+
+اگر header میں `gzip` نہیں ہے، تو یہ body کو decompress کرنے کی کوشش نہیں کرے گی۔
+
+اس طرح، ایک ہی route class gzip سے compress شدہ یا بغیر compress شدہ requests کو سنبھال سکتی ہے۔
+
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}
+
+### حسب ضرورت `GzipRoute` class بنائیں { #create-a-custom-gziproute-class }
+
+اس کے بعد، ہم `fastapi.routing.APIRoute` کی ایک حسب ضرورت subclass بناتے ہیں جو `GzipRequest` استعمال کرے گی۔
+
+اس بار، یہ `APIRoute.get_route_handler()` method کو overwrite کرے گی۔
+
+یہ method ایک function واپس کرتا ہے۔ اور وہ function ہی ہے جو request وصول کرے گا اور response واپس کرے گا۔
+
+یہاں ہم اسے اصل 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 کو "وصول" کرنے کا function ہے۔
+
+`scope` `dict` اور `receive` function دونوں ASGI specification کا حصہ ہیں۔
+
+اور یہ دو چیزیں، `scope` اور `receive`، نئی `Request` instance بنانے کے لیے درکار ہیں۔
+
+`Request` کے بارے میں مزید جاننے کے لیے [Starlette کی Requests کے بارے میں دستاویزات](https://www.starlette.dev/requests/) دیکھیں۔
+
+///
+
+`GzipRequest.get_route_handler` کی واپس کردہ function صرف اتنا مختلف کام کرتی ہے کہ `Request` کو `GzipRequest` میں تبدیل کرتی ہے۔
+
+ایسا کرنے سے، ہماری `GzipRequest` ہماری *path operations* کو بھیجنے سے پہلے ڈیٹا کو decompress (اگر ضروری ہو) کا خیال رکھے گی۔
+
+اس کے بعد، تمام processing کی منطق ایک جیسی ہی ہے۔
+
+لیکن ہماری `GzipRequest.body` میں تبدیلیوں کی وجہ سے، request body خود بخود decompress ہو جائے گی جب **FastAPI** اسے ضرورت کے وقت load کرے گا۔
+
+## Exception handler میں request body تک رسائی { #accessing-the-request-body-in-an-exception-handler }
+
+/// tip | مشورہ
+
+اسی مسئلے کو حل کرنے کے لیے، `RequestValidationError` کے لیے حسب ضرورت handler میں `body` استعمال کرنا شاید بہت آسان ہے ([Handling Errors](../tutorial/handling-errors.md#use-the-requestvalidationerror-body))۔
+
+لیکن یہ مثال اب بھی درست ہے اور یہ دکھاتی ہے کہ اندرونی اجزاء کے ساتھ کیسے تعامل کیا جائے۔
+
+///
+
+ہم اسی طریقے کو 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 میں حسب ضرورت `APIRoute` class { #custom-apiroute-class-in-a-router }
+
+آپ `APIRouter` کا `route_class` parameter بھی سیٹ کر سکتے ہیں:
+
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[26] *}
+
+اس مثال میں، `router` کے تحت *path operations* حسب ضرورت `TimedRoute` class استعمال کریں گی، اور response میں ایک اضافی `X-Response-Time` header ہوگا جس میں response تیار کرنے میں لگنے والا وقت ہوگا:
+
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[13:20] *}
diff --git a/docs/ur/docs/how-to/extending-openapi.md b/docs/ur/docs/how-to/extending-openapi.md
new file mode 100644
index 000000000..998b55d55
--- /dev/null
+++ b/docs/ur/docs/how-to/extending-openapi.md
@@ -0,0 +1,80 @@
+# OpenAPI کی توسیع { #extending-openapi }
+
+کچھ ایسے معاملات ہیں جہاں آپ کو تیار کردہ OpenAPI schema میں ترمیم کرنے کی ضرورت ہو سکتی ہے۔
+
+اس حصے میں آپ دیکھیں گے کہ یہ کیسے کریں۔
+
+## عام عمل { #the-normal-process }
+
+عام (default) عمل درج ذیل ہے۔
+
+ایک `FastAPI` application (instance) میں `.openapi()` method ہوتا ہے جس سے OpenAPI schema واپس آنے کی توقع ہوتی ہے۔
+
+Application object بنانے کے حصے کے طور پر، `/openapi.json` (یا جو بھی آپ نے اپنا `openapi_url` سیٹ کیا ہو) کے لیے ایک *path operation* رجسٹر ہوتی ہے۔
+
+یہ صرف application کے `.openapi()` method کے نتیجے کے ساتھ JSON response واپس کرتی ہے۔
+
+بطور default، `.openapi()` method `.openapi_schema` property کو چیک کرتی ہے کہ آیا اس میں مواد ہے اور اسے واپس کرتی ہے۔
+
+اگر نہیں ہے، تو یہ `fastapi.openapi.utils.get_openapi` پر موجود utility function کا استعمال کرتے ہوئے انہیں تیار کرتی ہے۔
+
+اور وہ `get_openapi()` function بطور parameters یہ وصول کرتا ہے:
+
+* `title`: OpenAPI کا عنوان، docs میں دکھایا جاتا ہے۔
+* `version`: آپ کی API کا ورژن، مثلاً `2.5.0`۔
+* `openapi_version`: استعمال شدہ OpenAPI specification کا ورژن۔ بطور default، تازہ ترین: `3.1.0`۔
+* `summary`: API کا مختصر خلاصہ۔
+* `description`: آپ کی API کی تفصیل، اس میں markdown شامل ہو سکتا ہے اور docs میں دکھایا جائے گا۔
+* `routes`: Routes کی فہرست، یہ ہر ایک رجسٹر شدہ *path operations* ہیں۔ یہ `app.routes` سے لیے جاتے ہیں۔
+
+/// info | معلومات
+
+`summary` parameter OpenAPI 3.1.0 اور اس سے اوپر میں دستیاب ہے، جسے FastAPI 0.99.0 اور اس سے اوپر سپورٹ کرتا ہے۔
+
+///
+
+## Defaults کو override کرنا { #overriding-the-defaults }
+
+اوپر دی گئی معلومات کا استعمال کرتے ہوئے، آپ اسی utility function کو OpenAPI schema تیار کرنے کے لیے استعمال کر سکتے ہیں اور ہر اس حصے کو override کر سکتے ہیں جس کی آپ کو ضرورت ہے۔
+
+مثال کے طور پر، آئیے [ReDoc کی OpenAPI extension شامل کریں تاکہ حسب ضرورت logo شامل ہو](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-the-openapi-schema }
+
+پھر، `custom_openapi()` function کے اندر OpenAPI schema تیار کرنے کے لیے وہی utility function استعمال کریں:
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[2,15:21] *}
+
+### OpenAPI schema میں ترمیم کریں { #modify-the-openapi-schema }
+
+اب آپ ReDoc extension شامل کر سکتے ہیں، OpenAPI schema میں `info` "object" میں حسب ضرورت `x-logo` شامل کر کے:
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[22:24] *}
+
+### OpenAPI schema کو cache کریں { #cache-the-openapi-schema }
+
+آپ `.openapi_schema` property کو "cache" کے طور پر استعمال کر سکتے ہیں، اپنا تیار کردہ schema ذخیرہ کرنے کے لیے۔
+
+اس طرح، آپ کی application کو ہر بار جب کوئی صارف آپ کے API docs کھولے schema دوبارہ تیار نہیں کرنا پڑے گا۔
+
+یہ صرف ایک بار تیار ہوگا، اور پھر اگلی requests کے لیے وہی cached schema استعمال ہوگا۔
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[13:14,25:26] *}
+
+### Method کو override کریں { #override-the-method }
+
+اب آپ `.openapi()` method کو اپنے نئے function سے تبدیل کر سکتے ہیں۔
+
+{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[29] *}
+
+### جانچ کریں { #check-it }
+
+جب آپ [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) پر جائیں گے تو آپ دیکھیں گے کہ آپ اپنا حسب ضرورت logo استعمال کر رہے ہیں (اس مثال میں، **FastAPI** کا logo):
+
+
diff --git a/docs/ur/docs/how-to/general.md b/docs/ur/docs/how-to/general.md
new file mode 100644
index 000000000..2d5079fc0
--- /dev/null
+++ b/docs/ur/docs/how-to/general.md
@@ -0,0 +1,43 @@
+# عمومی - طریقہ کار - ترکیبیں { #general-how-to-recipes }
+
+یہاں عمومی یا اکثر پوچھے جانے والے سوالات کے لیے دستاویزات میں دیگر مقامات کی طرف کئی اشارے ہیں۔
+
+## ڈیٹا فلٹر کریں - Security { #filter-data-security }
+
+اس بات کو یقینی بنانے کے لیے کہ آپ ضرورت سے زیادہ ڈیٹا واپس نہ کریں، [Tutorial - Response Model - Return Type](../tutorial/response-model.md) کی دستاویزات پڑھیں۔
+
+## Response کی کارکردگی بہتر بنائیں - Response Model - Return Type { #optimize-response-performance-response-model-return-type }
+
+JSON ڈیٹا واپس کرتے وقت کارکردگی بہتر بنانے کے لیے، return type یا response model استعمال کریں، اس طرح Pydantic بغیر Python سے گزرے Rust کی طرف سے JSON میں serialization سنبھالے گا۔ مزید معلومات کے لیے [Tutorial - Response Model - Return Type](../tutorial/response-model.md) کی دستاویزات پڑھیں۔
+
+## دستاویزات کے Tags - OpenAPI { #documentation-tags-openapi }
+
+اپنی *path operations* میں tags شامل کرنے اور انہیں docs UI میں گروپ کرنے کے لیے، [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags) کی دستاویزات پڑھیں۔
+
+## دستاویزات کا خلاصہ اور تفصیل - 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) کی دستاویزات پڑھیں۔
+
+## دستاویزات Response description - OpenAPI { #documentation-response-description-openapi }
+
+Response کی تفصیل جو docs UI میں دکھائی جاتی ہے اس کی وضاحت کرنے کے لیے، [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description) کی دستاویزات پڑھیں۔
+
+## دستاویزات میں *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) کی دستاویزات پڑھیں۔
+
+## کسی بھی ڈیٹا کو JSON-compatible میں تبدیل کریں { #convert-any-data-to-json-compatible }
+
+کسی بھی ڈیٹا کو JSON-compatible میں تبدیل کرنے کے لیے، [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md) کی دستاویزات پڑھیں۔
+
+## OpenAPI Metadata - Docs { #openapi-metadata-docs }
+
+اپنے OpenAPI schema میں metadata شامل کرنے کے لیے، بشمول license، version، contact وغیرہ، [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md) کی دستاویزات پڑھیں۔
+
+## OpenAPI Custom URL { #openapi-custom-url }
+
+OpenAPI URL کو اپنی مرضی کے مطابق بنانے (یا ہٹانے) کے لیے، [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url) کی دستاویزات پڑھیں۔
+
+## OpenAPI Docs URLs { #openapi-docs-urls }
+
+خود کار طریقے سے تیار کردہ docs user interfaces کے لیے استعمال ہونے والے URLs کو اپ ڈیٹ کرنے کے لیے، [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls) کی دستاویزات پڑھیں۔
diff --git a/docs/ur/docs/how-to/graphql.md b/docs/ur/docs/how-to/graphql.md
new file mode 100644
index 000000000..3d8c45535
--- /dev/null
+++ b/docs/ur/docs/how-to/graphql.md
@@ -0,0 +1,60 @@
+# GraphQL { #graphql }
+
+چونکہ **FastAPI** کی بنیاد **ASGI** standard پر ہے، اس لیے ASGI کے ساتھ ہم آہنگ کسی بھی **GraphQL** لائبریری کو آسانی سے شامل کیا جا سکتا ہے۔
+
+آپ ایک ہی application میں عام FastAPI *path operations* کو GraphQL کے ساتھ ملا سکتے ہیں۔
+
+/// tip | مشورہ
+
+**GraphQL** کچھ بہت مخصوص استعمال کے معاملات حل کرتا ہے۔
+
+عام **web APIs** کے مقابلے میں اس کے **فوائد** اور **نقصانات** ہیں۔
+
+یقینی بنائیں کہ آپ کے استعمال کے معاملے کے لیے **فوائد** کیا **نقصانات** کی تلافی کرتے ہیں۔ 🤓
+
+///
+
+## GraphQL لائبریریاں { #graphql-libraries }
+
+یہاں کچھ **GraphQL** لائبریریاں ہیں جن میں **ASGI** سپورٹ موجود ہے۔ آپ انہیں **FastAPI** کے ساتھ استعمال کر سکتے ہیں:
+
+* [Strawberry](https://strawberry.rocks/) 🍓
+ * [FastAPI کے لیے دستاویزات](https://strawberry.rocks/docs/integrations/fastapi) کے ساتھ
+* [Ariadne](https://ariadnegraphql.org/)
+ * [FastAPI کے لیے دستاویزات](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/) **تجویز کردہ** لائبریری ہے کیونکہ اس کا ڈیزائن **FastAPI** کے ڈیزائن سے سب سے قریب ہے، یہ سب **type annotations** پر مبنی ہے۔
+
+آپ کے استعمال کے معاملے کے مطابق، آپ کسی مختلف لائبریری کو ترجیح دے سکتے ہیں، لیکن اگر آپ مجھ سے پوچھیں، تو میں غالباً **Strawberry** آزمانے کا مشورہ دوں گا۔
+
+یہاں ایک مختصر جائزہ ہے کہ آپ Strawberry کو FastAPI کے ساتھ کیسے شامل کر سکتے ہیں:
+
+{* ../../docs_src/graphql_/tutorial001_py310.py hl[3,22,25] *}
+
+آپ Strawberry کے بارے میں مزید [Strawberry دستاویزات](https://strawberry.rocks/) میں جان سکتے ہیں۔
+
+اور [Strawberry with FastAPI](https://strawberry.rocks/docs/integrations/fastapi) کی دستاویزات بھی دیکھیں۔
+
+## Starlette سے پرانا `GraphQLApp` { #older-graphqlapp-from-starlette }
+
+Starlette کے پچھلے ورژنز میں [Graphene](https://graphene-python.org/) کے ساتھ integration کے لیے `GraphQLApp` class شامل تھی۔
+
+اسے Starlette سے deprecated کر دیا گیا تھا، لیکن اگر آپ کے پاس ایسا کوڈ ہے جو اسے استعمال کرتا تھا، تو آپ آسانی سے [starlette-graphene3](https://github.com/ciscorn/starlette-graphene3) پر **منتقل** ہو سکتے ہیں، جو وہی استعمال کے معاملے کا احاطہ کرتا ہے اور **تقریباً ایک جیسا interface** رکھتا ہے۔
+
+/// tip | مشورہ
+
+اگر آپ کو GraphQL کی ضرورت ہے، تو میں پھر بھی تجویز کروں گا کہ آپ [Strawberry](https://strawberry.rocks/) دیکھیں، کیونکہ یہ custom classes اور types کی بجائے type annotations پر مبنی ہے۔
+
+///
+
+## مزید جانیں { #learn-more }
+
+آپ **GraphQL** کے بارے میں مزید [GraphQL کی سرکاری دستاویزات](https://graphql.org/) میں جان سکتے ہیں۔
+
+آپ اوپر بیان کردہ ہر لائبریری کے بارے میں ان کے لنکس میں مزید پڑھ سکتے ہیں۔
diff --git a/docs/ur/docs/how-to/index.md b/docs/ur/docs/how-to/index.md
new file mode 100644
index 000000000..5fd1295eb
--- /dev/null
+++ b/docs/ur/docs/how-to/index.md
@@ -0,0 +1,13 @@
+# طریقہ کار - ترکیبیں { #how-to-recipes }
+
+یہاں آپ کو **مختلف موضوعات** کے لیے مختلف ترکیبیں یا "طریقہ کار" کی رہنمائیاں ملیں گی۔
+
+ان میں سے زیادہ تر خیالات کم و بیش **آزادانہ** ہیں، اور زیادہ تر صورتوں میں آپ کو صرف انہی کا مطالعہ کرنا چاہیے جو براہ راست **آپ کے پروجیکٹ** پر لاگو ہوں۔
+
+اگر کوئی چیز آپ کے پروجیکٹ کے لیے دلچسپ اور مفید لگے، تو آگے بڑھیں اور اسے دیکھیں، ورنہ آپ شاید انہیں چھوڑ سکتے ہیں۔
+
+/// tip | مشورہ
+
+اگر آپ **FastAPI** کو منظم طریقے سے سیکھنا چاہتے ہیں (تجویز کردہ)، تو اس کی بجائے [Tutorial - User Guide](../tutorial/index.md) باب بہ باب پڑھیں۔
+
+///
diff --git a/docs/ur/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md b/docs/ur/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
new file mode 100644
index 000000000..e25a3d510
--- /dev/null
+++ b/docs/ur/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md
@@ -0,0 +1,135 @@
+# Pydantic v1 سے Pydantic v2 میں منتقلی { #migrate-from-pydantic-v1-to-pydantic-v2 }
+
+اگر آپ کے پاس پرانی FastAPI app ہے، تو آپ شاید Pydantic ورژن 1 استعمال کر رہے ہوں۔
+
+FastAPI ورژن 0.100.0 میں Pydantic v1 یا v2 دونوں کی سپورٹ تھی۔ یہ جو بھی آپ نے install کیا ہوتا اسے استعمال کرتا۔
+
+FastAPI ورژن 0.119.0 نے Pydantic v2 کے اندر سے Pydantic v1 کی جزوی سپورٹ (`pydantic.v1` کے طور پر) متعارف کرائی، تاکہ v2 میں منتقلی آسان ہو۔
+
+FastAPI 0.126.0 نے Pydantic v1 کی سپورٹ ختم کر دی، جبکہ تھوڑی دیر کے لیے `pydantic.v1` کی سپورٹ جاری رکھی۔
+
+/// warning | انتباہ
+
+Pydantic ٹیم نے Python کے تازہ ترین ورژنز کے لیے Pydantic v1 کی سپورٹ بند کر دی ہے، **Python 3.14** سے شروع کرتے ہوئے۔
+
+اس میں `pydantic.v1` بھی شامل ہے، جو Python 3.14 اور اس سے اوپر میں مزید سپورٹ نہیں ہے۔
+
+اگر آپ Python کی تازہ ترین خصوصیات استعمال کرنا چاہتے ہیں، تو آپ کو یقینی بنانا ہوگا کہ آپ Pydantic v2 استعمال کریں۔
+
+///
+
+اگر آپ کے پاس Pydantic v1 والی پرانی FastAPI app ہے، تو یہاں میں آپ کو دکھاؤں گا کہ اسے Pydantic v2 میں کیسے منتقل کیا جائے، اور **FastAPI 0.119.0 کی خصوصیات** جو بتدریج منتقلی میں مدد کرتی ہیں۔
+
+## سرکاری رہنما { #official-guide }
+
+Pydantic کے پاس v1 سے v2 میں منتقلی کی سرکاری [Migration Guide](https://docs.pydantic.dev/latest/migration/) ہے۔
+
+اس میں یہ بھی شامل ہے کہ کیا تبدیل ہوا ہے، validations اب کیسے زیادہ درست اور سخت ہیں، ممکنہ خدشات وغیرہ۔
+
+آپ اسے پڑھ کر بہتر سمجھ سکتے ہیں کہ کیا تبدیل ہوا ہے۔
+
+## Tests { #tests }
+
+یقینی بنائیں کہ آپ کی app کے لیے [tests](../tutorial/testing.md) ہیں اور آپ انہیں continuous integration (CI) پر چلاتے ہیں۔
+
+اس طرح، آپ اپ گریڈ کر سکتے ہیں اور یقینی بنا سکتے ہیں کہ سب کچھ توقع کے مطابق کام کر رہا ہے۔
+
+## `bump-pydantic` { #bump-pydantic }
+
+بہت سی صورتوں میں، جب آپ بغیر customizations کے عام Pydantic models استعمال کرتے ہیں، تو آپ Pydantic v1 سے Pydantic v2 میں منتقلی کے زیادہ تر عمل کو خودکار بنا سکتے ہیں۔
+
+آپ Pydantic ٹیم کا [`bump-pydantic`](https://github.com/pydantic/bump-pydantic) استعمال کر سکتے ہیں۔
+
+یہ ٹول زیادہ تر کوڈ کو خود بخود تبدیل کرنے میں مدد کرے گا جسے تبدیل کرنے کی ضرورت ہے۔
+
+اس کے بعد، آپ tests چلا سکتے ہیں اور جانچ سکتے ہیں کہ سب کچھ کام کرتا ہے۔ اگر کرتا ہے، تو آپ کا کام ہو گیا۔ 😎
+
+## Pydantic v2 میں Pydantic v1 { #pydantic-v1-in-v2 }
+
+Pydantic v2 میں Pydantic v1 کی ہر چیز بطور submodule `pydantic.v1` شامل ہے۔ لیکن یہ Python 3.13 سے اوپر کے ورژنز میں مزید سپورٹ نہیں ہے۔
+
+اس کا مطلب ہے کہ آپ Pydantic v2 کا تازہ ترین ورژن install کر سکتے ہیں اور اس submodule سے پرانے Pydantic v1 کے اجزاء import اور استعمال کر سکتے ہیں، جیسے کہ آپ کے پاس پرانا Pydantic v1 install ہو۔
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial001_an_py310.py hl[1,4] *}
+
+### Pydantic v2 میں Pydantic v1 کے لیے FastAPI سپورٹ { #fastapi-support-for-pydantic-v1-in-v2 }
+
+FastAPI 0.119.0 سے، Pydantic v2 کے اندر سے Pydantic v1 کی جزوی سپورٹ بھی ہے، تاکہ v2 میں منتقلی آسان ہو۔
+
+لہذا، آپ Pydantic کو تازہ ترین ورژن 2 میں اپ گریڈ کر سکتے ہیں، اور `pydantic.v1` submodule استعمال کرنے کے لیے imports تبدیل کر سکتے ہیں، اور بہت سی صورتوں میں یہ بس کام کر جائے گا۔
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial002_an_py310.py hl[2,5,15] *}
+
+/// warning | انتباہ
+
+ذہن میں رکھیں کہ چونکہ Pydantic ٹیم Python کے حالیہ ورژنز میں Pydantic v1 کو مزید سپورٹ نہیں کرتی، Python 3.14 سے شروع کرتے ہوئے، `pydantic.v1` کا استعمال بھی Python 3.14 اور اس سے اوپر میں سپورٹ نہیں ہے۔
+
+///
+
+### ایک ہی app میں Pydantic v1 اور v2 { #pydantic-v1-and-v2-on-the-same-app }
+
+Pydantic کی طرف سے یہ **سپورٹ نہیں** ہے کہ 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 اور 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 کے ساتھ FastAPI کے مخصوص ٹولز جیسے `Body`، `Query`، `Form` وغیرہ استعمال کرنے کی ضرورت ہے، تو آپ Pydantic v2 میں منتقلی مکمل ہونے تک انہیں `fastapi.temp_pydantic_v1_params` سے import کر سکتے ہیں:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial004_an_py310.py hl[4,18] *}
+
+### مراحل میں منتقلی { #migrate-in-steps }
+
+/// tip | مشورہ
+
+پہلے `bump-pydantic` آزمائیں، اگر آپ کے tests پاس ہو جائیں اور یہ کام کر جائے، تو آپ کا کام ایک command میں ہو گیا۔ ✨
+
+///
+
+اگر `bump-pydantic` آپ کے استعمال کے لیے کام نہیں کرتا، تو آپ ایک ہی app میں Pydantic v1 اور v2 دونوں models کی سپورٹ استعمال کر کے بتدریج Pydantic v2 میں منتقلی کر سکتے ہیں۔
+
+آپ پہلے Pydantic کو تازہ ترین ورژن 2 میں اپ گریڈ کر سکتے ہیں، اور اپنے تمام models کے لیے `pydantic.v1` استعمال کرنے کے لیے imports تبدیل کر سکتے ہیں۔
+
+پھر، آپ اپنے models کو بتدریج گروپس میں Pydantic v1 سے v2 میں منتقل کرنا شروع کر سکتے ہیں۔ 🚶
diff --git a/docs/ur/docs/how-to/separate-openapi-schemas.md b/docs/ur/docs/how-to/separate-openapi-schemas.md
new file mode 100644
index 000000000..067eb86d1
--- /dev/null
+++ b/docs/ur/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** کی ریلیز کے بعد سے، تیار کردہ 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 **ضروری نہیں** ہوگا۔ کیونکہ اس کی default value `None` ہے۔
+
+### Docs میں Input Model { #input-model-in-docs }
+
+آپ docs میں تصدیق کر سکتے ہیں، `description` field پر **سرخ ستارہ** نہیں ہے، اسے ضروری نشان زد نہیں کیا گیا:
+
+
+
+
+
+
+
+ 
+
+ FastAPI framework، اعلیٰ کارکردگی، سیکھنے میں آسان، تیز کوڈنگ، پروڈکشن کے لیے تیار +
+ + +--- + +**دستاویزات**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com) + +**سورس کوڈ**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi) + +--- + +FastAPI ایک جدید، تیز رفتار (اعلیٰ کارکردگی والا) web framework ہے جو معیاری Python type hints کی بنیاد پر Python کے ساتھ APIs بنانے کے لیے بنایا گیا ہے۔ + +اہم خصوصیات یہ ہیں: + +* **تیز**: بہت اعلیٰ کارکردگی، **NodeJS** اور **Go** کے برابر (Starlette اور Pydantic کی بدولت)۔ [دستیاب تیز ترین Python frameworks میں سے ایک](#performance)۔ +* **تیز کوڈنگ**: فیچرز بنانے کی رفتار تقریباً 200% سے 300% بڑھائیں۔ * +* **کم غلطیاں**: انسانی (ڈویلپر) غلطیوں میں تقریباً 40% کمی۔ * +* **بدیہی**: بہترین ایڈیٹر سپورٹ۔ ہر جگہ Completion۔ debugging میں کم وقت۔ +* **آسان**: استعمال اور سیکھنے میں آسان بنایا گیا ہے۔ دستاویزات پڑھنے میں کم وقت۔ +* **مختصر**: code کی تکرار کم سے کم۔ ہر parameter کے اعلان سے متعدد خصوصیات۔ کم غلطیاں۔ +* **مضبوط**: پروڈکشن کے لیے تیار code حاصل کریں۔ خودکار تعاملی دستاویزات کے ساتھ۔ +* **معیارات پر مبنی**: APIs کے کھلے معیارات پر مبنی (اور مکمل طور پر ہم آہنگ): [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (پہلے Swagger کے نام سے جانا جاتا تھا) اور [JSON Schema](https://json-schema.org/)۔ + +* اندرونی ترقیاتی ٹیم کے ذریعے پروڈکشن ایپلیکیشنز بناتے ہوئے کیے گئے ٹیسٹس پر مبنی تخمینہ۔ + +## سپانسرز { #sponsors } + + + +### کلیدی سپانسر { #keystone-sponsor } + +{% for sponsor in sponsors.keystone -%} +
+
+## **Typer**، CLIs کا FastAPI { #typer-the-fastapi-of-clis }
+
+
+
+اگر آپ web API کے بجائے ٹرمینل میں استعمال ہونے والی CLI ایپ بنا رہے ہیں، تو [**Typer**](https://typer.tiangolo.com/) دیکھیں۔
+
+**Typer** FastAPI کا چھوٹا بھائی ہے۔ اور اس کا مقصد **CLIs کا FastAPI** بننا ہے۔ ⌨️ 🚀
+
+## تقاضے { #requirements }
+
+FastAPI دیو ہیکل ہستیوں کے کندھوں پر کھڑا ہے:
+
+* ویب حصوں کے لیے [Starlette](https://www.starlette.dev/)۔
+* ڈیٹا حصوں کے لیے [Pydantic](https://docs.pydantic.dev/)۔
+
+## انسٹالیشن { #installation }
+
+ایک [virtual environment](https://fastapi.tiangolo.com/virtual-environments/) بنائیں اور فعال کریں اور پھر FastAPI انسٹال کریں:
+
+
+
+
+
+async def استعمال کریں...fastapi dev کمانڈ کے بارے میں...
+
+### Types شامل کریں { #add-types }
+
+آئیے پچھلے ورژن کی ایک لائن تبدیل کرتے ہیں۔
+
+ہم بالکل یہ حصہ تبدیل کریں گے، function کے parameters، اس سے:
+
+```Python
+ first_name, last_name
+```
+
+اس میں:
+
+```Python
+ first_name: str, last_name: str
+```
+
+بس اتنا ہی۔
+
+یہ ہیں "type hints":
+
+{* ../../docs_src/python_types/tutorial002_py310.py hl[1] *}
+
+یہ وہی نہیں ہے جو default values بیان کرنا ہوتا جیسے:
+
+```Python
+ first_name="john", last_name="doe"
+```
+
+یہ ایک الگ چیز ہے۔
+
+ہم colons (`:`) استعمال کر رہے ہیں، نہ کہ equals (`=`)۔
+
+اور type hints شامل کرنے سے عام طور پر وہ نہیں بدلتا جو ان کے بغیر ہوتا۔
+
+لیکن اب، تصور کریں کہ آپ پھر سے وہ function بنا رہے ہیں، لیکن type hints کے ساتھ۔
+
+اسی مقام پر، آپ `Ctrl+Space` سے autocomplete شروع کرتے ہیں اور آپ دیکھتے ہیں:
+
+
+
+اس کے ساتھ، آپ سکرول کر سکتے ہیں، اختیارات دیکھتے ہوئے، جب تک وہ نہ ملے جو "یاد آتا ہے":
+
+
+
+## مزید مقصد { #more-motivation }
+
+یہ function دیکھیں، اس میں پہلے سے type hints ہیں:
+
+{* ../../docs_src/python_types/tutorial003_py310.py hl[1] *}
+
+کیونکہ ایڈیٹر variables کی types جانتا ہے، آپ کو صرف completion ہی نہیں ملتی، بلکہ error checks بھی ملتی ہیں:
+
+
+
+اب آپ جانتے ہیں کہ آپ کو اسے ٹھیک کرنا ہے، `age` کو `str(age)` سے string میں تبدیل کرنا ہے:
+
+{* ../../docs_src/python_types/tutorial004_py310.py hl[2] *}
+
+## Types بیان کرنا { #declaring-types }
+
+آپ نے ابھی type hints بیان کرنے کی اصل جگہ دیکھی۔ Function parameters کے طور پر۔
+
+یہ وہ اصل جگہ بھی ہے جہاں آپ انہیں **FastAPI** کے ساتھ استعمال کریں گے۔
+
+### سادہ types { #simple-types }
+
+آپ تمام معیاری Python types بیان کر سکتے ہیں، نہ صرف `str`۔
+
+آپ استعمال کر سکتے ہیں، مثال کے طور پر:
+
+* `int`
+* `float`
+* `bool`
+* `bytes`
+
+{* ../../docs_src/python_types/tutorial005_py310.py hl[1] *}
+
+### `typing` module { #typing-module }
+
+کچھ اضافی استعمال کے معاملات کے لیے، آپ کو معیاری لائبریری `typing` module سے کچھ چیزیں import کرنی پڑ سکتی ہیں، مثال کے طور پر جب آپ بیان کرنا چاہیں کہ کسی چیز کی "کوئی بھی type" ہے، تو آپ `typing` سے `Any` استعمال کر سکتے ہیں:
+
+```python
+from typing import Any
+
+
+def some_function(data: Any):
+ print(data)
+```
+
+### Generic types { #generic-types }
+
+کچھ types اپنے اندرونی types بیان کرنے کے لیے مربع بریکٹس میں "type parameters" لے سکتی ہیں، مثال کے طور پر "strings کی list" کو `list[str]` لکھا جائے گا۔
+
+وہ types جو type parameters لے سکتی ہیں، انہیں **Generic types** یا **Generics** کہا جاتا ہے۔
+
+آپ وہی بلٹ ان types بطور generics استعمال کر سکتے ہیں (مربع بریکٹس اور اندر types کے ساتھ):
+
+* `list`
+* `tuple`
+* `set`
+* `dict`
+
+#### List { #list }
+
+مثال کے طور پر، آئیے ایک variable کو `str` کی `list` کے طور پر بیان کرتے ہیں۔
+
+اسی colon (`:`) syntax کے ساتھ variable بیان کریں۔
+
+Type کے طور پر `list` رکھیں۔
+
+چونکہ list ایک ایسی type ہے جس میں کچھ اندرونی types ہیں، آپ انہیں مربع بریکٹس میں رکھتے ہیں:
+
+{* ../../docs_src/python_types/tutorial006_py310.py hl[1] *}
+
+/// info | معلومات
+
+مربع بریکٹس میں وہ اندرونی types "type parameters" کہلاتی ہیں۔
+
+اس صورت میں، `str` وہ type parameter ہے جو `list` کو دیا گیا ہے۔
+
+///
+
+اس کا مطلب ہے: "variable `items` ایک `list` ہے، اور اس list کا ہر آئٹم ایک `str` ہے"۔
+
+ایسا کرنے سے، آپ کا ایڈیٹر list سے آئٹمز پر عمل کرتے ہوئے بھی سپورٹ فراہم کر سکتا ہے:
+
+
+
+Types کے بغیر، یہ تقریباً ناممکن ہے۔
+
+غور کریں کہ variable `item` list `items` کے عناصر میں سے ایک ہے۔
+
+اور پھر بھی، ایڈیٹر جانتا ہے کہ یہ ایک `str` ہے، اور اس کے لیے سپورٹ فراہم کرتا ہے۔
+
+#### Tuple اور Set { #tuple-and-set }
+
+`tuple` اور `set` بیان کرنے کے لیے بھی آپ ایسا ہی کریں گے:
+
+{* ../../docs_src/python_types/tutorial007_py310.py hl[1] *}
+
+اس کا مطلب ہے:
+
+* Variable `items_t` ایک `tuple` ہے جس میں 3 آئٹمز ہیں، ایک `int`، ایک اور `int`، اور ایک `str`۔
+* Variable `items_s` ایک `set` ہے، اور اس کا ہر آئٹم `bytes` type کا ہے۔
+
+#### Dict { #dict }
+
+`dict` بیان کرنے کے لیے، آپ کوما سے الگ کر کے 2 type parameters دیتے ہیں۔
+
+پہلا type parameter `dict` کی keys کے لیے ہے۔
+
+دوسرا type parameter `dict` کی values کے لیے ہے:
+
+{* ../../docs_src/python_types/tutorial008_py310.py hl[1] *}
+
+اس کا مطلب ہے:
+
+* Variable `prices` ایک `dict` ہے:
+ * اس `dict` کی keys `str` type کی ہیں (فرض کریں، ہر آئٹم کا نام)۔
+ * اس `dict` کی values `float` type کی ہیں (فرض کریں، ہر آئٹم کی قیمت)۔
+
+#### Union { #union }
+
+آپ بیان کر سکتے ہیں کہ ایک variable **کئی types** میں سے کوئی بھی ہو سکتا ہے، مثال کے طور پر، ایک `int` یا ایک `str`۔
+
+اسے بیان کرنے کے لیے آپ دونوں types کو الگ کرنے کے لیے عمودی بار (`|`) استعمال کرتے ہیں۔
+
+اسے "union" کہا جاتا ہے، کیونکہ variable ان دو types کے مجموعے میں سے کچھ بھی ہو سکتا ہے۔
+
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial008b_py310.py!}
+```
+
+اس کا مطلب ہے کہ `item` ایک `int` یا ایک `str` ہو سکتا ہے۔
+
+#### ممکنہ طور پر `None` { #possibly-none }
+
+آپ بیان کر سکتے ہیں کہ کسی value کی type ہو سکتی ہے، جیسے `str`، لیکن یہ `None` بھی ہو سکتی ہے۔
+
+//// tab | Python 3.10+
+
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial009_py310.py!}
+```
+
+////
+
+صرف `str` کے بجائے `str | None` استعمال کرنے سے ایڈیٹر آپ کو ان غلطیوں کا پتہ لگانے میں مدد کر سکے گا جہاں آپ فرض کر رہے ہوں کہ کوئی value ہمیشہ `str` ہے، جبکہ یہ دراصل `None` بھی ہو سکتی ہے۔
+
+### بطور types Classes { #classes-as-types }
+
+آپ کسی class کو بھی variable کی type کے طور پر بیان کر سکتے ہیں۔
+
+فرض کریں آپ کے پاس ایک `Person` class ہے، جس میں ایک name ہے:
+
+{* ../../docs_src/python_types/tutorial010_py310.py hl[1:3] *}
+
+پھر آپ ایک variable کو `Person` type کا بیان کر سکتے ہیں:
+
+{* ../../docs_src/python_types/tutorial010_py310.py hl[6] *}
+
+اور پھر، آپ کو دوبارہ تمام ایڈیٹر سپورٹ ملتی ہے:
+
+
+
+غور کریں کہ اس کا مطلب ہے "`one_person` class `Person` کی ایک **instance** ہے"۔
+
+اس کا مطلب یہ نہیں کہ "`one_person` وہ **class** ہے جو `Person` کہلاتی ہے"۔
+
+## Pydantic models { #pydantic-models }
+
+[Pydantic](https://docs.pydantic.dev/) data validation کے لیے ایک Python لائبریری ہے۔
+
+آپ ڈیٹا کی "شکل" attributes والی classes کے طور پر بیان کرتے ہیں۔
+
+اور ہر attribute کی ایک type ہوتی ہے۔
+
+پھر آپ کچھ values کے ساتھ اس class کی ایک instance بناتے ہیں اور یہ values کی توثیق کرے گا، انہیں مناسب type میں تبدیل کرے گا (اگر ایسا ہو) اور آپ کو تمام ڈیٹا کے ساتھ ایک object دے گا۔
+
+اور آپ کو اس نتیجے میں ملنے والی object کے ساتھ تمام ایڈیٹر سپورٹ ملتی ہے۔
+
+سرکاری Pydantic دستاویزات سے ایک مثال:
+
+{* ../../docs_src/python_types/tutorial011_py310.py *}
+
+/// info | معلومات
+
+[Pydantic کے بارے میں مزید جاننے کے لیے، اس کی دستاویزات دیکھیں](https://docs.pydantic.dev/)۔
+
+///
+
+**FastAPI** مکمل طور پر Pydantic پر مبنی ہے۔
+
+آپ [Tutorial - User Guide](tutorial/index.md) میں عملی طور پر یہ سب بہت زیادہ دیکھیں گے۔
+
+## Metadata Annotations کے ساتھ Type Hints { #type-hints-with-metadata-annotations }
+
+Python میں ایک خصوصیت بھی ہے جو `Annotated` استعمال کر کے ان type hints میں **اضافی metadata** رکھنے کی اجازت دیتی ہے۔
+
+آپ `typing` سے `Annotated` import کر سکتے ہیں۔
+
+{* ../../docs_src/python_types/tutorial013_py310.py hl[1,4] *}
+
+Python خود اس `Annotated` کے ساتھ کچھ نہیں کرتا۔ اور ایڈیٹرز اور دیگر ٹولز کے لیے، type ابھی بھی `str` ہے۔
+
+لیکن آپ `Annotated` میں اس جگہ کو **FastAPI** کو اضافی metadata فراہم کرنے کے لیے استعمال کر سکتے ہیں کہ آپ اپنی ایپلیکیشن کو کیسے چلانا چاہتے ہیں۔
+
+یاد رکھنے کی اہم بات یہ ہے کہ `Annotated` کو دیا جانے والا **پہلا *type parameter*** ہی **اصل type** ہے۔ باقی سب دوسرے ٹولز کے لیے صرف metadata ہے۔
+
+ابھی کے لیے، آپ کو بس یہ جاننا ہے کہ `Annotated` موجود ہے، اور یہ معیاری Python ہے۔ 😎
+
+بعد میں آپ دیکھیں گے کہ یہ کتنا **طاقتور** ہو سکتا ہے۔
+
+/// tip | مشورہ
+
+یہ حقیقت کہ یہ **معیاری Python** ہے اس کا مطلب ہے کہ آپ کو اپنے ایڈیٹر میں ابھی بھی **بہترین ممکنہ ڈویلپر تجربہ** ملے گا، ان ٹولز کے ساتھ جو آپ code کا تجزیہ اور refactor کرنے کے لیے استعمال کرتے ہیں، وغیرہ۔ ✨
+
+اور یہ بھی کہ آپ کا code بہت سے دیگر Python ٹولز اور لائبریریز کے ساتھ بہت ہم آہنگ ہوگا۔ 🚀
+
+///
+
+## **FastAPI** میں Type hints { #type-hints-in-fastapi }
+
+**FastAPI** ان type hints کا فائدہ اٹھاتا ہے کئی کام کرنے کے لیے۔
+
+**FastAPI** کے ساتھ آپ type hints کے ساتھ parameters بیان کرتے ہیں اور آپ کو ملتا ہے:
+
+* **ایڈیٹر سپورٹ**۔
+* **Type checks**۔
+
+...اور **FastAPI** انہی اعلانات کو استعمال کرتا ہے:
+
+* **ضروریات بیان کرنے** کے لیے: request path parameters، query parameters، headers، bodies، dependencies وغیرہ سے۔
+* **ڈیٹا تبدیل کرنے** کے لیے: request سے مطلوبہ type میں۔
+* **ڈیٹا کی توثیق** کے لیے: ہر request سے آنے والے:
+ * ڈیٹا غلط ہونے پر client کو واپس بھیجی جانے والی **خودکار غلطیاں** بنانا۔
+* OpenAPI استعمال کرتے ہوئے API کی **دستاویزات** بنانا:
+ * جو پھر خودکار تعاملی دستاویزات کے یوزر انٹرفیسز استعمال کرتی ہیں۔
+
+یہ سب خلاصہ لگ سکتا ہے۔ فکر نہ کریں۔ آپ [Tutorial - User Guide](tutorial/index.md) میں یہ سب عمل میں دیکھیں گے۔
+
+اہم بات یہ ہے کہ معیاری Python types استعمال کر کے، ایک ہی جگہ پر (مزید classes، decorators وغیرہ شامل کرنے کے بجائے)، **FastAPI** آپ کا بہت سا کام خود کر لے گا۔
+
+/// info | معلومات
+
+اگر آپ پورا tutorial پڑھ چکے ہیں اور types کے بارے میں مزید جاننے واپس آئے ہیں، تو ایک اچھا ذریعہ [`mypy` کی "cheat sheet"](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html) ہے۔
+
+///
diff --git a/docs/ur/docs/reference/apirouter.md b/docs/ur/docs/reference/apirouter.md
new file mode 100644
index 000000000..4911830a9
--- /dev/null
+++ b/docs/ur/docs/reference/apirouter.md
@@ -0,0 +1,24 @@
+# `APIRouter` class
+
+یہاں `APIRouter` class کی حوالہ جاتی معلومات ہیں، اس کے تمام parameters، attributes اور methods کے ساتھ۔
+
+آپ `APIRouter` class کو براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import APIRouter
+```
+
+::: fastapi.APIRouter
+ options:
+ members:
+ - websocket
+ - include_router
+ - get
+ - put
+ - post
+ - delete
+ - options
+ - head
+ - patch
+ - trace
+ - on_event
diff --git a/docs/ur/docs/reference/background.md b/docs/ur/docs/reference/background.md
new file mode 100644
index 000000000..9700e7505
--- /dev/null
+++ b/docs/ur/docs/reference/background.md
@@ -0,0 +1,11 @@
+# Background Tasks - `BackgroundTasks`
+
+آپ *path operation function* یا dependency function میں `BackgroundTasks` type کا parameter declare کر سکتے ہیں، اور پھر اسے response بھیجنے کے بعد background tasks کے عمل کو schedule کرنے کے لیے استعمال کر سکتے ہیں۔
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import BackgroundTasks
+```
+
+::: fastapi.BackgroundTasks
diff --git a/docs/ur/docs/reference/dependencies.md b/docs/ur/docs/reference/dependencies.md
new file mode 100644
index 000000000..55eeefd5b
--- /dev/null
+++ b/docs/ur/docs/reference/dependencies.md
@@ -0,0 +1,29 @@
+# Dependencies - `Depends()` اور `Security()`
+
+## `Depends()`
+
+Dependencies کو بنیادی طور پر خاص function `Depends()` کے ذریعے سنبھالا جاتا ہے جو ایک callable لیتا ہے۔
+
+یہاں اس کی اور اس کے parameters کی حوالہ جاتی معلومات ہیں۔
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import Depends
+```
+
+::: fastapi.Depends
+
+## `Security()`
+
+بہت سے منظرناموں میں، آپ `Depends()` استعمال کر کے dependencies کے ذریعے security (authorization، authentication، وغیرہ) کو سنبھال سکتے ہیں۔
+
+لیکن جب آپ OAuth2 scopes بھی declare کرنا چاہیں، تو آپ `Depends()` کی بجائے `Security()` استعمال کر سکتے ہیں۔
+
+آپ `Security()` کو براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import Security
+```
+
+::: fastapi.Security
diff --git a/docs/ur/docs/reference/encoders.md b/docs/ur/docs/reference/encoders.md
new file mode 100644
index 000000000..28df2e43a
--- /dev/null
+++ b/docs/ur/docs/reference/encoders.md
@@ -0,0 +1,3 @@
+# Encoders - `jsonable_encoder`
+
+::: fastapi.encoders.jsonable_encoder
diff --git a/docs/ur/docs/reference/exceptions.md b/docs/ur/docs/reference/exceptions.md
new file mode 100644
index 000000000..afa153d64
--- /dev/null
+++ b/docs/ur/docs/reference/exceptions.md
@@ -0,0 +1,20 @@
+# Exceptions - `HTTPException` اور `WebSocketException`
+
+یہ وہ exceptions ہیں جو آپ client کو غلطیاں دکھانے کے لیے raise کر سکتے ہیں۔
+
+جب آپ کوئی exception raise کرتے ہیں، جیسا کہ عام Python میں ہوتا ہے، باقی کا عمل روک دیا جاتا ہے۔ اس طرح آپ code میں کہیں سے بھی یہ exceptions raise کر کے request کو روک سکتے ہیں اور client کو غلطی دکھا سکتے ہیں۔
+
+آپ یہ استعمال کر سکتے ہیں:
+
+* `HTTPException`
+* `WebSocketException`
+
+یہ exceptions براہ راست `fastapi` سے import کی جا سکتی ہیں:
+
+```python
+from fastapi import HTTPException, WebSocketException
+```
+
+::: fastapi.HTTPException
+
+::: fastapi.WebSocketException
diff --git a/docs/ur/docs/reference/fastapi.md b/docs/ur/docs/reference/fastapi.md
new file mode 100644
index 000000000..63a7c1a8a
--- /dev/null
+++ b/docs/ur/docs/reference/fastapi.md
@@ -0,0 +1,31 @@
+# `FastAPI` class
+
+یہاں `FastAPI` class کی حوالہ جاتی معلومات ہیں، اس کے تمام parameters، attributes اور methods کے ساتھ۔
+
+آپ `FastAPI` class کو براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import FastAPI
+```
+
+::: fastapi.FastAPI
+ options:
+ members:
+ - openapi_version
+ - webhooks
+ - state
+ - dependency_overrides
+ - openapi
+ - websocket
+ - include_router
+ - get
+ - put
+ - post
+ - delete
+ - options
+ - head
+ - patch
+ - trace
+ - on_event
+ - middleware
+ - exception_handler
diff --git a/docs/ur/docs/reference/httpconnection.md b/docs/ur/docs/reference/httpconnection.md
new file mode 100644
index 000000000..17bf6db4e
--- /dev/null
+++ b/docs/ur/docs/reference/httpconnection.md
@@ -0,0 +1,11 @@
+# `HTTPConnection` class
+
+جب آپ ایسی dependencies define کرنا چاہیں جو HTTP اور WebSockets دونوں کے ساتھ مطابقت رکھتی ہوں، تو آپ `Request` یا `WebSocket` کی بجائے `HTTPConnection` لینے والا parameter define کر سکتے ہیں۔
+
+آپ اسے `fastapi.requests` سے import کر سکتے ہیں:
+
+```python
+from fastapi.requests import HTTPConnection
+```
+
+::: fastapi.requests.HTTPConnection
diff --git a/docs/ur/docs/reference/index.md b/docs/ur/docs/reference/index.md
new file mode 100644
index 000000000..76f455183
--- /dev/null
+++ b/docs/ur/docs/reference/index.md
@@ -0,0 +1,6 @@
+# حوالہ جات
+
+یہاں حوالہ جات یا code API موجود ہے، جس میں classes، functions، parameters، attributes، اور FastAPI کے تمام وہ حصے شامل ہیں جو آپ اپنی applications میں استعمال کر سکتے ہیں۔
+
+اگر آپ **FastAPI سیکھنا** چاہتے ہیں تو آپ کے لیے
+[FastAPI ٹیوٹوریل](https://fastapi.tiangolo.com/tutorial/) پڑھنا زیادہ بہتر ہوگا۔
diff --git a/docs/ur/docs/reference/middleware.md b/docs/ur/docs/reference/middleware.md
new file mode 100644
index 000000000..9d8a703e9
--- /dev/null
+++ b/docs/ur/docs/reference/middleware.md
@@ -0,0 +1,37 @@
+# Middleware
+
+Starlette کی طرف سے براہ راست فراہم کردہ کئی middlewares دستیاب ہیں۔
+
+ان کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Middleware](https://fastapi.tiangolo.com/advanced/middleware/)۔
+
+::: fastapi.middleware.cors.CORSMiddleware
+
+اسے `fastapi` سے import کیا جا سکتا ہے:
+
+```python
+from fastapi.middleware.cors import CORSMiddleware
+```
+
+::: fastapi.middleware.gzip.GZipMiddleware
+
+اسے `fastapi` سے import کیا جا سکتا ہے:
+
+```python
+from fastapi.middleware.gzip import GZipMiddleware
+```
+
+::: fastapi.middleware.httpsredirect.HTTPSRedirectMiddleware
+
+اسے `fastapi` سے import کیا جا سکتا ہے:
+
+```python
+from fastapi.middleware.httpsredirect import HTTPSRedirectMiddleware
+```
+
+::: fastapi.middleware.trustedhost.TrustedHostMiddleware
+
+اسے `fastapi` سے import کیا جا سکتا ہے:
+
+```python
+from fastapi.middleware.trustedhost import TrustedHostMiddleware
+```
diff --git a/docs/ur/docs/reference/openapi/docs.md b/docs/ur/docs/reference/openapi/docs.md
new file mode 100644
index 000000000..7adf91912
--- /dev/null
+++ b/docs/ur/docs/reference/openapi/docs.md
@@ -0,0 +1,11 @@
+# OpenAPI `docs`
+
+OpenAPI خودکار UI دستاویزات کو سنبھالنے کے لیے utilities، بشمول Swagger UI (بطور ڈیفالٹ `/docs` پر) اور ReDoc (بطور ڈیفالٹ `/redoc` پر)۔
+
+::: fastapi.openapi.docs.get_swagger_ui_html
+
+::: fastapi.openapi.docs.get_redoc_html
+
+::: fastapi.openapi.docs.get_swagger_ui_oauth2_redirect_html
+
+::: fastapi.openapi.docs.swagger_ui_default_parameters
diff --git a/docs/ur/docs/reference/openapi/index.md b/docs/ur/docs/reference/openapi/index.md
new file mode 100644
index 000000000..bde19f41d
--- /dev/null
+++ b/docs/ur/docs/reference/openapi/index.md
@@ -0,0 +1,5 @@
+# OpenAPI
+
+OpenAPI کو سنبھالنے کے لیے کئی utilities دستیاب ہیں۔
+
+عام طور پر آپ کو انہیں استعمال کرنے کی ضرورت نہیں ہوتی جب تک کہ آپ کے پاس کوئی مخصوص جدید استعمال کا معاملہ نہ ہو جس کے لیے ان کی ضرورت ہو۔
diff --git a/docs/ur/docs/reference/openapi/models.md b/docs/ur/docs/reference/openapi/models.md
new file mode 100644
index 000000000..a8f3072aa
--- /dev/null
+++ b/docs/ur/docs/reference/openapi/models.md
@@ -0,0 +1,5 @@
+# OpenAPI `models`
+
+OpenAPI Pydantic models جو تیار کردہ OpenAPI کو generate اور validate کرنے کے لیے استعمال ہوتے ہیں۔
+
+::: fastapi.openapi.models
diff --git a/docs/ur/docs/reference/parameters.md b/docs/ur/docs/reference/parameters.md
new file mode 100644
index 000000000..e95c774bc
--- /dev/null
+++ b/docs/ur/docs/reference/parameters.md
@@ -0,0 +1,35 @@
+# Request Parameters
+
+یہاں request parameters کی حوالہ جاتی معلومات ہیں۔
+
+یہ وہ خاص functions ہیں جو آپ *path operation function* کے parameters یا dependency functions میں `Annotated` کے ساتھ استعمال کر کے request سے ڈیٹا حاصل کر سکتے ہیں۔
+
+اس میں شامل ہیں:
+
+* `Query()`
+* `Path()`
+* `Body()`
+* `Cookie()`
+* `Header()`
+* `Form()`
+* `File()`
+
+آپ ان سب کو براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import Body, Cookie, File, Form, Header, Path, Query
+```
+
+::: fastapi.Query
+
+::: fastapi.Path
+
+::: fastapi.Body
+
+::: fastapi.Cookie
+
+::: fastapi.Header
+
+::: fastapi.Form
+
+::: fastapi.File
diff --git a/docs/ur/docs/reference/request.md b/docs/ur/docs/reference/request.md
new file mode 100644
index 000000000..6174dce86
--- /dev/null
+++ b/docs/ur/docs/reference/request.md
@@ -0,0 +1,19 @@
+# `Request` class
+
+آپ *path operation function* یا dependency میں `Request` type کا parameter declare کر سکتے ہیں اور پھر بغیر کسی validation وغیرہ کے خام request object تک براہ راست رسائی حاصل کر سکتے ہیں۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Request کو براہ راست استعمال کرنا](https://fastapi.tiangolo.com/advanced/using-request-directly/)
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import Request
+```
+
+/// tip | مشورہ
+
+جب آپ ایسی dependencies define کرنا چاہیں جو HTTP اور WebSockets دونوں کے ساتھ مطابقت رکھتی ہوں، تو آپ `Request` یا `WebSocket` کی بجائے `HTTPConnection` لینے والا parameter define کر سکتے ہیں۔
+
+///
+
+::: fastapi.Request
diff --git a/docs/ur/docs/reference/response.md b/docs/ur/docs/reference/response.md
new file mode 100644
index 000000000..a3153ee8d
--- /dev/null
+++ b/docs/ur/docs/reference/response.md
@@ -0,0 +1,15 @@
+# `Response` class
+
+آپ *path operation function* یا dependency میں `Response` type کا parameter declare کر سکتے ہیں اور پھر response کے لیے ڈیٹا جیسے headers یا cookies سیٹ کر سکتے ہیں۔
+
+آپ اسے براہ راست ایک instance بنانے اور اپنی *path operations* سے واپس کرنے کے لیے بھی استعمال کر سکتے ہیں۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں حسب ضرورت Response واپس کرنا](https://fastapi.tiangolo.com/advanced/response-directly/#returning-a-custom-response)
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import Response
+```
+
+::: fastapi.Response
diff --git a/docs/ur/docs/reference/responses.md b/docs/ur/docs/reference/responses.md
new file mode 100644
index 000000000..1507bfe12
--- /dev/null
+++ b/docs/ur/docs/reference/responses.md
@@ -0,0 +1,172 @@
+# حسب ضرورت Response Classes - File، HTML، Redirect، Streaming، وغیرہ
+
+کئی حسب ضرورت response classes دستیاب ہیں جنہیں آپ ایک instance بنا کر اپنی *path operations* سے براہ راست واپس کر سکتے ہیں۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں حسب ضرورت Response - HTML، Stream، File، اور دیگر](https://fastapi.tiangolo.com/advanced/custom-response/)۔
+
+آپ انہیں براہ راست `fastapi.responses` سے import کر سکتے ہیں:
+
+```python
+from fastapi.responses import (
+ FileResponse,
+ HTMLResponse,
+ JSONResponse,
+ ORJSONResponse,
+ PlainTextResponse,
+ RedirectResponse,
+ Response,
+ StreamingResponse,
+ UJSONResponse,
+)
+```
+
+## FastAPI Responses
+
+کچھ حسب ضرورت FastAPI response classes تھیں جو JSON کی کارکردگی کو بہتر بنانے کے لیے بنائی گئی تھیں۔
+
+تاہم، اب یہ deprecated ہو چکی ہیں کیونکہ اب آپ [Response Model - Return Type](https://fastapi.tiangolo.com/tutorial/response-model/) استعمال کر کے بہتر کارکردگی حاصل کر سکتے ہیں۔
+
+اس طرح، Pydantic ڈیٹا کو Rust کی طرف JSON bytes میں serialize کرے گا، جو ان حسب ضرورت JSON responses سے بہتر کارکردگی فراہم کرے گا۔
+
+اس کے بارے میں مزید پڑھیں [حسب ضرورت Response - HTML، Stream، File، اور دیگر - `orjson` یا Response Model](https://fastapi.tiangolo.com/advanced/custom-response/#orjson-or-response-model)۔
+
+::: fastapi.responses.UJSONResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.ORJSONResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+## Starlette Responses
+
+آپ ان سب کے بارے میں مزید پڑھ سکتے ہیں [FastAPI دستاویزات میں حسب ضرورت Response](https://fastapi.tiangolo.com/advanced/custom-response/) اور [Starlette دستاویزات میں Responses](https://starlette.dev/responses/)۔
+
+::: fastapi.responses.FileResponse
+ options:
+ members:
+ - chunk_size
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.HTMLResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.JSONResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.PlainTextResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.RedirectResponse
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.Response
+ options:
+ members:
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
+
+::: fastapi.responses.StreamingResponse
+ options:
+ members:
+ - body_iterator
+ - charset
+ - status_code
+ - media_type
+ - body
+ - background
+ - raw_headers
+ - render
+ - init_headers
+ - headers
+ - set_cookie
+ - delete_cookie
diff --git a/docs/ur/docs/reference/security/index.md b/docs/ur/docs/reference/security/index.md
new file mode 100644
index 000000000..534c0f7fa
--- /dev/null
+++ b/docs/ur/docs/reference/security/index.md
@@ -0,0 +1,75 @@
+# Security ٹولز
+
+جب آپ کو OAuth2 scopes کے ساتھ dependencies declare کرنی ہوں تو آپ `Security()` استعمال کرتے ہیں۔
+
+لیکن آپ کو پھر بھی یہ define کرنا ہوگا کہ dependable کیا ہے، یعنی وہ callable جو آپ `Depends()` یا `Security()` کو parameter کے طور پر دیتے ہیں۔
+
+ایسے dependables بنانے کے لیے کئی ٹولز دستیاب ہیں، اور یہ OpenAPI میں ضم ہو جاتے ہیں تاکہ یہ خودکار docs UI میں دکھائے جائیں، خودکار طور پر بنائے گئے clients اور SDKs کے ذریعے استعمال ہو سکیں، وغیرہ۔
+
+آپ انہیں `fastapi.security` سے import کر سکتے ہیں:
+
+```python
+from fastapi.security import (
+ APIKeyCookie,
+ APIKeyHeader,
+ APIKeyQuery,
+ HTTPAuthorizationCredentials,
+ HTTPBasic,
+ HTTPBasicCredentials,
+ HTTPBearer,
+ HTTPDigest,
+ OAuth2,
+ OAuth2AuthorizationCodeBearer,
+ OAuth2PasswordBearer,
+ OAuth2PasswordRequestForm,
+ OAuth2PasswordRequestFormStrict,
+ OpenIdConnect,
+ SecurityScopes,
+)
+```
+
+ان کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Security](https://fastapi.tiangolo.com/tutorial/security/)۔
+
+## API Key Security Schemes
+
+::: fastapi.security.APIKeyCookie
+
+::: fastapi.security.APIKeyHeader
+
+::: fastapi.security.APIKeyQuery
+
+## HTTP Authentication Schemes
+
+::: fastapi.security.HTTPBasic
+
+::: fastapi.security.HTTPBearer
+
+::: fastapi.security.HTTPDigest
+
+## HTTP Credentials
+
+::: fastapi.security.HTTPAuthorizationCredentials
+
+::: fastapi.security.HTTPBasicCredentials
+
+## OAuth2 Authentication
+
+::: fastapi.security.OAuth2
+
+::: fastapi.security.OAuth2AuthorizationCodeBearer
+
+::: fastapi.security.OAuth2PasswordBearer
+
+## OAuth2 Password Form
+
+::: fastapi.security.OAuth2PasswordRequestForm
+
+::: fastapi.security.OAuth2PasswordRequestFormStrict
+
+## OAuth2 Security Scopes میں Dependencies
+
+::: fastapi.security.SecurityScopes
+
+## OpenID Connect
+
+::: fastapi.security.OpenIdConnect
diff --git a/docs/ur/docs/reference/staticfiles.md b/docs/ur/docs/reference/staticfiles.md
new file mode 100644
index 000000000..204995389
--- /dev/null
+++ b/docs/ur/docs/reference/staticfiles.md
@@ -0,0 +1,13 @@
+# Static Files - `StaticFiles`
+
+آپ `StaticFiles` class کو static files فراہم کرنے کے لیے استعمال کر سکتے ہیں، جیسے JavaScript، CSS، تصاویر، وغیرہ۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Static Files](https://fastapi.tiangolo.com/tutorial/static-files/)۔
+
+آپ اسے براہ راست `fastapi.staticfiles` سے import کر سکتے ہیں:
+
+```python
+from fastapi.staticfiles import StaticFiles
+```
+
+::: fastapi.staticfiles.StaticFiles
diff --git a/docs/ur/docs/reference/status.md b/docs/ur/docs/reference/status.md
new file mode 100644
index 000000000..ba04f7f53
--- /dev/null
+++ b/docs/ur/docs/reference/status.md
@@ -0,0 +1,36 @@
+# Status Codes
+
+آپ `status` module کو `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import status
+```
+
+`status` براہ راست Starlette کی طرف سے فراہم کیا گیا ہے۔
+
+اس میں نامزد constants (variables) کا ایک گروپ ہے جن کی قدریں integer status codes ہیں۔
+
+مثال کے طور پر:
+
+* 200: `status.HTTP_200_OK`
+* 403: `status.HTTP_403_FORBIDDEN`
+* وغیرہ۔
+
+یہ آپ کی app میں HTTP (اور WebSocket) status codes تک فوری رسائی کے لیے آسان ہو سکتا ہے، نام کے لیے autocompletion استعمال کرتے ہوئے بغیر integer status codes یاد رکھنے کی ضرورت کے۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Response Status Code](https://fastapi.tiangolo.com/tutorial/response-status-code/)۔
+
+## مثال
+
+```python
+from fastapi import FastAPI, status
+
+app = FastAPI()
+
+
+@app.get("/items/", status_code=status.HTTP_418_IM_A_TEAPOT)
+def read_items():
+ return [{"name": "Plumbus"}, {"name": "Portal Gun"}]
+```
+
+::: fastapi.status
diff --git a/docs/ur/docs/reference/templating.md b/docs/ur/docs/reference/templating.md
new file mode 100644
index 000000000..4b8255259
--- /dev/null
+++ b/docs/ur/docs/reference/templating.md
@@ -0,0 +1,13 @@
+# Templating - `Jinja2Templates`
+
+آپ `Jinja2Templates` class کو Jinja templates render کرنے کے لیے استعمال کر سکتے ہیں۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Templates](https://fastapi.tiangolo.com/advanced/templates/)۔
+
+آپ اسے براہ راست `fastapi.templating` سے import کر سکتے ہیں:
+
+```python
+from fastapi.templating import Jinja2Templates
+```
+
+::: fastapi.templating.Jinja2Templates
diff --git a/docs/ur/docs/reference/testclient.md b/docs/ur/docs/reference/testclient.md
new file mode 100644
index 000000000..dfecf5aab
--- /dev/null
+++ b/docs/ur/docs/reference/testclient.md
@@ -0,0 +1,13 @@
+# Test Client - `TestClient`
+
+آپ `TestClient` class کو FastAPI applications کی جانچ کرنے کے لیے استعمال کر سکتے ہیں بغیر کوئی حقیقی HTTP اور socket connection بنائے، بس FastAPI code کے ساتھ براہ راست بات چیت کر کے۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں Testing](https://fastapi.tiangolo.com/tutorial/testing/)۔
+
+آپ اسے براہ راست `fastapi.testclient` سے import کر سکتے ہیں:
+
+```python
+from fastapi.testclient import TestClient
+```
+
+::: fastapi.testclient.TestClient
diff --git a/docs/ur/docs/reference/uploadfile.md b/docs/ur/docs/reference/uploadfile.md
new file mode 100644
index 000000000..2d7458281
--- /dev/null
+++ b/docs/ur/docs/reference/uploadfile.md
@@ -0,0 +1,22 @@
+# `UploadFile` class
+
+آپ *path operation function* کے parameters کو `UploadFile` type کا define کر سکتے ہیں تاکہ request سے files وصول کی جا سکیں۔
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import UploadFile
+```
+
+::: fastapi.UploadFile
+ options:
+ members:
+ - file
+ - filename
+ - size
+ - headers
+ - content_type
+ - read
+ - write
+ - seek
+ - close
diff --git a/docs/ur/docs/reference/websockets.md b/docs/ur/docs/reference/websockets.md
new file mode 100644
index 000000000..fd2028b97
--- /dev/null
+++ b/docs/ur/docs/reference/websockets.md
@@ -0,0 +1,73 @@
+# WebSockets
+
+WebSockets define کرتے وقت، آپ عام طور پر `WebSocket` type کا parameter declare کرتے ہیں اور اس کے ذریعے client سے ڈیٹا پڑھ سکتے ہیں اور اسے ڈیٹا بھیج سکتے ہیں۔
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں WebSockets](https://fastapi.tiangolo.com/advanced/websockets/)
+
+یہ Starlette کی طرف سے براہ راست فراہم کیا گیا ہے، لیکن آپ اسے `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import WebSocket
+```
+
+/// tip | مشورہ
+
+جب آپ ایسی dependencies define کرنا چاہیں جو HTTP اور WebSockets دونوں کے ساتھ مطابقت رکھتی ہوں، تو آپ `Request` یا `WebSocket` کی بجائے `HTTPConnection` لینے والا parameter define کر سکتے ہیں۔
+
+///
+
+::: fastapi.WebSocket
+ options:
+ members:
+ - scope
+ - app
+ - url
+ - base_url
+ - headers
+ - query_params
+ - path_params
+ - cookies
+ - client
+ - state
+ - url_for
+ - client_state
+ - application_state
+ - receive
+ - send
+ - accept
+ - receive_text
+ - receive_bytes
+ - receive_json
+ - iter_text
+ - iter_bytes
+ - iter_json
+ - send_text
+ - send_bytes
+ - send_json
+ - close
+
+## WebSockets - اضافی classes
+
+WebSockets کو سنبھالنے کے لیے اضافی classes۔
+
+Starlette کی طرف سے براہ راست فراہم کی گئی ہیں، لیکن آپ انہیں `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi.websockets import WebSocketDisconnect, WebSocketState
+```
+
+::: fastapi.websockets.WebSocketDisconnect
+
+جب کوئی client منقطع ہوتا ہے تو `WebSocketDisconnect` exception raise ہوتا ہے، آپ اسے catch کر سکتے ہیں۔
+
+آپ اسے براہ راست `fastapi` سے import کر سکتے ہیں:
+
+```python
+from fastapi import WebSocketDisconnect
+```
+
+اس کے بارے میں مزید پڑھیں [FastAPI دستاویزات میں WebSockets](https://fastapi.tiangolo.com/advanced/websockets/#handling-disconnections-and-multiple-clients)
+
+::: fastapi.websockets.WebSocketState
+
+`WebSocketState` ایک enumeration ہے جو WebSocket connection کی ممکنہ حالتوں کو ظاہر کرتا ہے۔
diff --git a/docs/ur/docs/release-notes.md b/docs/ur/docs/release-notes.md
new file mode 100644
index 000000000..96f8498f2
--- /dev/null
+++ b/docs/ur/docs/release-notes.md
@@ -0,0 +1,6 @@
+---
+hide:
+ - navigation
+---
+
+# ریلیز نوٹس
diff --git a/docs/ur/docs/resources/index.md b/docs/ur/docs/resources/index.md
new file mode 100644
index 000000000..ed5e643a3
--- /dev/null
+++ b/docs/ur/docs/resources/index.md
@@ -0,0 +1,3 @@
+# وسائل { #resources }
+
+اضافی وسائل، بیرونی لنکس، اور مزید۔ ✈️
diff --git a/docs/ur/docs/translation-banner.md b/docs/ur/docs/translation-banner.md
new file mode 100644
index 000000000..991e46fda
--- /dev/null
+++ b/docs/ur/docs/translation-banner.md
@@ -0,0 +1,11 @@
+/// details | 🌐 مصنوعی ذہانت اور انسانوں کی مدد سے ترجمہ
+
+یہ ترجمہ انسانوں کی رہنمائی میں مصنوعی ذہانت کے ذریعے تیار کیا گیا ہے۔ 🤝
+
+اس میں اصل معنی کی غلط تشریح یا غیر فطری زبان جیسی خامیاں ہو سکتی ہیں۔ 🤖
+
+آپ [مصنوعی ذہانت LLM کو بہتر رہنمائی دینے میں ہماری مدد کر کے](https://fastapi.tiangolo.com/contributing/#translations) اس ترجمے کو بہتر بنا سکتے ہیں۔
+
+[انگریزی نسخہ](ENGLISH_VERSION_URL)
+
+///
diff --git a/docs/ur/docs/tutorial/background-tasks.md b/docs/ur/docs/tutorial/background-tasks.md
new file mode 100644
index 000000000..fcc309730
--- /dev/null
+++ b/docs/ur/docs/tutorial/background-tasks.md
@@ -0,0 +1,84 @@
+# Background Tasks { #background-tasks }
+
+آپ background tasks define کر سکتے ہیں جو response واپس بھیجنے کے *بعد* چلائے جائیں۔
+
+یہ ان operations کے لیے مفید ہے جو request کے بعد ہونے چاہئیں، لیکن client کو response وصول کرنے سے پہلے ان کے مکمل ہونے کا انتظار کرنے کی ضرورت نہیں ہے۔
+
+اس میں مثال کے طور پر شامل ہیں:
+
+* کوئی عمل انجام دینے کے بعد بھیجی جانے والی email notifications:
+ * چونکہ email server سے connect ہونا اور email بھیجنا "سست" ہوتا ہے (کئی سیکنڈز)، آپ فوری طور پر response واپس بھیج سکتے ہیں اور email notification background میں بھیج سکتے ہیں۔
+* Data کی processing:
+ * مثال کے طور پر، فرض کریں آپ کو ایک فائل ملتی ہے جسے سست process سے گزرنا ہے، آپ "Accepted" (HTTP 202) کا response واپس بھیج سکتے ہیں اور فائل کو background میں process کر سکتے ہیں۔
+
+## `BackgroundTasks` استعمال کرنا { #using-backgroundtasks }
+
+سب سے پہلے، `BackgroundTasks` import کریں اور اپنے *path operation function* میں `BackgroundTasks` کی type declaration کے ساتھ ایک parameter define کریں:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}
+
+**FastAPI** آپ کے لیے `BackgroundTasks` قسم کا object بنائے گا اور اسے اس parameter کے طور پر منتقل کرے گا۔
+
+## ایک task function بنائیں { #create-a-task-function }
+
+background task کے طور پر چلایا جانے والا function بنائیں۔
+
+یہ ایک عام function ہے جو parameters وصول کر سکتا ہے۔
+
+یہ `async def` یا عام `def` function ہو سکتا ہے، **FastAPI** اسے درست طریقے سے handle کرنا جانتا ہے۔
+
+اس صورت میں، task function ایک فائل میں لکھے گا (email بھیجنے کی نقل)۔
+
+اور چونکہ write operation `async` اور `await` استعمال نہیں کرتا، ہم function کو عام `def` سے define کرتے ہیں:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[6:9] *}
+
+## Background task شامل کریں { #add-the-background-task }
+
+اپنے *path operation function* کے اندر، اپنا task function `.add_task()` method کے ذریعے *background tasks* object کو دیں:
+
+{* ../../docs_src/background_tasks/tutorial001_py310.py hl[14] *}
+
+`.add_task()` arguments کے طور پر وصول کرتا ہے:
+
+* background میں چلایا جانے والا task function (`write_notification`)۔
+* task function کو ترتیب سے منتقل کیے جانے والے arguments کی کوئی بھی sequence (`email`)۔
+* task function کو منتقل کیے جانے والے کوئی بھی keyword arguments (`message="some notification"`)۔
+
+## Dependency Injection { #dependency-injection }
+
+`BackgroundTasks` کا استعمال dependency injection system کے ساتھ بھی کام کرتا ہے، آپ متعدد سطحوں پر `BackgroundTasks` قسم کا parameter declare کر سکتے ہیں: *path operation function* میں، dependency (dependable) میں، sub-dependency میں، وغیرہ۔
+
+**FastAPI** جانتا ہے کہ ہر صورت میں کیا کرنا ہے اور ایک ہی object کو دوبارہ استعمال کرنا ہے، تاکہ تمام background tasks آپس میں مل جائیں اور بعد میں background میں چلائے جائیں:
+
+{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
+
+اس مثال میں، پیغامات `log.txt` فائل میں response بھیجنے کے *بعد* لکھے جائیں گے۔
+
+اگر request میں کوئی query تھی، تو اسے background task میں log میں لکھا جائے گا۔
+
+اور پھر *path operation function* میں بنایا گیا ایک اور background task `email` path parameter استعمال کرتے ہوئے ایک پیغام لکھے گا۔
+
+## تکنیکی تفصیلات { #technical-details }
+
+`BackgroundTasks` class براہ راست [`starlette.background`](https://www.starlette.dev/background/) سے آتی ہے۔
+
+اسے FastAPI میں براہ راست import/شامل کیا گیا ہے تاکہ آپ اسے `fastapi` سے import کر سکیں اور غلطی سے `starlette.background` سے متبادل `BackgroundTask` (آخر میں `s` کے بغیر) import کرنے سے بچ سکیں۔
+
+صرف `BackgroundTasks` (نہ کہ `BackgroundTask`) استعمال کر کے، اسے *path operation function* parameter کے طور پر استعمال کرنا ممکن ہو جاتا ہے اور **FastAPI** باقی کام خود سنبھال لیتا ہے، بالکل اسی طرح جیسے `Request` object کو براہ راست استعمال کرتے وقت۔
+
+FastAPI میں اکیلے `BackgroundTask` استعمال کرنا بھی ممکن ہے، لیکن آپ کو اپنے code میں object بنانا ہوگا اور اسے شامل کرتے ہوئے Starlette `Response` واپس کرنا ہوگا۔
+
+آپ [Starlette کی Background Tasks کی سرکاری دستاویزات](https://www.starlette.dev/background/) میں مزید تفصیلات دیکھ سکتے ہیں۔
+
+## احتیاط { #caveat }
+
+اگر آپ کو بھاری background computation کرنے کی ضرورت ہے اور آپ کو لازمی طور پر اسی process سے چلانے کی ضرورت نہیں ہے (مثلاً، آپ کو memory، variables وغیرہ share کرنے کی ضرورت نہیں)، تو آپ کو [Celery](https://docs.celeryq.dev) جیسے بڑے tools استعمال کرنے سے فائدہ ہو سکتا ہے۔
+
+ان میں عام طور پر زیادہ پیچیدہ configurations، message/job queue manager، جیسے RabbitMQ یا Redis کی ضرورت ہوتی ہے، لیکن یہ آپ کو background tasks کو متعدد processes میں، اور خاص طور پر، متعدد servers میں چلانے کی اجازت دیتے ہیں۔
+
+لیکن اگر آپ کو اسی **FastAPI** app سے variables اور objects تک رسائی حاصل کرنے کی ضرورت ہے، یا آپ کو چھوٹے background tasks (جیسے email notification بھیجنا) انجام دینے کی ضرورت ہے، تو آپ آسانی سے `BackgroundTasks` استعمال کر سکتے ہیں۔
+
+## خلاصہ { #recap }
+
+Background tasks شامل کرنے کے لیے *path operation functions* اور dependencies میں parameters کے ساتھ `BackgroundTasks` import اور استعمال کریں۔
diff --git a/docs/ur/docs/tutorial/bigger-applications.md b/docs/ur/docs/tutorial/bigger-applications.md
new file mode 100644
index 000000000..ad0b0d615
--- /dev/null
+++ b/docs/ur/docs/tutorial/bigger-applications.md
@@ -0,0 +1,535 @@
+# بڑی Applications - متعدد فائلیں { #bigger-applications-multiple-files }
+
+اگر آپ کوئی application یا web API بنا رہے ہیں، تو شاذ و نادر ہی ایسا ہوتا ہے کہ آپ سب کچھ ایک واحد فائل میں رکھ سکیں۔
+
+**FastAPI** آپ کی application کی ساخت بنانے کے لیے ایک آسان tool فراہم کرتا ہے جبکہ تمام لچک برقرار رکھتا ہے۔
+
+/// info | معلومات
+
+اگر آپ Flask سے آئے ہیں، تو یہ Flask کے Blueprints کے مساوی ہوگا۔
+
+///
+
+## فائل کی ساخت کی مثال { #an-example-file-structure }
+
+فرض کریں آپ کے پاس اس طرح کی فائل ساخت ہے:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+│ ├── dependencies.py
+│ └── routers
+│ │ ├── __init__.py
+│ │ ├── items.py
+│ │ └── users.py
+│ └── internal
+│ ├── __init__.py
+│ └── admin.py
+```
+
+/// tip | مشورہ
+
+کئی `__init__.py` فائلیں ہیں: ہر directory یا subdirectory میں ایک۔
+
+یہی وہ چیز ہے جو ایک فائل سے دوسری میں code import کرنے کی اجازت دیتی ہے۔
+
+مثال کے طور پر، `app/main.py` میں آپ کے پاس ایسی لائن ہو سکتی ہے:
+
+```
+from app.routers import items
+```
+
+///
+
+* `app` directory میں سب کچھ ہے۔ اور اس میں ایک خالی فائل `app/__init__.py` ہے، تو یہ ایک "Python package" ہے (Python "modules" کا مجموعہ): `app`۔
+* اس میں ایک `app/main.py` فائل ہے۔ چونکہ یہ ایک Python package (ایسی directory جس میں `__init__.py` فائل ہو) کے اندر ہے، یہ اس package کا ایک "module" ہے: `app.main`۔
+* ایک `app/dependencies.py` فائل بھی ہے، بالکل `app/main.py` کی طرح، یہ ایک "module" ہے: `app.dependencies`۔
+* ایک subdirectory `app/routers/` ہے جس میں ایک اور `__init__.py` فائل ہے، تو یہ ایک "Python subpackage" ہے: `app.routers`۔
+* فائل `app/routers/items.py` ایک package `app/routers/` کے اندر ہے، تو یہ ایک submodule ہے: `app.routers.items`۔
+* `app/routers/users.py` کے ساتھ بھی یہی ہے، یہ ایک اور submodule ہے: `app.routers.users`۔
+* ایک subdirectory `app/internal/` بھی ہے جس میں ایک اور `__init__.py` فائل ہے، تو یہ ایک اور "Python subpackage" ہے: `app.internal`۔
+* اور فائل `app/internal/admin.py` ایک اور submodule ہے: `app.internal.admin`۔
+
+
+
+تبصروں کے ساتھ وہی فائل ساخت:
+
+```bash
+.
+├── app # "app" is a Python package
+│ ├── __init__.py # this file makes "app" a "Python package"
+│ ├── main.py # "main" module, e.g. import app.main
+│ ├── dependencies.py # "dependencies" module, e.g. import app.dependencies
+│ └── routers # "routers" is a "Python subpackage"
+│ │ ├── __init__.py # makes "routers" a "Python subpackage"
+│ │ ├── items.py # "items" submodule, e.g. import app.routers.items
+│ │ └── users.py # "users" submodule, e.g. import app.routers.users
+│ └── internal # "internal" is a "Python subpackage"
+│ ├── __init__.py # makes "internal" a "Python subpackage"
+│ └── admin.py # "admin" submodule, e.g. import app.internal.admin
+```
+
+## `APIRouter` { #apirouter }
+
+فرض کریں صرف users کو handle کرنے کے لیے وقف فائل submodule `/app/routers/users.py` میں ہے۔
+
+آپ اپنے users سے متعلق *path operations* کو باقی code سے الگ رکھنا چاہتے ہیں، تاکہ اسے منظم رکھا جا سکے۔
+
+لیکن یہ اب بھی اسی **FastAPI** application/web API کا حصہ ہے (یہ اسی "Python Package" کا حصہ ہے)۔
+
+آپ `APIRouter` استعمال کر کے اس module کے لیے *path operations* بنا سکتے ہیں۔
+
+### `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` کو ایک "چھوٹا `FastAPI`" class سمجھ سکتے ہیں۔
+
+تمام اختیارات حمایت یافتہ ہیں۔
+
+تمام وہی `parameters`، `responses`، `dependencies`، `tags`، وغیرہ۔
+
+/// tip | مشورہ
+
+اس مثال میں، variable کا نام `router` ہے، لیکن آپ اسے جو چاہیں نام دے سکتے ہیں۔
+
+///
+
+ہم اس `APIRouter` کو مرکزی `FastAPI` app میں شامل کریں گے، لیکن پہلے، آئیں dependencies اور ایک اور `APIRouter` دیکھتے ہیں۔
+
+## Dependencies { #dependencies }
+
+ہم دیکھتے ہیں کہ ہمیں application کے کئی مقامات پر استعمال ہونے والی کچھ dependencies کی ضرورت ہوگی۔
+
+تو ہم انہیں ان کے اپنے `dependencies` module (`app/dependencies.py`) میں رکھتے ہیں۔
+
+ہم اب ایک سادہ dependency استعمال کریں گے تاکہ ایک custom `X-Token` header پڑھا جا سکے:
+
+{* ../../docs_src/bigger_applications/app_an_py310/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
+
+/// tip | مشورہ
+
+ہم اس مثال کو آسان بنانے کے لیے ایک فرضی header استعمال کر رہے ہیں۔
+
+لیکن حقیقی صورتوں میں آپ کو مربوط [Security utilities](security/index.md) استعمال کرنے سے بہتر نتائج ملیں گے۔
+
+///
+
+## `APIRouter` کے ساتھ ایک اور module { #another-module-with-apirouter }
+
+فرض کریں آپ کے پاس `app/routers/items.py` module میں "items" کو handle کرنے کے لیے وقف endpoints بھی ہیں۔
+
+آپ کے پاس ان کے لیے *path operations* ہیں:
+
+* `/items/`
+* `/items/{item_id}`
+
+یہ سب `app/routers/users.py` جیسی ہی ساخت ہے۔
+
+لیکن ہم زیادہ ہوشیار بننا چاہتے ہیں اور code کو تھوڑا آسان بنانا چاہتے ہیں۔
+
+ہم جانتے ہیں کہ اس 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` اور اضافی `responses` کی فہرست بھی شامل کر سکتے ہیں جو اس router میں شامل تمام *path operations* پر لاگو ہوں گے۔
+
+اور ہم `dependencies` کی فہرست شامل کر سکتے ہیں جو router کے تمام *path operations* میں شامل ہوں گی اور ان کی ہر request کے لیے execute/solve ہوں گی۔
+
+/// tip | مشورہ
+
+یاد رکھیں، بالکل [dependencies in *path operation decorators*](dependencies/dependencies-in-path-operation-decorators.md) کی طرح، آپ کے *path operation function* کو کوئی قدر منتقل نہیں کی جائے گی۔
+
+///
+
+آخری نتیجہ یہ ہے کہ item paths اب ہیں:
+
+* `/items/`
+* `/items/{item_id}`
+
+...جیسا کہ ہم چاہتے تھے۔
+
+* انہیں ایک واحد string `"items"` پر مشتمل tags کی فہرست سے نشان زد کیا جائے گا۔
+ * یہ "tags" خاص طور پر خودکار interactive documentation systems (OpenAPI استعمال کرتے ہوئے) کے لیے مفید ہیں۔
+* ان سب میں پہلے سے define شدہ `responses` شامل ہوں گے۔
+* ان تمام *path operations* سے پہلے `dependencies` کی فہرست evaluate/execute ہوگی۔
+ * اگر آپ کسی مخصوص *path operation* میں بھی dependencies declare کرتے ہیں، **تو وہ بھی execute ہوں گی**۔
+ * Router dependencies پہلے execute ہوتی ہیں، پھر [decorator میں `dependencies`](dependencies/dependencies-in-path-operation-decorators.md)، اور پھر عام parameter dependencies۔
+ * آپ [`Security` dependencies بمع `scopes`](../advanced/security/oauth2-scopes.md) بھی شامل کر سکتے ہیں۔
+
+/// tip | مشورہ
+
+`APIRouter` میں `dependencies` رکھنا استعمال کیا جا سکتا ہے، مثال کے طور پر، *path operations* کے پورے گروپ کے لیے authentication لازمی بنانے کے لیے۔ چاہے dependencies انفرادی طور پر ہر ایک میں شامل نہ کی گئی ہوں۔
+
+///
+
+/// check
+
+`prefix`، `tags`، `responses`، اور `dependencies` parameters (جیسا کہ بہت سی دوسری صورتوں میں) code کی تکرار سے بچنے میں **FastAPI** کی طرف سے ایک آسانی ہے۔
+
+///
+
+### Dependencies import کریں { #import-the-dependencies }
+
+یہ code module `app.routers.items` میں ہے، فائل `app/routers/items.py`۔
+
+اور ہمیں module `app.dependencies` سے dependency function حاصل کرنی ہے، فائل `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 کے کام کرنے کے طریقے کو بخوبی جانتے ہیں، تو نیچے اگلے سیکشن پر جائیں۔
+
+///
+
+ایک واحد ڈاٹ `.`، جیسے:
+
+```Python
+from .dependencies import get_token_header
+```
+
+کا مطلب ہوگا:
+
+* اسی package سے شروع کریں جس میں یہ module (فائل `app/routers/items.py`) موجود ہے (directory `app/routers/`)...
+* `dependencies` module تلاش کریں (ایک فرضی فائل `app/routers/dependencies.py` پر)...
+* اور اس سے function `get_token_header` import کریں۔
+
+لیکن وہ فائل موجود نہیں ہے، ہماری dependencies `app/dependencies.py` پر ایک فائل میں ہیں۔
+
+یاد رکھیں ہماری app/فائل کی ساخت کیسی ہے:
+
+
+
+---
+
+دو ڈاٹ `..`، جیسے:
+
+```Python
+from ..dependencies import get_token_header
+```
+
+کا مطلب ہے:
+
+* اسی package سے شروع کریں جس میں یہ module (فائل `app/routers/items.py`) موجود ہے (directory `app/routers/`)...
+* parent package (directory `app/`) پر جائیں...
+* اور وہاں، `dependencies` module تلاش کریں (فائل `app/dependencies.py`)...
+* اور اس سے function `get_token_header` import کریں۔
+
+یہ درست طریقے سے کام کرتا ہے! 🎉
+
+---
+
+اسی طرح، اگر ہم تین ڈاٹ `...` استعمال کرتے، جیسے:
+
+```Python
+from ...dependencies import get_token_header
+```
+
+تو اس کا مطلب ہوتا:
+
+* اسی package سے شروع کریں جس میں یہ module (فائل `app/routers/items.py`) موجود ہے (directory `app/routers/`)...
+* parent package (directory `app/`) پر جائیں...
+* پھر اس package کے parent پر جائیں (کوئی parent package نہیں ہے، `app` سب سے اوپر کی سطح ہے 😱)...
+* اور وہاں، `dependencies` module تلاش کریں (فائل `app/dependencies.py`)...
+* اور اس سے function `get_token_header` import کریں۔
+
+یہ `app/` سے اوپر کسی package سے مراد ہوگا، جس کی اپنی `__init__.py` فائل ہو، وغیرہ۔ لیکن ہمارے پاس ایسا نہیں ہے۔ تو، یہ ہماری مثال میں error دے گا۔ 🚨
+
+لیکن اب آپ جانتے ہیں کہ یہ کیسے کام کرتا ہے، تو آپ اپنی apps میں relative imports استعمال کر سکتے ہیں چاہے وہ کتنی بھی پیچیدہ ہوں۔ 🤓
+
+### کچھ custom `tags`، `responses`، اور `dependencies` شامل کریں { #add-some-custom-tags-responses-and-dependencies }
+
+ہم ہر *path operation* میں `/items` prefix یا `tags=["items"]` شامل نہیں کر رہے ہیں کیونکہ ہم نے انہیں `APIRouter` میں شامل کر دیا ہے۔
+
+لیکن ہم پھر بھی _مزید_ `tags` شامل کر سکتے ہیں جو کسی مخصوص *path operation* پر لاگو ہوں گے، اور اس *path operation* کے لیے مخصوص کچھ اضافی `responses` بھی:
+
+{* ../../docs_src/bigger_applications/app_an_py310/routers/items.py hl[30:31] title["app/routers/items.py"] *}
+
+/// tip | مشورہ
+
+اس آخری path operation میں tags کا مجموعہ ہوگا: `["items", "custom"]`۔
+
+اور documentation میں اس کے دونوں responses ہوں گے، ایک `404` کے لیے اور ایک `403` کے لیے۔
+
+///
+
+## مرکزی `FastAPI` { #the-main-fastapi }
+
+اب، آئیں `app/main.py` module دیکھتے ہیں۔
+
+یہاں آپ `FastAPI` class import اور استعمال کرتے ہیں۔
+
+یہ آپ کی application کی مرکزی فائل ہوگی جو سب کچھ جوڑتی ہے۔
+
+اور چونکہ آپ کی زیادہ تر logic اب اپنے مخصوص module میں ہوگی، مرکزی فائل کافی سادہ ہوگی۔
+
+### `FastAPI` import کریں { #import-fastapi }
+
+آپ `FastAPI` class کو عام طریقے سے import اور بنائیں۔
+
+اور ہم [global dependencies](dependencies/global-dependencies.md) بھی declare کر سکتے ہیں جو ہر `APIRouter` کی dependencies کے ساتھ مل جائیں گی:
+
+{* ../../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"] *}
+
+چونکہ فائلیں `app/routers/users.py` اور `app/routers/items.py` submodules ہیں جو اسی Python package `app` کا حصہ ہیں، ہم ایک واحد ڈاٹ `.` سے "relative imports" استعمال کرتے ہوئے انہیں import کر سکتے ہیں۔
+
+### Import کیسے کام کرتا ہے { #how-the-importing-works }
+
+یہ سیکشن:
+
+```Python
+from .routers import items, users
+```
+
+کا مطلب ہے:
+
+* اسی package سے شروع کریں جس میں یہ module (فائل `app/main.py`) موجود ہے (directory `app/`)...
+* subpackage `routers` تلاش کریں (directory `app/routers/`)...
+* اور اس سے submodule `items` (فائل `app/routers/items.py`) اور `users` (فائل `app/routers/users.py`) import کریں...
+
+Module `items` میں ایک variable `router` ہوگا (`items.router`)۔ یہ وہی ہے جو ہم نے فائل `app/routers/items.py` میں بنایا تھا، یہ ایک `APIRouter` object ہے۔
+
+اور پھر ہم module `users` کے لیے بھی ایسا ہی کرتے ہیں۔
+
+ہم انہیں اس طرح بھی import کر سکتے تھے:
+
+```Python
+from app.routers import items, users
+```
+
+/// info | معلومات
+
+پہلا ورژن "relative import" ہے:
+
+```Python
+from .routers import items, users
+```
+
+دوسرا ورژن "absolute import" ہے:
+
+```Python
+from app.routers import items, users
+```
+
+Python Packages اور Modules کے بارے میں مزید جاننے کے لیے [Modules کے بارے میں سرکاری Python دستاویزات](https://docs.python.org/3/tutorial/modules.html) پڑھیں۔
+
+///
+
+### نام کے ٹکراؤ سے بچیں { #avoid-name-collisions }
+
+ہم صرف اس کا variable `router` import کرنے کی بجائے submodule `items` کو براہ راست import کر رہے ہیں۔
+
+اس کی وجہ یہ ہے کہ ہمارے پاس submodule `users` میں بھی `router` نام کا ایک اور variable ہے۔
+
+اگر ہم ایک کے بعد دوسرا import کرتے، جیسے:
+
+```Python
+from .routers.items import router
+from .routers.users import router
+```
+
+تو `users` کا `router` `items` والے کو overwrite کر دیتا اور ہم دونوں کو ایک ساتھ استعمال نہ کر پاتے۔
+
+تو، دونوں کو ایک ہی فائل میں استعمال کرنے کے لیے، ہم submodules کو براہ راست import کرتے ہیں:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[5] title["app/main.py"] *}
+
+### `users` اور `items` کے `APIRouter`s شامل کریں { #include-the-apirouters-for-users-and-items }
+
+اب، آئیں submodules `users` اور `items` سے `router`s شامل کرتے ہیں:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[10:11] title["app/main.py"] *}
+
+/// info | معلومات
+
+`users.router` فائل `app/routers/users.py` کے اندر `APIRouter` پر مشتمل ہے۔
+
+اور `items.router` فائل `app/routers/items.py` کے اندر `APIRouter` پر مشتمل ہے۔
+
+///
+
+`app.include_router()` کے ذریعے ہم ہر `APIRouter` کو مرکزی `FastAPI` application میں شامل کر سکتے ہیں۔
+
+یہ اس router کے تمام routes کو اس کے حصے کے طور پر شامل کرے گا۔
+
+/// note | تکنیکی تفصیلات
+
+یہ دراصل اندرونی طور پر `APIRouter` میں declare کیے گئے ہر *path operation* کے لیے ایک *path operation* بنائے گا۔
+
+تو، پردے کے پیچھے، یہ دراصل ایسے کام کرے گا جیسے سب کچھ ایک ہی واحد app ہو۔
+
+///
+
+/// check
+
+آپ کو routers شامل کرتے وقت performance کی فکر کرنے کی ضرورت نہیں۔
+
+اس میں microseconds لگیں گے اور یہ صرف startup پر ہوگا۔
+
+تو اس سے performance متاثر نہیں ہوگی۔ ⚡
+
+///
+
+### Custom `prefix`، `tags`، `responses`، اور `dependencies` کے ساتھ `APIRouter` شامل کریں { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
+
+اب، تصور کریں آپ کی تنظیم نے آپ کو `app/internal/admin.py` فائل دی ہے۔
+
+اس میں کچھ admin *path operations* والا ایک `APIRouter` ہے جو آپ کی تنظیم کئی projects میں share کرتی ہے۔
+
+اس مثال کے لیے یہ بہت سادہ ہوگا۔ لیکن فرض کریں کہ چونکہ یہ تنظیم کے دوسرے projects کے ساتھ share ہوتا ہے، ہم اسے تبدیل نہیں کر سکتے اور براہ راست `APIRouter` میں `prefix`، `dependencies`، `tags` وغیرہ شامل نہیں کر سکتے:
+
+{* ../../docs_src/bigger_applications/app_an_py310/internal/admin.py hl[3] title["app/internal/admin.py"] *}
+
+لیکن ہم پھر بھی `APIRouter` شامل کرتے وقت custom `prefix` سیٹ کرنا چاہتے ہیں تاکہ اس کے تمام *path operations* `/admin` سے شروع ہوں، ہم اسے اس project کے لیے پہلے سے موجود `dependencies` سے محفوظ بنانا چاہتے ہیں، اور ہم `tags` اور `responses` شامل کرنا چاہتے ہیں۔
+
+ہم اصل `APIRouter` کو تبدیل کیے بغیر یہ سب declare کر سکتے ہیں ان parameters کو `app.include_router()` میں منتقل کر کے:
+
+{* ../../docs_src/bigger_applications/app_an_py310/main.py hl[14:17] title["app/main.py"] *}
+
+اس طرح، اصل `APIRouter` غیر تبدیل شدہ رہے گا، تو ہم اب بھی وہی `app/internal/admin.py` فائل تنظیم کے دوسرے projects کے ساتھ share کر سکتے ہیں۔
+
+نتیجہ یہ ہے کہ ہماری app میں، `admin` module کے ہر *path operation* میں ہوگا:
+
+* `/admin` prefix۔
+* `admin` tag۔
+* `get_token_header` dependency۔
+* `418` response۔ 🍵
+
+لیکن یہ صرف ہماری app میں اس `APIRouter` پر اثر ڈالے گا، کسی دوسرے code پر نہیں جو اسے استعمال کرتا ہو۔
+
+تو، مثال کے طور پر، دوسرے projects اسی `APIRouter` کو مختلف authentication method کے ساتھ استعمال کر سکتے ہیں۔
+
+### ایک *path operation* شامل کریں { #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* کے ساتھ مل کر۔
+
+/// info | انتہائی تکنیکی تفصیلات
+
+**نوٹ**: یہ ایک انتہائی تکنیکی تفصیل ہے جسے آپ شاید **چھوڑ سکتے ہیں**۔
+
+---
+
+`APIRouter`s "mount" نہیں ہوتے، وہ باقی application سے الگ نہیں ہوتے۔
+
+اس کی وجہ یہ ہے کہ ہم ان کے *path operations* کو OpenAPI schema اور user interfaces میں شامل کرنا چاہتے ہیں۔
+
+چونکہ ہم انہیں صرف الگ کر کے باقی سے آزادانہ طور پر "mount" نہیں کر سکتے، *path operations* "clone" کیے جاتے ہیں (دوبارہ بنائے جاتے ہیں)، براہ راست شامل نہیں کیے جاتے۔
+
+///
+
+## `pyproject.toml` میں `entrypoint` configure کریں { #configure-the-entrypoint-in-pyproject-toml }
+
+چونکہ آپ کا FastAPI `app` object `app/main.py` میں ہے، آپ اپنی `pyproject.toml` فائل میں `entrypoint` اس طرح configure کر سکتے ہیں:
+
+```toml
+[tool.fastapi]
+entrypoint = "app.main:app"
+```
+
+جو اس طرح import کرنے کے مساوی ہے:
+
+```python
+from app.main import app
+```
+
+اس طرح `fastapi` command کو پتہ چلے گا کہ آپ کی app کہاں ملے گی۔
+
+/// Note
+
+آپ command میں path بھی دے سکتے ہیں، جیسے:
+
+```console
+$ fastapi dev app/main.py
+```
+
+لیکن آپ کو ہر بار `fastapi` command چلاتے وقت درست path یاد رکھنا ہوگا۔
+
+اس کے علاوہ، دوسرے tools شاید اسے نہ ڈھونڈ سکیں، مثلاً [VS Code Extension](../editor-support.md) یا [FastAPI Cloud](https://fastapicloud.com)، تو `pyproject.toml` میں `entrypoint` استعمال کرنا تجویز کیا جاتا ہے۔
+
+///
+
+## خودکار API docs چیک کریں { #check-the-automatic-api-docs }
+
+اب، اپنی app چلائیں:
+
+
+
+## مختلف `prefix` کے ساتھ وہی router کئی بار شامل کریں { #include-the-same-router-multiple-times-with-different-prefix }
+
+آپ مختلف prefixes استعمال کرتے ہوئے *ایک ہی* router کے ساتھ `.include_router()` کئی بار بھی استعمال کر سکتے ہیں۔
+
+یہ مفید ہو سکتا ہے، مثلاً، ایک ہی API کو مختلف prefixes پر expose کرنے کے لیے، جیسے `/api/v1` اور `/api/latest`۔
+
+یہ ایک جدید استعمال ہے جس کی آپ کو شاید واقعی ضرورت نہ ہو، لیکن ضرورت پڑنے پر یہ موجود ہے۔
+
+## ایک `APIRouter` کو دوسرے میں شامل کریں { #include-an-apirouter-in-another }
+
+بالکل اسی طرح جیسے آپ `FastAPI` application میں ایک `APIRouter` شامل کر سکتے ہیں، آپ ایک `APIRouter` کو دوسرے `APIRouter` میں شامل کر سکتے ہیں:
+
+```Python
+router.include_router(other_router)
+```
+
+یقینی بنائیں کہ آپ یہ `router` کو `FastAPI` app میں شامل کرنے سے پہلے کریں، تاکہ `other_router` کے *path operations* بھی شامل ہوں۔
diff --git a/docs/ur/docs/tutorial/body-fields.md b/docs/ur/docs/tutorial/body-fields.md
new file mode 100644
index 000000000..7d2b62929
--- /dev/null
+++ b/docs/ur/docs/tutorial/body-fields.md
@@ -0,0 +1,61 @@
+# Body - Fields { #body-fields }
+
+اسی طرح جیسے آپ `Query`، `Path` اور `Body` کے ساتھ *path operation function* parameters میں اضافی توثیق اور metadata اعلان کر سکتے ہیں، آپ Pydantic کے `Field` استعمال کر کے Pydantic models کے اندر بھی توثیق اور 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 کی ذیلی classes کے objects بناتے ہیں، جو خود Pydantic کی `FieldInfo` class کی ذیلی class ہے۔
+
+اور Pydantic کا `Field` بھی `FieldInfo` کا ایک instance واپس کرتا ہے۔
+
+`Body` بھی براہ راست `FieldInfo` کی ذیلی class کے objects واپس کرتا ہے۔ اور دوسرے بھی ہیں جو آپ بعد میں دیکھیں گے جو `Body` class کی ذیلی classes ہیں۔
+
+یاد رکھیں جب آپ `fastapi` سے `Query`، `Path` اور دوسرے import کرتے ہیں، وہ دراصل functions ہیں جو خاص classes واپس کرتے ہیں۔
+
+///
+
+/// tip | مشورہ
+
+غور کریں کہ type، طے شدہ قدر اور `Field` کے ساتھ ہر model کی attribute کی ساخت ویسی ہی ہے جیسی *path operation function* کے parameter کی ہوتی ہے، `Path`، `Query` اور `Body` کی بجائے `Field` کے ساتھ۔
+
+///
+
+## اضافی معلومات شامل کریں { #add-extra-information }
+
+آپ `Field`، `Query`، `Body` وغیرہ میں اضافی معلومات اعلان کر سکتے ہیں۔ اور یہ تیار کردہ JSON Schema میں شامل ہوں گی۔
+
+آپ مثالیں اعلان کرنا سیکھتے وقت docs میں بعد میں اضافی معلومات شامل کرنے کے بارے میں مزید جانیں گے۔
+
+/// warning | انتباہ
+
+`Field` کو دیے گئے اضافی keys آپ کی ایپلیکیشن کے نتیجے میں بننے والے OpenAPI schema میں بھی موجود ہوں گے۔
+چونکہ یہ keys ضروری نہیں کہ OpenAPI تصریح کا حصہ ہوں، کچھ OpenAPI ٹولز، مثال کے طور پر [OpenAPI validator](https://validator.swagger.io/)، شاید آپ کے تیار کردہ schema کے ساتھ کام نہ کریں۔
+
+///
+
+## خلاصہ { #recap }
+
+آپ Pydantic کا `Field` استعمال کر کے model attributes کے لیے اضافی validations اور metadata اعلان کر سکتے ہیں۔
+
+آپ اضافی JSON Schema metadata دینے کے لیے اضافی keyword arguments بھی استعمال کر سکتے ہیں۔
diff --git a/docs/ur/docs/tutorial/body-multiple-params.md b/docs/ur/docs/tutorial/body-multiple-params.md
new file mode 100644
index 000000000..be3624dae
--- /dev/null
+++ b/docs/ur/docs/tutorial/body-multiple-params.md
@@ -0,0 +1,169 @@
+# Body - متعدد Parameters { #body-multiple-parameters }
+
+اب جب ہم `Path` اور `Query` استعمال کرنا دیکھ چکے ہیں، آئیے request body اعلانات کے مزید جدید استعمال دیکھتے ہیں۔
+
+## `Path`، `Query` اور body parameters کو ملائیں { #mix-path-query-and-body-parameters }
+
+سب سے پہلے، یقیناً، آپ `Path`، `Query` اور request body parameter اعلانات کو آزادانہ طور پر ملا سکتے ہیں اور **FastAPI** جانے گا کیا کرنا ہے۔
+
+اور آپ body parameters کو اختیاری بھی اعلان کر سکتے ہیں، طے شدہ قدر `None` سیٹ کر کے:
+
+{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
+
+/// note | نوٹ
+
+غور کریں کہ، اس صورت میں، `item` جو body سے لیا جائے گا اختیاری ہے۔ کیونکہ اس کی `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 بھی اعلان کر سکتے ہیں، مثلاً `item` اور `user`:
+
+{* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
+
+
+اس صورت میں، **FastAPI** نوٹ کرے گا کہ function میں ایک سے زیادہ body parameter ہیں (دو parameters ہیں جو Pydantic models ہیں)۔
+
+تو، یہ parameter کے ناموں کو body میں keys (فیلڈ ناموں) کے طور پر استعمال کرے گا، اور اس طرح کی body کی توقع کرے گا:
+
+```JSON
+{
+ "item": {
+ "name": "Foo",
+ "description": "The pretender",
+ "price": 42.0,
+ "tax": 3.2
+ },
+ "user": {
+ "username": "dave",
+ "full_name": "Dave Grohl"
+ }
+}
+```
+
+/// note | نوٹ
+
+غور کریں کہ اگرچہ `item` پہلے کی طرح ہی اعلان کیا گیا تھا، اب اس کی توقع body کے اندر key `item` کے ساتھ ہے۔
+
+///
+
+**FastAPI** request سے خودکار تبدیلی کرے گا، تاکہ parameter `item` کو اس کا مخصوص مواد ملے اور `user` کو بھی وہی۔
+
+یہ مرکب ڈیٹا کی توثیق کرے گا، اور اسے OpenAPI schema اور خودکار docs کے لیے اسی طرح دستاویز کرے گا۔
+
+## Body میں واحد اقدار { #singular-values-in-body }
+
+اسی طرح جیسے query اور path parameters کے لیے اضافی ڈیٹا بیان کرنے کے لیے `Query` اور `Path` ہیں، **FastAPI** ایک مساوی `Body` فراہم کرتا ہے۔
+
+مثال کے طور پر، پچھلے model کو بڑھاتے ہوئے، آپ فیصلہ کر سکتے ہیں کہ `item` اور `user` کے علاوہ اسی body میں ایک اور key `importance` چاہتے ہیں۔
+
+اگر آپ اسے جیسا ہے اعلان کریں، چونکہ یہ واحد قدر ہے، **FastAPI** فرض کرے گا کہ یہ query parameter ہے۔
+
+لیکن آپ **FastAPI** کو ہدایت دے سکتے ہیں کہ اسے `Body` استعمال کر کے ایک اور body key کے طور پر سمجھے:
+
+{* ../../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 تبدیل کرے گا، توثیق کرے گا، دستاویز بنائے گا وغیرہ۔
+
+## متعدد body params اور query { #multiple-body-params-and-query }
+
+یقیناً، آپ کسی بھی body parameters کے علاوہ جب بھی ضرورت ہو اضافی query parameters بھی اعلان کر سکتے ہیں۔
+
+چونکہ، پہلے سے، واحد اقدار query parameters کے طور پر سمجھی جاتی ہیں، آپ کو واضح طور پر `Query` شامل کرنے کی ضرورت نہیں، آپ بس یہ کر سکتے ہیں:
+
+```Python
+q: str | None = None
+```
+
+مثال کے طور پر:
+
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
+
+
+/// info | معلومات
+
+`Body` میں بھی وہی تمام اضافی توثیق اور metadata parameters ہیں جو `Query`، `Path` اور دوسروں میں ہیں جو آپ بعد میں دیکھیں گے۔
+
+///
+
+## واحد body parameter کو embed کریں { #embed-a-single-body-parameter }
+
+فرض کریں آپ کے پاس Pydantic model `Item` سے صرف ایک `item` body parameter ہے۔
+
+پہلے سے، **FastAPI** اس کی body براہ راست توقع کرے گا۔
+
+لیکن اگر آپ چاہتے ہیں کہ یہ ایک JSON کی توقع کرے جس میں key `item` ہو اور اس کے اندر model کا مواد، جیسا کہ اضافی body parameters اعلان کرنے پر ہوتا ہے، تو آپ خاص `Body` parameter `embed` استعمال کر سکتے ہیں:
+
+```Python
+item: 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 }
+
+آپ اپنے *path operation function* میں متعدد body parameters شامل کر سکتے ہیں، اگرچہ ایک request میں صرف ایک body ہو سکتی ہے۔
+
+لیکن **FastAPI** اسے سنبھالے گا، آپ کو آپ کے function میں صحیح ڈیٹا دے گا، اور *path operation* میں صحیح schema کی توثیق اور دستاویز بنائے گا۔
+
+آپ واحد اقدار کو body کے حصے کے طور پر وصول کرنے کا بھی اعلان کر سکتے ہیں۔
+
+اور آپ **FastAPI** کو ہدایت دے سکتے ہیں کہ body کو ایک key میں embed کرے چاہے صرف ایک parameter اعلان کیا گیا ہو۔
diff --git a/docs/ur/docs/tutorial/body-nested-models.md b/docs/ur/docs/tutorial/body-nested-models.md
new file mode 100644
index 000000000..b49fd7c69
--- /dev/null
+++ b/docs/ur/docs/tutorial/body-nested-models.md
@@ -0,0 +1,221 @@
+# Body - Nested Models { #body-nested-models }
+
+**FastAPI** کے ساتھ، آپ من مانی گہرائی سے nested models بنا سکتے، توثیق کر سکتے، دستاویز بنا سکتے اور استعمال کر سکتے ہیں (Pydantic کی بدولت)۔
+
+## List fields { #list-fields }
+
+آپ کسی attribute کو ذیلی قسم کے طور پر بنا سکتے ہیں۔ مثال کے طور پر، Python `list`:
+
+{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}
+
+یہ `tags` کو list بنائے گا، اگرچہ یہ list کے عناصر کی قسم اعلان نہیں کرتا۔
+
+## Type parameter کے ساتھ List fields { #list-fields-with-type-parameter }
+
+لیکن Python میں اندرونی اقسام، یا "type parameters" کے ساتھ lists اعلان کرنے کا ایک مخصوص طریقہ ہے:
+
+### Type parameter کے ساتھ `list` اعلان کریں { #declare-a-list-with-a-type-parameter }
+
+ایسی اقسام اعلان کرنے کے لیے جن میں type parameters (اندرونی اقسام) ہوں، جیسے `list`، `dict`، `tuple`،
+اندرونی قسم(قسمیں) "type parameters" کے طور پر مربع بریکٹ استعمال کر کے دیں: `[` اور `]`
+
+```Python
+my_list: list[str]
+```
+
+یہ سب معیاری Python syntax ہے type declarations کے لیے۔
+
+اندرونی اقسام کے ساتھ model attributes کے لیے وہی معیاری syntax استعمال کریں۔
+
+تو، ہماری مثال میں، ہم `tags` کو خاص طور پر "strings کی list" بنا سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
+
+## Set types { #set-types }
+
+لیکن پھر ہم سوچتے ہیں اور محسوس کرتے ہیں کہ tags دہرائے نہیں جانے چاہییں، وہ شاید منفرد strings ہوں گے۔
+
+اور Python میں منفرد آئٹمز کے sets کے لیے ایک خاص data type ہے، `set`۔
+
+پھر ہم `tags` کو strings کے set کے طور پر اعلان کر سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}
+
+اس کے ساتھ، چاہے آپ کو نقل شدہ ڈیٹا کے ساتھ request ملے، اسے منفرد آئٹمز کے set میں تبدیل کر دیا جائے گا۔
+
+اور جب بھی آپ وہ ڈیٹا نکالیں گے، چاہے ماخذ میں نقل ہو، اسے منفرد آئٹمز کے set کے طور پر نکالا جائے گا۔
+
+اور اس کے مطابق تشریح / دستاویز بھی بنائی جائے گی۔
+
+## Nested Models { #nested-models }
+
+Pydantic model کی ہر attribute کی ایک قسم ہوتی ہے۔
+
+لیکن وہ قسم خود بھی ایک اور Pydantic model ہو سکتی ہے۔
+
+تو، آپ مخصوص attribute ناموں، اقسام اور validations کے ساتھ گہرے nested JSON "objects" اعلان کر سکتے ہیں۔
+
+یہ سب، من مانی گہرائی سے nested۔
+
+### ذیلی model بنائیں { #define-a-submodel }
+
+مثال کے طور پر، ہم ایک `Image` model بنا سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
+
+### ذیلی model کو بطور قسم استعمال کریں { #use-the-submodel-as-a-type }
+
+اور پھر ہم اسے کسی attribute کی قسم کے طور پر استعمال کر سکتے ہیں:
+
+{* ../../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"
+ }
+}
+```
+
+ایک بار پھر، صرف وہ اعلان کر کے، **FastAPI** کے ساتھ آپ کو ملتا ہے:
+
+* Nested models کے لیے بھی ایڈیٹر سپورٹ (completion وغیرہ)
+* ڈیٹا کی تبدیلی
+* ڈیٹا کی توثیق
+* خودکار دستاویزات
+
+## خاص اقسام اور توثیق { #special-types-and-validation }
+
+عام واحد اقسام جیسے `str`، `int`، `float` وغیرہ کے علاوہ آپ مزید پیچیدہ واحد اقسام استعمال کر سکتے ہیں جو `str` سے وراثت حاصل کرتی ہیں۔
+
+تمام دستیاب آپشنز دیکھنے کے لیے، [Pydantic کا Type Overview](https://docs.pydantic.dev/latest/concepts/types/) دیکھیں۔ آپ اگلے باب میں کچھ مثالیں دیکھیں گے۔
+
+مثال کے طور پر، جیسے `Image` model میں ہمارے پاس `url` فیلڈ ہے، ہم `str` کی بجائے Pydantic کے `HttpUrl` کا اعلان کر سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial005_py310.py hl[2,8] *}
+
+String کو درست URL ہونے کے لیے جانچا جائے گا، اور JSON Schema / OpenAPI میں اسی طرح دستاویز بنائی جائے گی۔
+
+## ذیلی models کی lists والی Attributes { #attributes-with-lists-of-submodels }
+
+آپ Pydantic models کو `list`، `set` وغیرہ کی ذیلی اقسام کے طور پر بھی استعمال کر سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}
+
+یہ اس طرح کی JSON body کی توقع کرے گا (تبدیل، توثیق، دستاویز وغیرہ):
+
+```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"
+ }
+ ]
+}
+```
+
+/// info | معلومات
+
+غور کریں کہ `images` key میں اب image objects کی list ہے۔
+
+///
+
+## گہرے nested models { #deeply-nested-models }
+
+آپ من مانی گہرائی سے nested models بنا سکتے ہیں:
+
+{* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}
+
+/// info | معلومات
+
+غور کریں کہ `Offer` میں `Item`s کی list ہے، جن میں بدلے میں اختیاری `Image`s کی list ہے۔
+
+///
+
+## خالص lists کی Bodies { #bodies-of-pure-lists }
+
+اگر آپ جس JSON body کی توقع کر رہے ہیں اس کی اعلیٰ ترین قدر JSON `array` (Python `list`) ہے، تو آپ function کے parameter میں قسم کا اعلان کر سکتے ہیں، بالکل Pydantic models کی طرح:
+
+```Python
+images: list[Image]
+```
+
+جیسے:
+
+{* ../../docs_src/body_nested_models/tutorial008_py310.py hl[13] *}
+
+## ہر جگہ ایڈیٹر سپورٹ { #editor-support-everywhere }
+
+اور آپ کو ہر جگہ ایڈیٹر سپورٹ ملتی ہے۔
+
+یہاں تک کہ lists کے اندر آئٹمز کے لیے بھی:
+
+
+
+اگر آپ Pydantic models کی بجائے براہ راست `dict` کے ساتھ کام کر رہے ہوتے تو آپ کو اس طرح کی ایڈیٹر سپورٹ نہیں ملتی۔
+
+لیکن آپ کو ان کی فکر کرنے کی ضرورت نہیں، آنے والے dicts خودکار طور پر تبدیل ہو جاتے ہیں اور آپ کا آؤٹ پٹ بھی خودکار طور پر JSON میں تبدیل ہو جاتا ہے۔
+
+## من مانی `dict`s کی Bodies { #bodies-of-arbitrary-dicts }
+
+آپ body کو ایسے `dict` کے طور پر بھی اعلان کر سکتے ہیں جس کی keys کسی قسم کی ہوں اور values کسی اور قسم کی۔
+
+اس طرح، آپ کو پہلے سے معلوم ہونے کی ضرورت نہیں کہ درست فیلڈ/attribute نام کیا ہیں (جیسا کہ Pydantic models کی صورت میں ہوتا)۔
+
+یہ مفید ہوگا اگر آپ ایسی keys وصول کرنا چاہتے ہیں جو آپ پہلے سے نہیں جانتے۔
+
+---
+
+ایک اور مفید صورت یہ ہے جب آپ کسی اور قسم (مثلاً `int`) کی keys رکھنا چاہیں۔
+
+یہی ہم یہاں دیکھنے والے ہیں۔
+
+اس صورت میں، آپ کوئی بھی `dict` قبول کریں گے بشرطیکہ اس میں `int` keys ہوں اور `float` values ہوں:
+
+{* ../../docs_src/body_nested_models/tutorial009_py310.py hl[7] *}
+
+/// tip | مشورہ
+
+یاد رکھیں کہ JSON صرف `str` کو keys کے طور پر تعاون کرتا ہے۔
+
+لیکن Pydantic میں خودکار ڈیٹا تبدیلی ہے۔
+
+اس کا مطلب ہے کہ، اگرچہ آپ کے API clients صرف strings بطور keys بھیج سکتے ہیں، جب تک وہ strings خالص integers رکھتی ہیں، Pydantic انہیں تبدیل اور توثیق کرے گا۔
+
+اور جو `dict` آپ `weights` کے طور پر وصول کریں گے اس میں دراصل `int` keys اور `float` values ہوں گی۔
+
+///
+
+## خلاصہ { #recap }
+
+**FastAPI** کے ساتھ آپ کو Pydantic models کی فراہم کردہ زیادہ سے زیادہ لچک ملتی ہے، جبکہ آپ کا کوڈ سادہ، مختصر اور خوبصورت رہتا ہے۔
+
+تمام فوائد کے ساتھ:
+
+* ایڈیٹر سپورٹ (ہر جگہ completion!)
+* ڈیٹا کی تبدیلی (جسے parsing / serialization بھی کہتے ہیں)
+* ڈیٹا کی توثیق
+* Schema دستاویزات
+* خودکار docs
diff --git a/docs/ur/docs/tutorial/body-updates.md b/docs/ur/docs/tutorial/body-updates.md
new file mode 100644
index 000000000..b6771bbd3
--- /dev/null
+++ b/docs/ur/docs/tutorial/body-updates.md
@@ -0,0 +1,100 @@
+# Body - اپ ڈیٹس { #body-updates }
+
+## `PUT` کے ساتھ مکمل تبدیلی { #update-replacing-with-put }
+
+کسی آئٹم کو اپ ڈیٹ کرنے کے لیے آپ [HTTP `PUT`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT) operation استعمال کر سکتے ہیں۔
+
+آپ `jsonable_encoder` استعمال کر سکتے ہیں تاکہ ان پٹ ڈیٹا کو اس ڈیٹا میں تبدیل کریں جو JSON کے طور پر محفوظ کیا جا سکے (مثلاً NoSQL ڈیٹابیس کے ساتھ)۔ مثال کے طور پر، `datetime` کو `str` میں تبدیل کرنا۔
+
+{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
+
+`PUT` ایسا ڈیٹا وصول کرنے کے لیے استعمال ہوتا ہے جو موجودہ ڈیٹا کی جگہ لے۔
+
+### تبدیلی کے بارے میں انتباہ { #warning-about-replacing }
+
+اس کا مطلب ہے کہ اگر آپ آئٹم `bar` کو `PUT` استعمال کر کے اس body کے ساتھ اپ ڈیٹ کرنا چاہتے ہیں:
+
+```Python
+{
+ "name": "Barz",
+ "price": 3,
+ "description": None,
+}
+```
+
+چونکہ اس میں پہلے سے محفوظ attribute `"tax": 20.2` شامل نہیں ہے، ان پٹ model طے شدہ قدر `"tax": 10.5` لے گا۔
+
+اور ڈیٹا اس "نئے" `tax` یعنی `10.5` کے ساتھ محفوظ ہوگا۔
+
+## `PATCH` کے ساتھ جزوی اپ ڈیٹس { #partial-updates-with-patch }
+
+آپ ڈیٹا کو *جزوی طور پر* اپ ڈیٹ کرنے کے لیے [HTTP `PATCH`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH) operation بھی استعمال کر سکتے ہیں۔
+
+اس کا مطلب ہے کہ آپ صرف وہ ڈیٹا بھیج سکتے ہیں جو آپ اپ ڈیٹ کرنا چاہتے ہیں، باقی کو جوں کا توں چھوڑ کر۔
+
+/// note | نوٹ
+
+`PATCH` `PUT` کے مقابلے میں کم استعمال ہوتا اور جانا جاتا ہے۔
+
+اور بہت سی ٹیمیں صرف `PUT` استعمال کرتی ہیں، جزوی اپ ڈیٹس کے لیے بھی۔
+
+آپ انہیں جیسے چاہیں استعمال کرنے کے لیے **آزاد** ہیں، **FastAPI** کوئی پابندی نہیں لگاتا۔
+
+لیکن یہ گائیڈ آپ کو کم و بیش دکھاتا ہے کہ ان کا مقصد کیا ہے۔
+
+///
+
+### Pydantic کا `exclude_unset` parameter استعمال کرنا { #using-pydantics-exclude-unset-parameter }
+
+اگر آپ جزوی اپ ڈیٹس وصول کرنا چاہتے ہیں، تو Pydantic کے model کے `.model_dump()` میں `exclude_unset` parameter بہت مفید ہے۔
+
+جیسے `item.model_dump(exclude_unset=True)`۔
+
+یہ صرف اس ڈیٹا کے ساتھ `dict` بنائے گا جو `item` model بناتے وقت سیٹ کیا گیا تھا، طے شدہ اقدار کو خارج کر کے۔
+
+پھر آپ اسے استعمال کر سکتے ہیں تاکہ صرف اس ڈیٹا کے ساتھ `dict` بنائیں جو سیٹ کیا گیا تھا (request میں بھیجا گیا)، طے شدہ اقدار کو چھوڑ کر:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
+
+### Pydantic کا `update` parameter استعمال کرنا { #using-pydantics-update-parameter }
+
+اب، آپ `.model_copy()` استعمال کر کے موجودہ model کی نقل بنا سکتے ہیں، اور `update` parameter میں اپ ڈیٹ کرنے والے ڈیٹا کے ساتھ `dict` دے سکتے ہیں۔
+
+جیسے `stored_item_model.model_copy(update=update_data)`:
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
+
+### جزوی اپ ڈیٹس کا خلاصہ { #partial-updates-recap }
+
+خلاصہ یہ ہے کہ جزوی اپ ڈیٹس لاگو کرنے کے لیے آپ:
+
+* (اختیاری طور پر) `PUT` کی بجائے `PATCH` استعمال کریں۔
+* محفوظ شدہ ڈیٹا حاصل کریں۔
+* وہ ڈیٹا Pydantic model میں رکھیں۔
+* ان پٹ model سے طے شدہ اقدار کے بغیر `dict` بنائیں (`exclude_unset` استعمال کر کے)۔
+ * اس طرح آپ صرف وہ اقدار اپ ڈیٹ کر سکتے ہیں جو صارف نے واقعی سیٹ کی ہیں، پہلے سے محفوظ اقدار کو اپنے model کی طے شدہ اقدار سے اوور رائیڈ کرنے کی بجائے۔
+* محفوظ model کی نقل بنائیں، وصول شدہ جزوی اپ ڈیٹس کے ساتھ اس کی attributes اپ ڈیٹ کر کے (`update` parameter استعمال کر کے)۔
+* نقل شدہ model کو کسی ایسی چیز میں تبدیل کریں جو آپ کے DB میں محفوظ ہو سکے (مثال کے طور پر، `jsonable_encoder` استعمال کر کے)۔
+ * یہ model کا `.model_dump()` method دوبارہ استعمال کرنے کے مشابہ ہے، لیکن یہ یقینی بناتا ہے (اور تبدیل کرتا ہے) اقدار کو ایسی data types میں جو JSON میں تبدیل ہو سکیں، مثلاً `datetime` کو `str` میں۔
+* ڈیٹا اپنے DB میں محفوظ کریں۔
+* اپ ڈیٹ شدہ model واپس کریں۔
+
+{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}
+
+/// tip | مشورہ
+
+آپ دراصل HTTP `PUT` operation کے ساتھ بھی یہی تکنیک استعمال کر سکتے ہیں۔
+
+لیکن یہاں مثال `PATCH` استعمال کرتی ہے کیونکہ یہ انہی استعمال کے معاملات کے لیے بنائی گئی تھی۔
+
+///
+
+/// note | نوٹ
+
+غور کریں کہ ان پٹ model کی پھر بھی توثیق ہوتی ہے۔
+
+تو، اگر آپ جزوی اپ ڈیٹس وصول کرنا چاہتے ہیں جو تمام attributes کو چھوڑ سکیں، تو آپ کو ایسا model رکھنا ہوگا جس کی تمام attributes اختیاری ہوں (طے شدہ اقدار یا `None` کے ساتھ)۔
+
+**اپ ڈیٹس** کے لیے تمام اختیاری اقدار والے models اور **تخلیق** کے لیے لازمی اقدار والے models میں فرق کرنے کے لیے، آپ [اضافی Models](extra-models.md) میں بیان کردہ خیالات استعمال کر سکتے ہیں۔
+
+///
diff --git a/docs/ur/docs/tutorial/body.md b/docs/ur/docs/tutorial/body.md
new file mode 100644
index 000000000..e7a988b3f
--- /dev/null
+++ b/docs/ur/docs/tutorial/body.md
@@ -0,0 +1,166 @@
+# Request Body { #request-body }
+
+جب آپ کو client (مثلاً براؤزر) سے اپنی API کو ڈیٹا بھیجنا ہو، تو آپ اسے **request body** کے طور پر بھیجتے ہیں۔
+
+**Request** body وہ ڈیٹا ہے جو client آپ کی API کو بھیجتا ہے۔ **Response** body وہ ڈیٹا ہے جو آپ کی API client کو بھیجتی ہے۔
+
+آپ کی API کو تقریباً ہمیشہ **response** body بھیجنا ہوتا ہے۔ لیکن clients کو ہمیشہ **request bodies** بھیجنے کی ضرورت نہیں ہوتی، بعض اوقات وہ صرف ایک path request کرتے ہیں، شاید کچھ query parameters کے ساتھ، لیکن body نہیں بھیجتے۔
+
+**Request** body کا اعلان کرنے کے لیے، آپ [Pydantic](https://docs.pydantic.dev/) models استعمال کرتے ہیں ان کی تمام طاقت اور فوائد کے ساتھ۔
+
+/// info | معلومات
+
+ڈیٹا بھیجنے کے لیے، آپ کو ان میں سے ایک استعمال کرنا چاہیے: `POST` (سب سے عام)، `PUT`، `DELETE` یا `PATCH`۔
+
+`GET` request کے ساتھ body بھیجنا تصریحات میں غیر متعین رویہ رکھتا ہے، بہرحال، FastAPI اسے صرف بہت پیچیدہ/انتہائی استعمال کے معاملات کے لیے تعاون کرتا ہے۔
+
+چونکہ اس کی حوصلہ شکنی کی جاتی ہے، Swagger UI کے ساتھ انٹرایکٹو docs `GET` استعمال کرتے وقت body کی دستاویزات نہیں دکھائیں گے، اور درمیان میں proxies شاید اسے تعاون نہ کریں۔
+
+///
+
+## Pydantic کا `BaseModel` import کریں { #import-pydantics-basemodel }
+
+سب سے پہلے، آپ کو `pydantic` سے `BaseModel` import کرنا ہوگا:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
+
+## اپنا ڈیٹا model بنائیں { #create-your-data-model }
+
+پھر آپ اپنا ڈیٹا model ایک class کے طور پر اعلان کریں جو `BaseModel` سے وراثت حاصل کرے۔
+
+تمام attributes کے لیے معیاری Python types استعمال کریں:
+
+{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
+
+
+Query parameters کا اعلان کرتے وقت جیسا ہوتا ہے، ویسے ہی جب model attribute کی طے شدہ قدر ہو، یہ لازمی نہیں ہوتا۔ ورنہ، یہ لازمی ہے۔ اسے محض اختیاری بنانے کے لیے `None` استعمال کریں۔
+
+مثال کے طور پر، اوپر والا model ایک JSON "`object`" (یا Python `dict`) کا اعلان کرتا ہے جیسے:
+
+```JSON
+{
+ "name": "Foo",
+ "description": "An optional description",
+ "price": 45.2,
+ "tax": 3.5
+}
+```
+
+...چونکہ `description` اور `tax` اختیاری ہیں (`None` کی طے شدہ قدر کے ساتھ)، یہ JSON "`object`" بھی درست ہوگا:
+
+```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] *}
+
+...اور اس کی قسم آپ کے بنائے ہوئے model، `Item` کے طور پر اعلان کریں۔
+
+## نتائج { #results }
+
+صرف اس Python type declaration کے ساتھ، **FastAPI** یہ کرے گا:
+
+* Request کی body کو JSON کے طور پر پڑھے گا۔
+* متعلقہ اقسام کو تبدیل کرے گا (اگر ضرورت ہو)۔
+* ڈیٹا کی توثیق کرے گا۔
+ * اگر ڈیٹا غلط ہے، تو یہ ایک اچھی اور واضح error واپس کرے گا، بالکل بتاتے ہوئے کہ غلط ڈیٹا کہاں اور کیا تھا۔
+* آپ کو وصول شدہ ڈیٹا parameter `item` میں دے گا۔
+ * چونکہ آپ نے function میں اسے `Item` قسم کا اعلان کیا ہے، آپ کو تمام attributes اور ان کی اقسام کے لیے ایڈیٹر سپورٹ (completion وغیرہ) بھی ملے گی۔
+* آپ کے model کے لیے [JSON Schema](https://json-schema.org) تعریفات تیار کرے گا، آپ انہیں کہیں بھی استعمال کر سکتے ہیں اگر یہ آپ کے پراجیکٹ کے لیے مناسب ہو۔
+* وہ schemas تیار کردہ OpenAPI schema کا حصہ ہوں گے، اور خودکار دستاویزاتی UIs کے ذریعے استعمال ہوں گے۔
+
+## خودکار دستاویزات { #automatic-docs }
+
+آپ کے models کے JSON Schemas آپ کے OpenAPI تیار کردہ schema کا حصہ ہوں گے، اور انٹرایکٹو API docs میں دکھائے جائیں گے:
+
+
+
+اور ہر *path operation* کے اندر API docs میں بھی استعمال ہوں گے جنہیں ان کی ضرورت ہو:
+
+
+
+## ایڈیٹر سپورٹ { #editor-support }
+
+آپ کے ایڈیٹر میں، آپ کے function کے اندر آپ کو ہر جگہ type hints اور completion ملے گی (یہ نہیں ہوتا اگر آپ Pydantic model کی بجائے `dict` وصول کرتے):
+
+
+
+آپ کو غلط type operations کے لیے error checks بھی ملتے ہیں:
+
+
+
+یہ اتفاق سے نہیں ہے، پورا framework اسی ڈیزائن کے گرد بنایا گیا تھا۔
+
+اور کسی بھی عملدرآمد سے پہلے، ڈیزائن مرحلے میں ہی اس کی مکمل جانچ کی گئی تھی، تاکہ یقینی بنایا جا سکے کہ یہ تمام ایڈیٹرز کے ساتھ کام کرے گا۔
+
+یہاں تک کہ اس کی تعاون کے لیے خود Pydantic میں بھی کچھ تبدیلیاں کی گئیں۔
+
+پچھلے screenshots [Visual Studio Code](https://code.visualstudio.com) سے لیے گئے تھے۔
+
+لیکن آپ کو [PyCharm](https://www.jetbrains.com/pycharm/) اور زیادہ تر دوسرے Python ایڈیٹرز کے ساتھ بھی وہی ایڈیٹر سپورٹ ملے گی:
+
+
+
+/// tip | مشورہ
+
+اگر آپ [PyCharm](https://www.jetbrains.com/pycharm/) کو اپنے ایڈیٹر کے طور پر استعمال کرتے ہیں، تو آپ [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/) استعمال کر سکتے ہیں۔
+
+یہ Pydantic models کے لیے ایڈیٹر سپورٹ بہتر کرتا ہے، اس کے ساتھ:
+
+* auto-completion
+* type checks
+* refactoring
+* تلاش
+* inspections
+
+///
+
+## Model استعمال کریں { #use-the-model }
+
+Function کے اندر، آپ model object کے تمام attributes تک براہ راست رسائی حاصل کر سکتے ہیں:
+
+{* ../../docs_src/body/tutorial002_py310.py *}
+
+## Request body + path parameters { #request-body-path-parameters }
+
+آپ path parameters اور request body ایک ساتھ اعلان کر سکتے ہیں۔
+
+**FastAPI** پہچان لے گا کہ وہ function parameters جو path parameters سے مماثل ہیں **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** ہر ایک کو پہچان لے گا اور صحیح جگہ سے ڈیٹا لے گا۔
+
+{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
+
+Function parameters کو اس طرح پہچانا جائے گا:
+
+* اگر parameter **path** میں بھی اعلان کیا گیا ہے، تو اسے path parameter کے طور پر استعمال کیا جائے گا۔
+* اگر parameter **واحد قسم** (جیسے `int`، `float`، `str`، `bool` وغیرہ) کا ہے تو اسے **query** parameter سمجھا جائے گا۔
+* اگر parameter **Pydantic model** کی قسم کا اعلان کیا گیا ہے، تو اسے request **body** سمجھا جائے گا۔
+
+/// note | نوٹ
+
+FastAPI جان لے گا کہ `q` کی قدر لازمی نہیں ہے کیونکہ اس کی طے شدہ قدر `= None` ہے۔
+
+`str | None` FastAPI کے ذریعے یہ تعین کرنے کے لیے استعمال نہیں ہوتا کہ قدر لازمی نہیں ہے، یہ جانتا ہے کہ لازمی نہیں ہے کیونکہ اس کی طے شدہ قدر `= None` ہے۔
+
+لیکن type annotations شامل کرنے سے آپ کا ایڈیٹر آپ کو بہتر سپورٹ دے سکے گا اور errors کا پتہ لگا سکے گا۔
+
+///
+
+## Pydantic کے بغیر { #without-pydantic }
+
+اگر آپ Pydantic models استعمال نہیں کرنا چاہتے، تو آپ **Body** parameters بھی استعمال کر سکتے ہیں۔ دستاویزات دیکھیں [Body - Multiple Parameters: Body میں واحد اقدار](body-multiple-params.md#singular-values-in-body)۔
diff --git a/docs/ur/docs/tutorial/cookie-param-models.md b/docs/ur/docs/tutorial/cookie-param-models.md
new file mode 100644
index 000000000..9613c20ac
--- /dev/null
+++ b/docs/ur/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** کا ڈیٹا **extract** کرے گا اور آپ کو وہ Pydantic model دے گا جو آپ نے define کیا ہے۔
+
+## Docs چیک کریں { #check-the-docs }
+
+آپ `/docs` پر docs UI میں defined cookies دیکھ سکتے ہیں:
+
+
+
+
+---
+
+اگر آپ Pycharm استعمال کرتے ہیں، تو آپ:
+
+* "Run" مینو کھولیں۔
+* "Debug..." اختیار منتخب کریں۔
+* پھر ایک context مینو ظاہر ہوگا۔
+* Debug کرنے کے لیے فائل منتخب کریں (اس صورت میں، `main.py`)۔
+
+یہ آپ کے **FastAPI** code کے ساتھ server شروع کرے گا، آپ کے breakpoints پر رکے گا، وغیرہ۔
+
+یہ اس طرح نظر آ سکتا ہے:
+
+
diff --git a/docs/ur/docs/tutorial/dependencies/classes-as-dependencies.md b/docs/ur/docs/tutorial/dependencies/classes-as-dependencies.md
new file mode 100644
index 000000000..ba1869686
--- /dev/null
+++ b/docs/ur/docs/tutorial/dependencies/classes-as-dependencies.md
@@ -0,0 +1,288 @@
+# Classes بطور Dependencies { #classes-as-dependencies }
+
+**Dependency Injection** نظام میں مزید گہرائی میں جانے سے پہلے، آئیے پچھلی مثال کو بہتر بناتے ہیں۔
+
+## پچھلی مثال سے ایک `dict` { #a-dict-from-the-previous-example }
+
+پچھلی مثال میں، ہم اپنی dependency ("dependable") سے ایک `dict` واپس کر رہے تھے:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[9] *}
+
+لیکن پھر ہمیں *path operation function* کے parameter `commons` میں ایک `dict` ملتا ہے۔
+
+اور ہم جانتے ہیں کہ editors `dict` کے لیے زیادہ مدد (جیسے completion) فراہم نہیں کر سکتے، کیونکہ وہ ان کی keys اور value types نہیں جان سکتے۔
+
+ہم بہتر کر سکتے ہیں...
+
+## Dependency کس چیز سے بنتی ہے { #what-makes-a-dependency }
+
+اب تک آپ نے dependencies کو functions کے طور پر declare ہوتے دیکھا ہے۔
+
+لیکن dependencies declare کرنے کا یہ واحد طریقہ نہیں ہے (حالانکہ یہ غالباً سب سے عام طریقہ ہوگا)۔
+
+اہم بات یہ ہے کہ dependency ایک "callable" ہونی چاہیے۔
+
+Python میں **"callable"** وہ چیز ہے جسے Python ایک function کی طرح "call" کر سکے۔
+
+تو، اگر آپ کے پاس ایک object `something` ہے (جو شاید function _نہ_ ہو) اور آپ اسے اس طرح "call" (execute) کر سکتے ہیں:
+
+```Python
+something()
+```
+
+یا
+
+```Python
+something(some_argument, some_keyword_argument="foo")
+```
+
+تو یہ "callable" ہے۔
+
+## Classes بطور dependencies { #classes-as-dependencies_1 }
+
+آپ نے شاید محسوس کیا ہوگا کہ Python class کا instance بنانے کے لیے بھی وہی syntax استعمال ہوتا ہے۔
+
+مثال کے طور پر:
+
+```Python
+class Cat:
+ def __init__(self, name: str):
+ self.name = name
+
+
+fluffy = Cat(name="Mr Fluffy")
+```
+
+اس صورت میں، `fluffy` class `Cat` کا ایک instance ہے۔
+
+اور `fluffy` بنانے کے لیے، آپ `Cat` کو "call" کر رہے ہیں۔
+
+تو، Python class بھی ایک **callable** ہے۔
+
+پھر، **FastAPI** میں، آپ Python class کو dependency کے طور پر استعمال کر سکتے ہیں۔
+
+FastAPI دراصل یہ چیک کرتا ہے کہ یہ "callable" ہے (function، class یا کوئی بھی اور چیز) اور اس میں define کیے گئے parameters۔
+
+اگر آپ **FastAPI** میں dependency کے طور پر "callable" پاس کرتے ہیں، تو یہ اس "callable" کے parameters کا تجزیہ کرے گا، اور انہیں اسی طرح process کرے گا جیسے *path operation function* کے parameters کو۔ بشمول sub-dependencies۔
+
+یہ بغیر کسی parameter والے callables پر بھی لاگو ہوتا ہے۔ بالکل ویسے ہی جیسے بغیر parameters والے *path operation functions* کے ساتھ ہوتا ہے۔
+
+پھر، ہم dependency "dependable" `common_parameters` کو اوپر سے class `CommonQueryParams` میں تبدیل کر سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[11:15] *}
+
+`__init__` method پر توجہ دیں جو class کا instance بنانے کے لیے استعمال ہوتا ہے:
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[12] *}
+
+...اس میں ہمارے پچھلے `common_parameters` جیسے ہی parameters ہیں:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8] *}
+
+یہ parameters وہ ہیں جو **FastAPI** dependency کو "حل" کرنے کے لیے استعمال کرے گا۔
+
+دونوں صورتوں میں، اس میں ہوگا:
+
+* ایک اختیاری `q` query parameter جو `str` ہے۔
+* ایک `skip` query parameter جو `int` ہے، جس کی default value `0` ہے۔
+* ایک `limit` query parameter جو `int` ہے، جس کی default value `100` ہے۔
+
+دونوں صورتوں میں data convert، validate، OpenAPI schema پر document ہوگا، وغیرہ۔
+
+## اسے استعمال کریں { #use-it }
+
+اب آپ اس class کا استعمال کرتے ہوئے اپنی dependency declare کر سکتے ہیں۔
+
+{* ../../docs_src/dependencies/tutorial002_an_py310.py hl[19] *}
+
+**FastAPI** `CommonQueryParams` class کو call کرتا ہے۔ اس سے اس class کا ایک "instance" بنتا ہے اور وہ instance آپ کے function میں parameter `commons` کے طور پر پاس ہوتا ہے۔
+
+## 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 declare کیے گئے parameters نکالے گا اور اسی کو FastAPI دراصل call کرے گا۔
+
+---
+
+اس صورت میں، پہلا `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` کے طور پر کیا پاس ہوگا، اور پھر یہ code completion، type checks، وغیرہ میں آپ کی مدد کر سکتا ہے:
+
+
+
+## شارٹ کٹ { #shortcut }
+
+لیکن آپ دیکھتے ہیں کہ یہاں کچھ 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)
+```
+
+////
+
+**FastAPI** ان صورتوں کے لیے ایک شارٹ کٹ فراہم کرتا ہے، جہاں dependency *خاص طور پر* ایک class ہے جسے **FastAPI** خود class کا instance بنانے کے لیے "call" کرے گا۔
+
+ان مخصوص صورتوں کے لیے، آپ یہ کر سکتے ہیں:
+
+یہ لکھنے کے بجائے:
+
+//// 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()` کو بغیر کسی parameter کے استعمال کرتے ہیں، `Depends(CommonQueryParams)` کے اندر پوری class *دوبارہ* لکھنے کے بجائے۔
+
+وہی مثال پھر اس طرح نظر آئے گی:
+
+{* ../../docs_src/dependencies/tutorial004_an_py310.py hl[19] *}
+
+...اور **FastAPI** جانے گا کہ کیا کرنا ہے۔
+
+/// tip | مشورہ
+
+اگر یہ مدد سے زیادہ الجھن لگے، تو اسے نظرانداز کریں، آپ کو اس کی *ضرورت* نہیں ہے۔
+
+یہ صرف ایک شارٹ کٹ ہے۔ کیونکہ **FastAPI** code کی تکرار کم کرنے میں آپ کی مدد کرنے کا خیال رکھتا ہے۔
+
+///
diff --git a/docs/ur/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/ur/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
new file mode 100644
index 000000000..77c4e8318
--- /dev/null
+++ b/docs/ur/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 کی واپسی value کی ضرورت نہیں ہوتی۔
+
+یا dependency کوئی value واپس نہیں کرتی۔
+
+لیکن پھر بھی آپ کو اسے execute/حل ہونے کی ضرورت ہے۔
+
+ان صورتوں میں، `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* ایک اختیاری argument `dependencies` وصول کرتا ہے۔
+
+یہ `Depends()` کی ایک `list` ہونی چاہیے:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[19] *}
+
+یہ dependencies عام dependencies کی طرح ہی execute/حل ہوں گی۔ لیکن ان کی value (اگر وہ کوئی واپس کریں) آپ کے *path operation function* میں پاس نہیں ہوگی۔
+
+/// tip | مشورہ
+
+کچھ editors غیر استعمال شدہ function parameters کی جانچ کرتے ہیں اور انہیں errors کے طور پر دکھاتے ہیں۔
+
+*path operation decorator* میں ان `dependencies` کو استعمال کر کے آپ یقینی بنا سکتے ہیں کہ وہ execute ہوں جبکہ editor/tooling errors سے بچا جائے۔
+
+یہ نئے developers کے لیے الجھن سے بچنے میں بھی مدد کر سکتا ہے جو آپ کے code میں غیر استعمال شدہ parameter دیکھ کر سوچ سکتے ہیں کہ یہ غیر ضروری ہے۔
+
+///
+
+/// info | معلومات
+
+اس مثال میں ہم من گھڑت custom headers `X-Key` اور `X-Token` استعمال کر رہے ہیں۔
+
+لیکن حقیقی صورتوں میں، security implement کرتے وقت، آپ کو مربوط [Security utilities (اگلا باب)](../security/index.md) استعمال کرنے سے زیادہ فائدہ ہوگا۔
+
+///
+
+## Dependencies کی errors اور واپسی values { #dependencies-errors-and-return-values }
+
+آپ وہی dependency *functions* استعمال کر سکتے ہیں جو آپ عام طور پر استعمال کرتے ہیں۔
+
+### Dependency کے تقاضے { #dependency-requirements }
+
+یہ request کے تقاضے (جیسے headers) یا دیگر sub-dependencies declare کر سکتی ہیں:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[8,13] *}
+
+### Exceptions raise کریں { #raise-exceptions }
+
+یہ dependencies عام dependencies کی طرح exceptions `raise` کر سکتی ہیں:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[10,15] *}
+
+### واپسی values { #return-values }
+
+اور یہ values واپس کر سکتی ہیں یا نہیں، values استعمال نہیں ہوں گی۔
+
+تو، آپ ایک عام dependency (جو value واپس کرتی ہے) جو آپ پہلے سے کہیں اور استعمال کر رہے ہیں، دوبارہ استعمال کر سکتے ہیں، اور اگرچہ value استعمال نہیں ہوگی، dependency execute ضرور ہوگی:
+
+{* ../../docs_src/dependencies/tutorial006_an_py310.py hl[11,16] *}
+
+## *path operations* کے گروپ کے لیے Dependencies { #dependencies-for-a-group-of-path-operations }
+
+بعد میں، جب آپ بڑی ایپلیکیشنز کی ساخت کے بارے میں پڑھیں گے ([بڑی ایپلیکیشنز - متعدد فائلیں](../../tutorial/bigger-applications.md))، ممکنہ طور پر متعدد فائلوں کے ساتھ، آپ سیکھیں گے کہ *path operations* کے گروپ کے لیے ایک `dependencies` parameter کیسے declare کیا جائے۔
+
+## Global Dependencies { #global-dependencies }
+
+اگلے مرحلے میں ہم دیکھیں گے کہ پوری `FastAPI` ایپلیکیشن میں dependencies کیسے شامل کی جائیں، تاکہ وہ ہر *path operation* پر لاگو ہوں۔
diff --git a/docs/ur/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/ur/docs/tutorial/dependencies/dependencies-with-yield.md
new file mode 100644
index 000000000..7e1962ac7
--- /dev/null
+++ b/docs/ur/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -0,0 +1,288 @@
+# `yield` والی Dependencies { #dependencies-with-yield }
+
+FastAPI ایسی dependencies کو سپورٹ کرتا ہے جو مکمل ہونے کے بعد کچھ اضافی اقدامات کرتی ہیں۔
+
+ایسا کرنے کے لیے، `return` کی بجائے `yield` استعمال کریں، اور اس کے بعد اضافی اقدامات (code) لکھیں۔
+
+/// tip | مشورہ
+
+یقینی بنائیں کہ ہر dependency میں `yield` صرف ایک بار استعمال ہو۔
+
+///
+
+/// note | تکنیکی تفصیلات
+
+کوئی بھی function جو ان کے ساتھ استعمال کے لیے درست ہو:
+
+* [`@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 کے طور پر استعمال کے لیے درست ہوگا۔
+
+دراصل، FastAPI اندرونی طور پر انہی دو decorators کو استعمال کرتا ہے۔
+
+///
+
+## `yield` کے ساتھ Database dependency { #a-database-dependency-with-yield }
+
+مثال کے طور پر، آپ اسے database session بنانے اور مکمل ہونے کے بعد بند کرنے کے لیے استعمال کر سکتے ہیں۔
+
+Response بنانے سے پہلے صرف `yield` statement تک کا code 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` یا عام functions استعمال کر سکتے ہیں۔
+
+**FastAPI** ہر ایک کے ساتھ صحیح کام کرے گا، بالکل جیسے عام dependencies کے ساتھ۔
+
+///
+
+## `yield` اور `try` والی dependency { #a-dependency-with-yield-and-try }
+
+اگر آپ `yield` والی dependency میں `try` block استعمال کرتے ہیں، تو dependency استعمال کرتے وقت پھینکی گئی کوئی بھی exception آپ کو ملے گی۔
+
+مثال کے طور پر، اگر درمیان میں کسی مقام پر، کسی دوسری dependency میں یا *path operation* میں، کسی code نے database transaction "rollback" کیا یا کوئی اور exception پیدا کی، تو آپ کو اپنی dependency میں وہ exception ملے گی۔
+
+تو، آپ `except SomeException` کے ذریعے dependency کے اندر اس مخصوص exception کو تلاش کر سکتے ہیں۔
+
+اسی طرح، آپ `finally` استعمال کر سکتے ہیں تاکہ exit کے اقدامات ضرور execute ہوں، چاہے exception ہو یا نہ ہو۔
+
+{* ../../docs_src/dependencies/tutorial007_py310.py hl[3,5] *}
+
+## `yield` والی Sub-dependencies { #sub-dependencies-with-yield }
+
+آپ کے پاس کسی بھی سائز اور شکل کی sub-dependencies اور sub-dependencies کے "درخت" ہو سکتے ہیں، اور ان میں سے کوئی بھی یا سب `yield` استعمال کر سکتی ہیں۔
+
+**FastAPI** یقینی بنائے گا کہ `yield` والی ہر dependency میں "exit code" صحیح ترتیب سے چلے۔
+
+مثال کے طور پر، `dependency_c` کی dependency `dependency_b` پر ہو سکتی ہے، اور `dependency_b` کی `dependency_a` پر:
+
+{* ../../docs_src/dependencies/tutorial008_an_py310.py hl[6,14,22] *}
+
+اور یہ سب `yield` استعمال کر سکتی ہیں۔
+
+اس صورت میں `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` کے ساتھ اور کچھ `return` کے ساتھ ہو سکتی ہیں، اور ان میں سے کچھ دوسروں پر منحصر ہو سکتی ہیں۔
+
+اور آپ کے پاس ایک dependency ہو سکتی ہے جس کو کئی دوسری `yield` والی dependencies کی ضرورت ہو، وغیرہ۔
+
+آپ dependencies کے جو بھی مجموعے چاہیں رکھ سکتے ہیں۔
+
+**FastAPI** یقینی بنائے گا کہ سب کچھ صحیح ترتیب سے چلے۔
+
+/// note | تکنیکی تفصیلات
+
+یہ Python کے [Context Managers](https://docs.python.org/3/library/contextlib.html) کی بدولت کام کرتا ہے۔
+
+**FastAPI** اسے حاصل کرنے کے لیے اندرونی طور پر انہیں استعمال کرتا ہے۔
+
+///
+
+## `yield` اور `HTTPException` والی Dependencies { #dependencies-with-yield-and-httpexception }
+
+آپ نے دیکھا کہ آپ `yield` والی dependencies استعمال کر سکتے ہیں اور `try` blocks رکھ سکتے ہیں جو کچھ code execute کرنے کی کوشش کرتے ہیں اور پھر `finally` کے بعد کچھ exit code چلاتے ہیں۔
+
+آپ `except` بھی استعمال کر سکتے ہیں تاکہ raise ہونے والی exception کو پکڑ سکیں اور اس کے ساتھ کچھ کر سکیں۔
+
+مثال کے طور پر، آپ ایک مختلف exception raise کر سکتے ہیں، جیسے `HTTPException`۔
+
+/// tip | مشورہ
+
+یہ ایک حد تک ایڈوانسڈ تکنیک ہے، اور زیادہ تر صورتوں میں آپ کو واقعی اس کی ضرورت نہیں ہوگی، کیونکہ آپ اپنی باقی ایپلیکیشن code کے اندر سے exceptions (بشمول `HTTPException`) raise کر سکتے ہیں، مثال کے طور پر، *path operation function* میں۔
+
+لیکن اگر آپ کو ضرورت ہو تو یہ آپ کے لیے موجود ہے۔
+
+///
+
+{* ../../docs_src/dependencies/tutorial008b_an_py310.py hl[18:22,31] *}
+
+اگر آپ exceptions پکڑنا چاہتے ہیں اور اس کی بنیاد پر ایک custom response بنانا چاہتے ہیں، تو ایک [Custom Exception Handler](../handling-errors.md#install-custom-exception-handlers) بنائیں۔
+
+## `yield` اور `except` والی Dependencies { #dependencies-with-yield-and-except }
+
+اگر آپ `yield` والی dependency میں `except` استعمال کر کے exception پکڑتے ہیں اور اسے دوبارہ raise نہیں کرتے (یا نئی exception raise نہیں کرتے)، تو FastAPI کو پتا نہیں چلے گا کہ کوئی exception تھی، بالکل ویسے ہی جیسے عام Python میں ہوتا ہے:
+
+{* ../../docs_src/dependencies/tutorial008c_an_py310.py hl[15:16] *}
+
+اس صورت میں، 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 پکڑتے ہیں، تو جب تک آپ کوئی اور `HTTPException` یا اس جیسی چیز raise نہیں کر رہے، **آپ کو اصل 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-of-dependencies-with-yield }
+
+عمل کی ترتیب تقریباً اس diagram کی طرح ہے۔ وقت اوپر سے نیچے کی طرف بہتا ہے۔ اور ہر column ان حصوں میں سے ایک ہے جو آپس میں تعامل کر رہے ہیں یا code execute کر رہے ہیں۔
+
+```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
+```
+
+/// info | معلومات
+
+Client کو صرف **ایک response** بھیجا جائے گا۔ یہ error responses میں سے ایک ہو سکتا ہے یا *path operation* سے آنے والا response ہو سکتا ہے۔
+
+ان میں سے ایک response بھیجے جانے کے بعد، کوئی اور response نہیں بھیجا جا سکتا۔
+
+///
+
+/// tip | مشورہ
+
+اگر آپ *path operation function* کے code میں کوئی exception raise کرتے ہیں، تو یہ `yield` والی dependencies کو پاس ہوگی، بشمول `HTTPException`۔ زیادہ تر صورتوں میں آپ وہی exception یا ایک نئی exception `yield` والی dependency سے دوبارہ raise کرنا چاہیں گے تاکہ یقینی ہو کہ اسے صحیح طریقے سے ہینڈل کیا جائے۔
+
+///
+
+## جلد بند ہونا اور `scope` { #early-exit-and-scope }
+
+عام طور پر `yield` والی dependencies کا exit code client کو **response بھیجے جانے کے بعد** execute ہوتا ہے۔
+
+لیکن اگر آپ جانتے ہیں کہ *path operation function* سے واپس آنے کے بعد آپ کو dependency استعمال کرنے کی ضرورت نہیں ہوگی، تو آپ `Depends(scope="function")` استعمال کر سکتے ہیں تاکہ FastAPI کو بتا سکیں کہ *path operation function* واپس آنے کے بعد dependency بند کر دے، لیکن response بھیجنے سے **پہلے**۔
+
+{* ../../docs_src/dependencies/tutorial008e_an_py310.py hl[12,16] *}
+
+`Depends()` ایک `scope` parameter وصول کرتا ہے جو ہو سکتا ہے:
+
+* `"function"`: request handle کرنے والے *path operation function* سے پہلے dependency شروع کریں، *path operation function* ختم ہونے کے بعد dependency ختم کریں، لیکن client کو response واپس بھیجنے سے **پہلے**۔ تو، dependency function *path operation **function*** کے **ارد گرد** execute ہوگا۔
+* `"request"`: request handle کرنے والے *path operation function* سے پہلے dependency شروع کریں (`"function"` جیسا ہی)، لیکن client کو response واپس بھیجنے کے **بعد** ختم کریں۔ تو، dependency function **request** اور response cycle کے **ارد گرد** execute ہوگا۔
+
+اگر مخصوص نہ کیا جائے اور dependency میں `yield` ہو، تو بطور default `scope` `"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 چلانے کے قابل ہونا ضروری ہے، کیونکہ اسے اپنے 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 وقت کے ساتھ مختلف استعمال کے معاملات کو پورا کرنے اور کچھ مسائل حل کرنے کے لیے ترقی پذیر ہوئی ہیں۔
+
+اگر آپ دیکھنا چاہتے ہیں کہ FastAPI کے مختلف versions میں کیا تبدیل ہوا ہے، تو آپ اس کے بارے میں ایڈوانسڈ گائیڈ میں مزید پڑھ سکتے ہیں، [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 میں استعمال کر سکتے ہیں۔
+
+مثال کے طور پر، [آپ `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 ختم ہوتا ہے، تو یہ فائل بند کرنے کو یقینی بناتا ہے، چاہے exceptions ہوں۔
+
+جب آپ `yield` کے ساتھ dependency بناتے ہیں، تو **FastAPI** اندرونی طور پر اس کے لیے ایک context manager بنائے گا، اور اسے دیگر متعلقہ ٹولز کے ساتھ جوڑے گا۔
+
+### `yield` والی dependencies میں context managers استعمال کرنا { #using-context-managers-in-dependencies-with-yield }
+
+/// warning | انتباہ
+
+یہ کم و بیش ایک "ایڈوانسڈ" خیال ہے۔
+
+اگر آپ ابھی **FastAPI** سے شروعات کر رہے ہیں تو آپ فی الحال اسے چھوڑنا چاہ سکتے ہیں۔
+
+///
+
+Python میں، آپ [دو methods والی class بنا کر Context Managers بنا سکتے ہیں: `__enter__()` اور `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers)۔
+
+آپ انہیں **FastAPI** dependencies کے اندر بھی `yield` کے ساتھ استعمال کر سکتے ہیں، dependency function کے اندر `with` یا `async with` statements استعمال کر کے:
+
+{* ../../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)
+
+ایک واحد `yield` والے function کو decorate کرنے کے لیے استعمال کریں۔
+
+یہی وہ چیز ہے جو **FastAPI** اندرونی طور پر `yield` والی dependencies کے لیے استعمال کرتا ہے۔
+
+لیکن آپ کو FastAPI dependencies کے لیے یہ decorators استعمال کرنے کی ضرورت نہیں ہے (اور نہیں کرنی چاہیے)۔
+
+FastAPI آپ کے لیے یہ اندرونی طور پر کرے گا۔
+
+///
diff --git a/docs/ur/docs/tutorial/dependencies/global-dependencies.md b/docs/ur/docs/tutorial/dependencies/global-dependencies.md
new file mode 100644
index 000000000..3e10b132e
--- /dev/null
+++ b/docs/ur/docs/tutorial/dependencies/global-dependencies.md
@@ -0,0 +1,16 @@
+# Global Dependencies { #global-dependencies }
+
+بعض قسم کی ایپلیکیشنز کے لیے آپ پوری ایپلیکیشن میں dependencies شامل کرنا چاہ سکتے ہیں۔
+
+جس طرح آپ [*path operation decorators* میں `dependencies` شامل](dependencies-in-path-operation-decorators.md) کر سکتے ہیں، اسی طرح آپ انہیں `FastAPI` ایپلیکیشن میں شامل کر سکتے ہیں۔
+
+اس صورت میں، یہ ایپلیکیشن کے تمام *path operations* پر لاگو ہوں گی:
+
+{* ../../docs_src/dependencies/tutorial012_an_py310.py hl[17] *}
+
+
+اور [*path operation decorators* میں `dependencies` شامل کرنے](dependencies-in-path-operation-decorators.md) کے سیکشن کے تمام تصورات ابھی بھی لاگو ہوتے ہیں، لیکن اس صورت میں، ایپ کے تمام *path operations* پر۔
+
+## *path operations* کے گروپوں کے لیے Dependencies { #dependencies-for-groups-of-path-operations }
+
+بعد میں، جب آپ بڑی ایپلیکیشنز کی ساخت کے بارے میں پڑھیں گے ([بڑی ایپلیکیشنز - متعدد فائلیں](../../tutorial/bigger-applications.md))، ممکنہ طور پر متعدد فائلوں کے ساتھ، آپ سیکھیں گے کہ *path operations* کے گروپ کے لیے ایک `dependencies` parameter کیسے declare کیا جائے۔
diff --git a/docs/ur/docs/tutorial/dependencies/index.md b/docs/ur/docs/tutorial/dependencies/index.md
new file mode 100644
index 000000000..8680b7ff0
--- /dev/null
+++ b/docs/ur/docs/tutorial/dependencies/index.md
@@ -0,0 +1,250 @@
+# Dependencies { #dependencies }
+
+**FastAPI** میں ایک بہت طاقتور لیکن آسان **Dependency Injection** نظام موجود ہے۔
+
+یہ استعمال میں بہت آسان ہونے کے لیے بنایا گیا ہے، اور کسی بھی developer کے لیے دوسرے components کو **FastAPI** کے ساتھ جوڑنا انتہائی سہل بناتا ہے۔
+
+## "Dependency Injection" کیا ہے { #what-is-dependency-injection }
+
+**"Dependency Injection"** کا مطلب، programming میں، یہ ہے کہ آپ کے code (اس صورت میں، آپ کے *path operation functions*) کے پاس یہ اعلان کرنے کا ایک طریقہ ہو کہ اسے کام کرنے کے لیے کن چیزوں کی ضرورت ہے: "dependencies"۔
+
+اور پھر، وہ نظام (اس صورت میں **FastAPI**) آپ کے code کو ان ضروری dependencies فراہم کرنے کا خیال رکھے گا ("inject" کرے گا)۔
+
+یہ بہت مفید ہے جب آپ کو ضرورت ہو:
+
+* مشترکہ logic رکھنا (ایک ہی code logic بار بار)۔
+* Database connections شیئر کرنا۔
+* Security، authentication، role کے تقاضے نافذ کرنا، وغیرہ۔
+* اور بہت سی دوسری چیزیں...
+
+یہ سب کچھ، code کی تکرار کو کم سے کم کرتے ہوئے۔
+
+## پہلے قدم { #first-steps }
+
+آئیے ایک بہت سادی مثال دیکھتے ہیں۔ یہ اتنی سادی ہوگی کہ ابھی بہت مفید نہیں ہوگی۔
+
+لیکن اس طرح ہم اس بات پر توجہ مرکوز کر سکتے ہیں کہ **Dependency Injection** نظام کیسے کام کرتا ہے۔
+
+### ایک dependency، یا "dependable" بنائیں { #create-a-dependency-or-dependable }
+
+آئیے پہلے dependency پر توجہ مرکوز کرتے ہیں۔
+
+یہ صرف ایک function ہے جو وہ تمام parameters لے سکتا ہے جو ایک *path operation function* لے سکتا ہے:
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8:9] *}
+
+بس اتنا ہی۔
+
+**2 سطریں**۔
+
+اور اس کی شکل اور ساخت وہی ہے جو آپ کے تمام *path operation functions* کی ہوتی ہے۔
+
+آپ اسے ایک *path operation function* کے طور پر سوچ سکتے ہیں بغیر "decorator" کے (بغیر `@app.get("/some-path")` کے)۔
+
+اور یہ جو بھی آپ چاہیں واپس کر سکتا ہے۔
+
+اس صورت میں، یہ dependency توقع رکھتی ہے:
+
+* ایک اختیاری query parameter `q` جو `str` ہے۔
+* ایک اختیاری query parameter `skip` جو `int` ہے، اور بطور default `0` ہے۔
+* ایک اختیاری query parameter `limit` جو `int` ہے، اور بطور default `100` ہے۔
+
+اور پھر یہ صرف ان اقدار پر مشتمل ایک `dict` واپس کرتا ہے۔
+
+/// info
+
+FastAPI نے `Annotated` کے لیے سپورٹ version 0.95.0 میں شامل کی (اور اس کی سفارش شروع کی)۔
+
+اگر آپ کے پاس پرانا version ہے، تو `Annotated` استعمال کرتے وقت آپ کو errors آئیں گے۔
+
+`Annotated` استعمال کرنے سے پہلے یقینی بنائیں کہ آپ [FastAPI version کو اپ گریڈ کریں](../../deployment/versions.md#upgrading-the-fastapi-versions) کم از کم 0.95.1 تک۔
+
+///
+
+### `Depends` import کریں { #import-depends }
+
+{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[3] *}
+
+### Dependency کا اعلان کریں، "dependant" میں { #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 نہیں کرتے** (آخر میں قوسین نہیں لگاتے)، بلکہ اسے `Depends()` میں بطور parameter پاس کرتے ہیں۔
+
+اور وہ function اسی طرح parameters لیتا ہے جیسے *path operation functions* لیتے ہیں۔
+
+/// tip | مشورہ
+
+آپ اگلے باب میں دیکھیں گے کہ functions کے علاوہ اور کون سی "چیزیں" dependencies کے طور پر استعمال ہو سکتی ہیں۔
+
+///
+
+جب بھی نئی request آتی ہے، **FastAPI** اس کا خیال رکھے گا:
+
+* آپ کے dependency ("dependable") function کو صحیح parameters کے ساتھ call کرنا۔
+* آپ کے function سے نتیجہ حاصل کرنا۔
+* اس نتیجے کو آپ کے *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
+```
+
+اس طرح آپ مشترکہ code ایک بار لکھتے ہیں اور **FastAPI** اسے آپ کے *path operations* کے لیے call کرنے کا خیال رکھتا ہے۔
+
+/// check
+
+دھیان دیں کہ آپ کو کوئی خاص class بنانے اور اسے **FastAPI** میں کہیں "register" کرنے یا اس جیسا کچھ کرنے کی ضرورت نہیں ہے۔
+
+آپ بس اسے `Depends` میں پاس کریں اور **FastAPI** باقی سب کرنا جانتا ہے۔
+
+///
+
+## `Annotated` dependencies شیئر کریں { #share-annotated-dependencies }
+
+اوپر کی مثالوں میں، آپ دیکھ سکتے ہیں کہ تھوڑی سی **code تکرار** ہے۔
+
+جب آپ کو `common_parameters()` dependency استعمال کرنی ہو، تو آپ کو type annotation اور `Depends()` کے ساتھ پورا parameter لکھنا پڑتا ہے:
+
+```Python
+commons: Annotated[dict, Depends(common_parameters)]
+```
+
+لیکن چونکہ ہم `Annotated` استعمال کر رہے ہیں، ہم اس `Annotated` value کو ایک variable میں محفوظ کر سکتے ہیں اور اسے کئی جگہوں پر استعمال کر سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial001_02_an_py310.py hl[12,16,21] *}
+
+/// tip | مشورہ
+
+یہ صرف معیاری Python ہے، اسے "type alias" کہتے ہیں، یہ دراصل **FastAPI** کے لیے مخصوص نہیں ہے۔
+
+لیکن چونکہ **FastAPI** Python کے معیارات پر مبنی ہے، بشمول `Annotated`، آپ اپنے code میں یہ ترکیب استعمال کر سکتے ہیں۔
+
+///
+
+Dependencies حسب توقع کام کرتی رہیں گی، اور **سب سے اچھی بات** یہ ہے کہ **type کی معلومات محفوظ رہیں گی**، جس کا مطلب ہے کہ آپ کا editor آپ کو **autocompletion**، **inline errors**، وغیرہ فراہم کرتا رہے گا۔ دوسرے ٹولز جیسے `mypy` کے لیے بھی یہی بات ہے۔
+
+یہ خاص طور پر اس وقت مفید ہوگا جب آپ اسے ایک **بڑے code base** میں استعمال کریں جہاں آپ **ایک ہی dependencies** کو **کئی *path operations*** میں بار بار استعمال کرتے ہیں۔
+
+## `async` یا نہ `async` { #to-async-or-not-to-async }
+
+چونکہ dependencies کو بھی **FastAPI** call کرے گا (بالکل جیسے آپ کے *path operation functions*)، اس لیے اپنے functions define کرتے وقت وہی قواعد لاگو ہوتے ہیں۔
+
+آپ `async def` یا عام `def` استعمال کر سکتے ہیں۔
+
+اور آپ عام `def` *path operation functions* کے اندر `async def` dependencies کا اعلان کر سکتے ہیں، یا `async def` *path operation functions* کے اندر `def` dependencies کا، وغیرہ۔
+
+اس سے کوئی فرق نہیں پڑتا۔ **FastAPI** جانتا ہے کہ کیا کرنا ہے۔
+
+/// note | نوٹ
+
+اگر آپ نہیں جانتے، تو docs میں [Async: *"جلدی میں ہیں؟"*](../../async.md#in-a-hurry) سیکشن میں `async` اور `await` کے بارے میں دیکھیں۔
+
+///
+
+## OpenAPI کے ساتھ مربوط { #integrated-with-openapi }
+
+آپ کی dependencies (اور sub-dependencies) کے تمام request اعلانات، validations اور تقاضے اسی OpenAPI schema میں شامل ہوں گے۔
+
+تو، interactive docs میں ان dependencies سے بھی تمام معلومات ہوں گی:
+
+
+
+## آسان استعمال { #simple-usage }
+
+اگر آپ غور کریں، تو *path operation functions* اس لیے declare کیے جاتے ہیں تاکہ جب بھی کوئی *path* اور *operation* ملے تو استعمال ہوں، اور پھر **FastAPI** صحیح parameters کے ساتھ function کو call کرنے اور request سے data نکالنے کا خیال رکھتا ہے۔
+
+دراصل، تمام (یا زیادہ تر) web frameworks اسی طرح کام کرتے ہیں۔
+
+آپ ان functions کو کبھی براہ راست call نہیں کرتے۔ انہیں آپ کا framework (اس صورت میں، **FastAPI**) call کرتا ہے۔
+
+Dependency Injection نظام کے ساتھ، آپ **FastAPI** کو یہ بھی بتا سکتے ہیں کہ آپ کا *path operation function* بھی کسی اور چیز پر "منحصر" ہے جو آپ کے *path operation function* سے پہلے execute ہونی چاہیے، اور **FastAPI** اسے execute کرنے اور نتائج "inject" کرنے کا خیال رکھے گا۔
+
+"dependency injection" کے اسی خیال کے دوسرے عام نام یہ ہیں:
+
+* resources
+* providers
+* services
+* injectables
+* components
+
+## **FastAPI** plug-ins { #fastapi-plug-ins }
+
+**Dependency Injection** نظام کا استعمال کرتے ہوئے integrations اور "plug-ins" بنائے جا سکتے ہیں۔ لیکن دراصل، **"plug-ins" بنانے کی ضرورت نہیں ہے**، کیونکہ dependencies استعمال کر کے لامحدود تعداد میں integrations اور interactions declare کرنا ممکن ہے جو آپ کے *path operation functions* کے لیے دستیاب ہو جاتے ہیں۔
+
+اور dependencies بہت آسان اور بدیہی طریقے سے بنائی جا سکتی ہیں جو آپ کو صرف ضروری Python packages import کرنے اور انہیں اپنے API functions کے ساتھ code کی چند سطروں میں جوڑنے دیتی ہیں، *لفظی طور پر*۔
+
+آپ اگلے ابواب میں اس کی مثالیں دیکھیں گے، relational اور NoSQL databases، security، وغیرہ کے بارے میں۔
+
+## **FastAPI** مطابقت { #fastapi-compatibility }
+
+Dependency injection نظام کی سادگی **FastAPI** کو ان سب کے ساتھ مطابق بناتی ہے:
+
+* تمام relational databases
+* NoSQL databases
+* بیرونی packages
+* بیرونی APIs
+* Authentication اور authorization نظام
+* API استعمال کی نگرانی کے نظام
+* Response data injection نظام
+* وغیرہ۔
+
+## سادہ اور طاقتور { #simple-and-powerful }
+
+اگرچہ درجہ بندی والا dependency injection نظام define اور استعمال کرنے میں بہت آسان ہے، پھر بھی یہ بہت طاقتور ہے۔
+
+آپ ایسی dependencies define کر سکتے ہیں جو خود بھی dependencies define کر سکتی ہیں۔
+
+آخر میں، dependencies کا ایک درجہ بندی والا درخت بنتا ہے، اور **Dependency Injection** نظام ان تمام dependencies (اور ان کی sub-dependencies) کو حل کرنے اور ہر قدم پر نتائج فراہم (inject) کرنے کا خیال رکھتا ہے۔
+
+مثال کے طور پر، فرض کریں آپ کے پاس 4 API endpoints (*path operations*) ہیں:
+
+* `/items/public/`
+* `/items/private/`
+* `/users/{user_id}/activate`
+* `/items/pro/`
+
+تو آپ صرف dependencies اور sub-dependencies کے ذریعے ہر ایک کے لیے مختلف permission کے تقاضے شامل کر سکتے ہیں:
+
+```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-with-openapi_1 }
+
+یہ تمام dependencies، اپنے تقاضوں کا اعلان کرتے ہوئے، آپ کے *path operations* میں parameters، validations، وغیرہ بھی شامل کرتی ہیں۔
+
+**FastAPI** ان سب کو OpenAPI schema میں شامل کرنے کا خیال رکھے گا، تاکہ یہ interactive documentation نظاموں میں دکھایا جائے۔
diff --git a/docs/ur/docs/tutorial/dependencies/sub-dependencies.md b/docs/ur/docs/tutorial/dependencies/sub-dependencies.md
new file mode 100644
index 000000000..ee3fae123
--- /dev/null
+++ b/docs/ur/docs/tutorial/dependencies/sub-dependencies.md
@@ -0,0 +1,105 @@
+# Sub-dependencies { #sub-dependencies }
+
+آپ ایسی dependencies بنا سکتے ہیں جن میں **sub-dependencies** ہوں۔
+
+یہ جتنی **گہری** بھی ہوں، آپ کی ضرورت کے مطابق ہو سکتی ہیں۔
+
+**FastAPI** انہیں حل کرنے کا خیال رکھے گا۔
+
+## پہلی dependency "dependable" { #first-dependency-dependable }
+
+آپ اس طرح پہلی dependency ("dependable") بنا سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}
+
+یہ ایک اختیاری query parameter `q` کو `str` کے طور پر declare کرتی ہے، اور پھر بس اسے واپس کر دیتی ہے۔
+
+یہ کافی سادہ ہے (زیادہ مفید نہیں)، لیکن ہمیں 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] *}
+
+آئیے declare کیے گئے parameters پر توجہ دیتے ہیں:
+
+* اگرچہ یہ function خود ایک dependency ("dependable") ہے، یہ ایک اور dependency بھی declare کرتا ہے (یہ کسی اور چیز پر "منحصر" ہے)۔
+ * یہ `query_extractor` پر منحصر ہے، اور اس سے واپس آنے والی value کو parameter `q` میں assign کرتا ہے۔
+* یہ ایک اختیاری `last_query` cookie بھی declare کرتا ہے، بطور `str`۔
+ * اگر صارف نے کوئی query `q` فراہم نہیں کی، تو ہم آخری استعمال شدہ query استعمال کرتے ہیں، جو ہم نے پہلے ایک cookie میں محفوظ کی تھی۔
+
+## Dependency استعمال کریں { #use-the-dependency }
+
+پھر ہم dependency کو اس طرح استعمال کر سکتے ہیں:
+
+{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[23] *}
+
+/// info | معلومات
+
+دھیان دیں کہ ہم *path operation function* میں صرف ایک dependency declare کر رہے ہیں، `query_or_cookie_extractor`۔
+
+لیکن **FastAPI** جانے گا کہ اسے پہلے `query_extractor` کو حل کرنا ہوگا، تاکہ اس کے نتائج `query_or_cookie_extractor` کو call کرتے وقت پاس کر سکے۔
+
+///
+
+```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 کی ایک مشترکہ sub-dependency ہو، تو **FastAPI** جانے گا کہ اس sub-dependency کو ہر request میں صرف ایک بار call کرنا ہے۔
+
+اور یہ واپس آنے والی value کو ایک "cache" میں محفوظ کر لے گا اور اسے اس مخصوص request میں ضرورت مند تمام "dependants" کو پاس کر دے گا، بجائے اس کے کہ ایک ہی request کے لیے dependency کو کئی بار call کرے۔
+
+ایک ایڈوانسڈ صورت میں جہاں آپ جانتے ہیں کہ dependency کو ایک ہی request میں ہر قدم پر (ممکنہ طور پر کئی بار) call ہونا ضروری ہے بجائے "cached" value استعمال کرنے کے، آپ `Depends` استعمال کرتے وقت `use_cache=False` parameter سیٹ کر سکتے ہیں:
+
+//// 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 }
+
+یہاں استعمال ہونے والے تمام فینسی الفاظ سے ہٹ کر، **Dependency Injection** نظام کافی سادہ ہے۔
+
+بس وہی functions جو *path operation functions* جیسے نظر آتے ہیں۔
+
+لیکن پھر بھی، یہ بہت طاقتور ہے، اور آپ کو من مانی گہرائی تک nested dependency "graphs" (درخت) declare کرنے دیتا ہے۔
+
+/// tip | مشورہ
+
+ان سادہ مثالوں سے شاید یہ سب اتنا مفید نہ لگے۔
+
+لیکن آپ **security** کے ابواب میں دیکھیں گے کہ یہ کتنا مفید ہے۔
+
+اور آپ یہ بھی دیکھیں گے کہ یہ آپ کا کتنا code بچائے گا۔
+
+///
diff --git a/docs/ur/docs/tutorial/encoder.md b/docs/ur/docs/tutorial/encoder.md
new file mode 100644
index 000000000..94a055f37
--- /dev/null
+++ b/docs/ur/docs/tutorial/encoder.md
@@ -0,0 +1,35 @@
+# JSON Compatible Encoder { #json-compatible-encoder }
+
+کچھ ایسے معاملات ہیں جن میں آپ کو کسی data type (جیسے Pydantic model) کو JSON کے ساتھ مطابقت رکھنے والی چیز (جیسے `dict`، `list` وغیرہ) میں تبدیل کرنے کی ضرورت ہو سکتی ہے۔
+
+مثال کے طور پر، اگر آپ کو اسے database میں محفوظ کرنا ہو۔
+
+اس کے لیے **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` میں تبدیل کرنا ہوگا۔
+
+اسی طرح، یہ 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` میں تبدیل کرے گا۔
+
+اسے call کرنے کا نتیجہ ایسی چیز ہے جسے Python کے معیاری [`json.dumps()`](https://docs.python.org/3/library/json.html#json.dumps) کے ساتھ encode کیا جا سکتا ہے۔
+
+یہ JSON format میں data رکھنے والی کوئی بڑی `str` واپس نہیں کرتا (بطور string)۔ یہ Python کا معیاری data structure (مثلاً ایک `dict`) واپس کرتا ہے جس کی values اور ذیلی values سب JSON کے ساتھ مطابقت رکھتی ہیں۔
+
+/// note | نوٹ
+
+`jsonable_encoder` دراصل **FastAPI** اندرونی طور پر data تبدیل کرنے کے لیے استعمال کرتا ہے۔ لیکن یہ بہت سے دوسرے منظرناموں میں بھی مفید ہے۔
+
+///
diff --git a/docs/ur/docs/tutorial/extra-data-types.md b/docs/ur/docs/tutorial/extra-data-types.md
new file mode 100644
index 000000000..5ec869e8a
--- /dev/null
+++ b/docs/ur/docs/tutorial/extra-data-types.md
@@ -0,0 +1,62 @@
+# اضافی ڈیٹا Types { #extra-data-types }
+
+اب تک آپ عام ڈیٹا types استعمال کر رہے ہیں، جیسے:
+
+* `int`
+* `float`
+* `str`
+* `bool`
+
+لیکن آپ مزید پیچیدہ ڈیٹا types بھی استعمال کر سکتے ہیں۔
+
+اور آپ کو پھر بھی وہی خصوصیات ملیں گی جو اب تک دیکھی ہیں:
+
+* بہترین editor سپورٹ۔
+* آنے والی requests سے ڈیٹا کی تبدیلی۔
+* response ڈیٹا کی تبدیلی۔
+* ڈیٹا validation۔
+* خودکار annotation اور documentation۔
+
+## دیگر ڈیٹا types { #other-data-types }
+
+یہاں کچھ اضافی ڈیٹا types ہیں جو آپ استعمال کر سکتے ہیں:
+
+* `UUID`:
+ * ایک معیاری "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 میں یہ کل سیکنڈز کے `float` کے طور پر ظاہر ہوگا۔
+ * Pydantic اسے "ISO 8601 time diff encoding" کے طور پر بھی ظاہر کرنے کی اجازت دیتا ہے، [مزید معلومات کے لیے docs دیکھیں](https://docs.pydantic.dev/latest/concepts/serialization/#custom-serializers)۔
+* `frozenset`:
+ * Requests اور responses میں، `set` کی طرح برتاؤ ہوگا:
+ * Requests میں، ایک list پڑھی جائے گی، ڈپلیکیٹس ہٹائے جائیں گے اور اسے `set` میں تبدیل کیا جائے گا۔
+ * Responses میں، `set` کو `list` میں تبدیل کیا جائے گا۔
+ * تیار کردہ schema بتائے گا کہ `set` کی قدریں منفرد ہیں (JSON Schema کا `uniqueItems` استعمال کر کے)۔
+* `bytes`:
+ * معیاری Python `bytes`۔
+ * Requests اور responses میں `str` کے طور پر برتاؤ ہوگا۔
+ * تیار کردہ schema بتائے گا کہ یہ `binary` "format" کا `str` ہے۔
+* `Decimal`:
+ * معیاری Python `Decimal`۔
+ * Requests اور responses میں، `float` کی طرح handle ہوگا۔
+* آپ تمام درست Pydantic ڈیٹا types یہاں چیک کر سکتے ہیں: [Pydantic data types](https://docs.pydantic.dev/latest/usage/types/types/)۔
+
+## مثال { #example }
+
+یہاں ایک مثال *path operation* ہے جس کے parameters اوپر بیان کردہ کچھ types استعمال کرتے ہیں۔
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[1,3,12:16] *}
+
+نوٹ کریں کہ function کے اندر parameters کی اپنی فطری ڈیٹا type ہوتی ہے، اور آپ مثلاً عام تاریخ کی کارروائیاں کر سکتے ہیں، جیسے:
+
+{* ../../docs_src/extra_data_types/tutorial001_an_py310.py hl[18:19] *}
diff --git a/docs/ur/docs/tutorial/extra-models.md b/docs/ur/docs/tutorial/extra-models.md
new file mode 100644
index 000000000..2e093491c
--- /dev/null
+++ b/docs/ur/docs/tutorial/extra-models.md
@@ -0,0 +1,211 @@
+# اضافی Models { #extra-models }
+
+پچھلی مثال سے آگے بڑھتے ہوئے، ایک سے زیادہ متعلقہ models کا ہونا عام ہوگا۔
+
+یہ خاص طور پر user models کے معاملے میں ہوتا ہے، کیونکہ:
+
+* **input model** میں password ہونا ضروری ہے۔
+* **output model** میں password نہیں ہونا چاہیے۔
+* **database model** میں شاید hashed password ہونا ضروری ہو۔
+
+/// danger
+
+user کے سادہ متن کے passwords کبھی ذخیرہ نہ کریں۔ ہمیشہ ایک "محفوظ hash" ذخیرہ کریں جس کی آپ بعد میں تصدیق کر سکیں۔
+
+اگر آپ نہیں جانتے، تو آپ [سیکیورٹی ابواب](security/simple-oauth2.md#password-hashing) میں سیکھیں گے کہ "password hash" کیا ہے۔
+
+///
+
+## متعدد models { #multiple-models }
+
+یہاں ایک عام خیال ہے کہ 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` ایک Pydantic model ہے جس کی class `UserIn` ہے۔
+
+Pydantic models میں `.model_dump()` method ہوتا ہے جو model کے ڈیٹا کے ساتھ ایک `dict` واپس کرتا ہے۔
+
+تو اگر ہم ایک Pydantic object `user_in` اس طرح بنائیں:
+
+```Python
+user_in = UserIn(username="john", password="secret", email="john.doe@example.com")
+```
+
+اور پھر کال کریں:
+
+```Python
+user_dict = user_in.model_dump()
+```
+
+تو اب ہمارے پاس variable `user_dict` میں ڈیٹا کے ساتھ ایک `dict` ہے (یہ Pydantic model object کی بجائے `dict` ہے)۔
+
+اور اگر ہم کال کریں:
+
+```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` کے ساتھ پاس کریں، تو Python اسے "unpack" کرے گا۔ یہ `user_dict` کی keys اور values کو براہ راست key-value arguments کے طور پر پاس کرے گا۔
+
+تو اوپر والے `user_dict` سے آگے بڑھتے ہوئے، لکھنا:
+
+```Python
+UserInDB(**user_dict)
+```
+
+اس کے برابر ہوگا:
+
+```Python
+UserInDB(
+ username="john",
+ password="secret",
+ email="john.doe@example.com",
+ full_name=None,
+)
+```
+
+یا مزید درست طور پر، `user_dict` کو براہ راست استعمال کرتے ہوئے، جو بھی مواد اس میں مستقبل میں ہو:
+
+```Python
+UserInDB(
+ username = user_dict["username"],
+ password = user_dict["password"],
+ email = user_dict["email"],
+ full_name = user_dict["full_name"],
+)
+```
+
+#### ایک 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)
+```
+
+اس کے برابر ہوگا:
+
+```Python
+UserInDB(**user_in.model_dump())
+```
+
+...کیونکہ `user_in.model_dump()` ایک `dict` ہے، اور پھر ہم Python سے اسے `**` لگا کر `UserInDB` میں پاس کر کے "unpack" کراتے ہیں۔
+
+تو ہمیں ایک Pydantic model دوسرے Pydantic model کے ڈیٹا سے ملتا ہے۔
+
+#### `dict` Unpack کرنا اور اضافی keywords { #unpacking-a-dict-and-extra-keywords }
+
+اور پھر اضافی 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 | انتباہ
+
+معاون اضافی functions `fake_password_hasher` اور `fake_save_user` صرف ڈیٹا کے ممکنہ بہاؤ کا مظاہرہ کرنے کے لیے ہیں، لیکن یقیناً یہ کوئی حقیقی سیکیورٹی فراہم نہیں کرتے۔
+
+///
+
+## تکرار کم کریں { #reduce-duplication }
+
+Code کی تکرار کم کرنا **FastAPI** کے بنیادی خیالات میں سے ایک ہے۔
+
+کیونکہ code کی تکرار سے bugs، سیکیورٹی مسائل، code desynchronization مسائل (جب آپ ایک جگہ اپ ڈیٹ کریں لیکن دوسری جگہوں پر نہ کریں) وغیرہ کے امکانات بڑھ جاتے ہیں۔
+
+اور یہ models سب بہت سا ڈیٹا شیئر کر رہے ہیں اور attribute نام اور types کی تکرار کر رہے ہیں۔
+
+ہم بہتر کر سکتے ہیں۔
+
+ہم ایک `UserBase` model declare کر سکتے ہیں جو ہمارے دوسرے models کے لیے base کا کام کرے۔ اور پھر ہم اس model کی subclasses بنا سکتے ہیں جو اس کے attributes (type declarations، validation، وغیرہ) inherit کرتی ہیں۔
+
+تمام ڈیٹا تبدیلی، validation، documentation وغیرہ پھر بھی عام طور پر کام کریں گے۔
+
+اس طرح، ہم صرف models کے درمیان فرق declare کر سکتے ہیں (سادہ متن `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 ہوگا۔
+
+اس کے لیے، معیاری 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 کرتے وقت، سب سے مخصوص type پہلے رکھیں، اس کے بعد کم مخصوص type۔ نیچے کی مثال میں، زیادہ مخصوص `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 }
+
+اس مثال میں ہم `Union[PlaneItem, CarItem]` کو argument `response_model` کی قدر کے طور پر پاس کر رہے ہیں۔
+
+چونکہ ہم اسے **type annotation** میں رکھنے کی بجائے **argument کی قدر** کے طور پر پاس کر رہے ہیں، ہمیں Python 3.10 میں بھی `Union` استعمال کرنا ہوگا۔
+
+اگر یہ type annotation میں ہوتا تو ہم عمودی بار استعمال کر سکتے تھے، جیسے:
+
+```Python
+some_variable: PlaneItem | CarItem
+```
+
+لیکن اگر ہم اسے assignment `response_model=PlaneItem | CarItem` میں رکھیں تو ہمیں error ملے گا، کیونکہ Python `PlaneItem` اور `CarItem` کے درمیان ایک **غلط عمل** کرنے کی کوشش کرے گا بجائے اس کے کہ اسے type annotation سمجھے۔
+
+## Models کی List { #list-of-models }
+
+اسی طرح، آپ objects کی lists کے responses declare کر سکتے ہیں۔
+
+اس کے لیے، معیاری Python `list` استعمال کریں:
+
+{* ../../docs_src/extra_models/tutorial004_py310.py hl[18] *}
+
+## اختیاری `dict` کے ساتھ Response { #response-with-arbitrary-dict }
+
+آپ Pydantic model استعمال کیے بغیر، صرف keys اور values کی types declare کر کے، ایک سادہ اختیاری `dict` سے بھی response declare کر سکتے ہیں۔
+
+یہ اس وقت مفید ہے جب آپ کو پیشگی درست field/attribute نام (جو Pydantic model کے لیے ضروری ہوتے ہیں) معلوم نہ ہوں۔
+
+اس صورت میں، آپ `dict` استعمال کر سکتے ہیں:
+
+{* ../../docs_src/extra_models/tutorial005_py310.py hl[6] *}
+
+## خلاصہ { #recap }
+
+متعدد Pydantic models استعمال کریں اور ہر معاملے کے لیے آزادانہ طور پر inherit کریں۔
+
+آپ کو ہر entity کے لیے ایک واحد ڈیٹا model رکھنے کی ضرورت نہیں ہے اگر اس entity کی مختلف "حالتیں" ہونی ہوں۔ جیسا کہ user "entity" کا معاملہ ہے جس کی حالت `password`، `password_hash` اور بغیر password کے شامل ہے۔
diff --git a/docs/ur/docs/tutorial/first-steps.md b/docs/ur/docs/tutorial/first-steps.md
new file mode 100644
index 000000000..15760a7ea
--- /dev/null
+++ b/docs/ur/docs/tutorial/first-steps.md
@@ -0,0 +1,429 @@
+# پہلے قدم { #first-steps }
+
+سب سے سادہ FastAPI فائل کچھ ایسی ہو سکتی ہے:
+
+{* ../../docs_src/first_steps/tutorial001_py310.py *}
+
+اسے `main.py` فائل میں کاپی کریں۔
+
+لائیو سرور چلائیں:
+
+get operation استعمال کرتے ہوئے
+
+/// info | `@decorator` معلومات
+
+Python میں `@something` syntax کو "decorator" کہا جاتا ہے۔
+
+آپ اسے function کے اوپر رکھتے ہیں۔ جیسے ایک خوبصورت آرائشی ٹوپی (مجھے لگتا ہے یہ اصطلاح وہیں سے آئی ہے)۔
+
+"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** کوئی مخصوص معنی نافذ نہیں کرتا۔
+
+یہاں دی گئی معلومات ایک رہنمائی ہے، ضرورت نہیں۔
+
+مثال کے طور پر، GraphQL استعمال کرتے وقت آپ عام طور پر تمام عمل صرف `POST` operations استعمال کر کے انجام دیتے ہیں۔
+
+///
+
+### قدم 4: **path operation function** بنائیں { #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** کو URL "`/`" پر `GET` operation استعمال کرتے ہوئے کوئی request ملے گی تو یہ اسے کال کرے گا۔
+
+اس صورت میں، یہ ایک `async` function ہے۔
+
+---
+
+آپ اسے `async def` کی بجائے عام function کے طور پر بھی بنا سکتے ہیں:
+
+{* ../../docs_src/first_steps/tutorial003_py310.py hl[7] *}
+
+/// note | نوٹ
+
+اگر آپ فرق نہیں جانتے، تو [Async: *"جلدی میں ہیں؟"*](../async.md#in-a-hurry) دیکھیں۔
+
+///
+
+### قدم 5: مواد واپس کریں { #step-5-return-the-content }
+
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[8] *}
+
+آپ `dict`، `list`، واحد اقدار جیسے `str`، `int` وغیرہ واپس کر سکتے ہیں۔
+
+آپ Pydantic models بھی واپس کر سکتے ہیں (آپ اس کے بارے میں بعد میں مزید دیکھیں گے)۔
+
+بہت سی دوسری اشیاء اور models ہیں جو خودکار طور پر JSON میں تبدیل ہو جائیں گے (بشمول ORMs وغیرہ)۔ اپنے پسندیدہ استعمال کرنے کی کوشش کریں، بہت زیادہ امکان ہے کہ وہ پہلے سے تعاون یافتہ ہیں۔
+
+### قدم 6: اسے Deploy کریں { #step-6-deploy-it }
+
+اپنی ایپ کو **[FastAPI Cloud](https://fastapicloud.com)** پر ایک کمانڈ سے deploy کریں: `fastapi deploy`۔
+
+#### FastAPI Cloud کے بارے میں { #about-fastapi-cloud }
+
+**[FastAPI Cloud](https://fastapicloud.com)** اسی مصنف اور ٹیم نے بنایا ہے جو **FastAPI** کے پیچھے ہے۔
+
+یہ کم سے کم کوشش کے ساتھ API کو **بنانے**، **deploy کرنے**، اور **رسائی حاصل کرنے** کے عمل کو آسان بناتا ہے۔
+
+یہ FastAPI کے ساتھ ایپس بنانے کا وہی **ڈیولپر تجربہ** انہیں کلاؤڈ پر **deploy کرنے** میں لاتا ہے۔
+
+FastAPI Cloud *FastAPI اور دوستوں* کے اوپن سورس پراجیکٹس کا بنیادی اسپانسر اور فنڈنگ فراہم کنندہ ہے۔
+
+#### دوسرے کلاؤڈ فراہم کنندگان پر deploy کریں { #deploy-to-other-cloud-providers }
+
+FastAPI اوپن سورس ہے اور معیارات پر مبنی ہے۔ آپ FastAPI ایپس کو اپنی پسند کے کسی بھی کلاؤڈ فراہم کنندہ پر deploy کر سکتے ہیں۔
+
+اپنے کلاؤڈ فراہم کنندہ کی گائیڈز کی پیروی کریں تاکہ ان کے ساتھ FastAPI ایپس deploy کر سکیں۔
+
+## خلاصہ { #recap }
+
+* `FastAPI` import کریں۔
+* ایک `app` instance بنائیں۔
+* ایک **path operation decorator** لکھیں جیسے `@app.get("/")`۔
+* ایک **path operation function** بنائیں؛ مثال کے طور پر، `def root(): ...`۔
+* `fastapi dev` کمانڈ استعمال کر کے ڈیولپمنٹ سرور چلائیں۔
+* اختیاری طور پر اپنی ایپ `fastapi deploy` سے deploy کریں۔
diff --git a/docs/ur/docs/tutorial/handling-errors.md b/docs/ur/docs/tutorial/handling-errors.md
new file mode 100644
index 000000000..1e58fbbba
--- /dev/null
+++ b/docs/ur/docs/tutorial/handling-errors.md
@@ -0,0 +1,244 @@
+# Errors کو سنبھالنا { #handling-errors }
+
+بہت سے حالات ایسے ہوتے ہیں جن میں آپ کو اپنی API استعمال کرنے والے client کو error کی اطلاع دینی ہوتی ہے۔
+
+یہ client ایک browser ہو سکتا ہے جس میں frontend ہو، کسی اور کا code ہو سکتا ہے، کوئی IoT device ہو سکتی ہے، وغیرہ۔
+
+آپ کو client کو بتانا پڑ سکتا ہے کہ:
+
+* Client کے پاس اس عمل کے لیے کافی اختیارات نہیں ہیں۔
+* Client کو اس resource تک رسائی نہیں ہے۔
+* جس item تک client رسائی حاصل کرنا چاہتا تھا وہ موجود نہیں ہے۔
+* وغیرہ۔
+
+ان صورتوں میں، آپ عام طور پر **400** کی حد میں (400 سے 499 تک) ایک **HTTP status code** واپس کریں گے۔
+
+یہ 200 HTTP status codes (200 سے 299 تک) کی طرح ہے۔ وہ "200" status codes یہ ظاہر کرتے ہیں کہ request میں کسی نہ کسی طرح "کامیابی" ہوئی۔
+
+400 کی حد میں status codes یہ ظاہر کرتے ہیں کہ client کی جانب سے کوئی error ہوا۔
+
+وہ تمام **"404 Not Found"** errors (اور لطیفے) یاد ہیں؟
+
+## `HTTPException` استعمال کریں { #use-httpexception }
+
+Client کو errors کے ساتھ HTTP responses واپس کرنے کے لیے آپ `HTTPException` استعمال کرتے ہیں۔
+
+### `HTTPException` کو Import کریں { #import-httpexception }
+
+{* ../../docs_src/handling_errors/tutorial001_py310.py hl[1] *}
+
+### اپنے code میں `HTTPException` raise کریں { #raise-an-httpexception-in-your-code }
+
+`HTTPException` ایک عام Python exception ہے جس میں APIs سے متعلق اضافی data شامل ہوتا ہے۔
+
+چونکہ یہ ایک Python exception ہے، آپ اسے `return` نہیں کرتے، بلکہ `raise` کرتے ہیں۔
+
+اس کا یہ بھی مطلب ہے کہ اگر آپ کسی utility function کے اندر ہیں جسے آپ اپنے *path operation function* کے اندر سے call کر رہے ہیں، اور آپ اس utility function کے اندر سے `HTTPException` raise کرتے ہیں، تو یہ *path operation function* کا باقی code نہیں چلائے گا، بلکہ فوری طور پر اس request کو ختم کر دے گا اور `HTTPException` سے HTTP error client کو بھیج دے گا۔
+
+Exception raise کرنے کا value واپس کرنے پر فائدہ Dependencies اور Security کے سیکشن میں مزید واضح ہوگا۔
+
+اس مثال میں، جب client ایسے ID کے ذریعے کوئی item طلب کرتا ہے جو موجود نہیں ہے تو `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"`) تو اس client کو HTTP status code 200 ملے گا، اور ایک JSON response:
+
+```JSON
+{
+ "item": "The Foo Wrestlers"
+}
+```
+
+لیکن اگر client `http://example.com/items/bar` کی درخواست کرتا ہے (ایک غیر موجود `item_id` `"bar"`) تو اس client کو HTTP status code 404 ("not found" error) ملے گا، اور ایک JSON response:
+
+```JSON
+{
+ "detail": "Item not found"
+}
+```
+
+/// tip | مشورہ
+
+`HTTPException` raise کرتے وقت، آپ `detail` parameter کے طور پر کوئی بھی value دے سکتے ہیں جو JSON میں تبدیل ہو سکے، صرف `str` نہیں۔
+
+آپ ایک `dict`، ایک `list` وغیرہ دے سکتے ہیں۔
+
+یہ **FastAPI** کے ذریعے خودکار طور پر سنبھالے جاتے ہیں اور JSON میں تبدیل کیے جاتے ہیں۔
+
+///
+
+## حسب ضرورت headers شامل کریں { #add-custom-headers }
+
+کچھ حالات ایسے ہیں جن میں HTTP error میں حسب ضرورت headers شامل کرنا مفید ہوتا ہے۔ مثال کے طور پر، کچھ قسم کی security کے لیے۔
+
+آپ کو شاید اپنے code میں اسے براہ راست استعمال کرنے کی ضرورت نہیں پڑے گی۔
+
+لیکن اگر آپ کو کسی پیچیدہ منظرنامے کے لیے اس کی ضرورت ہو تو آپ حسب ضرورت headers شامل کر سکتے ہیں:
+
+{* ../../docs_src/handling_errors/tutorial002_py310.py hl[14] *}
+
+## حسب ضرورت exception handlers انسٹال کریں { #install-custom-exception-handlers }
+
+آپ [Starlette سے ملتی جلتی exception utilities](https://www.starlette.dev/exceptions/) کے ساتھ حسب ضرورت exception handlers شامل کر سکتے ہیں۔
+
+فرض کریں کہ آپ کے پاس ایک حسب ضرورت exception `UnicornException` ہے جسے آپ (یا آپ کی استعمال کردہ library) `raise` کر سکتی ہے۔
+
+اور آپ اس exception کو FastAPI کے ساتھ عالمی سطح پر سنبھالنا چاہتے ہیں۔
+
+آپ `@app.exception_handler()` کے ساتھ ایک حسب ضرورت exception handler شامل کر سکتے ہیں:
+
+{* ../../docs_src/handling_errors/tutorial003_py310.py hl[5:7,13:18,24] *}
+
+یہاں، اگر آپ `/unicorns/yolo` کی درخواست کرتے ہیں تو *path operation* ایک `UnicornException` `raise` کرے گی۔
+
+لیکن اسے `unicorn_exception_handler` سنبھالے گا۔
+
+تو آپ کو ایک صاف error ملے گا، HTTP status code `418` کے ساتھ اور ایک JSON مواد:
+
+```JSON
+{"message": "Oops! yolo did something. There goes a rainbow..."}
+```
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.requests import Request` اور `from starlette.responses import JSONResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** آپ کی سہولت کے لیے وہی `starlette.responses` بطور `fastapi.responses` فراہم کرتا ہے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔ `Request` کے ساتھ بھی یہی معاملہ ہے۔
+
+///
+
+## پہلے سے طے شدہ exception handlers کو تبدیل کریں { #override-the-default-exception-handlers }
+
+**FastAPI** کے کچھ پہلے سے طے شدہ exception handlers ہیں۔
+
+یہ handlers جب آپ `HTTPException` `raise` کرتے ہیں اور جب request میں غلط data ہوتا ہے تو پہلے سے طے شدہ JSON responses واپس کرنے کے ذمہ دار ہوتے ہیں۔
+
+آپ ان exception handlers کو اپنے handlers سے تبدیل کر سکتے ہیں۔
+
+### Request validation exceptions کو تبدیل کریں { #override-request-validation-exceptions }
+
+جب کسی request میں غلط data ہوتا ہے تو **FastAPI** اندرونی طور پر ایک `RequestValidationError` raise کرتا ہے۔
+
+اور اس کے لیے ایک پہلے سے طے شدہ exception handler بھی شامل ہے۔
+
+اسے تبدیل کرنے کے لیے `RequestValidationError` کو import کریں اور اسے `@app.exception_handler(RequestValidationError)` کے ساتھ exception handler کو decorate کرنے کے لیے استعمال کریں۔
+
+Exception handler ایک `Request` اور exception وصول کرے گا۔
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[2,14:19] *}
+
+اب اگر آپ `/items/foo` پر جائیں تو پہلے سے طے شدہ 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-the-httpexception-error-handler }
+
+اسی طرح، آپ `HTTPException` handler کو بھی تبدیل کر سکتے ہیں۔
+
+مثال کے طور پر، آپ ان errors کے لیے JSON کی بجائے سادہ text response واپس کرنا چاہ سکتے ہیں:
+
+{* ../../docs_src/handling_errors/tutorial004_py310.py hl[3:4,9:11,25] *}
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import PlainTextResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** آپ کی سہولت کے لیے وہی `starlette.responses` بطور `fastapi.responses` فراہم کرتا ہے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+///
+
+/// warning | انتباہ
+
+ذہن میں رکھیں کہ `RequestValidationError` میں اس file کا نام اور لائن کی معلومات شامل ہوتی ہیں جہاں validation error ہوا تاکہ آپ چاہیں تو اپنے logs میں متعلقہ معلومات کے ساتھ اسے دکھا سکیں۔
+
+لیکن اس کا مطلب ہے کہ اگر آپ اسے صرف string میں تبدیل کر کے وہ معلومات براہ راست واپس کریں تو آپ اپنے سسٹم کے بارے میں کچھ معلومات ظاہر کر سکتے ہیں، اسی لیے یہاں code ہر error کو الگ سے نکال کر دکھاتا ہے۔
+
+///
+
+### `RequestValidationError` کا body استعمال کریں { #use-the-requestvalidationerror-body }
+
+`RequestValidationError` میں وہ `body` شامل ہوتا ہے جو غلط data کے ساتھ موصول ہوا تھا۔
+
+آپ اسے اپنی app بناتے وقت body کو log کرنے اور debug کرنے، user کو واپس کرنے وغیرہ کے لیے استعمال کر سکتے ہیں۔
+
+{* ../../docs_src/handling_errors/tutorial005_py310.py hl[14] *}
+
+اب ایک غلط item بھیجنے کی کوشش کریں جیسے:
+
+```JSON
+{
+ "title": "towel",
+ "size": "XL"
+}
+```
+
+آپ کو ایک response ملے گا جو بتائے گا کہ data غلط ہے اور اس میں موصول شدہ 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 میں قابل تبدیل data قبول کرتا ہے، جبکہ Starlette کا `HTTPException` صرف strings قبول کرتا ہے۔
+
+تو آپ **FastAPI** کا `HTTPException` عام طریقے سے اپنے code میں raise کرتے رہ سکتے ہیں۔
+
+لیکن جب آپ exception handler رجسٹر کریں تو اسے Starlette کے `HTTPException` کے لیے رجسٹر کریں۔
+
+اس طرح، اگر Starlette کے اندرونی code کا کوئی حصہ، یا کوئی Starlette extension یا plug-in، Starlette کا `HTTPException` raise کرے تو آپ کا handler اسے پکڑ کر سنبھال سکے گا۔
+
+اس مثال میں، ایک ہی code میں دونوں `HTTPException` رکھنے کے لیے، Starlette کے exception کا نام `StarletteHTTPException` رکھا گیا ہے:
+
+```Python
+from starlette.exceptions import HTTPException as StarletteHTTPException
+```
+
+### **FastAPI** کے exception handlers دوبارہ استعمال کریں { #reuse-fastapis-exception-handlers }
+
+اگر آپ exception کو **FastAPI** کے پہلے سے طے شدہ exception handlers کے ساتھ استعمال کرنا چاہتے ہیں تو آپ `fastapi.exception_handlers` سے پہلے سے طے شدہ exception handlers import اور دوبارہ استعمال کر سکتے ہیں:
+
+{* ../../docs_src/handling_errors/tutorial006_py310.py hl[2:5,15,21] *}
+
+اس مثال میں آپ بہت واضح پیغام کے ساتھ error print کر رہے ہیں، لیکن آپ کو خیال آ گیا ہوگا۔ آپ exception استعمال کر سکتے ہیں اور پھر صرف پہلے سے طے شدہ exception handlers کو دوبارہ استعمال کر سکتے ہیں۔
diff --git a/docs/ur/docs/tutorial/header-param-models.md b/docs/ur/docs/tutorial/header-param-models.md
new file mode 100644
index 000000000..1359ce7a8
--- /dev/null
+++ b/docs/ur/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` سے supported ہے۔ 🤓
+
+///
+
+## 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** کا ڈیٹا **extract** کرے گا اور آپ کو وہ Pydantic model دے گا جو آپ نے define کیا ہے۔
+
+## Docs چیک کریں { #check-the-docs }
+
+آپ `/docs` پر docs UI میں مطلوبہ headers دیکھ سکتے ہیں:
+
+
+contact fields| Parameter | Type | تفصیل |
|---|---|---|
name | str | رابطہ شخص/تنظیم کا شناختی نام۔ |
url | str | رابطہ معلومات کی طرف اشارہ کرنے والا URL۔ URL کی شکل میں ہونا ضروری ہے۔ |
email | str | رابطہ شخص/تنظیم کا email پتہ۔ email پتے کی شکل میں ہونا ضروری ہے۔ |
license_info fields| Parameter | Type | تفصیل |
|---|---|---|
name | str | ضروری (اگر license_info سیٹ ہو)۔ API کے لیے استعمال شدہ license کا نام۔ |
identifier | str | API کے لیے ایک [SPDX](https://spdx.org/licenses/) license expression۔ identifier field url field سے باہمی طور پر خارج ہے۔ OpenAPI 3.1.0 سے دستیاب، FastAPI 0.99.0۔ |
url | str | API کے لیے استعمال شدہ license کا URL۔ URL کی شکل میں ہونا ضروری ہے۔ |
+
+## License identifier { #license-identifier }
+
+OpenAPI 3.1.0 اور FastAPI 0.99.0 سے، آپ `license_info` کو `url` کی بجائے `identifier` کے ساتھ بھی سیٹ کر سکتے ہیں۔
+
+مثال کے طور پر:
+
+{* ../../docs_src/metadata/tutorial001_1_py310.py hl[31] *}
+
+## Tags کے لیے Metadata { #metadata-for-tags }
+
+آپ `openapi_tags` parameter کے ذریعے اپنے path operations کو گروپ کرنے کے لیے استعمال ہونے والے مختلف tags کے لیے اضافی metadata بھی شامل کر سکتے ہیں۔
+
+یہ ایک فہرست لیتا ہے جس میں ہر tag کے لیے ایک dictionary ہوتی ہے۔
+
+ہر dictionary میں یہ ہو سکتا ہے:
+
+* `name` (**ضروری**): ایک `str` جس میں وہی tag نام ہو جو آپ اپنے *path operations* اور `APIRouter`s میں `tags` parameter میں استعمال کرتے ہیں۔
+* `description`: ایک `str` جس میں tag کی مختصر تفصیل ہو۔ اس میں Markdown ہو سکتا ہے اور docs UI میں دکھایا جائے گا۔
+* `externalDocs`: ایک `dict` جو بیرونی دستاویزات بیان کرے:
+ * `description`: ایک `str` جس میں بیرونی docs کی مختصر تفصیل ہو۔
+ * `url` (**ضروری**): ایک `str` جس میں بیرونی دستاویزات کا URL ہو۔
+
+### Tags کے لیے metadata بنائیں { #create-metadata-for-tags }
+
+آئیں اسے `users` اور `items` کے tags کی مثال میں آزمائیں۔
+
+اپنے tags کے لیے metadata بنائیں اور اسے `openapi_tags` parameter کو دیں:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[3:16,18] *}
+
+دیکھیں کہ آپ descriptions کے اندر Markdown استعمال کر سکتے ہیں، مثلاً "login" بولڈ میں دکھایا جائے گا (**login**) اور "fancy" اٹالک میں (_fancy_)۔
+
+/// tip | مشورہ
+
+آپ کو ہر اس tag کے لیے metadata شامل کرنے کی ضرورت نہیں جو آپ استعمال کرتے ہیں۔
+
+///
+
+### اپنے tags استعمال کریں { #use-your-tags }
+
+اپنے *path operations* (اور `APIRouter`s) کے ساتھ `tags` parameter استعمال کریں تاکہ انہیں مختلف tags میں تقسیم کریں:
+
+{* ../../docs_src/metadata/tutorial004_py310.py hl[21,26] *}
+
+/// info | معلومات
+
+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` حروف تہجی کی ترتیب میں `items` کے بعد آتا ہے، یہ ان سے پہلے دکھایا جاتا ہے، کیونکہ ہم نے ان کا metadata فہرست میں پہلی dictionary کے طور پر شامل کیا ہے۔
+
+## OpenAPI URL { #openapi-url }
+
+بطور ڈیفالٹ، OpenAPI schema `/openapi.json` پر serve ہوتا ہے۔
+
+لیکن آپ اسے `openapi_url` parameter سے configure کر سکتے ہیں۔
+
+مثال کے طور پر، اسے `/api/v1/openapi.json` پر serve کرنے کے لیے:
+
+{* ../../docs_src/metadata/tutorial002_py310.py hl[3] *}
+
+اگر آپ OpenAPI schema کو مکمل طور پر غیر فعال کرنا چاہتے ہیں تو آپ `openapi_url=None` سیٹ کر سکتے ہیں، اس سے وہ documentation user interfaces بھی غیر فعال ہو جائیں گی جو اسے استعمال کرتے ہیں۔
+
+## Docs URLs { #docs-urls }
+
+آپ شامل کیے گئے دو documentation user interfaces کو configure کر سکتے ہیں:
+
+* **Swagger UI**: `/docs` پر serve ہوتا ہے۔
+ * آپ `docs_url` parameter سے اس کا URL سیٹ کر سکتے ہیں۔
+ * آپ `docs_url=None` سیٹ کر کے اسے غیر فعال کر سکتے ہیں۔
+* **ReDoc**: `/redoc` پر serve ہوتا ہے۔
+ * آپ `redoc_url` parameter سے اس کا URL سیٹ کر سکتے ہیں۔
+ * آپ `redoc_url=None` سیٹ کر کے اسے غیر فعال کر سکتے ہیں۔
+
+مثال کے طور پر، Swagger UI کو `/documentation` پر serve کرنے اور ReDoc کو غیر فعال کرنے کے لیے:
+
+{* ../../docs_src/metadata/tutorial003_py310.py hl[3] *}
diff --git a/docs/ur/docs/tutorial/middleware.md b/docs/ur/docs/tutorial/middleware.md
new file mode 100644
index 000000000..6cb0c3d03
--- /dev/null
+++ b/docs/ur/docs/tutorial/middleware.md
@@ -0,0 +1,95 @@
+# Middleware { #middleware }
+
+آپ **FastAPI** applications میں middleware شامل کر سکتے ہیں۔
+
+"middleware" ایک function ہے جو ہر **request** کے ساتھ کام کرتا ہے اس سے پہلے کہ اسے کسی مخصوص *path operation* سے process کیا جائے۔ اور ساتھ ہی ہر **response** کے ساتھ بھی اسے واپس بھیجنے سے پہلے کام کرتا ہے۔
+
+* یہ آپ کی application پر آنے والی ہر **request** کو لیتا ہے۔
+* پھر یہ اس **request** کے ساتھ کچھ کر سکتا ہے یا کوئی ضروری code چلا سکتا ہے۔
+* پھر یہ **request** کو باقی application (کسی *path operation*) کو process کرنے کے لیے آگے بھیجتا ہے۔
+* پھر یہ application (کسی *path operation*) کی طرف سے بنایا گیا **response** لیتا ہے۔
+* یہ اس **response** کے ساتھ کچھ کر سکتا ہے یا کوئی ضروری code چلا سکتا ہے۔
+* پھر یہ **response** واپس بھیجتا ہے۔
+
+/// note | تکنیکی تفصیلات
+
+اگر آپ کے پاس `yield` والی dependencies ہیں، تو exit code middleware کے *بعد* چلے گا۔
+
+اگر کوئی background tasks تھے (جن کا ذکر [Background Tasks](background-tasks.md) سیکشن میں ہے، آپ اسے بعد میں دیکھیں گے)، تو وہ تمام middleware کے *بعد* چلیں گے۔
+
+///
+
+## ایک middleware بنائیں { #create-a-middleware }
+
+middleware بنانے کے لیے آپ ایک function کے اوپر `@app.middleware("http")` decorator استعمال کریں۔
+
+middleware function یہ وصول کرتا ہے:
+
+* `request`۔
+* ایک function `call_next` جو `request` کو parameter کے طور پر وصول کرے گا۔
+ * یہ function `request` کو متعلقہ *path operation* تک پہنچائے گا۔
+ * پھر یہ متعلقہ *path operation* کی طرف سے بنایا گیا `response` واپس کرے گا۔
+* پھر آپ `response` کو واپس بھیجنے سے پہلے مزید تبدیل کر سکتے ہیں۔
+
+{* ../../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 دستاویزات](https://www.starlette.dev/middleware/#corsmiddleware) میں بیان کیا گیا ہے۔
+
+///
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.requests import Request` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** اسے آپ کی سہولت کے لیے فراہم کرتا ہے۔ لیکن یہ براہ راست Starlette سے آتا ہے۔
+
+///
+
+### `response` سے پہلے اور بعد { #before-and-after-the-response }
+
+آپ `request` کے ساتھ چلنے کے لیے code شامل کر سکتے ہیں، کسی بھی *path operation* کو وصول کرنے سے پہلے۔
+
+اور ساتھ ہی `response` بننے کے بعد، اسے واپس بھیجنے سے پہلے بھی۔
+
+مثال کے طور پر، آپ ایک custom header `X-Process-Time` شامل کر سکتے ہیں جس میں request کو process کرنے اور response بنانے میں لگنے والا وقت سیکنڈز میں ہو:
+
+{* ../../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) استعمال کر رہے ہیں کیونکہ یہ ان استعمالات کے لیے زیادہ درست ہو سکتا ہے۔ 🤓
+
+///
+
+## متعدد middleware کی عمل درآمد ترتیب { #multiple-middleware-execution-order }
+
+جب آپ `@app.middleware()` decorator یا `app.add_middleware()` method استعمال کرتے ہوئے متعدد middlewares شامل کرتے ہیں، تو ہر نیا middleware application کو wrap کرتا ہے اور ایک stack بناتا ہے۔ آخری شامل کیا گیا middleware *سب سے باہر* ہوتا ہے، اور پہلا *سب سے اندر*۔
+
+Request کے راستے پر، *سب سے باہر والا* middleware پہلے چلتا ہے۔
+
+Response کے راستے پر، یہ آخر میں چلتا ہے۔
+
+مثال کے طور پر:
+
+```Python
+app.add_middleware(MiddlewareA)
+app.add_middleware(MiddlewareB)
+```
+
+اس کا نتیجہ یہ عمل درآمد ترتیب ہے:
+
+* **Request**: MiddlewareB → MiddlewareA → route
+
+* **Response**: route → MiddlewareA → MiddlewareB
+
+یہ stacking رویہ اس بات کو یقینی بناتا ہے کہ middlewares ایک قابل پیشگوئی اور قابل کنٹرول ترتیب میں چلیں۔
+
+## دیگر middlewares { #other-middlewares }
+
+آپ دیگر middlewares کے بارے میں بعد میں [Advanced User Guide: Advanced Middleware](../advanced/middleware.md) میں مزید پڑھ سکتے ہیں۔
+
+آپ اگلے سیکشن میں پڑھیں گے کہ middleware کے ذریعے CORS کو کیسے handle کیا جائے۔
diff --git a/docs/ur/docs/tutorial/path-operation-configuration.md b/docs/ur/docs/tutorial/path-operation-configuration.md
new file mode 100644
index 000000000..87cc1658f
--- /dev/null
+++ b/docs/ur/docs/tutorial/path-operation-configuration.md
@@ -0,0 +1,107 @@
+# Path Operation Configuration { #path-operation-configuration }
+
+آپ اپنے *path operation decorator* کو configure کرنے کے لیے اس میں کئی parameters دے سکتے ہیں۔
+
+/// warning | انتباہ
+
+نوٹ کریں کہ یہ parameters براہ راست *path operation decorator* کو دیے جاتے ہیں، آپ کے *path operation function* کو نہیں۔
+
+///
+
+## Response Status Code { #response-status-code }
+
+آپ اپنے *path operation* کے response میں استعمال ہونے والا (HTTP) `status_code` بیان کر سکتے ہیں۔
+
+آپ براہ راست `int` code دے سکتے ہیں، جیسے `404`۔
+
+لیکن اگر آپ کو یاد نہیں کہ ہر نمبر code کس لیے ہے تو آپ `status` میں شارٹ کٹ constants استعمال کر سکتے ہیں:
+
+{* ../../docs_src/path_operation_configuration/tutorial001_py310.py hl[1,15] *}
+
+وہ status code response میں استعمال ہوگا اور OpenAPI schema میں شامل کیا جائے گا۔
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette import status` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** آپ کی سہولت کے لیے وہی `starlette.status` بطور `fastapi.status` فراہم کرتا ہے۔ لیکن یہ براہ راست Starlette سے آتا ہے۔
+
+///
+
+## Tags { #tags }
+
+آپ اپنے *path operation* میں tags شامل کر سکتے ہیں، `tags` parameter میں `str` کی ایک `list` دیں (عام طور پر صرف ایک `str`):
+
+{* ../../docs_src/path_operation_configuration/tutorial002_py310.py hl[15,20,25] *}
+
+یہ OpenAPI schema میں شامل کیے جائیں گے اور خودکار documentation interfaces میں استعمال ہوں گے:
+
+
+
+### Enums کے ساتھ Tags { #tags-with-enums }
+
+اگر آپ کی ایک بڑی application ہے تو آپ کے پاس **کئی tags** جمع ہو سکتے ہیں، اور آپ یقینی بنانا چاہیں گے کہ متعلقہ *path operations* کے لیے ہمیشہ **وہی tag** استعمال کریں۔
+
+ان صورتوں میں، tags کو ایک `Enum` میں محفوظ کرنا مناسب ہو سکتا ہے۔
+
+**FastAPI** اسے سادہ strings کی طرح ہی تعاون کرتا ہے:
+
+{* ../../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 طویل ہوتی ہیں اور متعدد سطروں پر پھیلی ہوتی ہیں، آپ *path operation* کی description function کے docstring میں بیان کر سکتے ہیں اور **FastAPI** اسے وہاں سے پڑھے گا۔
+
+آپ docstring میں [Markdown](https://en.wikipedia.org/wiki/Markdown) لکھ سکتے ہیں، اسے صحیح طریقے سے سمجھا اور دکھایا جائے گا (docstring indentation کو مدنظر رکھتے ہوئے)۔
+
+{* ../../docs_src/path_operation_configuration/tutorial004_py310.py hl[17:25] *}
+
+یہ interactive docs میں استعمال ہوگا:
+
+
+
+## Response description { #response-description }
+
+آپ `response_description` parameter کے ساتھ response کی description بیان کر سکتے ہیں:
+
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+
+/// info | معلومات
+
+نوٹ کریں کہ `response_description` خاص طور پر response سے متعلق ہے، `description` عمومی طور پر *path operation* سے متعلق ہے۔
+
+///
+
+/// check
+
+OpenAPI بتاتا ہے کہ ہر *path operation* کے لیے response description ضروری ہے۔
+
+تو اگر آپ کوئی فراہم نہیں کرتے تو **FastAPI** خودکار طور پر "Successful response" بنا دے گا۔
+
+///
+
+
+
+## *path operation* کو Deprecate کریں { #deprecate-a-path-operation }
+
+اگر آپ کو کسی *path operation* کو deprecated نشان زد کرنا ہو، لیکن اسے ہٹائے بغیر، تو `deprecated` parameter دیں:
+
+{* ../../docs_src/path_operation_configuration/tutorial006_py310.py hl[16] *}
+
+یہ interactive docs میں واضح طور پر deprecated نشان زد ہوگا:
+
+
+
+دیکھیں کہ deprecated اور غیر deprecated *path operations* کیسے نظر آتے ہیں:
+
+
+
+## خلاصہ { #recap }
+
+آپ *path operation decorators* میں parameters دے کر آسانی سے اپنے *path operations* کے لیے metadata configure اور شامل کر سکتے ہیں۔
diff --git a/docs/ur/docs/tutorial/path-params-numeric-validations.md b/docs/ur/docs/tutorial/path-params-numeric-validations.md
new file mode 100644
index 000000000..afc05c7b4
--- /dev/null
+++ b/docs/ur/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] *}
+
+/// info | معلومات
+
+FastAPI نے ورژن 0.95.0 میں `Annotated` کی تعاون شامل کی (اور اسے تجویز کرنا شروع کیا)۔
+
+اگر آپ کے پاس پرانا ورژن ہے، تو `Annotated` استعمال کرنے کی کوشش کرنے پر errors آئیں گی۔
+
+`Annotated` استعمال کرنے سے پہلے یقینی بنائیں کہ آپ [FastAPI ورژن اپ گریڈ کریں](../deployment/versions.md#upgrading-the-fastapi-versions) کم از کم 0.95.1 تک۔
+
+///
+
+## Metadata اعلان کریں { #declare-metadata }
+
+آپ `Query` کی طرح تمام وہی parameters اعلان کر سکتے ہیں۔
+
+مثال کے طور پر، path parameter `item_id` کے لیے `title` metadata قدر اعلان کرنے کے لیے آپ لکھ سکتے ہیں:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
+
+/// note | نوٹ
+
+Path parameter ہمیشہ لازمی ہوتا ہے کیونکہ یہ path کا حصہ ہونا ضروری ہے۔ چاہے آپ اسے `None` کے ساتھ اعلان کریں یا طے شدہ قدر سیٹ کریں، یہ کسی چیز پر اثر نہیں ڈالے گا، یہ پھر بھی ہمیشہ لازمی ہوگا۔
+
+///
+
+## Parameters کو اپنی ضرورت کے مطابق ترتیب دیں { #order-the-parameters-as-you-need }
+
+/// tip | مشورہ
+
+اگر آپ `Annotated` استعمال کرتے ہیں تو شاید یہ اتنا اہم یا ضروری نہیں ہے۔
+
+///
+
+فرض کریں کہ آپ query parameter `q` کو لازمی `str` کے طور پر اعلان کرنا چاہتے ہیں۔
+
+اور آپ کو اس parameter کے لیے کچھ اور اعلان کرنے کی ضرورت نہیں، تو آپ کو واقعی `Query` استعمال کرنے کی ضرورت نہیں۔
+
+لیکن آپ کو ابھی بھی `item_id` path parameter کے لیے `Path` استعمال کرنا ہے۔ اور آپ کسی وجہ سے `Annotated` استعمال نہیں کرنا چاہتے۔
+
+Python شکایت کرے گا اگر آپ "طے شدہ" والی قدر کو بغیر "طے شدہ" والی قدر سے پہلے رکھیں۔
+
+لیکن آپ انہیں دوبارہ ترتیب دے سکتے ہیں، اور بغیر طے شدہ والی قدر (query parameter `q`) کو پہلے رکھ سکتے ہیں۔
+
+**FastAPI** کے لیے اس سے فرق نہیں پڑتا۔ یہ parameters کو ان کے ناموں، اقسام اور طے شدہ اعلانات (`Query`، `Path` وغیرہ) سے پہچانے گا، ترتیب سے کوئی فرق نہیں پڑتا۔
+
+تو، آپ اپنا function اس طرح اعلان کر سکتے ہیں:
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_py310.py hl[7] *}
+
+لیکن یاد رکھیں کہ اگر آپ `Annotated` استعمال کرتے ہیں، تو آپ کو یہ مسئلہ نہیں ہوگا، کوئی فرق نہیں پڑتا کیونکہ آپ `Query()` یا `Path()` کے لیے function parameter طے شدہ اقدار استعمال نہیں کر رہے۔
+
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py310.py *}
+
+## Parameters کو اپنی ضرورت کے مطابق ترتیب دیں، ترکیبیں { #order-the-parameters-as-you-need-tricks }
+
+/// tip | مشورہ
+
+اگر آپ `Annotated` استعمال کرتے ہیں تو شاید یہ اتنا اہم یا ضروری نہیں ہے۔
+
+///
+
+یہاں ایک **چھوٹی ترکیب** ہے جو کام آ سکتی ہے، لیکن آپ کو اکثر اس کی ضرورت نہیں ہوگی۔
+
+اگر آپ چاہتے ہیں:
+
+* `q` query parameter کو `Query` یا کسی طے شدہ قدر کے بغیر اعلان کرنا
+* `item_id` path parameter کو `Path` استعمال کر کے اعلان کرنا
+* انہیں مختلف ترتیب میں رکھنا
+* `Annotated` استعمال نہ کرنا
+
+...Python میں اس کے لیے ایک خاص syntax ہے۔
+
+Function کے پہلے parameter کے طور پر `*` دیں۔
+
+Python اس `*` کے ساتھ کچھ نہیں کرے گا، لیکن یہ جان لے گا کہ تمام اگلے parameters کو keyword arguments (key-value جوڑوں) کے طور پر کال کیا جانا چاہیے، جنہیں kwargs بھی کہتے ہیں۔ چاہے ان کی طے شدہ قدر نہ ہو۔
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_py310.py hl[7] *}
+
+### `Annotated` کے ساتھ بہتر { #better-with-annotated }
+
+یاد رکھیں کہ اگر آپ `Annotated` استعمال کرتے ہیں، چونکہ آپ function parameter طے شدہ اقدار استعمال نہیں کر رہے، تو آپ کو یہ مسئلہ نہیں ہوگا، اور شاید آپ کو `*` استعمال کرنے کی ضرورت نہیں ہوگی۔
+
+{* ../../docs_src/path_params_numeric_validations/tutorial003_an_py310.py hl[10] *}
+
+## عددی validations: اس سے بڑا یا مساوی { #number-validations-greater-than-or-equal }
+
+`Query` اور `Path` (اور دوسرے جو آپ بعد میں دیکھیں گے) کے ساتھ آپ عددی حدود کا اعلان کر سکتے ہیں۔
+
+یہاں، `ge=1` کے ساتھ، `item_id` کو ایک integer نمبر ہونا ہوگا جو `1` سے "`g`reater than or `e`qual" ہو۔
+
+{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py310.py hl[10] *}
+
+## عددی validations: اس سے بڑا اور اس سے چھوٹا یا مساوی { #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] *}
+
+## عددی validations: floats، اس سے بڑا اور اس سے چھوٹا { #number-validations-floats-greater-than-and-less-than }
+
+عددی validations `float` اقدار کے لیے بھی کام کرتی ہیں۔
+
+یہاں جہاں یہ اہم ہو جاتا ہے کہ gt اعلان کر سکیں نہ کہ صرف ge۔ اس کے ساتھ آپ مثال کے طور پر تقاضا کر سکتے ہیں کہ قدر `0` سے بڑی ہونی چاہیے، چاہے یہ `1` سے کم ہو۔
+
+تو، `0.5` ایک درست قدر ہوگی۔ لیکن `0.0` یا `0` نہیں ہوگی۔
+
+اور lt کے لیے بھی یہی ہے۔
+
+{* ../../docs_src/path_params_numeric_validations/tutorial006_an_py310.py hl[13] *}
+
+## خلاصہ { #recap }
+
+`Query`، `Path` (اور دوسرے جو آپ نے ابھی نہیں دیکھے) کے ساتھ آپ [Query Parameters اور String Validations](query-params-str-validations.md) کی طرح ہی metadata اور string validations اعلان کر سکتے ہیں۔
+
+اور آپ عددی 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 (اس سے چھوٹا یا مساوی)
+
+/// info | معلومات
+
+`Query`، `Path`، اور دوسری classes جو آپ بعد میں دیکھیں گے ایک مشترک `Param` class کی ذیلی classes ہیں۔
+
+یہ سب اضافی توثیق اور metadata کے لیے وہی parameters شیئر کرتی ہیں جو آپ نے دیکھے ہیں۔
+
+///
+
+/// note | تکنیکی تفصیلات
+
+جب آپ `fastapi` سے `Query`، `Path` اور دوسرے import کرتے ہیں، تو وہ دراصل functions ہیں۔
+
+جب کال کیے جاتے ہیں، تو وہ اسی نام کی classes کے instances واپس کرتے ہیں۔
+
+تو، آپ `Query` import کرتے ہیں، جو ایک function ہے۔ اور جب آپ اسے کال کرتے ہیں، تو یہ `Query` نامی class کا بھی ایک instance واپس کرتا ہے۔
+
+یہ functions اس لیے ہیں (classes کو براہ راست استعمال کرنے کی بجائے) تاکہ آپ کا ایڈیٹر ان کی اقسام کے بارے میں errors نہ دکھائے۔
+
+اس طرح آپ ان errors کو نظرانداز کرنے کے لیے حسب ضرورت ترتیبات شامل کیے بغیر اپنا عام ایڈیٹر اور کوڈنگ ٹولز استعمال کر سکتے ہیں۔
+
+///
diff --git a/docs/ur/docs/tutorial/path-params.md b/docs/ur/docs/tutorial/path-params.md
new file mode 100644
index 000000000..82f9d88b9
--- /dev/null
+++ b/docs/ur/docs/tutorial/path-params.md
@@ -0,0 +1,251 @@
+# Path Parameters { #path-parameters }
+
+آپ Python format strings کی طرح syntax استعمال کر کے path "parameters" یا "variables" کا اعلان کر سکتے ہیں:
+
+{* ../../docs_src/path_params/tutorial001_py310.py hl[6:7] *}
+
+Path parameter `item_id` کی قدر آپ کے function میں argument `item_id` کے طور پر دی جائے گی۔
+
+تو، اگر آپ یہ مثال چلائیں اور [http://127.0.0.1:8000/items/foo](http://127.0.0.1:8000/items/foo) پر جائیں، آپ کو یہ response نظر آئے گا:
+
+```JSON
+{"item_id":"foo"}
+```
+
+## اقسام کے ساتھ Path parameters { #path-parameters-with-types }
+
+آپ معیاری Python type annotations استعمال کر کے function میں path parameter کی قسم کا اعلان کر سکتے ہیں:
+
+{* ../../docs_src/path_params/tutorial002_py310.py hl[7] *}
+
+اس صورت میں، `item_id` کو `int` ہونے کا اعلان کیا گیا ہے۔
+
+/// check
+
+یہ آپ کو function کے اندر ایڈیٹر سپورٹ دے گا، error checks، completion وغیرہ کے ساتھ۔
+
+///
+
+## ڈیٹا تبدیلی { #data-conversion }
+
+اگر آپ یہ مثال چلائیں اور اپنا براؤزر [http://127.0.0.1:8000/items/3](http://127.0.0.1:8000/items/3) پر کھولیں، آپ کو یہ response نظر آئے گا:
+
+```JSON
+{"item_id":3}
+```
+
+/// check
+
+غور کریں کہ آپ کے function نے جو قدر وصول کی (اور واپس کی) وہ `3` ہے، بطور Python `int`، نہ کہ string `"3"`۔
+
+تو، اس type declaration کے ساتھ، **FastAPI** آپ کو خودکار request "parsing" دیتا ہے۔
+
+///
+
+## ڈیٹا کی توثیق { #data-validation }
+
+لیکن اگر آپ براؤزر میں [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` کی قدر `"foo"` تھی، جو `int` نہیں ہے۔
+
+وہی error ظاہر ہوگی اگر آپ `int` کی بجائے `float` فراہم کریں، جیسے: [http://127.0.0.1:8000/items/4.2](http://127.0.0.1:8000/items/4.2)
+
+/// check
+
+تو، اسی Python type declaration کے ساتھ، **FastAPI** آپ کو ڈیٹا کی توثیق فراہم کرتا ہے۔
+
+غور کریں کہ error واضح طور پر بتاتی ہے کہ توثیق بالکل کس مقام پر ناکام ہوئی۔
+
+یہ آپ کی API کے ساتھ تعامل کرنے والے کوڈ کو تیار کرتے اور debug کرتے وقت ناقابل یقین حد تک مددگار ہے۔
+
+///
+
+## دستاویزات { #documentation }
+
+اور جب آپ اپنا براؤزر [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs) پر کھولیں، آپ کو ایک خودکار، انٹرایکٹو API دستاویز نظر آئے گی جیسے:
+
+
+
+/// check
+
+ایک بار پھر، صرف اسی Python type declaration کے ساتھ، **FastAPI** آپ کو خودکار، انٹرایکٹو دستاویزات فراہم کرتا ہے (Swagger UI کو مربوط کرتے ہوئے)۔
+
+غور کریں کہ path parameter کو integer ہونے کا اعلان کیا گیا ہے۔
+
+///
+
+## معیارات پر مبنی فوائد، متبادل دستاویزات { #standards-based-benefits-alternative-documentation }
+
+اور چونکہ تیار کردہ schema [OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md) معیار سے ہے، بہت سے مطابق ٹولز موجود ہیں۔
+
+اسی وجہ سے، **FastAPI** خود ایک متبادل API دستاویز فراہم کرتا ہے (ReDoc استعمال کرتے ہوئے)، جسے آپ [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc) پر دیکھ سکتے ہیں:
+
+
+
+اسی طرح، بہت سے مطابق ٹولز ہیں۔ بشمول بہت سی زبانوں کے لیے کوڈ جنریشن ٹولز۔
+
+## Pydantic { #pydantic }
+
+تمام ڈیٹا کی توثیق پردے کے پیچھے [Pydantic](https://docs.pydantic.dev/) کے ذریعے کی جاتی ہے، لہذا آپ کو اس سے تمام فوائد ملتے ہیں۔ اور آپ جانتے ہیں کہ آپ اچھے ہاتھوں میں ہیں۔
+
+آپ `str`، `float`، `bool` اور بہت سی دیگر پیچیدہ data types کے ساتھ وہی type declarations استعمال کر سکتے ہیں۔
+
+ان میں سے کئی ٹیوٹوریل کے اگلے ابواب میں دریافت کیے گئے ہیں۔
+
+## ترتیب اہم ہے { #order-matters }
+
+*Path operations* بناتے وقت، آپ کو ایسے حالات مل سکتے ہیں جہاں آپ کا ایک مقررہ path ہے۔
+
+جیسے `/users/me`، فرض کریں کہ یہ موجودہ صارف کا ڈیٹا حاصل کرنے کے لیے ہے۔
+
+اور پھر آپ کے پاس `/users/{user_id}` path بھی ہو سکتا ہے جو کسی مخصوص صارف کا ڈیٹا کسی user ID سے حاصل کرے۔
+
+چونکہ *path operations* ترتیب سے جانچے جاتے ہیں، آپ کو یقینی بنانا ہوگا کہ `/users/me` کا path `/users/{user_id}` سے پہلے اعلان کیا گیا ہے:
+
+{* ../../docs_src/path_params/tutorial003_py310.py hl[6,11] *}
+
+ورنہ، `/users/{user_id}` کا path `/users/me` کے لیے بھی مماثل ہوگا، یہ "سوچتے" ہوئے کہ اسے `"me"` قدر کے ساتھ parameter `user_id` مل رہا ہے۔
+
+اسی طرح، آپ path operation کو دوبارہ بیان نہیں کر سکتے:
+
+{* ../../docs_src/path_params/tutorial003b_py310.py hl[6,11] *}
+
+پہلا ہمیشہ استعمال ہوگا کیونکہ path پہلے مماثل ہوتا ہے۔
+
+## پہلے سے طے شدہ اقدار { #predefined-values }
+
+اگر آپ کے پاس ایک *path operation* ہے جو *path parameter* وصول کرتا ہے، لیکن آپ چاہتے ہیں کہ ممکنہ درست *path parameter* اقدار پہلے سے طے شدہ ہوں، تو آپ معیاری Python `Enum` استعمال کر سکتے ہیں۔
+
+### ایک `Enum` class بنائیں { #create-an-enum-class }
+
+`Enum` import کریں اور ایک ذیلی class بنائیں جو `str` اور `Enum` سے وراثت حاصل کرے۔
+
+`str` سے وراثت حاصل کرنے سے API docs جان سکیں گے کہ اقدار `string` قسم کی ہونی چاہییں اور صحیح طریقے سے ظاہر ہو سکیں گی۔
+
+پھر مقررہ اقدار کے ساتھ class attributes بنائیں، جو دستیاب درست اقدار ہوں گی:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[1,6:9] *}
+
+/// tip | مشورہ
+
+اگر آپ سوچ رہے ہیں، "AlexNet"، "ResNet"، اور "LeNet" بس Machine Learning models کے نام ہیں۔
+
+///
+
+### ایک *path parameter* کا اعلان کریں { #declare-a-path-parameter }
+
+پھر آپ نے بنائی ہوئی enum class (`ModelName`) کو type annotation کے طور پر استعمال کرتے ہوئے ایک *path parameter* بنائیں:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[16] *}
+
+### دستاویزات چیک کریں { #check-the-docs }
+
+چونکہ *path parameter* کے لیے دستیاب اقدار پہلے سے طے شدہ ہیں، انٹرایکٹو docs انہیں اچھے طریقے سے دکھا سکتے ہیں:
+
+
+
+### Python *enumerations* کے ساتھ کام کرنا { #working-with-python-enumerations }
+
+*Path parameter* کی قدر ایک *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` استعمال کر کے اصل قدر (اس صورت میں `str`) حاصل کر سکتے ہیں، یا عمومی طور پر، `your_enum_member.value`:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[20] *}
+
+/// tip | مشورہ
+
+آپ `"lenet"` قدر تک `ModelName.lenet.value` سے بھی رسائی حاصل کر سکتے ہیں۔
+
+///
+
+#### *Enumeration members* واپس کریں { #return-enumeration-members }
+
+آپ اپنے *path operation* سے *enum members* واپس کر سکتے ہیں، یہاں تک کہ JSON body میں nested (مثلاً ایک `dict`)۔
+
+انہیں client کو واپس کرنے سے پہلے ان کی متعلقہ اقدار (اس صورت میں strings) میں تبدیل کیا جائے گا:
+
+{* ../../docs_src/path_params/tutorial005_py310.py hl[18,21,23] *}
+
+آپ کے client کو JSON response کچھ ایسا ملے گا:
+
+```JSON
+{
+ "model_name": "alexnet",
+ "message": "Deep Learning FTW!"
+}
+```
+
+## Path parameters جن میں paths ہوں { #path-parameters-containing-paths }
+
+فرض کریں آپ کے پاس ایک *path operation* ہے جس کا path `/files/{file_path}` ہے۔
+
+لیکن آپ چاہتے ہیں کہ `file_path` میں خود ایک *path* ہو، جیسے `home/johndoe/myfile.txt`۔
+
+تو، اس فائل کا URL کچھ ایسا ہوگا: `/files/home/johndoe/myfile.txt`۔
+
+### OpenAPI سپورٹ { #openapi-support }
+
+OpenAPI میں *path parameter* کے اندر *path* رکھنے کا اعلان کرنے کا کوئی طریقہ نہیں ہے، کیونکہ اس سے ایسے منظرنامے پیدا ہو سکتے ہیں جنہیں ٹیسٹ اور بیان کرنا مشکل ہو۔
+
+بہرحال، آپ اسے **FastAPI** میں پھر بھی کر سکتے ہیں، Starlette کے اندرونی ٹولز میں سے ایک استعمال کر کے۔
+
+اور docs پھر بھی کام کریں گے، اگرچہ کوئی دستاویز شامل نہیں ہوگی جو بتائے کہ parameter میں path ہونا چاہیے۔
+
+### Path convertor { #path-convertor }
+
+Starlette سے براہ راست ایک آپشن استعمال کرتے ہوئے آپ *path parameter* کا اعلان کر سکتے ہیں جس میں *path* ہو، اس طرح کے URL کے ساتھ:
+
+```
+/files/{file_path:path}
+```
+
+اس صورت میں، parameter کا نام `file_path` ہے، اور آخری حصہ، `:path`، بتاتا ہے کہ parameter کو کسی بھی *path* سے مماثل ہونا چاہیے۔
+
+تو، آپ اسے اس طرح استعمال کر سکتے ہیں:
+
+{* ../../docs_src/path_params/tutorial004_py310.py hl[6] *}
+
+/// tip | مشورہ
+
+آپ کو parameter میں `/home/johndoe/myfile.txt` رکھنے کی ضرورت ہو سکتی ہے، ابتدائی سلیش (`/`) کے ساتھ۔
+
+اس صورت میں، URL ہوگا: `/files//home/johndoe/myfile.txt`، `files` اور `home` کے درمیان ڈبل سلیش (`//`) کے ساتھ۔
+
+///
+
+## خلاصہ { #recap }
+
+**FastAPI** کے ساتھ، مختصر، بدیہی اور معیاری Python type declarations استعمال کر کے، آپ کو ملتا ہے:
+
+* ایڈیٹر سپورٹ: error checks، autocompletion وغیرہ۔
+* ڈیٹا "parsing"
+* ڈیٹا کی توثیق
+* API تشریح اور خودکار دستاویزات
+
+اور آپ کو انہیں صرف ایک بار اعلان کرنا ہوتا ہے۔
+
+یہ شاید متبادل frameworks کے مقابلے میں **FastAPI** کا سب سے نمایاں فائدہ ہے (خام کارکردگی کے علاوہ)۔
diff --git a/docs/ur/docs/tutorial/query-param-models.md b/docs/ur/docs/tutorial/query-param-models.md
new file mode 100644
index 000000000..776f3c629
--- /dev/null
+++ b/docs/ur/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** کا ڈیٹا **extract** کرے گا اور آپ کو وہ Pydantic model دے گا جو آپ نے define کیا ہے۔
+
+## Docs چیک کریں { #check-the-docs }
+
+آپ `/docs` پر docs UI میں query parameters دیکھ سکتے ہیں:
+
+
+
+
+### Query parameter list / طے شدہ اقدار کے ساتھ متعدد اقدار { #query-parameter-list-multiple-values-with-defaults }
+
+اگر کوئی فراہم نہ کی جائے تو آپ اقدار کی طے شدہ `list` بھی بنا سکتے ہیں:
+
+{* ../../docs_src/query_params_str_validations/tutorial012_an_py310.py hl[9] *}
+
+اگر آپ یہاں جائیں:
+
+```
+http://localhost:8000/items/
+```
+
+`q` کی طے شدہ قدر ہوگی: `["foo", "bar"]` اور آپ کا response ہوگا:
+
+```JSON
+{
+ "q": [
+ "foo",
+ "bar"
+ ]
+}
+```
+
+#### صرف `list` استعمال کرنا { #using-just-list }
+
+آپ `list[str]` کی بجائے براہ راست `list` بھی استعمال کر سکتے ہیں:
+
+{* ../../docs_src/query_params_str_validations/tutorial013_an_py310.py hl[9] *}
+
+/// note | نوٹ
+
+یاد رکھیں کہ اس صورت میں، FastAPI list کے مندرجات کی جانچ نہیں کرے گا۔
+
+مثال کے طور پر، `list[int]` جانچے گا (اور دستاویز بنائے گا) کہ list کے مندرجات integers ہیں۔ لیکن اکیلا `list` ایسا نہیں کرے گا۔
+
+///
+
+## مزید metadata اعلان کریں { #declare-more-metadata }
+
+آپ parameter کے بارے میں مزید معلومات شامل کر سکتے ہیں۔
+
+وہ معلومات تیار کردہ OpenAPI میں شامل ہوں گی اور دستاویزاتی صارف انٹرفیسز اور بیرونی ٹولز کے ذریعے استعمال ہوں گی۔
+
+/// note | نوٹ
+
+یاد رکھیں کہ مختلف ٹولز میں OpenAPI تعاون کی مختلف سطحیں ہو سکتی ہیں۔
+
+ان میں سے کچھ شاید ابھی تک تمام اعلان کردہ اضافی معلومات نہ دکھائیں، اگرچہ زیادہ تر صورتوں میں، غائب خصوصیت پہلے سے ترقی کے لیے منصوبہ بند ہے۔
+
+///
+
+آپ `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` ایک درست Python variable نام نہیں ہے۔
+
+سب سے قریب ترین `item_query` ہوگا۔
+
+لیکن آپ کو ابھی بھی اسے بالکل `item-query` ہونا چاہیے...
+
+تو آپ ایک `alias` اعلان کر سکتے ہیں، اور وہ alias parameter کی قدر تلاش کرنے کے لیے استعمال ہوگا:
+
+{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
+
+## Parameters کو deprecated کرنا { #deprecating-parameters }
+
+فرض کریں آپ کو یہ parameter اب پسند نہیں۔
+
+آپ کو اسے کچھ وقت کے لیے رکھنا ہوگا کیونکہ clients اسے استعمال کر رہے ہیں، لیکن آپ چاہتے ہیں کہ docs واضح طور پر اسے deprecated دکھائیں۔
+
+پھر `Query` کو `deprecated=True` parameter دیں:
+
+{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
+
+Docs اسے اس طرح دکھائیں گے:
+
+
+
+## OpenAPI سے parameters خارج کریں { #exclude-parameters-from-openapi }
+
+تیار کردہ OpenAPI schema سے query parameter کو خارج کرنے کے لیے (اور اس طرح، خودکار دستاویزاتی نظاموں سے)، `Query` کا `include_in_schema` parameter `False` سیٹ کریں:
+
+{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+
+## حسب ضرورت Validation { #custom-validation }
+
+ایسے معاملات ہو سکتے ہیں جہاں آپ کو **حسب ضرورت توثیق** کی ضرورت ہو جو اوپر دکھائے گئے parameters سے نہیں ہو سکتی۔
+
+ان صورتوں میں، آپ ایک **حسب ضرورت validator function** استعمال کر سکتے ہیں جو عام توثیق کے بعد لاگو ہوتا ہے (مثلاً یہ توثیق کرنے کے بعد کہ قدر `str` ہے)۔
+
+آپ `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) اور دوسرے بھی ہیں۔
+
+///
+
+مثال کے طور پر، یہ حسب ضرورت validator جانچتا ہے کہ item ID ISBN کتاب نمبر کے لیے `isbn-` سے یا IMDB فلم URL ID کے لیے `imdb-` سے شروع ہوتا ہے:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
+
+/// info | معلومات
+
+یہ Pydantic ورژن 2 یا اس سے اوپر کے ساتھ دستیاب ہے۔
+
+///
+
+/// tip | مشورہ
+
+اگر آپ کو کسی ایسی توثیق کی ضرورت ہے جس کے لیے کسی **بیرونی جزو** سے بات چیت کرنی ہو، جیسے ڈیٹابیس یا کوئی اور API، تو آپ کو اس کی بجائے **FastAPI Dependencies** استعمال کرنی چاہییں، آپ ان کے بارے میں بعد میں سیکھیں گے۔
+
+یہ حسب ضرورت validators ان چیزوں کے لیے ہیں جو **صرف** request میں فراہم کردہ **اسی ڈیٹا** سے جانچی جا سکتی ہیں۔
+
+///
+
+### اس کوڈ کو سمجھیں { #understand-that-code }
+
+اہم نکتہ بس **`Annotated` کے اندر function کے ساتھ `AfterValidator`** استعمال کرنا ہے۔ اس حصے کو چھوڑنے میں کوئی حرج نہیں۔
+
+---
+
+لیکن اگر آپ اس مخصوص کوڈ مثال کے بارے میں جاننا چاہتے ہیں، تو یہاں کچھ اضافی تفصیلات ہیں۔
+
+#### `value.startswith()` کے ساتھ String { #string-with-value-startswith }
+
+کیا آپ نے غور کیا؟ `value.startswith()` استعمال کرنے والی string ایک tuple لے سکتی ہے، اور یہ tuple میں ہر قدر کو جانچے گی:
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
+
+#### ایک بے ترتیب آئٹم { #a-random-item }
+
+`data.items()` سے ہمیں ایک iterable object ملتا ہے جس میں ہر dictionary آئٹم کے لیے key اور value پر مشتمل tuples ہوتے ہیں۔
+
+ہم اس iterable object کو `list(data.items())` سے صحیح `list` میں تبدیل کرتے ہیں۔
+
+پھر `random.choice()` سے ہم list سے ایک **بے ترتیب قدر** حاصل کر سکتے ہیں، تو ہمیں `(id, name)` کے ساتھ ایک tuple ملتا ہے۔ یہ کچھ ایسا ہوگا جیسے `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`۔
+
+پھر ہم tuple کی وہ **دو اقدار** متغیرات `id` اور `name` کو **تفویض** کرتے ہیں۔
+
+تو، اگر صارف نے item ID فراہم نہیں کی، تو انہیں پھر بھی ایک بے ترتیب تجویز ملے گی۔
+
+...ہم یہ سب ایک **سادہ لائن** میں کرتے ہیں۔ کیا آپ کو Python پسند نہیں؟
+
+{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
+
+## خلاصہ { #recap }
+
+آپ اپنے parameters کے لیے اضافی validations اور metadata اعلان کر سکتے ہیں۔
+
+عمومی validations اور metadata:
+
+* `alias`
+* `title`
+* `description`
+* `deprecated`
+
+Strings کے لیے مخصوص validations:
+
+* `min_length`
+* `max_length`
+* `pattern`
+
+`AfterValidator` استعمال کر کے حسب ضرورت validations۔
+
+ان مثالوں میں آپ نے دیکھا کہ `str` اقدار کے لیے validations کیسے اعلان کیے جائیں۔
+
+اگلے ابواب دیکھیں تاکہ جانیں کہ دوسری اقسام، جیسے نمبروں کے لیے validations کیسے اعلان کیے جائیں۔
diff --git a/docs/ur/docs/tutorial/query-params.md b/docs/ur/docs/tutorial/query-params.md
new file mode 100644
index 000000000..edb41e6f1
--- /dev/null
+++ b/docs/ur/docs/tutorial/query-params.md
@@ -0,0 +1,188 @@
+# Query Parameters { #query-parameters }
+
+جب آپ دوسرے function parameters کا اعلان کرتے ہیں جو path parameters کا حصہ نہیں ہیں، تو وہ خودکار طور پر "query" parameters کے طور پر سمجھے جاتے ہیں۔
+
+{* ../../docs_src/query_params/tutorial001_py310.py hl[9] *}
+
+Query وہ key-value جوڑوں کا مجموعہ ہے جو URL میں `?` کے بعد آتے ہیں، `&` حروف سے الگ کیے گئے۔
+
+مثال کے طور پر، اس URL میں:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+...query parameters یہ ہیں:
+
+* `skip`: قدر `0` کے ساتھ
+* `limit`: قدر `10` کے ساتھ
+
+چونکہ یہ URL کا حصہ ہیں، یہ "قدرتی طور پر" strings ہیں۔
+
+لیکن جب آپ انہیں Python types کے ساتھ اعلان کرتے ہیں (اوپر کی مثال میں، `int` کے طور پر)، تو وہ اس قسم میں تبدیل اور اس کے خلاف توثیق ہو جاتے ہیں۔
+
+وہ تمام عمل جو path parameters پر لاگو ہوتا ہے query parameters پر بھی لاگو ہوتا ہے:
+
+* ایڈیٹر سپورٹ (ظاہر ہے)
+* ڈیٹا "parsing"
+* ڈیٹا کی توثیق
+* خودکار دستاویزات
+
+## طے شدہ اقدار { #defaults }
+
+چونکہ query parameters path کا مقررہ حصہ نہیں ہیں، وہ اختیاری ہو سکتے ہیں اور طے شدہ اقدار رکھ سکتے ہیں۔
+
+اوپر کی مثال میں ان کی طے شدہ اقدار `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 اقدار ہوں گی:
+
+* `skip=20`: کیونکہ آپ نے URL میں یہ سیٹ کیا
+* `limit=10`: کیونکہ یہ طے شدہ قدر تھی
+
+## اختیاری parameters { #optional-parameters }
+
+اسی طرح، آپ اختیاری query parameters کا اعلان کر سکتے ہیں، ان کی طے شدہ قدر `None` سیٹ کر کے:
+
+{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
+
+اس صورت میں، function parameter `q` اختیاری ہوگا، اور پہلے سے `None` ہوگا۔
+
+/// check
+
+یہ بھی نوٹ کریں کہ **FastAPI** اتنا ذہین ہے کہ وہ جان لے کہ path parameter `item_id` ایک path parameter ہے اور `q` نہیں ہے، لہذا یہ query parameter ہے۔
+
+///
+
+## Query parameter type کی تبدیلی { #query-parameter-type-conversion }
+
+آپ `bool` types کا بھی اعلان کر سکتے ہیں، اور وہ تبدیل ہو جائیں گے:
+
+{* ../../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
+```
+
+یا کوئی بھی دوسری حروف کی تبدیلی (بڑے حروف، پہلا حرف بڑا وغیرہ)، آپ کا function `short` parameter کو `bool` قدر `True` کے ساتھ دیکھے گا۔ ورنہ `False`۔
+
+
+## متعدد path اور query parameters { #multiple-path-and-query-parameters }
+
+آپ ایک ساتھ متعدد path parameters اور query parameters کا اعلان کر سکتے ہیں، **FastAPI** جانتا ہے کون سا کون سا ہے۔
+
+اور آپ کو انہیں کسی مخصوص ترتیب میں اعلان کرنے کی ضرورت نہیں۔
+
+وہ نام سے پہچانے جائیں گے:
+
+{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
+
+## لازمی query parameters { #required-query-parameters }
+
+جب آپ غیر path parameters (ابھی تک ہم نے صرف query parameters دیکھے ہیں) کے لیے طے شدہ قدر کا اعلان کرتے ہیں، تو یہ لازمی نہیں ہوتا۔
+
+اگر آپ کوئی مخصوص قدر شامل نہیں کرنا چاہتے لیکن اسے اختیاری بنانا چاہتے ہیں، تو طے شدہ قدر `None` سیٹ کریں۔
+
+لیکن جب آپ query parameter کو لازمی بنانا چاہتے ہیں، تو آپ کوئی طے شدہ قدر اعلان نہ کریں:
+
+{* ../../docs_src/query_params/tutorial005_py310.py hl[6:7] *}
+
+یہاں query parameter `needy` ایک لازمی query parameter ہے جس کی قسم `str` ہے۔
+
+اگر آپ اپنے براؤزر میں یہ URL کھولیں:
+
+```
+http://127.0.0.1:8000/items/foo-item
+```
+
+...لازمی parameter `needy` شامل کیے بغیر، آپ کو یہ error نظر آئے گی:
+
+```JSON
+{
+ "detail": [
+ {
+ "type": "missing",
+ "loc": [
+ "query",
+ "needy"
+ ],
+ "msg": "Field required",
+ "input": null
+ }
+ ]
+}
+```
+
+چونکہ `needy` ایک لازمی parameter ہے، آپ کو اسے URL میں سیٹ کرنا ہوگا:
+
+```
+http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
+```
+
+...یہ کام کرے گا:
+
+```JSON
+{
+ "item_id": "foo-item",
+ "needy": "sooooneedy"
+}
+```
+
+اور یقیناً، آپ کچھ parameters کو لازمی، کچھ کو طے شدہ قدر کے ساتھ، اور کچھ کو مکمل طور پر اختیاری بنا سکتے ہیں:
+
+{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
+
+اس صورت میں، 3 query parameters ہیں:
+
+* `needy`، ایک لازمی `str`۔
+* `skip`، ایک `int` جس کی طے شدہ قدر `0` ہے۔
+* `limit`، ایک اختیاری `int`۔
+
+/// tip | مشورہ
+
+آپ `Enum`s بھی اسی طرح استعمال کر سکتے ہیں جیسے [Path Parameters](path-params.md#predefined-values) کے ساتھ۔
+
+///
diff --git a/docs/ur/docs/tutorial/request-files.md b/docs/ur/docs/tutorial/request-files.md
new file mode 100644
index 000000000..558aed1f0
--- /dev/null
+++ b/docs/ur/docs/tutorial/request-files.md
@@ -0,0 +1,176 @@
+# Request Files { #request-files }
+
+آپ `File` استعمال کر کے client کی جانب سے upload کی جانے والی files کی وضاحت کر سکتے ہیں۔
+
+/// info
+
+Upload کی گئی files وصول کرنے کے لیے پہلے [`python-multipart`](https://github.com/Kludex/python-multipart) انسٹال کریں۔
+
+یقینی بنائیں کہ آپ ایک [virtual environment](../virtual-environments.md) بنائیں، اسے فعال کریں، اور پھر اسے انسٹال کریں، مثال کے طور پر:
+
+```console
+$ pip install python-multipart
+```
+
+یہ اس لیے ضروری ہے کیونکہ upload کی گئی 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] *}
+
+/// info
+
+`File` ایک class ہے جو براہ راست `Form` سے inherit ہوتی ہے۔
+
+لیکن یاد رکھیں کہ جب آپ `fastapi` سے `Query`، `Path`، `File` اور دوسرے import کرتے ہیں تو یہ دراصل functions ہیں جو خاص classes واپس کرتے ہیں۔
+
+///
+
+/// tip | مشورہ
+
+File bodies بیان کرنے کے لیے آپ کو `File` استعمال کرنا ہوگا، کیونکہ ورنہ parameters کو query parameters یا body (JSON) parameters سمجھا جائے گا۔
+
+///
+
+Files "form data" کے طور پر upload ہوں گی۔
+
+اگر آپ اپنے *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] *}
+
+`UploadFile` استعمال کرنے کے `bytes` کے مقابلے میں کئی فوائد ہیں:
+
+* آپ کو parameter کی default value میں `File()` استعمال کرنے کی ضرورت نہیں۔
+* یہ ایک "spooled" file استعمال کرتا ہے:
+ * ایک مخصوص حد تک memory میں محفوظ ہونے والی file، اور اس حد سے گزرنے کے بعد یہ disk پر محفوظ ہو جائے گی۔
+* اس کا مطلب ہے کہ یہ بڑی files جیسے تصاویر، ویڈیوز، بڑی binaries وغیرہ کے لیے تمام memory استعمال کیے بغیر اچھا کام کرے گا۔
+* آپ upload کی گئی 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 فراہم کرتا ہے جسے آپ براہ راست ان دوسری libraries کو دے سکتے ہیں جو file-like object کی توقع رکھتی ہیں۔
+
+### `UploadFile` { #uploadfile }
+
+`UploadFile` کے درج ذیل attributes ہیں:
+
+* `filename`: ایک `str` جس میں upload کی گئی اصل file کا نام ہوتا ہے (مثلاً `myimage.jpg`)۔
+* `content_type`: ایک `str` جس میں content type (MIME type / media type) ہوتا ہے (مثلاً `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 ہیں۔ یہ سب اندرونی `SpooledTemporaryFile` استعمال کرتے ہوئے متعلقہ file methods کو call کرتے ہیں۔
+
+* `write(data)`: File میں `data` (`str` یا `bytes`) لکھتا ہے۔
+* `read(size)`: File کے `size` (`int`) bytes/characters پڑھتا ہے۔
+* `seek(offset)`: File میں byte position `offset` (`int`) پر جاتا ہے۔
+ * مثلاً `await myfile.seek(0)` file کے شروع میں لے جائے گا۔
+ * یہ خاص طور پر مفید ہے اگر آپ `await myfile.read()` ایک بار چلائیں اور پھر مواد دوبارہ پڑھنا چاہیں۔
+* `close()`: File کو بند کرتا ہے۔
+
+چونکہ یہ سب `async` methods ہیں، آپ کو انہیں "await" کرنا ہوگا۔
+
+مثال کے طور پر، ایک `async` *path operation function* کے اندر آپ مواد اس طرح حاصل کر سکتے ہیں:
+
+```Python
+contents = await myfile.read()
+```
+
+اگر آپ ایک عام `def` *path operation function* کے اندر ہیں تو آپ `UploadFile.file` تک براہ راست رسائی حاصل کر سکتے ہیں، مثال کے طور پر:
+
+```Python
+contents = myfile.file.read()
+```
+
+/// note | `async` تکنیکی تفصیلات
+
+جب آپ `async` methods استعمال کرتے ہیں تو **FastAPI** file methods کو ایک threadpool میں چلاتا ہے اور ان کا انتظار کرتا ہے۔
+
+///
+
+/// note | Starlette تکنیکی تفصیلات
+
+**FastAPI** کا `UploadFile` براہ راست **Starlette** کے `UploadFile` سے inherit ہوتا ہے، لیکن اسے **Pydantic** اور FastAPI کے دوسرے حصوں کے ساتھ مطابقت پذیر بنانے کے لیے کچھ ضروری حصے شامل کرتا ہے۔
+
+///
+
+## "Form Data" کیا ہے { #what-is-form-data }
+
+HTML forms (``) جس طرح سے server کو data بھیجتے ہیں وہ عام طور پر اس data کے لیے ایک "خاص" encoding استعمال کرتے ہیں، جو JSON سے مختلف ہوتی ہے۔
+
+**FastAPI** اس data کو JSON کی بجائے صحیح جگہ سے پڑھنے کو یقینی بنائے گا۔
+
+/// note | تکنیکی تفصیلات
+
+Forms سے آنے والا data عام طور پر "media type" `application/x-www-form-urlencoded` کے ساتھ encode ہوتا ہے جب اس میں files شامل نہ ہوں۔
+
+لیکن جب form میں files شامل ہوں تو یہ `multipart/form-data` کے طور پر encode ہوتا ہے۔ اگر آپ `File` استعمال کرتے ہیں تو **FastAPI** جان لے گا کہ اسے body کے صحیح حصے سے files حاصل کرنی ہیں۔
+
+اگر آپ ان encodings اور form fields کے بارے میں مزید پڑھنا چاہتے ہیں تو [MDN web docs for `POST`](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` کے ساتھ encode ہوگا۔
+
+یہ **FastAPI** کی کوئی حد نہیں ہے، یہ HTTP protocol کا حصہ ہے۔
+
+///
+
+## اختیاری File Upload { #optional-file-upload }
+
+آپ معیاری type annotations استعمال کر کے اور `None` کی default value مقرر کر کے file کو اختیاری بنا سکتے ہیں:
+
+{* ../../docs_src/request_files/tutorial001_02_an_py310.py hl[9,17] *}
+
+## اضافی Metadata کے ساتھ `UploadFile` { #uploadfile-with-additional-metadata }
+
+آپ `File()` کو `UploadFile` کے ساتھ بھی استعمال کر سکتے ہیں، مثال کے طور پر، اضافی metadata مقرر کرنے کے لیے:
+
+{* ../../docs_src/request_files/tutorial001_03_an_py310.py hl[9,15] *}
+
+## متعدد File Uploads { #multiple-file-uploads }
+
+ایک ہی وقت میں کئی files upload کرنا ممکن ہے۔
+
+وہ "form data" استعمال کرتے ہوئے بھیجے گئے ایک ہی "form field" سے منسلک ہوں گی۔
+
+اس کے لیے `bytes` یا `UploadFile` کی ایک list بیان کریں:
+
+{* ../../docs_src/request_files/tutorial002_an_py310.py hl[10,15] *}
+
+آپ کو، جیسا کہ بیان کیا گیا ہے، `bytes` یا `UploadFile` کی ایک `list` ملے گی۔
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette.responses import HTMLResponse` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** آپ کی سہولت کے لیے وہی `starlette.responses` بطور `fastapi.responses` فراہم کرتا ہے۔ لیکن زیادہ تر دستیاب responses براہ راست Starlette سے آتے ہیں۔
+
+///
+
+### اضافی Metadata کے ساتھ متعدد File Uploads { #multiple-file-uploads-with-additional-metadata }
+
+اور پہلے کی طرح، آپ `File()` استعمال کر کے اضافی parameters مقرر کر سکتے ہیں، حتیٰ کہ `UploadFile` کے لیے بھی:
+
+{* ../../docs_src/request_files/tutorial003_an_py310.py hl[11,18:20] *}
+
+## خلاصہ { #recap }
+
+Request میں form data کے طور پر upload ہونے والی files بیان کرنے کے لیے `File`، `bytes`، اور `UploadFile` استعمال کریں۔
diff --git a/docs/ur/docs/tutorial/request-form-models.md b/docs/ur/docs/tutorial/request-form-models.md
new file mode 100644
index 000000000..0d55ec620
--- /dev/null
+++ b/docs/ur/docs/tutorial/request-form-models.md
@@ -0,0 +1,78 @@
+# Form Models { #form-models }
+
+آپ FastAPI میں **form fields** بیان کرنے کے لیے **Pydantic models** استعمال کر سکتے ہیں۔
+
+/// info
+
+Forms استعمال کرنے کے لیے پہلے [`python-multipart`](https://github.com/Kludex/python-multipart) انسٹال کریں۔
+
+یقینی بنائیں کہ آپ ایک [virtual environment](../virtual-environments.md) بنائیں، اسے فعال کریں، اور پھر اسے انسٹال کریں، مثال کے طور پر:
+
+```console
+$ pip install python-multipart
+```
+
+///
+
+/// note | نوٹ
+
+یہ FastAPI version `0.113.0` سے تعاون یافتہ ہے۔ 🤓
+
+///
+
+## Forms کے لیے Pydantic Models { #pydantic-models-for-forms }
+
+آپ کو صرف ایک **Pydantic model** بنانا ہوگا جس میں وہ fields ہوں جو آپ **form fields** کے طور پر وصول کرنا چاہتے ہیں، اور پھر parameter کو `Form` کے طور پر بیان کریں:
+
+{* ../../docs_src/request_form_models/tutorial001_an_py310.py hl[9:11,15] *}
+
+**FastAPI** request میں موجود **form data** سے **ہر field** کا data **نکالے** گا اور آپ کو آپ کا بیان کردہ Pydantic model دے گا۔
+
+## Docs چیک کریں { #check-the-docs }
+
+آپ `/docs` پر docs UI میں اس کی تصدیق کر سکتے ہیں:
+
+
+
+
+اور دونوں models انٹرایکٹو API documentation میں استعمال ہوں گے:
+
+
+
+## دیگر Return Type Annotations { #other-return-type-annotations }
+
+ایسے معاملات ہو سکتے ہیں جہاں آپ کوئی ایسی چیز واپس کرتے ہیں جو درست Pydantic field نہیں ہے اور آپ اسے function میں صرف ٹولنگ (editor، mypy، وغیرہ) سے سہولت حاصل کرنے کے لیے annotate کرتے ہیں۔
+
+### براہ راست Response واپس کریں { #return-a-response-directly }
+
+سب سے عام معاملہ [براہ راست Response واپس کرنا ہوگا جیسا کہ بعد میں ایڈوانسڈ docs میں بیان ہوا ہے](../advanced/response-directly.md)۔
+
+{* ../../docs_src/response_model/tutorial003_02_py310.py hl[8,10:11] *}
+
+یہ سادہ معاملہ FastAPI خودکار طور پر handle کرتا ہے کیونکہ return type annotation وہ class (یا `Response` کی subclass) ہے۔
+
+اور ٹولز بھی خوش ہوں گے کیونکہ `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 خودکار طور پر اس سادہ معاملے کو handle کرے گا۔
+
+### غلط Return Type Annotations { #invalid-return-type-annotations }
+
+لیکن جب آپ کوئی اور اختیاری object واپس کرتے ہیں جو درست Pydantic type نہیں ہے (مثلاً database object) اور آپ اسے function میں اسی طرح annotate کرتے ہیں، تو FastAPI اس type annotation سے Pydantic response model بنانے کی کوشش کرے گا، اور ناکام ہو جائے گا۔
+
+یہی ہوگا اگر آپ کے پاس مختلف types کے درمیان union ہو جہاں ایک یا زیادہ درست Pydantic types نہ ہوں، مثلاً یہ ناکام ہو جائے گا 💥:
+
+{* ../../docs_src/response_model/tutorial003_04_py310.py hl[8] *}
+
+...یہ اس لیے ناکام ہوتا ہے کیونکہ type annotation ایک Pydantic type نہیں ہے اور صرف ایک `Response` class یا subclass بھی نہیں ہے، یہ `Response` اور `dict` کے درمیان union (دونوں میں سے کوئی ایک) ہے۔
+
+### Response Model غیر فعال کریں { #disable-response-model }
+
+اوپر کی مثال سے آگے بڑھتے ہوئے، شاید آپ وہ ڈیفالٹ ڈیٹا validation، documentation، filtering وغیرہ نہ چاہیں جو FastAPI کرتا ہے۔
+
+لیکن آپ شاید function میں return type annotation رکھنا چاہیں تاکہ editors اور type checkers (مثلاً mypy) جیسے ٹولز سے سہولت ملتی رہے۔
+
+اس صورت میں، آپ `response_model=None` سیٹ کر کے response model generation غیر فعال کر سکتے ہیں:
+
+{* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
+
+اس سے FastAPI response model generation چھوڑ دے گا اور اس طرح آپ جو بھی 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 ہے: `[]`۔
+
+لیکن آپ انہیں نتیجے سے خارج کرنا چاہ سکتے ہیں اگر وہ دراصل ذخیرہ نہیں کیے گئے تھے۔
+
+مثال کے طور پر، اگر آپ کے پاس 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` سیٹ کر سکتے ہیں:
+
+{* ../../docs_src/response_model/tutorial004_py310.py hl[22] *}
+
+اور وہ default values response میں شامل نہیں ہوں گی، صرف وہ قدریں شامل ہوں گی جو واقعی سیٹ کی گئی تھیں۔
+
+تو اگر آپ اس *path operation* کو ID `foo` والے item کے لیے request بھیجیں، تو response (default values شامل کیے بغیر) یہ ہوگا:
+
+```JSON
+{
+ "name": "Foo",
+ "price": 50.2
+}
+```
+
+/// info | معلومات
+
+آپ یہ بھی استعمال کر سکتے ہیں:
+
+* `response_model_exclude_defaults=True`
+* `response_model_exclude_none=True`
+
+جیسا کہ [Pydantic docs](https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict) میں `exclude_defaults` اور `exclude_none` کے لیے بیان ہے۔
+
+///
+
+#### Default values والے fields کے لیے ڈیٹا { #data-with-values-for-fields-with-defaults }
+
+لیکن اگر آپ کے ڈیٹا میں model کے default values والے fields کے لیے قدریں ہیں، جیسے ID `bar` والا item:
+
+```Python hl_lines="3 5"
+{
+ "name": "Bar",
+ "description": "The bartenders",
+ "price": 62,
+ "tax": 20.2
+}
+```
+
+تو وہ response میں شامل ہوں گی۔
+
+#### Defaults جیسی ہی قدروں والا ڈیٹا { #data-with-the-same-values-as-the-defaults }
+
+اگر ڈیٹا میں default values جیسی ہی قدریں ہیں، جیسے ID `baz` والا item:
+
+```Python hl_lines="3 5-6"
+{
+ "name": "Baz",
+ "description": None,
+ "price": 50.2,
+ "tax": 10.5,
+ "tags": []
+}
+```
+
+FastAPI اتنا ذہین ہے (دراصل Pydantic اتنا ذہین ہے) کہ سمجھ لے کہ، اگرچہ `description`، `tax`، اور `tags` کی قدریں defaults جیسی ہیں، وہ واضح طور پر سیٹ کی گئی تھیں (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` بھی استعمال کر سکتے ہیں۔
+
+یہ `str` کا ایک `set` لیتے ہیں جن میں شامل کرنے (باقی چھوڑنے) یا خارج کرنے (باقی شامل کرنے) والے attributes کے نام ہوتے ہیں۔
+
+اگر آپ کے پاس صرف ایک Pydantic model ہے اور آپ آؤٹ پٹ سے کچھ ڈیٹا ہٹانا چاہتے ہیں تو اسے فوری شارٹ کٹ کے طور پر استعمال کیا جا سکتا ہے۔
+
+/// tip | مشورہ
+
+لیکن پھر بھی مشورہ یہ ہے کہ ان parameters کی بجائے اوپر بیان کیے گئے خیالات استعمال کریں، یعنی متعدد classes۔
+
+اس کی وجہ یہ ہے کہ آپ کی ایپ کے OpenAPI میں تیار ہونے والا JSON Schema (اور docs) پھر بھی مکمل model کا ہوگا، چاہے آپ `response_model_include` یا `response_model_exclude` استعمال کر کے کچھ attributes ہٹا دیں۔
+
+یہ `response_model_by_alias` پر بھی لاگو ہوتا ہے جو اسی طرح کام کرتا ہے۔
+
+///
+
+{* ../../docs_src/response_model/tutorial005_py310.py hl[29,35] *}
+
+/// tip | مشورہ
+
+`{"name", "description"}` کی ترکیب ان دو قدروں کے ساتھ ایک `set` بناتی ہے۔
+
+یہ `set(["name", "description"])` کے برابر ہے۔
+
+///
+
+#### `set`s کی بجائے `list`s کا استعمال { #using-lists-instead-of-sets }
+
+اگر آپ `set` استعمال کرنا بھول جائیں اور `list` یا `tuple` استعمال کر لیں، تو FastAPI پھر بھی اسے `set` میں تبدیل کرے گا اور درست طریقے سے کام کرے گا:
+
+{* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
+
+## خلاصہ { #recap }
+
+*path operation decorator* کا parameter `response_model` استعمال کریں تاکہ response models define کریں اور خاص طور پر نجی ڈیٹا فلٹر ہونا یقینی بنائیں۔
+
+صرف واضح طور پر سیٹ کی گئی قدریں واپس کرنے کے لیے `response_model_exclude_unset` استعمال کریں۔
diff --git a/docs/ur/docs/tutorial/response-status-code.md b/docs/ur/docs/tutorial/response-status-code.md
new file mode 100644
index 000000000..64ff414b8
--- /dev/null
+++ b/docs/ur/docs/tutorial/response-status-code.md
@@ -0,0 +1,101 @@
+# Response Status Code { #response-status-code }
+
+جس طرح آپ response model بیان کر سکتے ہیں، اسی طرح آپ کسی بھی *path operation* میں `status_code` parameter کے ساتھ response کے لیے استعمال ہونے والا HTTP status code بھی بیان کر سکتے ہیں:
+
+* `@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* کا نہیں، جیسے کہ تمام parameters اور body ہیں۔
+
+///
+
+`status_code` parameter ایک نمبر وصول کرتا ہے جس میں HTTP status code ہوتا ہے۔
+
+/// info | معلومات
+
+`status_code` متبادل طور پر ایک `IntEnum` بھی قبول کر سکتا ہے، جیسے Python کا [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus)۔
+
+///
+
+یہ:
+
+* Response میں وہ status code واپس کرے گا۔
+* OpenAPI schema میں اسے اسی طرح document کرے گا (اور اس طرح، user interfaces میں بھی):
+
+
+
+/// note | نوٹ
+
+کچھ response codes (اگلا سیکشن دیکھیں) یہ ظاہر کرتے ہیں کہ response میں کوئی body نہیں ہے۔
+
+FastAPI یہ جانتا ہے، اور OpenAPI docs تیار کرے گا جو بتائیں گے کہ response body نہیں ہے۔
+
+///
+
+## HTTP status codes کے بارے میں { #about-http-status-codes }
+
+/// note | نوٹ
+
+اگر آپ پہلے سے جانتے ہیں کہ HTTP status codes کیا ہیں تو اگلے سیکشن پر جائیں۔
+
+///
+
+HTTP میں، آپ response کے حصے کے طور پر 3 ہندسوں کا ایک عددی status code بھیجتے ہیں۔
+
+ان status codes کا ایک نام ہوتا ہے جو انہیں پہچاننے کے لیے ہے، لیکن اہم حصہ نمبر ہے۔
+
+مختصراً:
+
+* `100 - 199` "معلومات" کے لیے ہیں۔ آپ انہیں شاذ و نادر ہی براہ راست استعمال کرتے ہیں۔ ان status codes والے responses میں body نہیں ہو سکتا۔
+* **`200 - 299`** "کامیاب" responses کے لیے ہیں۔ آپ انہیں سب سے زیادہ استعمال کریں گے۔
+ * `200` پہلے سے طے شدہ status code ہے، جس کا مطلب ہے سب کچھ "ٹھیک" تھا۔
+ * ایک اور مثال `201`، "Created" ہے۔ یہ عام طور پر database میں نیا record بنانے کے بعد استعمال ہوتا ہے۔
+ * ایک خاص صورت `204`، "No Content" ہے۔ یہ response تب استعمال ہوتا ہے جب client کو واپس کرنے کے لیے کوئی مواد نہ ہو، اس لیے response میں body نہیں ہونا چاہیے۔
+* **`300 - 399`** "Redirection" کے لیے ہیں۔ ان status codes والے responses میں body ہو بھی سکتا ہے اور نہیں بھی، سوائے `304`، "Not Modified" کے، جس میں body نہیں ہونا چاہیے۔
+* **`400 - 499`** "Client error" responses کے لیے ہیں۔ یہ دوسری قسم ہے جو آپ شاید سب سے زیادہ استعمال کریں گے۔
+ * ایک مثال `404` ہے، "Not Found" response کے لیے۔
+ * Client کی عمومی errors کے لیے آپ صرف `400` استعمال کر سکتے ہیں۔
+* `500 - 599` server errors کے لیے ہیں۔ آپ تقریباً کبھی انہیں براہ راست استعمال نہیں کرتے۔ جب آپ کے application code یا server میں کسی حصے میں کچھ غلط ہو جاتا ہے تو یہ خودکار طور پر ان میں سے ایک status code واپس کرے گا۔
+
+/// tip | مشورہ
+
+ہر status code کے بارے میں مزید جاننے کے لیے اور کون سا code کس کے لیے ہے، [MDN documentation about HTTP status codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) دیکھیں۔
+
+///
+
+## نام یاد رکھنے کا آسان طریقہ { #shortcut-to-remember-the-names }
+
+آئیے پچھلی مثال دوبارہ دیکھتے ہیں:
+
+{* ../../docs_src/response_status_code/tutorial001_py310.py hl[6] *}
+
+`201` "Created" کا status code ہے۔
+
+لیکن آپ کو ان میں سے ہر ایک code کا مطلب یاد رکھنے کی ضرورت نہیں۔
+
+آپ `fastapi.status` سے آسان variables استعمال کر سکتے ہیں۔
+
+{* ../../docs_src/response_status_code/tutorial002_py310.py hl[1,6] *}
+
+یہ صرف ایک سہولت ہے، ان میں وہی نمبر ہے، لیکن اس طرح آپ انہیں تلاش کرنے کے لیے editor کا autocomplete استعمال کر سکتے ہیں:
+
+
+
+/// note | تکنیکی تفصیلات
+
+آپ `from starlette import status` بھی استعمال کر سکتے ہیں۔
+
+**FastAPI** آپ کی سہولت کے لیے وہی `starlette.status` بطور `fastapi.status` فراہم کرتا ہے۔ لیکن یہ براہ راست Starlette سے آتا ہے۔
+
+///
+
+## پہلے سے طے شدہ کو تبدیل کرنا { #changing-the-default }
+
+بعد میں، [Advanced User Guide](../advanced/response-change-status-code.md) میں، آپ دیکھیں گے کہ یہاں بیان کردہ پہلے سے طے شدہ status code سے مختلف status code کیسے واپس کیا جائے۔
diff --git a/docs/ur/docs/tutorial/schema-extra-example.md b/docs/ur/docs/tutorial/schema-extra-example.md
new file mode 100644
index 000000000..b55e6c3e5
--- /dev/null
+++ b/docs/ur/docs/tutorial/schema-extra-example.md
@@ -0,0 +1,202 @@
+# Request Example Data Declare کریں { #declare-request-example-data }
+
+آپ اپنی ایپ کو موصول ہونے والے ڈیٹا کی مثالیں declare کر سکتے ہیں۔
+
+یہاں ایسا کرنے کے کئی طریقے ہیں۔
+
+## Pydantic models میں اضافی JSON Schema ڈیٹا { #extra-json-schema-data-in-pydantic-models }
+
+آپ Pydantic model کے لیے `examples` declare کر سکتے ہیں جو تیار کردہ JSON Schema میں شامل ہوں گی۔
+
+{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
+
+وہ اضافی معلومات جوں کی توں اس model کے آؤٹ پٹ **JSON Schema** میں شامل ہوں گی، اور API docs میں استعمال ہوں گی۔
+
+آپ `model_config` attribute استعمال کر سکتے ہیں جو ایک `dict` لیتا ہے جیسا کہ [Pydantic کے docs: Configuration](https://docs.pydantic.dev/latest/api/config/) میں بیان ہے۔
+
+آپ `"json_schema_extra"` کو ایک `dict` کے ساتھ سیٹ کر سکتے ہیں جس میں کوئی بھی اضافی ڈیٹا ہو جو آپ تیار کردہ JSON Schema میں دکھانا چاہتے ہیں، بشمول `examples`۔
+
+/// tip | مشورہ
+
+آپ اسی تکنیک کو JSON Schema کو بڑھانے اور اپنی مرضی کی اضافی معلومات شامل کرنے کے لیے استعمال کر سکتے ہیں۔
+
+مثال کے طور پر آپ اسے frontend user interface کے لیے metadata شامل کرنے وغیرہ کے لیے استعمال کر سکتے ہیں۔
+
+///
+
+/// info | معلومات
+
+OpenAPI 3.1.0 (جو FastAPI 0.99.0 سے استعمال ہو رہا ہے) نے `examples` کی سپورٹ شامل کی، جو **JSON Schema** معیار کا حصہ ہے۔
+
+اس سے پہلے، یہ صرف `example` keyword کو ایک واحد مثال کے ساتھ سپورٹ کرتا تھا۔ یہ ابھی بھی OpenAPI 3.1.0 سے supported ہے، لیکن deprecated ہے اور JSON Schema معیار کا حصہ نہیں ہے۔ لہذا آپ کو `example` سے `examples` میں منتقل ہونے کی ترغیب دی جاتی ہے۔ 🤓
+
+آپ اس صفحے کے آخر میں مزید پڑھ سکتے ہیں۔
+
+///
+
+## `Field` کے اضافی arguments { #field-additional-arguments }
+
+Pydantic models کے ساتھ `Field()` استعمال کرتے وقت، آپ اضافی `examples` بھی declare کر سکتے ہیں:
+
+{* ../../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` کا ایک گروپ بھی declare کر سکتے ہیں جو **OpenAPI** کے اندر ان کے **JSON Schemas** میں شامل ہوں گے۔
+
+### `examples` کے ساتھ `Body` { #body-with-examples }
+
+یہاں ہم `Body()` میں متوقع ڈیٹا کی ایک مثال پر مشتمل `examples` پاس کر رہے ہیں:
+
+{* ../../docs_src/schema_extra_example/tutorial003_an_py310.py hl[22:29] *}
+
+### Docs UI میں مثال { #example-in-the-docs-ui }
+
+اوپر کے کسی بھی طریقے سے یہ `/docs` میں اس طرح نظر آئے گا:
+
+
+
+### متعدد `examples` کے ساتھ `Body` { #body-with-multiple-examples }
+
+آپ یقیناً متعدد `examples` بھی پاس کر سکتے ہیں:
+
+{* ../../docs_src/schema_extra_example/tutorial004_an_py310.py hl[23:38] *}
+
+جب آپ ایسا کریں، تو مثالیں اس body ڈیٹا کے اندرونی **JSON Schema** کا حصہ ہوں گی۔
+
+تاہم، اس تحریر کے وقت، Swagger UI، جو docs UI دکھانے کا ذمہ دار ٹول ہے، **JSON Schema** میں ڈیٹا کی متعدد مثالیں دکھانے کی سپورٹ نہیں کرتا۔ لیکن ایک حل کے لیے نیچے پڑھیں۔
+
+### OpenAPI-مخصوص `examples` { #openapi-specific-examples }
+
+**JSON Schema** نے `examples` کی سپورٹ سے پہلے ہی OpenAPI میں ایک مختلف field جس کا نام بھی `examples` تھا، کی سپورٹ موجود تھی۔
+
+یہ **OpenAPI-مخصوص** `examples` OpenAPI specification کے ایک اور حصے میں جاتا ہے۔ یہ **ہر *path operation* کی تفصیلات** میں جاتا ہے، ہر JSON Schema کے اندر نہیں۔
+
+اور Swagger UI نے اس مخصوص `examples` field کو کافی عرصے سے سپورٹ کیا ہے۔ تو آپ اسے docs UI میں مختلف **مثالیں دکھانے** کے لیے استعمال کر سکتے ہیں۔
+
+اس OpenAPI-مخصوص field `examples` کی شکل ایک `dict` ہے جس میں **متعدد مثالیں** ہیں (`list` کی بجائے)، ہر ایک میں اضافی معلومات جو **OpenAPI** میں بھی شامل ہوں گی۔
+
+یہ OpenAPI میں موجود ہر JSON Schema کے اندر نہیں جاتا، بلکہ *path operation* میں براہ راست باہر جاتا ہے۔
+
+### `openapi_examples` Parameter کا استعمال { #using-the-openapi-examples-parameter }
+
+آپ FastAPI میں OpenAPI-مخصوص `examples` کو `openapi_examples` parameter کے ساتھ declare کر سکتے ہیں، ان کے لیے:
+
+* `Path()`
+* `Query()`
+* `Header()`
+* `Cookie()`
+* `Body()`
+* `Form()`
+* `File()`
+
+`dict` کی keys ہر مثال کی شناخت کرتی ہیں، اور ہر قدر ایک اور `dict` ہے۔
+
+`examples` میں ہر مخصوص مثال `dict` میں یہ شامل ہو سکتا ہے:
+
+* `summary`: مثال کی مختصر وضاحت۔
+* `description`: ایک تفصیلی وضاحت جس میں Markdown متن ہو سکتا ہے۔
+* `value`: یہ اصل مثال ہے جو دکھائی جاتی ہے، مثلاً ایک `dict`۔
+* `externalValue`: `value` کا متبادل، مثال کی طرف اشارہ کرنے والا URL۔ اگرچہ یہ شاید اتنے ٹولز سے supported نہ ہو جتنا `value` ہے۔
+
+آپ اسے اس طرح استعمال کر سکتے ہیں:
+
+{* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
+
+### Docs UI میں OpenAPI مثالیں { #openapi-examples-in-the-docs-ui }
+
+`Body()` میں `openapi_examples` شامل کرنے سے `/docs` اس طرح نظر آئے گا:
+
+
+
+## تکنیکی تفصیلات { #technical-details }
+
+/// tip | مشورہ
+
+اگر آپ پہلے سے **FastAPI** version **0.99.0 یا اس سے اوپر** استعمال کر رہے ہیں، تو شاید آپ ان تفصیلات کو **چھوڑ** سکتے ہیں۔
+
+یہ پرانے versions کے لیے زیادہ متعلقہ ہیں، جب OpenAPI 3.1.0 دستیاب نہیں تھا۔
+
+آپ اسے OpenAPI اور JSON Schema کی ایک مختصر **تاریخ کا سبق** سمجھ سکتے ہیں۔ 🤓
+
+///
+
+/// warning | انتباہ
+
+یہ **JSON Schema** اور **OpenAPI** معیارات کے بارے میں بہت تکنیکی تفصیلات ہیں۔
+
+اگر اوپر بیان کیے گئے خیالات آپ کے لیے پہلے سے کام کر رہے ہیں، تو یہ کافی ہو سکتا ہے، اور شاید آپ کو ان تفصیلات کی ضرورت نہ ہو، بلا جھجک انہیں چھوڑ دیں۔
+
+///
+
+OpenAPI 3.1.0 سے پہلے، OpenAPI **JSON Schema** کا ایک پرانا اور ترمیم شدہ ورژن استعمال کرتا تھا۔
+
+JSON Schema میں `examples` نہیں تھا، اس لیے OpenAPI نے اپنے ترمیم شدہ ورژن میں اپنا `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`، `content` field میں، `Media Type Object` پر (specification میں)](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#media-type-object) جو FastAPI کے ان میں استعمال ہوتا تھا:
+ * `Body()`
+ * `File()`
+ * `Form()`
+
+/// info | معلومات
+
+یہ پرانا OpenAPI-مخصوص `examples` parameter اب FastAPI `0.103.0` سے `openapi_examples` ہے۔
+
+///
+
+### JSON Schema کا `examples` field { #json-schemas-examples-field }
+
+لیکن پھر JSON Schema نے specification کے ایک نئے ورژن میں [`examples`](https://json-schema.org/draft/2019-09/json-schema-validation.html#rfc.section.9.5) field شامل کیا۔
+
+اور پھر نیا OpenAPI 3.1.0 تازہ ترین ورژن (JSON Schema 2020-12) پر مبنی تھا جس میں یہ نیا `examples` field شامل تھا۔
+
+اور اب یہ نیا `examples` field پرانے واحد (اور حسب ضرورت) `example` field پر فوقیت رکھتا ہے، جو اب deprecated ہے۔
+
+JSON Schema میں یہ نیا `examples` field **صرف ایک `list`** مثالوں کی ہے، نہ کہ اضافی metadata کے ساتھ dict جیسا OpenAPI کے دوسرے مقامات پر ہے (اوپر بیان کیا گیا)۔
+
+/// info | معلومات
+
+OpenAPI 3.1.0 ریلیز ہونے کے بعد بھی JSON Schema کے ساتھ اس نئے آسان انضمام کے ساتھ، کچھ عرصے تک Swagger UI، جو خودکار docs فراہم کرنے والا ٹول ہے، OpenAPI 3.1.0 سپورٹ نہیں کرتا تھا (یہ version 5.0.0 سے سپورٹ کرتا ہے 🎉)۔
+
+اسی وجہ سے، 0.99.0 سے پہلے کے FastAPI versions ابھی بھی 3.1.0 سے نچلے OpenAPI versions استعمال کرتے تھے۔
+
+///
+
+### Pydantic اور FastAPI `examples` { #pydantic-and-fastapi-examples }
+
+جب آپ Pydantic model کے اندر `examples` شامل کرتے ہیں، `schema_extra` یا `Field(examples=["something"])` استعمال کر کے، تو وہ مثال اس Pydantic model کے **JSON Schema** میں شامل ہو جاتی ہے۔
+
+اور وہ Pydantic model کا **JSON Schema** آپ کی API کے **OpenAPI** میں شامل ہوتا ہے، اور پھر docs UI میں استعمال ہوتا ہے۔
+
+0.99.0 سے پہلے کے FastAPI versions میں (0.99.0 اور اس سے اوپر نئے OpenAPI 3.1.0 استعمال کرتے ہیں) جب آپ کسی دوسری utilities (`Query()`، `Body()` وغیرہ) کے ساتھ `example` یا `examples` استعمال کرتے تھے تو وہ مثالیں JSON Schema میں شامل نہیں ہوتی تھیں جو اس ڈیٹا کو بیان کرتا ہے (نہ ہی OpenAPI کے اپنے JSON Schema ورژن میں)، بلکہ وہ OpenAPI میں *path operation* declaration میں براہ راست شامل ہوتی تھیں (JSON Schema استعمال کرنے والے OpenAPI حصوں سے باہر)۔
+
+لیکن اب جب FastAPI 0.99.0 اور اس سے اوپر OpenAPI 3.1.0 استعمال کرتا ہے، جو JSON Schema 2020-12 استعمال کرتا ہے، اور Swagger UI 5.0.0 اور اس سے اوپر، سب کچھ زیادہ مستقل ہے اور مثالیں JSON Schema میں شامل ہیں۔
+
+### Swagger UI اور OpenAPI-مخصوص `examples` { #swagger-ui-and-openapi-specific-examples }
+
+اب، چونکہ Swagger UI متعدد JSON Schema مثالیں سپورٹ نہیں کرتا تھا (2023-08-26 تک)، صارفین کے پاس docs میں متعدد مثالیں دکھانے کا کوئی طریقہ نہیں تھا۔
+
+اسے حل کرنے کے لیے، FastAPI `0.103.0` نے نئے parameter `openapi_examples` کے ساتھ اسی پرانے **OpenAPI-مخصوص** `examples` field کو declare کرنے کی **سپورٹ شامل** کی۔ 🤓
+
+### خلاصہ { #summary }
+
+میں کہا کرتا تھا کہ مجھے تاریخ زیادہ پسند نہیں... اور دیکھیں اب میں "ٹیک تاریخ" کے سبق دے رہا ہوں۔ 😅
+
+مختصراً، **FastAPI 0.99.0 یا اس سے اوپر اپ گریڈ کریں**، اور چیزیں بہت **آسان، مستقل، اور بدیہی** ہیں، اور آپ کو یہ تمام تاریخی تفصیلات جاننے کی ضرورت نہیں ہے۔ 😎
diff --git a/docs/ur/docs/tutorial/security/first-steps.md b/docs/ur/docs/tutorial/security/first-steps.md
new file mode 100644
index 000000000..2a64177a9
--- /dev/null
+++ b/docs/ur/docs/tutorial/security/first-steps.md
@@ -0,0 +1,203 @@
+# Security - پہلے قدم { #security-first-steps }
+
+آئیے تصور کریں کہ آپ کی **backend** API کسی domain پر ہے۔
+
+اور آپ کا **frontend** کسی اور domain پر یا اسی domain کے کسی مختلف path پر ہے (یا کسی mobile application میں)۔
+
+اور آپ چاہتے ہیں کہ frontend، backend کے ساتھ **username** اور **password** استعمال کرتے ہوئے authenticate کر سکے۔
+
+ہم **FastAPI** کے ساتھ **OAuth2** استعمال کرکے یہ بنا سکتے ہیں۔
+
+لیکن آئیے آپ کا وقت بچاتے ہیں کہ آپ کو پوری لمبی specification پڑھنے کی ضرورت نہ پڑے صرف ان چھوٹی سی معلومات کے لیے جو آپ کو چاہئیں۔
+
+آئیے **FastAPI** کی طرف سے فراہم کردہ tools استعمال کرتے ہیں security کو سنبھالنے کے لیے۔
+
+## یہ کیسا دکھتا ہے { #how-it-looks }
+
+آئیے پہلے صرف code استعمال کریں اور دیکھیں کہ یہ کیسے کام کرتا ہے، اور پھر ہم واپس آ کر سمجھیں گے کہ کیا ہو رہا ہے۔
+
+## `main.py` بنائیں { #create-main-py }
+
+مثال کو ایک فائل `main.py` میں کاپی کریں:
+
+{* ../../docs_src/security/tutorial001_an_py310.py *}
+
+## اسے چلائیں { #run-it }
+
+/// info | معلومات
+
+[`python-multipart`](https://github.com/Kludex/python-multipart) package خودکار طور پر **FastAPI** کے ساتھ install ہو جاتا ہے جب آپ `pip install "fastapi[standard]"` command چلاتے ہیں۔
+
+تاہم، اگر آپ `pip install fastapi` command استعمال کرتے ہیں، تو `python-multipart` package بطور default شامل نہیں ہوتا۔
+
+اسے دستی طور پر install کرنے کے لیے، یقینی بنائیں کہ آپ ایک [virtual environment](../../virtual-environments.md) بنائیں، اسے activate کریں، اور پھر اسے install کریں:
+
+```console
+$ pip install python-multipart
+```
+
+یہ اس لیے ہے کیونکہ **OAuth2** `username` اور `password` بھیجنے کے لیے "form data" استعمال کرتا ہے۔
+
+///
+
+مثال کو اس طرح چلائیں:
+
+
+
+/// check | Authorize بٹن!
+
+آپ کے پاس پہلے سے ایک چمکدار نیا "Authorize" بٹن ہے۔
+
+اور آپ کے *path operation* میں اوپر دائیں کونے میں ایک چھوٹا سا تالے کا نشان ہے جس پر آپ کلک کر سکتے ہیں۔
+
+///
+
+اور اگر آپ اس پر کلک کریں، تو آپ کو ایک چھوٹا سا authorization فارم ملے گا جس میں `username` اور `password` (اور دیگر اختیاری فیلڈز) ٹائپ کر سکتے ہیں:
+
+
+
+/// note | نوٹ
+
+اس سے کوئی فرق نہیں پڑتا کہ آپ فارم میں کیا ٹائپ کریں، یہ ابھی کام نہیں کرے گا۔ لیکن ہم وہاں پہنچ جائیں گے۔
+
+///
+
+یہ یقیناً حتمی صارفین کے لیے frontend نہیں ہے، لیکن یہ آپ کی پوری API کو interactively document کرنے کے لیے ایک بہترین خودکار tool ہے۔
+
+یہ frontend ٹیم استعمال کر سکتی ہے (جو آپ خود بھی ہو سکتے ہیں)۔
+
+یہ third party applications اور systems استعمال کر سکتے ہیں۔
+
+اور آپ خود بھی اسی application کو debug، check اور test کرنے کے لیے استعمال کر سکتے ہیں۔
+
+## `password` flow { #the-password-flow }
+
+اب آئیے تھوڑا پیچھے جائیں اور سمجھیں کہ یہ سب کیا ہے۔
+
+`password` "flow" OAuth2 میں بیان کردہ security اور authentication کو سنبھالنے کے طریقوں ("flows") میں سے ایک ہے۔
+
+OAuth2 اس طرح ڈیزائن کیا گیا تھا کہ backend یا API اس server سے آزاد ہو سکے جو صارف کو authenticate کرتا ہے۔
+
+لیکن اس معاملے میں، وہی **FastAPI** application API اور authentication دونوں کو سنبھالے گی۔
+
+تو، آئیے اسے اس آسان نقطہ نظر سے دیکھتے ہیں:
+
+* صارف frontend میں `username` اور `password` ٹائپ کرتا ہے، اور `Enter` دباتا ہے۔
+* Frontend (صارف کے browser میں چل رہا) وہ `username` اور `password` ہماری API میں ایک مخصوص URL پر بھیجتا ہے (جو `tokenUrl="token"` کے ساتھ declare کیا گیا ہے)۔
+* API وہ `username` اور `password` چیک کرتی ہے، اور ایک "token" کے ساتھ جواب دیتی ہے (ہم نے ابھی تک اس میں سے کچھ بھی implement نہیں کیا)۔
+ * ایک "token" بس ایک string ہے جس میں کچھ مواد ہوتا ہے جسے ہم بعد میں اس صارف کی تصدیق کے لیے استعمال کر سکتے ہیں۔
+ * عام طور پر، ایک token کچھ وقت بعد expire ہونے کے لیے سیٹ کیا جاتا ہے۔
+ * تو، صارف کو کسی وقت بعد دوبارہ login کرنا ہوگا۔
+ * اور اگر token چوری ہو جائے، تو خطرہ کم ہے۔ یہ کسی مستقل key کی طرح نہیں جو ہمیشہ کام کرے (زیادہ تر معاملات میں)۔
+* Frontend وہ token عارضی طور پر کہیں محفوظ کرتا ہے۔
+* صارف frontend میں کلک کرتا ہے تاکہ frontend web app کے کسی اور سیکشن میں جائے۔
+* Frontend کو API سے مزید data لانا ہوتا ہے۔
+ * لیکن اسے اس مخصوص endpoint کے لیے authentication کی ضرورت ہوتی ہے۔
+ * تو، ہماری API کے ساتھ authenticate کرنے کے لیے، یہ ایک header `Authorization` بھیجتا ہے جس کی value `Bearer ` ہوتی ہے اور اس کے ساتھ token ہوتا ہے۔
+ * اگر token میں `foobar` ہو، تو `Authorization` header کا مواد ہوگا: `Bearer foobar`۔
+
+## **FastAPI** کا `OAuth2PasswordBearer` { #fastapis-oauth2passwordbearer }
+
+**FastAPI** مختلف سطحوں کی abstraction پر، ان security features کو implement کرنے کے لیے کئی tools فراہم کرتا ہے۔
+
+اس مثال میں ہم **OAuth2** استعمال کریں گے، **Password** flow کے ساتھ، **Bearer** token استعمال کرتے ہوئے۔ ہم یہ `OAuth2PasswordBearer` class استعمال کرکے کرتے ہیں۔
+
+/// info | معلومات
+
+"bearer" token واحد آپشن نہیں ہے۔
+
+لیکن ہمارے استعمال کے لیے یہ بہترین ہے۔
+
+اور زیادہ تر استعمال کے معاملات کے لیے یہ بہترین ہو سکتا ہے، جب تک کہ آپ OAuth2 ماہر نہ ہوں اور آپ کو بالکل معلوم نہ ہو کہ کوئی اور آپشن آپ کی ضروریات کے لیے بہتر ہے۔
+
+اس صورت میں، **FastAPI** آپ کو اسے بنانے کے tools بھی فراہم کرتا ہے۔
+
+///
+
+جب ہم `OAuth2PasswordBearer` class کی ایک instance بناتے ہیں تو ہم `tokenUrl` parameter پاس کرتے ہیں۔ یہ parameter وہ URL رکھتا ہے جو client (صارف کے browser میں چل رہا frontend) token حاصل کرنے کے لیے `username` اور `password` بھیجنے کے لیے استعمال کرے گا۔
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[8] *}
+
+/// tip | مشورہ
+
+یہاں `tokenUrl="token"` ایک relative URL `token` کی طرف اشارہ کرتا ہے جو ہم نے ابھی بنایا نہیں ہے۔ چونکہ یہ ایک relative URL ہے، یہ `./token` کے مساوی ہے۔
+
+کیونکہ ہم relative URL استعمال کر رہے ہیں، اگر آپ کی API `https://example.com/` پر تھی، تو یہ `https://example.com/token` کی طرف اشارہ کرے گا۔ لیکن اگر آپ کی API `https://example.com/api/v1/` پر تھی، تو یہ `https://example.com/api/v1/token` کی طرف اشارہ کرے گا۔
+
+Relative URL استعمال کرنا اہم ہے تاکہ آپ کی application ایک جدید استعمال کے معاملے جیسے [Behind a Proxy](../../advanced/behind-a-proxy.md) میں بھی کام کرتی رہے۔
+
+///
+
+یہ parameter وہ endpoint / *path operation* نہیں بناتا، بلکہ یہ declare کرتا ہے کہ URL `/token` وہ ہوگا جو client کو token حاصل کرنے کے لیے استعمال کرنا چاہیے۔ یہ معلومات OpenAPI میں، اور پھر interactive API documentation systems میں استعمال ہوتی ہیں۔
+
+ہم جلد ہی اصل path operation بھی بنائیں گے۔
+
+/// info | معلومات
+
+اگر آپ بہت سخت "Pythonista" ہیں تو آپ کو parameter کے نام `tokenUrl` کا انداز `token_url` کی بجائے ناپسند ہو سکتا ہے۔
+
+یہ اس لیے ہے کیونکہ یہ وہی نام استعمال کر رہا ہے جو OpenAPI spec میں ہے۔ تاکہ اگر آپ کو ان میں سے کسی security scheme کے بارے میں مزید تحقیق کرنی ہو تو آپ اسے کاپی اور پیسٹ کرکے مزید معلومات حاصل کر سکیں۔
+
+///
+
+`oauth2_scheme` variable `OAuth2PasswordBearer` کی ایک instance ہے، لیکن یہ ایک "callable" بھی ہے۔
+
+اسے اس طرح call کیا جا سکتا ہے:
+
+```Python
+oauth2_scheme(some, parameters)
+```
+
+تو، اسے `Depends` کے ساتھ استعمال کیا جا سکتا ہے۔
+
+### اسے استعمال کریں { #use-it }
+
+اب آپ اس `oauth2_scheme` کو `Depends` کے ساتھ ایک dependency میں پاس کر سکتے ہیں۔
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}
+
+یہ dependency ایک `str` فراہم کرے گی جو *path operation function* کے parameter `token` کو assign ہوگی۔
+
+**FastAPI** کو معلوم ہوگا کہ وہ اس dependency کو OpenAPI schema (اور خودکار API docs) میں ایک "security scheme" کی تعریف کے لیے استعمال کر سکتا ہے۔
+
+/// info | تکنیکی تفصیلات
+
+**FastAPI** کو معلوم ہوگا کہ وہ class `OAuth2PasswordBearer` (جو ایک dependency میں declare کی گئی ہے) کو OpenAPI میں security scheme کی تعریف کے لیے استعمال کر سکتا ہے کیونکہ یہ `fastapi.security.oauth2.OAuth2` سے inherit ہوتی ہے، جو بدلے میں `fastapi.security.base.SecurityBase` سے inherit ہوتی ہے۔
+
+تمام security utilities جو OpenAPI (اور خودکار API docs) کے ساتھ integrate ہوتی ہیں `SecurityBase` سے inherit ہوتی ہیں، اسی طرح **FastAPI** جانتا ہے کہ انہیں OpenAPI میں کیسے integrate کرنا ہے۔
+
+///
+
+## یہ کیا کرتا ہے { #what-it-does }
+
+یہ request میں `Authorization` header تلاش کرے گا، چیک کرے گا کہ value `Bearer ` ہے اور اس کے ساتھ کوئی token ہے، اور token کو `str` کے طور پر واپس کرے گا۔
+
+اگر اسے `Authorization` header نظر نہیں آتا، یا value میں `Bearer ` token نہیں ہے، تو یہ براہ راست 401 status code error (`UNAUTHORIZED`) کے ساتھ جواب دے گا۔
+
+آپ کو یہ بھی چیک کرنے کی ضرورت نہیں کہ token موجود ہے یا نہیں تاکہ error واپس کریں۔ آپ یقین رکھ سکتے ہیں کہ اگر آپ کی function execute ہوتی ہے، تو اس token میں ایک `str` ہوگی۔
+
+آپ اسے interactive docs میں ابھی آزما سکتے ہیں:
+
+
+
+ہم ابھی تک token کی validity کی تصدیق نہیں کر رہے، لیکن یہ ایک شروعات ہے۔
+
+## خلاصہ { #recap }
+
+تو، صرف 3 یا 4 اضافی لائنوں میں، آپ کے پاس پہلے سے security کی ایک بنیادی شکل موجود ہے۔
diff --git a/docs/ur/docs/tutorial/security/get-current-user.md b/docs/ur/docs/tutorial/security/get-current-user.md
new file mode 100644
index 000000000..584215d2d
--- /dev/null
+++ b/docs/ur/docs/tutorial/security/get-current-user.md
@@ -0,0 +1,105 @@
+# موجودہ صارف حاصل کریں { #get-current-user }
+
+پچھلے باب میں security system (جو dependency injection system پر مبنی ہے) *path operation function* کو `token` بطور `str` دے رہا تھا:
+
+{* ../../docs_src/security/tutorial001_an_py310.py hl[12] *}
+
+لیکن یہ ابھی تک اتنا کارآمد نہیں ہے۔
+
+آئیے اسے ہمیں موجودہ صارف دینے کے قابل بنائیں۔
+
+## ایک user model بنائیں { #create-a-user-model }
+
+پہلے، آئیے ایک Pydantic user model بناتے ہیں۔
+
+جس طرح ہم Pydantic کو bodies declare کرنے کے لیے استعمال کرتے ہیں، ہم اسے کہیں بھی استعمال کر سکتے ہیں:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[5,12:6] *}
+
+## ایک `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` سے `token` بطور `str` وصول کرے گی:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[25] *}
+
+## صارف حاصل کریں { #get-the-user }
+
+`get_current_user` ایک (جعلی) utility function استعمال کرے گا جو ہم نے بنایا ہے، جو token کو `str` کے طور پر لیتا ہے اور ہمارا Pydantic `User` model واپس کرتا ہے:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[19:22,26:27] *}
+
+## موجودہ صارف inject کریں { #inject-the-current-user }
+
+تو اب ہم *path operation* میں `Depends` کے ساتھ اپنا `get_current_user` استعمال کر سکتے ہیں:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[31] *}
+
+دھیان دیں کہ ہم نے `current_user` کی type Pydantic model `User` بیان کی ہے۔
+
+یہ ہماری function کے اندر تمام completion اور type checks میں مدد کرے گا۔
+
+/// tip | مشورہ
+
+آپ کو یاد ہوگا کہ request bodies بھی Pydantic models کے ساتھ declare کی جاتی ہیں۔
+
+یہاں **FastAPI** الجھے گا نہیں کیونکہ آپ `Depends` استعمال کر رہے ہیں۔
+
+///
+
+/// check
+
+جس طرح یہ dependency system ڈیزائن کیا گیا ہے وہ ہمیں مختلف dependencies (مختلف "dependables") رکھنے کی اجازت دیتا ہے جو سب ایک `User` model واپس کرتی ہیں۔
+
+ہم صرف ایک dependency تک محدود نہیں ہیں جو اس قسم کا data واپس کر سکے۔
+
+///
+
+## دوسرے models { #other-models }
+
+اب آپ موجودہ صارف کو براہ راست *path operation functions* میں حاصل کر سکتے ہیں اور security کے طریقہ کار کو **Dependency Injection** کی سطح پر، `Depends` استعمال کرتے ہوئے سنبھال سکتے ہیں۔
+
+اور آپ security کی ضروریات کے لیے کوئی بھی model یا data استعمال کر سکتے ہیں (اس معاملے میں، ایک Pydantic model `User`)۔
+
+لیکن آپ کسی مخصوص data model، class یا type استعمال کرنے تک محدود نہیں ہیں۔
+
+کیا آپ اپنے model میں `id` اور `email` رکھنا چاہتے ہیں اور کوئی `username` نہیں چاہتے؟ ضرور۔ آپ یہی tools استعمال کر سکتے ہیں۔
+
+کیا آپ صرف ایک `str` چاہتے ہیں؟ یا صرف ایک `dict`؟ یا براہ راست ایک database class model instance؟ یہ سب اسی طرح کام کرتا ہے۔
+
+آپ کے پاس حقیقت میں ایسے صارف نہیں ہیں جو آپ کی application میں login کرتے ہوں بلکہ robots، bots، یا دوسرے systems ہیں، جن کے پاس صرف ایک access token ہے؟ پھر بھی، یہ سب اسی طرح کام کرتا ہے۔
+
+بس اپنی application کے لیے جو بھی model، class، یا database آپ کو درکار ہو استعمال کریں۔ **FastAPI** dependency injection system کے ساتھ آپ کا ساتھ دیتا ہے۔
+
+## Code کا سائز { #code-size }
+
+یہ مثال طویل لگ سکتی ہے۔ یاد رکھیں کہ ہم security، data models، utility functions اور *path operations* کو ایک ہی فائل میں ملا رہے ہیں۔
+
+لیکن یہاں اہم نکتہ یہ ہے۔
+
+Security اور dependency injection کا کام ایک بار لکھا جاتا ہے۔
+
+اور آپ اسے جتنا پیچیدہ چاہیں بنا سکتے ہیں۔ اور پھر بھی، یہ صرف ایک بار، ایک ہی جگہ لکھا جاتا ہے۔ تمام لچک کے ساتھ۔
+
+لیکن آپ کے پاس ہزاروں endpoints (*path operations*) ہو سکتے ہیں جو اسی security system کو استعمال کریں۔
+
+اور ان سب (یا ان کا جو بھی حصہ آپ چاہیں) ان dependencies یا آپ کی بنائی ہوئی کسی بھی اور dependency کو دوبارہ استعمال کرنے کا فائدہ اٹھا سکتے ہیں۔
+
+اور یہ سب ہزاروں *path operations* صرف 3 لائنوں جتنی چھوٹی ہو سکتی ہیں:
+
+{* ../../docs_src/security/tutorial002_an_py310.py hl[30:32] *}
+
+## خلاصہ { #recap }
+
+اب آپ موجودہ صارف کو براہ راست اپنی *path operation function* میں حاصل کر سکتے ہیں۔
+
+ہم پہلے سے آدھے راستے پر ہیں۔
+
+ہمیں بس ایک *path operation* شامل کرنے کی ضرورت ہے تاکہ صارف/client حقیقت میں `username` اور `password` بھیج سکے۔
+
+یہ اگلے باب میں آتا ہے۔
diff --git a/docs/ur/docs/tutorial/security/index.md b/docs/ur/docs/tutorial/security/index.md
new file mode 100644
index 000000000..594fe862c
--- /dev/null
+++ b/docs/ur/docs/tutorial/security/index.md
@@ -0,0 +1,106 @@
+# Security { #security }
+
+Security، authentication اور authorization کو سنبھالنے کے بہت سے طریقے ہیں۔
+
+اور یہ عام طور پر ایک پیچیدہ اور "مشکل" موضوع ہوتا ہے۔
+
+بہت سے frameworks اور systems میں صرف security اور authentication کو سنبھالنے میں بہت زیادہ محنت اور code لگتا ہے (بہت سے معاملات میں یہ لکھے گئے کل code کا 50% یا اس سے زیادہ ہو سکتا ہے)۔
+
+**FastAPI** آپ کو **Security** کو آسانی سے، تیزی سے، ایک معیاری طریقے سے سنبھالنے میں مدد کرنے کے لیے کئی tools فراہم کرتا ہے، بغیر اس کے کہ آپ کو تمام security specifications کا مطالعہ اور سیکھنا پڑے۔
+
+لیکن پہلے، آئیے کچھ چھوٹے تصورات کو سمجھتے ہیں۔
+
+## جلدی میں ہیں؟ { #in-a-hurry }
+
+اگر آپ کو ان میں سے کسی بھی اصطلاح سے کوئی سروکار نہیں اور آپ کو صرف username اور password پر مبنی authentication کے ساتھ security ابھی شامل کرنی ہے، تو اگلے ابواب پر چلے جائیں۔
+
+## OAuth2 { #oauth2 }
+
+OAuth2 ایک specification ہے جو authentication اور authorization کو سنبھالنے کے کئی طریقے بیان کرتی ہے۔
+
+یہ کافی وسیع specification ہے اور کئی پیچیدہ استعمال کے معاملات کا احاطہ کرتی ہے۔
+
+اس میں "third party" کا استعمال کرتے ہوئے authenticate کرنے کے طریقے شامل ہیں۔
+
+یہی وہ چیز ہے جو "Facebook، Google، X (Twitter)، GitHub سے login کریں" والے تمام systems اندرونی طور پر استعمال کرتے ہیں۔
+
+### OAuth 1 { #oauth-1 }
+
+ایک OAuth 1 بھی تھا، جو OAuth2 سے بہت مختلف اور زیادہ پیچیدہ ہے، کیونکہ اس میں communication کو encrypt کرنے کے طریقے کی براہ راست specifications شامل تھیں۔
+
+یہ آج کل زیادہ مقبول یا استعمال نہیں ہوتا۔
+
+OAuth2 communication کو encrypt کرنے کا طریقہ متعین نہیں کرتا، یہ توقع کرتا ہے کہ آپ کی application HTTPS کے ساتھ سرو ہو رہی ہو۔
+
+/// tip | مشورہ
+
+**deployment** کے سیکشن میں آپ دیکھیں گے کہ Traefik اور Let's Encrypt کا استعمال کرتے ہوئے مفت میں HTTPS کیسے سیٹ اپ کریں۔
+
+///
+
+## OpenID Connect { #openid-connect }
+
+OpenID Connect ایک اور specification ہے، جو **OAuth2** پر مبنی ہے۔
+
+یہ OAuth2 کو بس اتنا بڑھاتی ہے کہ OAuth2 میں جو چیزیں نسبتاً مبہم ہیں انہیں متعین کرتی ہے، تاکہ اسے زیادہ interoperable بنایا جا سکے۔
+
+مثال کے طور پر، Google login OpenID Connect استعمال کرتا ہے (جو اندرونی طور پر OAuth2 استعمال کرتا ہے)۔
+
+لیکن Facebook login OpenID Connect کو سپورٹ نہیں کرتا۔ اس کا OAuth2 کا اپنا انداز ہے۔
+
+### OpenID ("OpenID Connect" نہیں) { #openid-not-openid-connect }
+
+ایک "OpenID" specification بھی تھی۔ اس نے **OpenID Connect** جیسا ہی مسئلہ حل کرنے کی کوشش کی، لیکن OAuth2 پر مبنی نہیں تھی۔
+
+لہذا، یہ ایک مکمل الگ system تھا۔
+
+یہ آج کل زیادہ مقبول یا استعمال نہیں ہوتا۔
+
+## OpenAPI { #openapi }
+
+OpenAPI (پہلے Swagger کے نام سے جانا جاتا تھا) APIs بنانے کے لیے ایک open specification ہے (اب Linux Foundation کا حصہ ہے)۔
+
+**FastAPI** **OpenAPI** پر مبنی ہے۔
+
+یہی وہ چیز ہے جو متعدد خودکار interactive documentation interfaces، code generation وغیرہ کو ممکن بناتی ہے۔
+
+OpenAPI متعدد security "schemes" کی تعریف کرنے کا ایک طریقہ رکھتا ہے۔
+
+انہیں استعمال کرکے، آپ ان تمام معیار پر مبنی tools کا فائدہ اٹھا سکتے ہیں، بشمول یہ interactive documentation systems۔
+
+OpenAPI درج ذیل security schemes کی تعریف کرتا ہے:
+
+* `apiKey`: ایک application مخصوص key جو آ سکتی ہے:
+ * ایک query parameter سے۔
+ * ایک header سے۔
+ * ایک cookie سے۔
+* `http`: معیاری HTTP authentication systems، بشمول:
+ * `bearer`: ایک header `Authorization` جس کی value `Bearer ` ہو اور اس کے ساتھ ایک token ہو۔ یہ OAuth2 سے وراثت میں ملا ہے۔
+ * HTTP Basic authentication۔
+ * HTTP Digest، وغیرہ۔
+* `oauth2`: security کو سنبھالنے کے تمام OAuth2 طریقے (جنہیں "flows" کہتے ہیں)۔
+ * ان میں سے کئی flows OAuth 2.0 authentication provider بنانے کے لیے موزوں ہیں (جیسے Google، Facebook، X (Twitter)، GitHub، وغیرہ):
+ * `implicit`
+ * `clientCredentials`
+ * `authorizationCode`
+ * لیکن ایک مخصوص "flow" ہے جو براہ راست اسی application میں authentication کو سنبھالنے کے لیے بالکل درست استعمال ہو سکتا ہے:
+ * `password`: آنے والے کچھ ابواب میں اس کی مثالیں دی جائیں گی۔
+* `openIdConnect`: OAuth2 authentication data کو خودکار طور پر دریافت کرنے کا طریقہ بیان کرتا ہے۔
+ * یہ خودکار دریافت OpenID Connect specification میں متعین ہے۔
+
+
+/// tip | مشورہ
+
+Google، Facebook، X (Twitter)، GitHub وغیرہ جیسے دوسرے authentication/authorization providers کو integrate کرنا بھی ممکن اور نسبتاً آسان ہے۔
+
+سب سے پیچیدہ مسئلہ ان جیسا authentication/authorization provider بنانا ہے، لیکن **FastAPI** آپ کو یہ آسانی سے کرنے کے tools دیتا ہے، جبکہ بھاری کام آپ کے لیے خود کرتا ہے۔
+
+///
+
+## **FastAPI** utilities { #fastapi-utilities }
+
+FastAPI ان میں سے ہر security scheme کے لیے `fastapi.security` module میں کئی tools فراہم کرتا ہے جو ان security mechanisms کو استعمال کرنا آسان بناتے ہیں۔
+
+آنے والے ابواب میں آپ دیکھیں گے کہ **FastAPI** کی طرف سے فراہم کردہ ان tools کا استعمال کرتے ہوئے اپنی API میں security کیسے شامل کریں۔
+
+اور آپ یہ بھی دیکھیں گے کہ یہ خودکار طور پر interactive documentation system میں کیسے شامل ہو جاتی ہے۔
diff --git a/docs/ur/docs/tutorial/security/oauth2-jwt.md b/docs/ur/docs/tutorial/security/oauth2-jwt.md
new file mode 100644
index 000000000..50b86d49f
--- /dev/null
+++ b/docs/ur/docs/tutorial/security/oauth2-jwt.md
@@ -0,0 +1,277 @@
+# Password (اور hashing) کے ساتھ OAuth2، JWT tokens کے ساتھ Bearer { #oauth2-with-password-and-hashing-bearer-with-jwt-tokens }
+
+اب جبکہ ہمارے پاس پورا security flow ہے، آئیے JWT tokens اور محفوظ password hashing استعمال کرکے application کو حقیقتاً محفوظ بنائیں۔
+
+یہ code وہ ہے جو آپ حقیقت میں اپنی application میں استعمال کر سکتے ہیں، password hashes اپنے database میں محفوظ کر سکتے ہیں، وغیرہ۔
+
+ہم وہاں سے شروع کریں گے جہاں ہم نے پچھلے باب میں چھوڑا تھا اور اسے بڑھائیں گے۔
+
+## JWT کے بارے میں { #about-jwt }
+
+JWT کا مطلب ہے "JSON Web Tokens"۔
+
+یہ ایک JSON object کو ایک لمبی گھنی string میں بغیر خالی جگہوں کے encode کرنے کا معیار ہے۔ یہ کچھ ایسا دکھتا ہے:
+
+```
+eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c
+```
+
+یہ encrypted نہیں ہے، تو کوئی بھی مواد سے معلومات حاصل کر سکتا ہے۔
+
+لیکن یہ signed ہے۔ تو، جب آپ کو وہ token ملے جو آپ نے جاری کیا تھا، آپ تصدیق کر سکتے ہیں کہ آپ نے واقعی اسے جاری کیا تھا۔
+
+اس طرح، آپ مثلاً 1 ہفتے کی expiration کے ساتھ token بنا سکتے ہیں۔ اور پھر جب صارف اگلے دن token کے ساتھ واپس آئے، تو آپ جانتے ہیں کہ وہ صارف ابھی بھی آپ کے system میں logged in ہے۔
+
+ایک ہفتے کے بعد، token expire ہو جائے گا اور صارف authorized نہیں ہوگا اور اسے نیا token حاصل کرنے کے لیے دوبارہ sign in کرنا ہوگا۔ اور اگر صارف (یا کسی third party) نے expiration تبدیل کرنے کے لیے token میں ترمیم کرنے کی کوشش کی، تو آپ اسے دریافت کر سکیں گے، کیونکہ signatures میل نہیں کھائیں گے۔
+
+اگر آپ JWT tokens کے ساتھ کھیلنا اور دیکھنا چاہتے ہیں کہ یہ کیسے کام کرتے ہیں، تو [https://jwt.io](https://jwt.io/) دیکھیں۔
+
+## `PyJWT` install کریں { #install-pyjwt }
+
+ہمیں Python میں JWT tokens بنانے اور تصدیق کرنے کے لیے `PyJWT` install کرنا ہوگا۔
+
+یقینی بنائیں کہ آپ ایک [virtual environment](../../virtual-environments.md) بنائیں، اسے activate کریں، اور پھر `pyjwt` install کریں:
+
+
+
+Application کو پہلے کی طرح authorize کریں۔
+
+یہ credentials استعمال کریں:
+
+Username: `johndoe`
+Password: `secret`
+
+/// check | اضافی معلومات
+
+دھیان دیں کہ code میں کہیں بھی سادہ متن کا 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 میں بھیجا جاتا ہے تاکہ صارف کو authenticate کیا جائے اور وہ access token حاصل کیا جائے، لیکن اس کے بعد نہیں:
+
+
+
+/// note | نوٹ
+
+`Authorization` header کو دیکھیں، جس کی value `Bearer ` سے شروع ہوتی ہے۔
+
+///
+
+## `scopes` کے ساتھ جدید استعمال { #advanced-usage-with-scopes }
+
+OAuth2 میں "scopes" کا تصور ہے۔
+
+آپ انہیں JWT token میں permissions کا ایک مخصوص مجموعہ شامل کرنے کے لیے استعمال کر سکتے ہیں۔
+
+پھر آپ یہ token کسی صارف کو براہ راست یا کسی third party کو دے سکتے ہیں، تاکہ وہ آپ کی API کے ساتھ پابندیوں کے ایک مجموعے کے ساتھ تعامل کر سکے۔
+
+آپ **Advanced User Guide** میں بعد میں سیکھ سکتے ہیں کہ انہیں کیسے استعمال کریں اور یہ **FastAPI** میں کیسے integrated ہیں۔
+
+## خلاصہ { #recap }
+
+جو آپ نے اب تک دیکھا ہے اس سے، آپ OAuth2 اور JWT جیسے معیارات کا استعمال کرتے ہوئے ایک محفوظ **FastAPI** application ترتیب دے سکتے ہیں۔
+
+تقریباً ہر framework میں security کو سنبھالنا بہت جلد ایک پیچیدہ موضوع بن جاتا ہے۔
+
+بہت سے packages جو اسے بہت آسان بناتے ہیں انہیں data model، database، اور دستیاب features کے ساتھ بہت سے سمجھوتے کرنے پڑتے ہیں۔ اور ان میں سے کچھ packages جو چیزوں کو بہت زیادہ آسان بنا دیتے ہیں ان میں حقیقت میں اندرونی طور پر security کی خامیاں ہوتی ہیں۔
+
+---
+
+**FastAPI** کسی بھی database، data model یا tool کے ساتھ کوئی سمجھوتا نہیں کرتا۔
+
+یہ آپ کو پوری لچک دیتا ہے کہ آپ وہ چنیں جو آپ کے پروجیکٹ کے لیے بہترین ہوں۔
+
+اور آپ بہت سے اچھی طرح سے برقرار رکھے جانے والے اور وسیع پیمانے پر استعمال ہونے والے packages جیسے `pwdlib` اور `PyJWT` براہ راست استعمال کر سکتے ہیں، کیونکہ **FastAPI** بیرونی packages کو integrate کرنے کے لیے کسی پیچیدہ طریقہ کار کی ضرورت نہیں رکھتا۔
+
+لیکن یہ آپ کو لچک، مضبوطی، یا security سے سمجھوتہ کیے بغیر عمل کو زیادہ سے زیادہ آسان بنانے کے tools فراہم کرتا ہے۔
+
+اور آپ OAuth2 جیسے محفوظ، معیاری protocols کو نسبتاً آسان طریقے سے استعمال اور implement کر سکتے ہیں۔
+
+آپ **Advanced User Guide** میں مزید سیکھ سکتے ہیں کہ OAuth2 "scopes" کو کیسے استعمال کریں، مزید باریک بینی سے permissions کے نظام کے لیے، انہی معیارات کی پیروی کرتے ہوئے۔ OAuth2 with scopes وہ طریقہ کار ہے جو بہت سے بڑے authentication providers، جیسے Facebook، Google، GitHub، Microsoft، X (Twitter) وغیرہ، اپنے صارفین کی جانب سے third party applications کو اپنی APIs کے ساتھ تعامل کرنے کی اجازت دینے کے لیے استعمال کرتے ہیں۔
diff --git a/docs/ur/docs/tutorial/security/simple-oauth2.md b/docs/ur/docs/tutorial/security/simple-oauth2.md
new file mode 100644
index 000000000..6aa4374c3
--- /dev/null
+++ b/docs/ur/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/صارف کو `username` اور `password` فیلڈز بطور form data بھیجنے ہوں گے۔
+
+اور spec کہتی ہے کہ فیلڈز کے نام بالکل ایسے ہی ہونے چاہئیں۔ تو `user-name` یا `email` کام نہیں کرے گا۔
+
+لیکن فکر نہ کریں، آپ اسے frontend میں اپنے حتمی صارفین کو جیسے چاہیں دکھا سکتے ہیں۔
+
+اور آپ کے database models جو بھی نام چاہیں استعمال کر سکتے ہیں۔
+
+لیکن login *path operation* کے لیے، ہمیں spec کے مطابق ان ناموں کا استعمال کرنا ہوگا (اور مثال کے طور پر، integrated API documentation system استعمال کرنے کے قابل ہونا)۔
+
+Spec یہ بھی کہتی ہے کہ `username` اور `password` بطور form data بھیجے جائیں (تو، یہاں JSON نہیں)۔
+
+### `scope` { #scope }
+
+Spec یہ بھی کہتی ہے کہ client ایک اور form field "`scope`" بھیج سکتا ہے۔
+
+Form field کا نام `scope` (واحد) ہے، لیکن یہ حقیقت میں ایک لمبی string ہے جس میں "scopes" خالی جگہوں سے الگ ہوتے ہیں۔
+
+ہر "scope" بس ایک string ہے (بغیر خالی جگہوں کے)۔
+
+یہ عام طور پر مخصوص security permissions declare کرنے کے لیے استعمال ہوتے ہیں، مثال کے طور پر:
+
+* `users:read` یا `users:write` عام مثالیں ہیں۔
+* `instagram_basic` Facebook / Instagram استعمال کرتا ہے۔
+* `https://www.googleapis.com/auth/drive` Google استعمال کرتا ہے۔
+
+/// info | معلومات
+
+OAuth2 میں ایک "scope" بس ایک string ہے جو ایک مخصوص مطلوبہ permission declare کرتی ہے۔
+
+اس سے کوئی فرق نہیں پڑتا کہ اس میں `:` جیسے دوسرے حروف ہوں یا یہ ایک URL ہو۔
+
+یہ تفصیلات implementation پر منحصر ہیں۔
+
+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 declare کرتی ہے جس میں:
+
+* `username`۔
+* `password`۔
+* ایک اختیاری `scope` فیلڈ بطور ایک بڑی string، جو خالی جگہوں سے الگ strings پر مشتمل ہو۔
+* ایک اختیاری `grant_type`۔
+
+/// tip | مشورہ
+
+OAuth2 spec دراصل ایک فیلڈ `grant_type` *مطلوب* کرتی ہے جس کی مقررہ value `password` ہو، لیکن `OAuth2PasswordRequestForm` اسے لازمی نہیں بناتا۔
+
+اگر آپ کو اسے لازمی بنانا ہے تو `OAuth2PasswordRequestForm` کی بجائے `OAuth2PasswordRequestFormStrict` استعمال کریں۔
+
+///
+
+* ایک اختیاری `client_id` (ہماری مثال کے لیے اس کی ضرورت نہیں)۔
+* ایک اختیاری `client_secret` (ہماری مثال کے لیے اس کی ضرورت نہیں)۔
+
+/// info | معلومات
+
+`OAuth2PasswordRequestForm` **FastAPI** کے لیے `OAuth2PasswordBearer` کی طرح کوئی خاص class نہیں ہے۔
+
+`OAuth2PasswordBearer` **FastAPI** کو بتاتا ہے کہ یہ ایک security scheme ہے۔ اس لیے اسے اس طریقے سے OpenAPI میں شامل کیا جاتا ہے۔
+
+لیکن `OAuth2PasswordRequestForm` بس ایک class dependency ہے جو آپ خود بھی لکھ سکتے تھے، یا آپ براہ راست `Form` parameters declare کر سکتے تھے۔
+
+لیکن چونکہ یہ ایک عام استعمال کا معاملہ ہے، اسے آسان بنانے کے لیے **FastAPI** براہ راست فراہم کرتا ہے۔
+
+///
+
+### Form data استعمال کریں { #use-the-form-data }
+
+/// tip | مشورہ
+
+Dependency class `OAuth2PasswordRequestForm` کی instance میں `scope` attribute نہیں ہوگا جس میں خالی جگہوں سے الگ لمبی string ہو، بلکہ اس میں `scopes` attribute ہوگا جس میں بھیجے گئے ہر scope کے لیے strings کی اصل list ہوگی۔
+
+ہم اس مثال میں `scopes` استعمال نہیں کر رہے، لیکن اگر آپ کو ضرورت ہو تو یہ فعالیت موجود ہے۔
+
+///
+
+اب، form field سے `username` استعمال کرتے ہوئے (جعلی) database سے صارف کا data حاصل کریں۔
+
+اگر ایسا کوئی صارف نہیں ہے، تو ہم "Incorrect username or password" کی error واپس کرتے ہیں۔
+
+Error کے لیے، ہم exception `HTTPException` استعمال کرتے ہیں:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[3,79:81] *}
+
+### Password چیک کریں { #check-the-password }
+
+اس وقت ہمارے پاس اپنے database سے صارف کا data ہے، لیکن ہم نے password چیک نہیں کیا ہے۔
+
+آئیے پہلے اس data کو Pydantic `UserInDB` model میں ڈالتے ہیں۔
+
+آپ کو کبھی بھی سادہ متن کے passwords محفوظ نہیں کرنے چاہئیں، تو ہم (جعلی) password hashing system استعمال کریں گے۔
+
+اگر passwords میل نہیں کھاتے، تو ہم وہی error واپس کرتے ہیں۔
+
+#### Password hashing { #password-hashing }
+
+"Hashing" کا مطلب ہے: کسی مواد (اس معاملے میں password) کو bytes کی ایک ترتیب (بس ایک string) میں تبدیل کرنا جو بے معنی سی لگتی ہے۔
+
+جب بھی آپ بالکل وہی مواد (بالکل وہی password) دیں گے، آپ کو بالکل وہی بے معنی نتیجہ ملے گا۔
+
+لیکن آپ اس بے معنی نتیجے سے واپس password حاصل نہیں کر سکتے۔
+
+##### Password hashing کیوں استعمال کریں { #why-use-password-hashing }
+
+اگر آپ کا database چوری ہو جائے، تو چور کے پاس آپ کے صارفین کے سادہ متن کے passwords نہیں ہوں گے، صرف hashes ہوں گے۔
+
+تو، چور ان passwords کو کسی اور system میں استعمال نہیں کر سکے گا (چونکہ بہت سے صارف ہر جگہ ایک ہی 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"],
+)
+```
+
+/// info | معلومات
+
+`**user_dict` کی مزید مکمل وضاحت کے لیے [**Extra Models** کی دستاویزات](../extra-models.md#about-user-in-dict) دیکھیں۔
+
+///
+
+## Token واپس کریں { #return-the-token }
+
+`token` endpoint کا response ایک JSON object ہونا چاہیے۔
+
+اس میں ایک `token_type` ہونا چاہیے۔ ہمارے معاملے میں، چونکہ ہم "Bearer" tokens استعمال کر رہے ہیں، token type "`bearer`" ہونی چاہیے۔
+
+اور اس میں ایک `access_token` ہونا چاہیے، ایک string جس میں ہمارا access token ہو۔
+
+اس سادہ مثال کے لیے، ہم بالکل غیر محفوظ طریقے سے وہی `username` بطور token واپس کریں گے۔
+
+/// tip | مشورہ
+
+اگلے باب میں، آپ password hashing اور JWT tokens کے ساتھ ایک حقیقی محفوظ implementation دیکھیں گے۔
+
+لیکن ابھی کے لیے، آئیے ان مخصوص تفصیلات پر توجہ مرکوز کرتے ہیں جو ہمیں چاہئیں۔
+
+///
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[87] *}
+
+/// tip | مشورہ
+
+Spec کے مطابق، آپ کو ایک JSON واپس کرنا چاہیے جس میں `access_token` اور `token_type` ہو، بالکل اسی مثال کی طرح۔
+
+یہ وہ چیز ہے جو آپ کو اپنے code میں خود کرنی ہوگی، اور یقینی بنائیں کہ آپ وہ JSON keys استعمال کریں۔
+
+specifications کے مطابق رہنے کے لیے یہ تقریباً واحد چیز ہے جو آپ کو خود درست طریقے سے کرنا یاد رکھنا ہوگا۔
+
+باقی سب کے لیے، **FastAPI** آپ کے لیے سنبھال لیتا ہے۔
+
+///
+
+## Dependencies کو اپ ڈیٹ کریں { #update-the-dependencies }
+
+اب ہم اپنی dependencies کو اپ ڈیٹ کریں گے۔
+
+ہم `current_user` *صرف* اس وقت حاصل کرنا چاہتے ہیں جب یہ صارف active ہو۔
+
+تو، ہم ایک اضافی dependency `get_current_active_user` بناتے ہیں جو بدلے میں `get_current_user` کو بطور dependency استعمال کرتی ہے۔
+
+یہ دونوں dependencies HTTP error واپس کریں گی اگر صارف موجود نہ ہو، یا غیر فعال ہو۔
+
+تو، ہمارے endpoint میں، ہمیں صارف صرف اسی صورت میں ملے گا جب صارف موجود ہو، درست طریقے سے authenticated ہو، اور active ہو:
+
+{* ../../docs_src/security/tutorial003_an_py310.py hl[58:66,69:74,94] *}
+
+/// info | معلومات
+
+اضافی header `WWW-Authenticate` جس کی value `Bearer` ہے جو ہم یہاں واپس کر رہے ہیں، وہ بھی spec کا حصہ ہے۔
+
+کسی بھی HTTP (error) status code 401 "UNAUTHORIZED" کو بھی `WWW-Authenticate` header واپس کرنا چاہیے۔
+
+Bearer tokens کے معاملے میں (ہمارا معاملہ)، اس header کی value `Bearer` ہونی چاہیے۔
+
+آپ حقیقت میں اس اضافی header کو چھوڑ سکتے ہیں اور یہ پھر بھی کام کرے گا۔
+
+لیکن یہ یہاں specifications کے مطابق رہنے کے لیے فراہم کیا گیا ہے۔
+
+نیز، ایسے tools ہو سکتے ہیں جو اسے توقع رکھتے ہیں اور استعمال کرتے ہیں (ابھی یا مستقبل میں) اور یہ آپ یا آپ کے صارفین کے لیے مفید ہو سکتے ہیں، ابھی یا مستقبل میں۔
+
+معیارات کا یہی فائدہ ہے...
+
+///
+
+## اسے عمل میں دیکھیں { #see-it-in-action }
+
+Interactive docs کھولیں: [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs)۔
+
+### Authenticate کریں { #authenticate }
+
+"Authorize" بٹن پر کلک کریں۔
+
+یہ credentials استعمال کریں:
+
+User: `johndoe`
+
+Password: `secret`
+
+
+
+System میں authenticate ہونے کے بعد، آپ اسے اس طرح دیکھیں گے:
+
+
+
+### اپنا صارف data حاصل کریں { #get-your-own-user-data }
+
+اب operation `GET` path `/users/me` کے ساتھ استعمال کریں۔
+
+آپ کو اپنے صارف کا data ملے گا، جیسے:
+
+```JSON
+{
+ "username": "johndoe",
+ "email": "johndoe@example.com",
+ "full_name": "John Doe",
+ "disabled": false,
+ "hashed_password": "fakehashedsecret"
+}
+```
+
+
+
+اگر آپ lock آئیکن پر کلک کریں اور logout کریں، اور پھر وہی operation دوبارہ آزمائیں، تو آپ کو HTTP 401 error ملے گی:
+
+```JSON
+{
+ "detail": "Not authenticated"
+}
+```
+
+### غیر فعال صارف { #inactive-user }
+
+اب ایک غیر فعال صارف کے ساتھ آزمائیں، اس سے authenticate کریں:
+
+User: `alice`
+
+Password: `secret2`
+
+اور operation `GET` path `/users/me` کے ساتھ استعمال کرنے کی کوشش کریں۔
+
+آپ کو "Inactive user" error ملے گی، جیسے:
+
+```JSON
+{
+ "detail": "Inactive user"
+}
+```
+
+## خلاصہ { #recap }
+
+اب آپ کے پاس اپنی API کے لیے `username` اور `password` پر مبنی مکمل security system بنانے کے tools ہیں۔
+
+ان tools کا استعمال کرتے ہوئے، آپ security system کو کسی بھی database اور کسی بھی صارف یا data model کے ساتھ مطابقت پذیر بنا سکتے ہیں۔
+
+بس ایک تفصیل باقی ہے کہ یہ حقیقت میں ابھی "محفوظ" نہیں ہے۔
+
+اگلے باب میں آپ دیکھیں گے کہ ایک محفوظ password hashing library اور JWT tokens کیسے استعمال کریں۔
diff --git a/docs/ur/docs/tutorial/server-sent-events.md b/docs/ur/docs/tutorial/server-sent-events.md
new file mode 100644
index 000000000..5d0411a55
--- /dev/null
+++ b/docs/ur/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) کے ذریعے مقامی طور پر حمایت یافتہ ہے۔
+
+/// info | معلومات
+
+FastAPI 0.135.0 میں شامل کیا گیا۔
+
+///
+
+## Server-Sent Events کیا ہیں؟ { #what-are-server-sent-events }
+
+SSE HTTP پر server سے client کو data stream کرنے کا ایک معیار ہے۔
+
+ہر event ایک چھوٹا text block ہوتا ہے جس میں `data`، `event`، `id`، اور `retry` جیسے "fields" ہوتے ہیں، جو خالی لائنوں سے الگ ہوتے ہیں۔
+
+یہ اس طرح نظر آتا ہے:
+
+```
+data: {"name": "Portal Gun", "price": 999.99}
+
+data: {"name": "Plumbus", "price": 32.99}
+
+```
+
+SSE عام طور پر AI chat streaming، لائیو notifications، logs اور observability، اور دیگر صورتوں کے لیے استعمال ہوتا ہے جہاں server client کو updates بھیجتا ہے۔
+
+/// tip | مشورہ
+
+اگر آپ binary data stream کرنا چاہتے ہیں، مثلاً video یا audio، تو advanced گائیڈ دیکھیں: [Stream Data](../advanced/stream-data.md)۔
+
+///
+
+## FastAPI کے ساتھ SSE Stream کریں { #stream-sse-with-fastapi }
+
+FastAPI کے ساتھ SSE stream کرنے کے لیے، اپنے *path operation function* میں `yield` استعمال کریں اور `response_class=EventSourceResponse` سیٹ کریں۔
+
+`fastapi.sse` سے `EventSourceResponse` import کریں:
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[1:25] hl[4,22] *}
+
+ہر yield شدہ آئٹم 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** کی طرف سے serialize کرے گا، آپ کو return type declare نہ کرنے کی نسبت بہت زیادہ **performance** ملے گی۔
+
+///
+
+### غیر async *path operation functions* { #non-async-path-operation-functions }
+
+آپ عام `def` functions (بغیر `async`) بھی استعمال کر سکتے ہیں، اور اسی طرح `yield` استعمال کر سکتے ہیں۔
+
+FastAPI یقینی بنائے گا کہ یہ درست طریقے سے چلے تاکہ 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 کو تبدیل کرنے اور بھیجنے کے لیے [`jsonable_encoder`](./encoder.md) استعمال کرے گا۔
+
+{* ../../docs_src/server_sent_events/tutorial001_py310.py ln[34:37] hl[35] *}
+
+## `ServerSentEvent` { #serversentevent }
+
+اگر آپ کو SSE fields جیسے `event`، `id`، `retry`، یا `comment` سیٹ کرنے کی ضرورت ہے، تو آپ سادہ data کی بجائے `ServerSentEvent` objects yield کر سکتے ہیں۔
+
+`fastapi.sse` سے `ServerSentEvent` import کریں:
+
+{* ../../docs_src/server_sent_events/tutorial002_py310.py hl[4,26] *}
+
+`data` field ہمیشہ JSON کے طور پر encode ہوتا ہے۔ آپ JSON کے طور پر serialize ہونے کے قابل کوئی بھی قدر دے سکتے ہیں، بشمول Pydantic models۔
+
+## Raw Data { #raw-data }
+
+اگر آپ کو JSON encoding **کے بغیر** data بھیجنے کی ضرورت ہے، تو `data` کی بجائے `raw_data` استعمال کریں۔
+
+یہ پہلے سے فارمیٹ شدہ text، log lines، یا خاص "sentinel" قدروں جیسے `[DONE]` بھیجنے کے لیے مفید ہے۔
+
+{* ../../docs_src/server_sent_events/tutorial003_py310.py hl[17] *}
+
+/// note | نوٹ
+
+`data` اور `raw_data` باہمی طور پر خارج ہیں۔ آپ ہر `ServerSentEvent` میں ان میں سے صرف ایک سیٹ کر سکتے ہیں۔
+
+///
+
+## `Last-Event-ID` کے ساتھ دوبارہ شروع کرنا { #resuming-with-last-event-id }
+
+جب connection ٹوٹنے کے بعد browser دوبارہ connect ہوتا ہے، تو وہ آخری وصول شدہ `id` کو `Last-Event-ID` header میں بھیجتا ہے۔
+
+آپ اسے ایک header parameter کے طور پر پڑھ سکتے ہیں اور اسے استعمال کر کے stream کو وہیں سے دوبارہ شروع کر سکتے ہیں جہاں 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 بہترین طریقے خود بخود لاگو کرتا ہے۔
+
+* جب کوئی پیغام نہ ہو تو ہر 15 سیکنڈ بعد **"keep alive" `ping` comment** بھیجتا ہے، تاکہ بعض proxies کو connection بند کرنے سے روکا جا سکے، جیسا کہ [HTML specification: Server-Sent Events](https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes) میں تجویز کیا گیا ہے۔
+* Stream کی **caching روکنے** کے لیے `Cache-Control: no-cache` header سیٹ کرتا ہے۔
+* Nginx جیسے بعض proxies میں **buffering روکنے** کے لیے ایک خاص header `X-Accel-Buffering: no` سیٹ کرتا ہے۔
+
+آپ کو اس بارے میں کچھ نہیں کرنا، یہ خود بخود کام کرتا ہے۔ 🤓
diff --git a/docs/ur/docs/tutorial/sql-databases.md b/docs/ur/docs/tutorial/sql-databases.md
new file mode 100644
index 000000000..4962f983d
--- /dev/null
+++ b/docs/ur/docs/tutorial/sql-databases.md
@@ -0,0 +1,357 @@
+# SQL (Relational) Databases { #sql-relational-databases }
+
+**FastAPI** آپ سے SQL (relational) database استعمال کرنے کا تقاضا نہیں کرتا۔ لیکن آپ **کوئی بھی database** استعمال کر سکتے ہیں جو آپ چاہیں۔
+
+یہاں ہم [SQLModel](https://sqlmodel.tiangolo.com/) استعمال کرنے کی ایک مثال دیکھیں گے۔
+
+**SQLModel** [SQLAlchemy](https://www.sqlalchemy.org/) اور Pydantic کے اوپر بنایا گیا ہے۔ اسے **FastAPI** کے اسی مصنف نے بنایا تھا تاکہ یہ ان FastAPI applications کے لیے بہترین ہو جنہیں **SQL databases** استعمال کرنے کی ضرورت ہوتی ہے۔
+
+/// tip | مشورہ
+
+آپ کوئی بھی دوسری SQL یا NoSQL database library استعمال کر سکتے ہیں (بعض صورتوں میں جنہیں "ORMs" کہا جاتا ہے)، FastAPI آپ کو کسی بھی چیز کے استعمال پر مجبور نہیں کرتا۔ 😎
+
+///
+
+چونکہ SQLModel SQLAlchemy پر مبنی ہے، آپ آسانی سے SQLAlchemy کی طرف سے **حمایت یافتہ کوئی بھی database** استعمال کر سکتے ہیں (جو انہیں SQLModel کی طرف سے بھی حمایت یافتہ بناتا ہے)، جیسے:
+
+* PostgreSQL
+* MySQL
+* SQLite
+* Oracle
+* Microsoft SQL Server، وغیرہ
+
+اس مثال میں، ہم **SQLite** استعمال کریں گے، کیونکہ یہ ایک واحد فائل استعمال کرتا ہے اور Python میں اس کی بلٹ ان حمایت موجود ہے۔ تو، آپ اس مثال کو کاپی کر کے جیسے ہے ویسے چلا سکتے ہیں۔
+
+بعد میں، اپنی production application کے لیے، آپ **PostgreSQL** جیسا database server استعمال کرنا چاہ سکتے ہیں۔
+
+/// tip | مشورہ
+
+**FastAPI** اور **PostgreSQL** کے ساتھ ایک سرکاری project generator موجود ہے جس میں frontend اور مزید tools شامل ہیں: [https://github.com/fastapi/full-stack-fastapi-template](https://github.com/fastapi/full-stack-fastapi-template)
+
+///
+
+یہ ایک بہت سادہ اور مختصر tutorial ہے، اگر آپ databases کے بارے میں عمومی طور پر، SQL کے بارے میں، یا مزید جدید خصوصیات کے بارے میں سیکھنا چاہتے ہیں، تو [SQLModel دستاویزات](https://sqlmodel.tiangolo.com/) پر جائیں۔
+
+## `SQLModel` انسٹال کریں { #install-sqlmodel }
+
+سب سے پہلے، یقینی بنائیں کہ آپ نے اپنا [virtual environment](../virtual-environments.md) بنایا ہے، اسے فعال کیا ہے، اور پھر `sqlmodel` انسٹال کریں:
+
+
+
+