diff --git a/.vscode/cspell.json b/.vscode/cspell.json
index b6538176b590..31e214c5c504 100644
--- a/.vscode/cspell.json
+++ b/.vscode/cspell.json
@@ -75,6 +75,7 @@
     "sdk/eventhub/azure-eventhub/**",
     "sdk/easm/azure-defender-easm/azure/defender/easm/**",
     "sdk/graphrbac/azure-graphrbac/**",
+    "sdk/healthdataaiservices/azure-health-deidentification/tests/data/**/*",
     "sdk/healthinsights/azure-healthinsights-cancerprofiling/azure/**",
     "sdk/healthinsights/azure-healthinsights-clinicalmatching/azure/**",
     "sdk/formrecognizer/azure-ai-formrecognizer/samples/sample_forms/**",
@@ -224,6 +225,8 @@
     "dateutil",
     "ddos",
     "decryptor",
+    "deidentification",
+    "deidservice",
     "delenv",
     "dependened",
     "deque",
@@ -426,6 +429,7 @@
     "struct",
     "STRUCT",
     "substringof",
+    "surrogated",
     "systemperf",
     "tenvparallel",
     "Teradata",
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/CHANGELOG.md b/sdk/healthdataaiservices/azure-health-deidentification/CHANGELOG.md
index be2efaec75db..4c9f4f3d03c9 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/CHANGELOG.md
+++ b/sdk/healthdataaiservices/azure-health-deidentification/CHANGELOG.md
@@ -1,14 +1,31 @@
 # Release History
 
-## 1.0.0b2 (Unreleased)
+## 1.0.0 (Unreleased)
 
 ### Features Added
 
-### Breaking Changes
+- Introduced `DeidentificationCustomizationOptions` and `DeidentificationJobCustomizationOptions` models.
+    - Added `surrogate_locale` field in these models.
+    - Moved `redaction_format` field into these models.
+- Introduced `overwrite` property in `TargetStorageLocation` model, which allows a job to overwrite existing documents in the storage location. 
 
-### Bugs Fixed
+### Breaking Changes
 
-### Other Changes
+- Changed method names in `DeidentificationClient` to match functionality:
+    - Changed the `deidentify` method name to `deidentify_text`.
+    - Changed the `begin_create_job` method name to `begin_deidentify_documents`.
+- Renamed the property `DeidentificationContent.operation` to `operation_type`.
+- Deprecated `DocumentDataType`.
+- Changed the model `DeidentificationDocumentDetails`:
+    - Renamed `input` to `input_location`.
+    - Renamed `output` to `output_location`.
+- Changed the model `DeidentificationJob`
+    - Renamed `name` to `job_name`.
+    - Renamed `operation` to `operation_type`.
+- Renamed the model `OperationState` to `OperationStatus`.
+- Changed `path` field to `location` in `SourceStorageLocation` and `TargetStorageLocation`.
+- Changed `outputPrefix` behavior to no longer include `job_name` by default.
+- Deprecated `path` and `location` from `TaggerResult` model.
 
 ## 1.0.0b1 (2024-08-15)
 
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/MANIFEST.in b/sdk/healthdataaiservices/azure-health-deidentification/MANIFEST.in
index 9f9ff90e4267..55f7e682755b 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/MANIFEST.in
+++ b/sdk/healthdataaiservices/azure-health-deidentification/MANIFEST.in
@@ -4,4 +4,4 @@ include azure/health/deidentification/py.typed
 recursive-include tests *.py
 recursive-include samples *.py *.md
 include azure/__init__.py
-include azure/health/__init__.py
\ No newline at end of file
+include azure/health/__init__.py
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/README.md b/sdk/healthdataaiservices/azure-health-deidentification/README.md
index 88008785e019..468f40a10a31 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/README.md
+++ b/sdk/healthdataaiservices/azure-health-deidentification/README.md
@@ -1,82 +1,220 @@
+# Azure Health Data Services de-identification service client library for Python
 
+This package contains a client library for the de-identification service in Azure Health Data Services which 
+enables users to tag, redact, or surrogate health data containing Protected Health Information (PHI).
+For more on service functionality and important usage considerations, see [the de-identification service overview][product_documentation].
 
-# Azure Health Deidentification client library for Python
-Azure.Health.Deidentification is a managed service that enables users to tag, redact, or surrogate health data.
+This library support API versions `2024-11-15` and earlier.
+
+Use the client library for the de-identification service to:
+- Discover PHI in unstructured text
+- Replace PHI in unstructured text with placeholder values
+- Replace PHI in unstructured text with realistic surrogate values
+- Manage asynchronous jobs to de-identify documents in Azure Storage
+
+[Source code](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification)
+| [Package (PyPI)](https://pypi.org/project/azure-health-deidentification)
+| [API reference documentation](https://learn.microsoft.com/python/api/overview/azure/health-deidentification)
+| [Product documentation][product_documentation]
+| [Samples][samples]
 
 ## Getting started
 
+### Prequisites
+
+- Python 3.9 or later is required to use this package.
+- Install [pip][pip].
+- You need an [Azure subscription][azure_sub] to use this package.
+- [Deploy the de-identification service][deid_quickstart].
+- [Configure Azure role-based access control (RBAC)][deid_rbac] for the operations you will perform.
+
 ### Install the package
 
 ```bash
 python -m pip install azure-health-deidentification
 ```
 
-#### Prequisites
+### Authentication
+To authenticate with the de-identification service, install [`azure-identity`][azure_identity_pip]:
 
-- Python 3.8 or later is required to use this package.
-- You need an [Azure subscription][azure_sub] to use this package.
-- An existing Azure Health Deidentification instance.
-#### Create with an Azure Active Directory Credential
-To use an [Azure Active Directory (AAD) token credential][authenticate_with_token],
-provide an instance of the desired credential type obtained from the
-[azure-identity][azure_identity_credentials] library.
+```bash
+python -m pip install azure.identity
+```
+
+You can use [DefaultAzureCredential][default_azure_credential] to automatically find the best credential to use at runtime.
 
-To authenticate with AAD, you must first [pip][pip] install [`azure-identity`][azure_identity_pip]
+You will need a **service URL** to instantiate a client object. You can find the service URL for a particular resource in the [Azure portal][azure_portal], or using the [Azure CLI][azure_cli]:
 
-After setup, you can choose which type of [credential][azure_identity_credentials] from azure.identity to use.
-As an example, [DefaultAzureCredential][default_azure_credential] can be used to authenticate the client:
+```bash
+# Get the service URL for the resource
+az deidservice show --name "<resource-name>" --resource-group "<resource-group-name>" --query "properties.serviceUrl"
+```
 
-Set the values of the client ID, tenant ID, and client secret of the AAD application as environment variables:
-`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_SECRET`
+Optionally, save the service URL as an environment variable named `AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT` for the sample client initialization code.
 
-Use the returned token credential to authenticate the client:
+Create a client with the endpoint and credential:
+<!-- SNIPPET: examples.create_client -->
 
 ```python
->>> from azure.health.deidentification import DeidentificationClient
->>> from azure.identity import DefaultAzureCredential
->>> client = DeidentificationClient(endpoint='<endpoint>', credential=DefaultAzureCredential())
+endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+credential = DefaultAzureCredential()
+client = DeidentificationClient(endpoint, credential)
 ```
 
+<!-- END SNIPPET -->
+
 ## Key concepts
 
-**Operation Modes**
-- Tag: Will return a structure of offset and length with the PHI category of the related text spans.
-- Redact: Will return output text with placeholder stubbed text. ex. `[name]`
-- Surrogate: Will return output text with synthetic replacements.
-  - `My name is John Smith`
-  - `My name is Tom Jones`
+### De-identification operations:
+Given an input text, the de-identification service can perform three main operations:
+- `Tag` returns the category and location within the text of detected PHI entities.
+- `Redact` returns output text where detected PHI entities are replaced with placeholder text. For example `John` replaced with `[name]`.
+- `Surrogate` returns output text where detected PHI entities are replaced with realistic replacement values. For example, `My name is John Smith` could become `My name is Tom Jones`.
+
+### Available endpoints
+There are two ways to interact with the de-identification service. You can send text directly, or you can create jobs 
+to de-identify documents in Azure Storage.
+
+You can de-identify text directly using the `DeidentificationClient`:
+<!-- SNIPPET: deidentify_text_surrogate.surrogate -->
+
+```python
+body = DeidentificationContent(input_text="Hello, my name is John Smith.")
+result: DeidentificationResult = client.deidentify_text(body)
+print(f'\nOriginal Text:        "{body.input_text}"')
+print(f'Surrogated Text:   "{result.output_text}"')  # Surrogated output: Hello, my name is <synthetic name>.
+```
+
+<!-- END SNIPPET -->
+
+To de-identify documents in Azure Storage, see [Tutorial: Configure Azure Storage to de-identify documents][deid_configure_storage]
+for prerequisites and configuration options.
+
+To run the sample code below, populate the following environment variables:
+- `AZURE_STORAGE_ACCOUNT_LOCATION`: an Azure Storage container endpoint, like `https://<storageaccount>.blob.core.windows.net/<container>`.
+- `INPUT_PREFIX`: the prefix of the input document name(s) in the container. For example, providing `folder1` would create a job that would process documents like `https://<storageaccount>.blob.core.windows.net/<container>/folder1/document1.txt`
+
+The client exposes a `begin_deidentify_documents` method that returns a [LROPoller](https://learn.microsoft.com/python/api/azure-core/azure.core.polling.lropoller) instance. You can get the result of the operation by calling `result()`, optionally passing in a `timeout` value in seconds:
+<!-- SNIPPET: deidentify_documents.sample -->
+
+```python
+endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
+inputPrefix = os.environ["INPUT_PREFIX"]
+outputPrefix = "_output"
+
+credential = DefaultAzureCredential()
+
+client = DeidentificationClient(endpoint, credential)
 
-**Job Integration with Azure Storage**
-Instead of sending text, you can send an Azure Storage Location to the service. We will asynchronously
-process the list of files and output the deidentified files to a location of your choice.
+jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
 
-Limitations:
-- Maximum file count per job: 1000 documents
-- Maximum file size per file: 2 MB
+job = DeidentificationJob(
+    source_location=SourceStorageLocation(
+        location=storage_location,
+        prefix=inputPrefix,
+    ),
+    target_location=TargetStorageLocation(location=storage_location, prefix=outputPrefix, overwrite=True),
+)
+
+finished_job: DeidentificationJob = client.begin_deidentify_documents(jobname, job).result(timeout=60)
+
+print(f"Job Name:   {finished_job.job_name}")
+print(f"Job Status: {finished_job.status}")
+print(f"File Count: {finished_job.summary.total_count if finished_job.summary is not None else 0}")
+```
+
+<!-- END SNIPPET -->
 
 ## Examples
+The following sections provide code samples covering some of the most common client use cases, including: 
+
+- [Discover PHI in unstructured text](#discover-phi-in-unstructured-text)
+- [Replace PHI in unstructured text with placeholder values](#replace-phi-in-unstructured-text-with-placeholder-values)
+- [Replace PHI in unstructured text with realistic surrogate values](#replace-phi-in-unstructured-text-with-realistic-surrogate-values)
+
+See the [samples][samples] for code files illustrating common patterns, including creating and managing jobs to de-identify documents in Azure Storage. 
+
+### Discover PHI in unstructured text
+When you specify the `TAG` operation, the service will return information about the PHI entities it detects. You can use this information to customize your de-identification workflow:
+<!-- SNIPPET: deidentify_text_tag.tag -->
 
 ```python
->>> from azure.health.deidentification import DeidentificationClient
->>> from azure.identity import DefaultAzureCredential
->>> from azure.core.exceptions import HttpResponseError
+body = DeidentificationContent(
+    input_text="Hello, I'm Dr. John Smith.", operation_type=DeidentificationOperationType.TAG
+)
+result: DeidentificationResult = client.deidentify_text(body)
+print(f'\nOriginal Text:    "{body.input_text}"')
+
+if result.tagger_result and result.tagger_result.entities:
+    print(f"Tagged Entities:")
+    for entity in result.tagger_result.entities:
+        print(
+            f'\tEntity Text: "{entity.text}", Entity Category: "{entity.category}", Offset: "{entity.offset.code_point}", Length: "{entity.length.code_point}"'
+        )
+else:
+    print("\tNo tagged entities found.")
+```
+
+<!-- END SNIPPET -->
 
->>> client = DeidentificationClient(endpoint='<endpoint>', credential=DefaultAzureCredential())
->>> try:
-        <!-- write test code here -->
-    except HttpResponseError as e:
-        print('service responds error: {}'.format(e.response.json()))
+### Replace PHI in unstructured text with placeholder values
+When you specify the `REDACT` operation, the service will replace the PHI entities it detects with placeholder values. You can learn more about [redaction customization][deid_redact]. 
+<!-- SNIPPET: deidentify_text_redact.redact -->
 
+```python
+body = DeidentificationContent(
+    input_text="It's great to work at Contoso.", operation_type=DeidentificationOperationType.REDACT
+)
+result: DeidentificationResult = client.deidentify_text(body)
+print(f'\nOriginal Text:        "{body.input_text}"')
+print(f'Redacted Text:   "{result.output_text}"')  # Redacted output: "It's great to work at [organization]."
 ```
 
-## Next steps
+<!-- END SNIPPET -->
 
-- Find a bug, or have feedback? Raise an issue with "Health Deidentification" Label.
+### Replace PHI in unstructured text with realistic surrogate values
+The default operation is the `SURROGATE` operation. Using this operation, the service will replace the PHI entities it detects with realistic surrogate values:
+<!-- SNIPPET: deidentify_text_surrogate.surrogate -->
 
+```python
+body = DeidentificationContent(input_text="Hello, my name is John Smith.")
+result: DeidentificationResult = client.deidentify_text(body)
+print(f'\nOriginal Text:        "{body.input_text}"')
+print(f'Surrogated Text:   "{result.output_text}"')  # Surrogated output: Hello, my name is <synthetic name>.
+```
+
+<!-- END SNIPPET -->
+
+### Troubleshooting
+The `DeidentificationClient` raises various `AzureError` [exceptions][azure_error]. For example, if you
+provide an invalid service URL, an `ServiceRequestError` would be raised with a message indicating the failure cause.
+In the following code snippet, the error is handled and displayed:
+<!-- SNIPPET: examples.handle_error -->
+
+```python
+error_client = DeidentificationClient("https://contoso.deid.azure.com", credential)
+body = DeidentificationContent(input_text="Hello, I'm Dr. John Smith.")
+
+try:
+    error_client.deidentify_text(body)
+except AzureError as e:
+    print("\nError: " + e.message)
+```
+
+<!-- END SNIPPET -->
+
+If you encounter an error indicating that the service is unable to access source or target storage in a de-identification job:
+- Ensure you [assign a managed identity][deid_managed_identity] to your de-identification service
+- Ensure you [assign appropriate permissions][deid_rbac] to the managed identity to access the storage account
+
+## Next steps
+
+Find a bug, or have feedback? Raise an issue with the [Health Deidentification][github_issue_label] label.
 
 ## Troubleshooting
 
-- **Unabled to Access Source or Target Storage**
+- **Unable to Access Source or Target Storage**
   - Ensure you create your deid service with a system assigned managed identity
   - Ensure your storage account has given permissions to that managed identity
 
@@ -99,10 +237,18 @@ additional questions or comments.
 
 <!-- LINKS -->
 [code_of_conduct]: https://opensource.microsoft.com/codeofconduct/
-[authenticate_with_token]: https://learn.microsoft.com/azure/cognitive-services/authentication?tabs=powershell#authenticate-with-an-authentication-token
-[azure_identity_credentials]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#credentials
+[product_documentation]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/
 [azure_identity_pip]: https://pypi.org/project/azure-identity/
 [default_azure_credential]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/identity/azure-identity#defaultazurecredential
 [pip]: https://pypi.org/project/pip/
 [azure_sub]: https://azure.microsoft.com/free/
-
+[deid_quickstart]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/quickstart
+[deid_redact]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format
+[deid_rbac]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/manage-access-rbac
+[deid_managed_identity]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/managed-identities
+[deid_configure_storage]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/configure-storage
+[azure_cli]: https://learn.microsoft.com/cli/azure/healthcareapis/deidservice?view=azure-cli-latest
+[azure_portal]: https://ms.portal.azure.com
+[azure_error]: https://learn.microsoft.com/python/api/azure-core/azure.core.exceptions.azureerror
+[samples]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples
+[github_issue_label]: https://github.com/Azure/azure-sdk-for-python/labels/Health%20Deidentification
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/apiview-properties.json b/sdk/healthdataaiservices/azure-health-deidentification/apiview-properties.json
new file mode 100644
index 000000000000..ca581aa8fd80
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/apiview-properties.json
@@ -0,0 +1,26 @@
+{
+    "CrossLanguagePackageId": "HealthDataAIServices.DeidServices",
+    "CrossLanguageDefinitionId": {
+        "azure.health.deidentification.models.DeidentificationContent": "HealthDataAIServices.DeidServices.DeidentificationContent",
+        "azure.health.deidentification.models.DeidentificationCustomizationOptions": "HealthDataAIServices.DeidServices.DeidentificationCustomizationOptions",
+        "azure.health.deidentification.models.DeidentificationDocumentDetails": "HealthDataAIServices.DeidServices.DeidentificationDocumentDetails",
+        "azure.health.deidentification.models.DeidentificationDocumentLocation": "HealthDataAIServices.DeidServices.DeidentificationDocumentLocation",
+        "azure.health.deidentification.models.DeidentificationJob": "HealthDataAIServices.DeidServices.DeidentificationJob",
+        "azure.health.deidentification.models.DeidentificationJobCustomizationOptions": "HealthDataAIServices.DeidServices.DeidentificationJobCustomizationOptions",
+        "azure.health.deidentification.models.DeidentificationJobSummary": "HealthDataAIServices.DeidServices.DeidentificationJobSummary",
+        "azure.health.deidentification.models.DeidentificationResult": "HealthDataAIServices.DeidServices.DeidentificationResult",
+        "azure.health.deidentification.models.PhiEntity": "HealthDataAIServices.DeidServices.PhiEntity",
+        "azure.health.deidentification.models.PhiTaggerResult": "HealthDataAIServices.DeidServices.PhiTaggerResult",
+        "azure.health.deidentification.models.SourceStorageLocation": "HealthDataAIServices.DeidServices.SourceStorageLocation",
+        "azure.health.deidentification.models.StringIndex": "HealthDataAIServices.DeidServices.StringIndex",
+        "azure.health.deidentification.models.TargetStorageLocation": "HealthDataAIServices.DeidServices.TargetStorageLocation",
+        "azure.health.deidentification.models.DeidentificationOperationType": "HealthDataAIServices.DeidServices.DeidentificationOperationType",
+        "azure.health.deidentification.models.OperationStatus": "Azure.Core.Foundations.OperationState",
+        "azure.health.deidentification.models.PhiCategory": "HealthDataAIServices.DeidServices.PhiCategory",
+        "azure.health.deidentification.DeidentificationClient.get_job": "HealthDataAIServices.DeidServices.getJob",
+        "azure.health.deidentification.DeidentificationClient.begin_deidentify_documents": "HealthDataAIServices.DeidServices.deidentifyDocuments",
+        "azure.health.deidentification.DeidentificationClient.cancel_job": "HealthDataAIServices.DeidServices.cancelJob",
+        "azure.health.deidentification.DeidentificationClient.delete_job": "HealthDataAIServices.DeidServices.deleteJob",
+        "azure.health.deidentification.DeidentificationClient.deidentify_text": "HealthDataAIServices.DeidServices.deidentifyText"
+    }
+}
\ No newline at end of file
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/assets.json b/sdk/healthdataaiservices/azure-health-deidentification/assets.json
index b3c9831d2065..570b3437333f 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/assets.json
+++ b/sdk/healthdataaiservices/azure-health-deidentification/assets.json
@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "python",
   "TagPrefix": "python/healthdataaiservices/azure-health-deidentification",
-  "Tag": "python/healthdataaiservices/azure-health-deidentification_a8eed6d322"
+  "Tag": "python/healthdataaiservices/azure-health-deidentification_a9eda6ed27"
 }
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/__init__.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/__init__.py
index 01d9492ed4f6..75df74cc79f6 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/__init__.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/__init__.py
@@ -5,15 +5,21 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
 
-from ._client import DeidentificationClient
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+
+from ._client import DeidentificationClient  # type: ignore
 from ._version import VERSION
 
 __version__ = VERSION
 
 try:
     from ._patch import __all__ as _patch_all
-    from ._patch import *  # pylint: disable=unused-wildcard-import
+    from ._patch import *
 except ImportError:
     _patch_all = []
 from ._patch import patch_sdk as _patch_sdk
@@ -21,6 +27,6 @@
 __all__ = [
     "DeidentificationClient",
 ]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__])  # pyright: ignore
 
 _patch_sdk()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_client.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_client.py
index 787817c317d9..c146765707fd 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_client.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_client.py
@@ -19,30 +19,27 @@
 from ._serialization import Deserializer, Serializer
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core.credentials import TokenCredential
 
 
-class DeidentificationClient(
-    DeidentificationClientOperationsMixin
-):  # pylint: disable=client-accepts-api-version-keyword
+class DeidentificationClient(DeidentificationClientOperationsMixin):
     """DeidentificationClient.
 
     :param endpoint: Url of your De-identification Service. Required.
     :type endpoint: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials.TokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is
-     "2024-07-12-preview". Note that overriding this default value may result in unsupported
-     behavior.
+    :keyword api_version: The API version to use for this operation. Default value is "2024-11-15".
+     Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
      Retry-After header is present.
     """
 
     def __init__(self, endpoint: str, credential: "TokenCredential", **kwargs: Any) -> None:
-        _endpoint = "https://{endpoint}"
+        _endpoint = "{endpoint}"
         self._config = DeidentificationClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
+
         _policies = kwargs.pop("policies", None)
         if _policies is None:
             _policies = [
@@ -86,7 +83,7 @@ def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs:
 
         request_copy = deepcopy(request)
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
 
         request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_configuration.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_configuration.py
index 35237a99ba8f..1ac729392e01 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_configuration.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_configuration.py
@@ -13,11 +13,10 @@
 from ._version import VERSION
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core.credentials import TokenCredential
 
 
-class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
+class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-attributes
     """Configuration for DeidentificationClient.
 
     Note that all parameters used to create this instance are saved as instance
@@ -27,14 +26,13 @@ class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-
     :type endpoint: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials.TokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is
-     "2024-07-12-preview". Note that overriding this default value may result in unsupported
-     behavior.
+    :keyword api_version: The API version to use for this operation. Default value is "2024-11-15".
+     Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, endpoint: str, credential: "TokenCredential", **kwargs: Any) -> None:
-        api_version: str = kwargs.pop("api_version", "2024-07-12-preview")
+        api_version: str = kwargs.pop("api_version", "2024-11-15")
 
         if endpoint is None:
             raise ValueError("Parameter 'endpoint' must not be None.")
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_model_base.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_model_base.py
index 43fd8c7e9b1b..49d5c7259389 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_model_base.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_model_base.py
@@ -1,10 +1,12 @@
+# pylint: disable=too-many-lines
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
-# pylint: disable=protected-access, arguments-differ, signature-differs, broad-except
+# pylint: disable=protected-access, broad-except
 
 import copy
 import calendar
@@ -19,6 +21,8 @@
 import email.utils
 from datetime import datetime, date, time, timedelta, timezone
 from json import JSONEncoder
+import xml.etree.ElementTree as ET
+from collections.abc import MutableMapping
 from typing_extensions import Self
 import isodate
 from azure.core.exceptions import DeserializationError
@@ -26,11 +30,6 @@
 from azure.core.pipeline import PipelineResponse
 from azure.core.serialization import _Null
 
-if sys.version_info >= (3, 9):
-    from collections.abc import MutableMapping
-else:
-    from typing import MutableMapping
-
 _LOGGER = logging.getLogger(__name__)
 
 __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
@@ -123,7 +122,7 @@ def _serialize_datetime(o, format: typing.Optional[str] = None):
 
 def _is_readonly(p):
     try:
-        return p._visibility == ["read"]  # pylint: disable=protected-access
+        return p._visibility == ["read"]
     except AttributeError:
         return False
 
@@ -286,6 +285,12 @@ def _deserialize_decimal(attr):
     return decimal.Decimal(str(attr))
 
 
+def _deserialize_int_as_str(attr):
+    if isinstance(attr, int):
+        return attr
+    return int(attr)
+
+
 _DESERIALIZE_MAPPING = {
     datetime: _deserialize_datetime,
     date: _deserialize_date,
@@ -307,9 +312,11 @@ def _deserialize_decimal(attr):
 
 
 def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None):
+    if annotation is int and rf and rf._format == "str":
+        return _deserialize_int_as_str
     if rf and rf._format:
         return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format)
-    return _DESERIALIZE_MAPPING.get(annotation)
+    return _DESERIALIZE_MAPPING.get(annotation)  # pyright: ignore
 
 
 def _get_type_alias_type(module_name: str, alias_name: str):
@@ -337,7 +344,7 @@ def _get_model(module_name: str, model_name: str):
 _UNSET = object()
 
 
-class _MyMutableMapping(MutableMapping[str, typing.Any]):  # pylint: disable=unsubscriptable-object
+class _MyMutableMapping(MutableMapping[str, typing.Any]):
     def __init__(self, data: typing.Dict[str, typing.Any]) -> None:
         self._data = data
 
@@ -363,50 +370,97 @@ def __ne__(self, other: typing.Any) -> bool:
         return not self.__eq__(other)
 
     def keys(self) -> typing.KeysView[str]:
+        """
+        :returns: a set-like object providing a view on D's keys
+        :rtype: ~typing.KeysView
+        """
         return self._data.keys()
 
     def values(self) -> typing.ValuesView[typing.Any]:
+        """
+        :returns: an object providing a view on D's values
+        :rtype: ~typing.ValuesView
+        """
         return self._data.values()
 
     def items(self) -> typing.ItemsView[str, typing.Any]:
+        """
+        :returns: set-like object providing a view on D's items
+        :rtype: ~typing.ItemsView
+        """
         return self._data.items()
 
     def get(self, key: str, default: typing.Any = None) -> typing.Any:
+        """
+        Get the value for key if key is in the dictionary, else default.
+        :param str key: The key to look up.
+        :param any default: The value to return if key is not in the dictionary. Defaults to None
+        :returns: D[k] if k in D, else d.
+        :rtype: any
+        """
         try:
             return self[key]
         except KeyError:
             return default
 
     @typing.overload
-    def pop(self, key: str) -> typing.Any: ...
+    def pop(self, key: str) -> typing.Any: ...  # pylint: disable=arguments-differ
 
     @typing.overload
-    def pop(self, key: str, default: _T) -> _T: ...
+    def pop(self, key: str, default: _T) -> _T: ...  # pylint: disable=signature-differs
 
     @typing.overload
-    def pop(self, key: str, default: typing.Any) -> typing.Any: ...
+    def pop(self, key: str, default: typing.Any) -> typing.Any: ...  # pylint: disable=signature-differs
 
     def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        """
+        Removes specified key and return the corresponding value.
+        :param str key: The key to pop.
+        :param any default: The value to return if key is not in the dictionary
+        :returns: The value corresponding to the key.
+        :rtype: any
+        :raises KeyError: If key is not found and default is not given.
+        """
         if default is _UNSET:
             return self._data.pop(key)
         return self._data.pop(key, default)
 
     def popitem(self) -> typing.Tuple[str, typing.Any]:
+        """
+        Removes and returns some (key, value) pair
+        :returns: The (key, value) pair.
+        :rtype: tuple
+        :raises KeyError: if D is empty.
+        """
         return self._data.popitem()
 
     def clear(self) -> None:
+        """
+        Remove all items from D.
+        """
         self._data.clear()
 
-    def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+    def update(self, *args: typing.Any, **kwargs: typing.Any) -> None:  # pylint: disable=arguments-differ
+        """
+        Updates D from mapping/iterable E and F.
+        :param any args: Either a mapping object or an iterable of key-value pairs.
+        """
         self._data.update(*args, **kwargs)
 
     @typing.overload
     def setdefault(self, key: str, default: None = None) -> None: ...
 
     @typing.overload
-    def setdefault(self, key: str, default: typing.Any) -> typing.Any: ...
+    def setdefault(self, key: str, default: typing.Any) -> typing.Any: ...  # pylint: disable=signature-differs
 
     def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any:
+        """
+        Same as calling D.get(k, d), and setting D[k]=d if k not found
+        :param str key: The key to look up.
+        :param any default: The value to set if key is not in the dictionary
+        :returns: D[k] if k in D, else d.
+        :rtype: any
+        """
         if default is _UNSET:
             return self._data.setdefault(key)
         return self._data.setdefault(key, default)
@@ -441,6 +495,10 @@ def _serialize(o, format: typing.Optional[str] = None):  # pylint: disable=too-m
         return float(o)
     if isinstance(o, enum.Enum):
         return o.value
+    if isinstance(o, int):
+        if format == "str":
+            return str(o)
+        return o
     try:
         # First try datetime.datetime
         return _serialize_datetime(o, format)
@@ -471,11 +529,16 @@ def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typin
         return value
     if rf._is_model:
         return _deserialize(rf._type, value)
+    if isinstance(value, ET.Element):
+        value = _deserialize(rf._type, value)
     return _serialize(value, rf._format)
 
 
 class Model(_MyMutableMapping):
     _is_model = True
+    # label whether current class's _attr_to_rest_field has been calculated
+    # could not see _attr_to_rest_field directly because subclass inherits it from parent class
+    _calculated: typing.Set[str] = set()
 
     def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         class_name = self.__class__.__name__
@@ -486,10 +549,58 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
             for rest_field in self._attr_to_rest_field.values()
             if rest_field._default is not _UNSET
         }
-        if args:
-            dict_to_pass.update(
-                {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()}
-            )
+        if args:  # pylint: disable=too-many-nested-blocks
+            if isinstance(args[0], ET.Element):
+                existed_attr_keys = []
+                model_meta = getattr(self, "_xml", {})
+
+                for rf in self._attr_to_rest_field.values():
+                    prop_meta = getattr(rf, "_xml", {})
+                    xml_name = prop_meta.get("name", rf._rest_name)
+                    xml_ns = prop_meta.get("ns", model_meta.get("ns", None))
+                    if xml_ns:
+                        xml_name = "{" + xml_ns + "}" + xml_name
+
+                    # attribute
+                    if prop_meta.get("attribute", False) and args[0].get(xml_name) is not None:
+                        existed_attr_keys.append(xml_name)
+                        dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].get(xml_name))
+                        continue
+
+                    # unwrapped element is array
+                    if prop_meta.get("unwrapped", False):
+                        # unwrapped array could either use prop items meta/prop meta
+                        if prop_meta.get("itemsName"):
+                            xml_name = prop_meta.get("itemsName")
+                            xml_ns = prop_meta.get("itemNs")
+                            if xml_ns:
+                                xml_name = "{" + xml_ns + "}" + xml_name
+                        items = args[0].findall(xml_name)  # pyright: ignore
+                        if len(items) > 0:
+                            existed_attr_keys.append(xml_name)
+                            dict_to_pass[rf._rest_name] = _deserialize(rf._type, items)
+                        continue
+
+                    # text element is primitive type
+                    if prop_meta.get("text", False):
+                        if args[0].text is not None:
+                            dict_to_pass[rf._rest_name] = _deserialize(rf._type, args[0].text)
+                        continue
+
+                    # wrapped element could be normal property or array, it should only have one element
+                    item = args[0].find(xml_name)
+                    if item is not None:
+                        existed_attr_keys.append(xml_name)
+                        dict_to_pass[rf._rest_name] = _deserialize(rf._type, item)
+
+                # rest thing is additional properties
+                for e in args[0]:
+                    if e.tag not in existed_attr_keys:
+                        dict_to_pass[e.tag] = _convert_element(e)
+            else:
+                dict_to_pass.update(
+                    {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()}
+                )
         else:
             non_attr_kwargs = [k for k in kwargs if k not in self._attr_to_rest_field]
             if non_attr_kwargs:
@@ -507,55 +618,70 @@ def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
     def copy(self) -> "Model":
         return Model(self.__dict__)
 
-    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:  # pylint: disable=unused-argument
-        # we know the last three classes in mro are going to be 'Model', 'dict', and 'object'
-        mros = cls.__mro__[:-3][::-1]  # ignore model, dict, and object parents, and reverse the mro order
-        attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
-            k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
-        }
-        annotations = {
-            k: v
-            for mro_class in mros
-            if hasattr(mro_class, "__annotations__")  # pylint: disable=no-member
-            for k, v in mro_class.__annotations__.items()  # pylint: disable=no-member
-        }
-        for attr, rf in attr_to_rest_field.items():
-            rf._module = cls.__module__
-            if not rf._type:
-                rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
-            if not rf._rest_name_input:
-                rf._rest_name_input = attr
-        cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
-
-        return super().__new__(cls)  # pylint: disable=no-value-for-parameter
+    def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self:
+        if f"{cls.__module__}.{cls.__qualname__}" not in cls._calculated:
+            # we know the last nine classes in mro are going to be 'Model', '_MyMutableMapping', 'MutableMapping',
+            # 'Mapping', 'Collection', 'Sized', 'Iterable', 'Container' and 'object'
+            mros = cls.__mro__[:-9][::-1]  # ignore parents, and reverse the mro order
+            attr_to_rest_field: typing.Dict[str, _RestField] = {  # map attribute name to rest_field property
+                k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type")
+            }
+            annotations = {
+                k: v
+                for mro_class in mros
+                if hasattr(mro_class, "__annotations__")
+                for k, v in mro_class.__annotations__.items()
+            }
+            for attr, rf in attr_to_rest_field.items():
+                rf._module = cls.__module__
+                if not rf._type:
+                    rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None))
+                if not rf._rest_name_input:
+                    rf._rest_name_input = attr
+            cls._attr_to_rest_field: typing.Dict[str, _RestField] = dict(attr_to_rest_field.items())
+            cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}")
+
+        return super().__new__(cls)
 
     def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None:
         for base in cls.__bases__:
-            if hasattr(base, "__mapping__"):  # pylint: disable=no-member
-                base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore  # pylint: disable=no-member
+            if hasattr(base, "__mapping__"):
+                base.__mapping__[discriminator or cls.__name__] = cls  # type: ignore
 
     @classmethod
-    def _get_discriminator(cls, exist_discriminators) -> typing.Optional[str]:
+    def _get_discriminator(cls, exist_discriminators) -> typing.Optional["_RestField"]:
         for v in cls.__dict__.values():
-            if (
-                isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators
-            ):  # pylint: disable=protected-access
-                return v._rest_name  # pylint: disable=protected-access
+            if isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators:
+                return v
         return None
 
     @classmethod
     def _deserialize(cls, data, exist_discriminators):
-        if not hasattr(cls, "__mapping__"):  # pylint: disable=no-member
+        if not hasattr(cls, "__mapping__"):
             return cls(data)
         discriminator = cls._get_discriminator(exist_discriminators)
-        exist_discriminators.append(discriminator)
-        mapped_cls = cls.__mapping__.get(data.get(discriminator), cls)  # pyright: ignore # pylint: disable=no-member
-        if mapped_cls == cls:
+        if discriminator is None:
             return cls(data)
-        return mapped_cls._deserialize(data, exist_discriminators)  # pylint: disable=protected-access
+        exist_discriminators.append(discriminator._rest_name)
+        if isinstance(data, ET.Element):
+            model_meta = getattr(cls, "_xml", {})
+            prop_meta = getattr(discriminator, "_xml", {})
+            xml_name = prop_meta.get("name", discriminator._rest_name)
+            xml_ns = prop_meta.get("ns", model_meta.get("ns", None))
+            if xml_ns:
+                xml_name = "{" + xml_ns + "}" + xml_name
+
+            if data.get(xml_name) is not None:
+                discriminator_value = data.get(xml_name)
+            else:
+                discriminator_value = data.find(xml_name).text  # pyright: ignore
+        else:
+            discriminator_value = data.get(discriminator._rest_name)
+        mapped_cls = cls.__mapping__.get(discriminator_value, cls)  # pyright: ignore # pylint: disable=no-member
+        return mapped_cls._deserialize(data, exist_discriminators)
 
     def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing.Any]:
-        """Return a dict that can be JSONify using json.dump.
+        """Return a dict that can be turned into json using json.dump.
 
         :keyword bool exclude_readonly: Whether to remove the readonly properties.
         :returns: A dict JSON compatible object
@@ -563,6 +689,7 @@ def as_dict(self, *, exclude_readonly: bool = False) -> typing.Dict[str, typing.
         """
 
         result = {}
+        readonly_props = []
         if exclude_readonly:
             readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)]
         for k, v in self.items():
@@ -617,6 +744,8 @@ def _deserialize_dict(
 ):
     if obj is None:
         return obj
+    if isinstance(obj, ET.Element):
+        obj = {child.tag: child for child in obj}
     return {k: _deserialize(value_deserializer, v, module) for k, v in obj.items()}
 
 
@@ -637,6 +766,8 @@ def _deserialize_sequence(
 ):
     if obj is None:
         return obj
+    if isinstance(obj, ET.Element):
+        obj = list(obj)
     return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
 
 
@@ -647,12 +778,12 @@ def _sorted_annotations(types: typing.List[typing.Any]) -> typing.List[typing.An
     )
 
 
-def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915, R0912
+def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-return-statements, too-many-branches
     annotation: typing.Any,
     module: typing.Optional[str],
     rf: typing.Optional["_RestField"] = None,
 ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]:
-    if not annotation or annotation in [int, float]:
+    if not annotation:
         return None
 
     # is it a type alias?
@@ -667,7 +798,7 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
         except AttributeError:
             model_name = annotation
         if module is not None:
-            annotation = _get_model(module, model_name)
+            annotation = _get_model(module, model_name)  # type: ignore
 
     try:
         if module and _is_model(annotation):
@@ -727,7 +858,6 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     try:
         if annotation._name in ["List", "Set", "Tuple", "Sequence"]:  # pyright: ignore
             if len(annotation.__args__) > 1:  # pyright: ignore
-
                 entry_deserializers = [
                     _get_deserialize_callable_from_annotation(dt, module, rf)
                     for dt in annotation.__args__  # pyright: ignore
@@ -762,12 +892,23 @@ def _deserialize_default(
 def _deserialize_with_callable(
     deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]],
     value: typing.Any,
-):
+):  # pylint: disable=too-many-return-statements
     try:
         if value is None or isinstance(value, _Null):
             return None
+        if isinstance(value, ET.Element):
+            if deserializer is str:
+                return value.text or ""
+            if deserializer is int:
+                return int(value.text) if value.text else None
+            if deserializer is float:
+                return float(value.text) if value.text else None
+            if deserializer is bool:
+                return value.text == "true" if value.text else None
         if deserializer is None:
             return value
+        if deserializer in [int, float, bool]:
+            return deserializer(value)
         if isinstance(deserializer, CaseInsensitiveEnumMeta):
             try:
                 return deserializer(value)
@@ -797,6 +938,35 @@ def _deserialize(
     return _deserialize_with_callable(deserializer, value)
 
 
+def _failsafe_deserialize(
+    deserializer: typing.Any,
+    value: typing.Any,
+    module: typing.Optional[str] = None,
+    rf: typing.Optional["_RestField"] = None,
+    format: typing.Optional[str] = None,
+) -> typing.Any:
+    try:
+        return _deserialize(deserializer, value, module, rf, format)
+    except DeserializationError:
+        _LOGGER.warning(
+            "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
+        )
+        return None
+
+
+def _failsafe_deserialize_xml(
+    deserializer: typing.Any,
+    value: typing.Any,
+) -> typing.Any:
+    try:
+        return _deserialize_xml(deserializer, value)
+    except DeserializationError:
+        _LOGGER.warning(
+            "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
+        )
+        return None
+
+
 class _RestField:
     def __init__(
         self,
@@ -808,6 +978,7 @@ def __init__(
         default: typing.Any = _UNSET,
         format: typing.Optional[str] = None,
         is_multipart_file_input: bool = False,
+        xml: typing.Optional[typing.Dict[str, typing.Any]] = None,
     ):
         self._type = type
         self._rest_name_input = name
@@ -818,6 +989,7 @@ def __init__(
         self._default = default
         self._format = format
         self._is_multipart_file_input = is_multipart_file_input
+        self._xml = xml if xml is not None else {}
 
     @property
     def _class_type(self) -> typing.Any:
@@ -868,6 +1040,7 @@ def rest_field(
     default: typing.Any = _UNSET,
     format: typing.Optional[str] = None,
     is_multipart_file_input: bool = False,
+    xml: typing.Optional[typing.Dict[str, typing.Any]] = None,
 ) -> typing.Any:
     return _RestField(
         name=name,
@@ -876,6 +1049,7 @@ def rest_field(
         default=default,
         format=format,
         is_multipart_file_input=is_multipart_file_input,
+        xml=xml,
     )
 
 
@@ -884,5 +1058,175 @@ def rest_discriminator(
     name: typing.Optional[str] = None,
     type: typing.Optional[typing.Callable] = None,  # pylint: disable=redefined-builtin
     visibility: typing.Optional[typing.List[str]] = None,
+    xml: typing.Optional[typing.Dict[str, typing.Any]] = None,
+) -> typing.Any:
+    return _RestField(name=name, type=type, is_discriminator=True, visibility=visibility, xml=xml)
+
+
+def serialize_xml(model: Model, exclude_readonly: bool = False) -> str:
+    """Serialize a model to XML.
+
+    :param Model model: The model to serialize.
+    :param bool exclude_readonly: Whether to exclude readonly properties.
+    :returns: The XML representation of the model.
+    :rtype: str
+    """
+    return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode")  # type: ignore
+
+
+def _get_element(
+    o: typing.Any,
+    exclude_readonly: bool = False,
+    parent_meta: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    wrapped_element: typing.Optional[ET.Element] = None,
+) -> typing.Union[ET.Element, typing.List[ET.Element]]:
+    if _is_model(o):
+        model_meta = getattr(o, "_xml", {})
+
+        # if prop is a model, then use the prop element directly, else generate a wrapper of model
+        if wrapped_element is None:
+            wrapped_element = _create_xml_element(
+                model_meta.get("name", o.__class__.__name__),
+                model_meta.get("prefix"),
+                model_meta.get("ns"),
+            )
+
+        readonly_props = []
+        if exclude_readonly:
+            readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)]
+
+        for k, v in o.items():
+            # do not serialize readonly properties
+            if exclude_readonly and k in readonly_props:
+                continue
+
+            prop_rest_field = _get_rest_field(o._attr_to_rest_field, k)
+            if prop_rest_field:
+                prop_meta = getattr(prop_rest_field, "_xml").copy()
+                # use the wire name as xml name if no specific name is set
+                if prop_meta.get("name") is None:
+                    prop_meta["name"] = k
+            else:
+                # additional properties will not have rest field, use the wire name as xml name
+                prop_meta = {"name": k}
+
+            # if no ns for prop, use model's
+            if prop_meta.get("ns") is None and model_meta.get("ns"):
+                prop_meta["ns"] = model_meta.get("ns")
+                prop_meta["prefix"] = model_meta.get("prefix")
+
+            if prop_meta.get("unwrapped", False):
+                # unwrapped could only set on array
+                wrapped_element.extend(_get_element(v, exclude_readonly, prop_meta))
+            elif prop_meta.get("text", False):
+                # text could only set on primitive type
+                wrapped_element.text = _get_primitive_type_value(v)
+            elif prop_meta.get("attribute", False):
+                xml_name = prop_meta.get("name", k)
+                if prop_meta.get("ns"):
+                    ET.register_namespace(prop_meta.get("prefix"), prop_meta.get("ns"))  # pyright: ignore
+                    xml_name = "{" + prop_meta.get("ns") + "}" + xml_name  # pyright: ignore
+                # attribute should be primitive type
+                wrapped_element.set(xml_name, _get_primitive_type_value(v))
+            else:
+                # other wrapped prop element
+                wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta))
+        return wrapped_element
+    if isinstance(o, list):
+        return [_get_element(x, exclude_readonly, parent_meta) for x in o]  # type: ignore
+    if isinstance(o, dict):
+        result = []
+        for k, v in o.items():
+            result.append(
+                _get_wrapped_element(
+                    v,
+                    exclude_readonly,
+                    {
+                        "name": k,
+                        "ns": parent_meta.get("ns") if parent_meta else None,
+                        "prefix": parent_meta.get("prefix") if parent_meta else None,
+                    },
+                )
+            )
+        return result
+
+    # primitive case need to create element based on parent_meta
+    if parent_meta:
+        return _get_wrapped_element(
+            o,
+            exclude_readonly,
+            {
+                "name": parent_meta.get("itemsName", parent_meta.get("name")),
+                "prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")),
+                "ns": parent_meta.get("itemsNs", parent_meta.get("ns")),
+            },
+        )
+
+    raise ValueError("Could not serialize value into xml: " + o)
+
+
+def _get_wrapped_element(
+    v: typing.Any,
+    exclude_readonly: bool,
+    meta: typing.Optional[typing.Dict[str, typing.Any]],
+) -> ET.Element:
+    wrapped_element = _create_xml_element(
+        meta.get("name") if meta else None, meta.get("prefix") if meta else None, meta.get("ns") if meta else None
+    )
+    if isinstance(v, (dict, list)):
+        wrapped_element.extend(_get_element(v, exclude_readonly, meta))
+    elif _is_model(v):
+        _get_element(v, exclude_readonly, meta, wrapped_element)
+    else:
+        wrapped_element.text = _get_primitive_type_value(v)
+    return wrapped_element
+
+
+def _get_primitive_type_value(v) -> str:
+    if v is True:
+        return "true"
+    if v is False:
+        return "false"
+    if isinstance(v, _Null):
+        return ""
+    return str(v)
+
+
+def _create_xml_element(tag, prefix=None, ns=None):
+    if prefix and ns:
+        ET.register_namespace(prefix, ns)
+    if ns:
+        return ET.Element("{" + ns + "}" + tag)
+    return ET.Element(tag)
+
+
+def _deserialize_xml(
+    deserializer: typing.Any,
+    value: str,
 ) -> typing.Any:
-    return _RestField(name=name, type=type, is_discriminator=True, visibility=visibility)
+    element = ET.fromstring(value)  # nosec
+    return _deserialize(deserializer, element)
+
+
+def _convert_element(e: ET.Element):
+    # dict case
+    if len(e.attrib) > 0 or len({child.tag for child in e}) > 1:
+        dict_result: typing.Dict[str, typing.Any] = {}
+        for child in e:
+            if dict_result.get(child.tag) is not None:
+                if isinstance(dict_result[child.tag], list):
+                    dict_result[child.tag].append(_convert_element(child))
+                else:
+                    dict_result[child.tag] = [dict_result[child.tag], _convert_element(child)]
+            else:
+                dict_result[child.tag] = _convert_element(child)
+        dict_result.update(e.attrib)
+        return dict_result
+    # array case
+    if len(e) > 0:
+        array_result: typing.List[typing.Any] = []
+        for child in e:
+            array_result.append(_convert_element(child))
+        return array_result
+    # primitive case
+    return e.text
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/__init__.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/__init__.py
index f30b11092e89..8a3952cdf768 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/__init__.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/__init__.py
@@ -5,15 +5,21 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
 
-from ._operations import DeidentificationClientOperationsMixin
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+
+from ._operations import DeidentificationClientOperationsMixin  # type: ignore
 
 from ._patch import __all__ as _patch_all
-from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import *
 from ._patch import patch_sdk as _patch_sdk
 
 __all__ = [
     "DeidentificationClientOperationsMixin",
 ]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__])  # pyright: ignore
 _patch_sdk()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/_operations.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/_operations.py
index f1aea8456604..144902854258 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/_operations.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_operations/_operations.py
@@ -1,4 +1,3 @@
-# pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
@@ -6,10 +5,10 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+from collections.abc import MutableMapping
 from io import IOBase
 import json
-import sys
-from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Optional, Type, TypeVar, Union, cast, overload
+from typing import Any, Callable, Dict, IO, Iterable, Iterator, List, Optional, TypeVar, Union, cast, overload
 import urllib.parse
 
 from azure.core.exceptions import (
@@ -18,6 +17,8 @@
     ResourceExistsError,
     ResourceNotFoundError,
     ResourceNotModifiedError,
+    StreamClosedError,
+    StreamConsumedError,
     map_error,
 )
 from azure.core.paging import ItemPaged
@@ -33,11 +34,7 @@
 from .._serialization import Serializer
 from .._vendor import DeidentificationClientMixinABC
 
-if sys.version_info >= (3, 9):
-    from collections.abc import MutableMapping
-else:
-    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
-JSON = MutableMapping[str, Any]  # pylint: disable=unsubscriptable-object
+JSON = MutableMapping[str, Any]
 T = TypeVar("T")
 ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
 
@@ -45,17 +42,17 @@
 _SERIALIZER.client_side_validation = False
 
 
-def build_deidentification_get_job_request(name: str, **kwargs: Any) -> HttpRequest:
+def build_deidentification_get_job_request(job_name: str, **kwargs: Any) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
     _url = "/jobs/{name}"
     path_format_arguments = {
-        "name": _SERIALIZER.url("name", name, "str"),
+        "name": _SERIALIZER.url("job_name", job_name, "str"),
     }
 
     _url: str = _url.format(**path_format_arguments)  # type: ignore
@@ -69,18 +66,20 @@ def build_deidentification_get_job_request(name: str, **kwargs: Any) -> HttpRequ
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_create_job_request(name: str, **kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+def build_deidentification_deidentify_documents_request(  # pylint: disable=name-too-long
+    job_name: str, **kwargs: Any
+) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
     _url = "/jobs/{name}"
     path_format_arguments = {
-        "name": _SERIALIZER.url("name", name, "str"),
+        "name": _SERIALIZER.url("job_name", job_name, "str"),
     }
 
     _url: str = _url.format(**path_format_arguments)  # type: ignore
@@ -96,13 +95,13 @@ def build_deidentification_create_job_request(name: str, **kwargs: Any) -> HttpR
     return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_list_jobs_request(
+def build_deidentification_list_jobs_internal_request(  # pylint: disable=name-too-long
     *, maxpagesize: Optional[int] = None, continuation_token_parameter: Optional[str] = None, **kwargs: Any
 ) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
@@ -123,19 +122,23 @@ def build_deidentification_list_jobs_request(
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_list_job_documents_request(  # pylint: disable=name-too-long
-    name: str, *, maxpagesize: Optional[int] = None, continuation_token_parameter: Optional[str] = None, **kwargs: Any
+def build_deidentification_list_job_documents_internal_request(  # pylint: disable=name-too-long
+    job_name: str,
+    *,
+    maxpagesize: Optional[int] = None,
+    continuation_token_parameter: Optional[str] = None,
+    **kwargs: Any
 ) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
     _url = "/jobs/{name}/documents"
     path_format_arguments = {
-        "name": _SERIALIZER.url("name", name, "str"),
+        "name": _SERIALIZER.url("job_name", job_name, "str"),
     }
 
     _url: str = _url.format(**path_format_arguments)  # type: ignore
@@ -155,17 +158,19 @@ def build_deidentification_list_job_documents_request(  # pylint: disable=name-t
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_cancel_job_request(name: str, **kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+def build_deidentification_cancel_job_request(  # pylint: disable=name-too-long
+    job_name: str, **kwargs: Any
+) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
     _url = "/jobs/{name}:cancel"
     path_format_arguments = {
-        "name": _SERIALIZER.url("name", name, "str"),
+        "name": _SERIALIZER.url("job_name", job_name, "str"),
     }
 
     _url: str = _url.format(**path_format_arguments)  # type: ignore
@@ -179,17 +184,19 @@ def build_deidentification_cancel_job_request(name: str, **kwargs: Any) -> HttpR
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_delete_job_request(name: str, **kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+def build_deidentification_delete_job_request(  # pylint: disable=name-too-long
+    job_name: str, **kwargs: Any
+) -> HttpRequest:
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
     _url = "/jobs/{name}"
     path_format_arguments = {
-        "name": _SERIALIZER.url("name", name, "str"),
+        "name": _SERIALIZER.url("job_name", job_name, "str"),
     }
 
     _url: str = _url.format(**path_format_arguments)  # type: ignore
@@ -203,12 +210,12 @@ def build_deidentification_delete_job_request(name: str, **kwargs: Any) -> HttpR
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_deidentification_deidentify_request(**kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+def build_deidentification_deidentify_text_request(**kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
     _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
     _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
 
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-07-12-preview"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-11-15"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
@@ -228,63 +235,18 @@ def build_deidentification_deidentify_request(**kwargs: Any) -> HttpRequest:  #
 class DeidentificationClientOperationsMixin(DeidentificationClientMixinABC):
 
     @distributed_trace
-    def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
+    def get_job(self, job_name: str, **kwargs: Any) -> _models.DeidentificationJob:
         """Get a de-identification job.
 
         Resource read operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: DeidentificationJob. The DeidentificationJob is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationJob
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -298,13 +260,13 @@ def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
         cls: ClsType[_models.DeidentificationJob] = kwargs.pop("cls", None)
 
         _request = build_deidentification_get_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -317,7 +279,10 @@ def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
 
         if response.status_code not in [200]:
             if _stream:
-                response.read()  # Load the body in memory and close the socket
+                try:
+                    response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
@@ -336,10 +301,10 @@ def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
 
         return deserialized  # type: ignore
 
-    def _create_job_initial(
-        self, name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
+    def _deidentify_documents_initial(
+        self, job_name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
     ) -> Iterator[bytes]:
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -360,8 +325,8 @@ def _create_job_initial(
         else:
             _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
 
-        _request = build_deidentification_create_job_request(
-            name=name,
+        _request = build_deidentification_deidentify_documents_request(
+            job_name=job_name,
             content_type=content_type,
             api_version=self._config.api_version,
             content=_content,
@@ -369,7 +334,7 @@ def _create_job_initial(
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -381,30 +346,20 @@ def _create_job_initial(
         response = pipeline_response.http_response
 
         if response.status_code not in [200, 201]:
-            response.read()  # Load the body in memory and close the socket
+            try:
+                response.read()  # Load the body in memory and close the socket
+            except (StreamConsumedError, StreamClosedError):
+                pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
         response_headers = {}
-        if response.status_code == 200:
-            response_headers["x-ms-client-request-id"] = self._deserialize(
-                "str", response.headers.get("x-ms-client-request-id")
-            )
-            response_headers["Operation-Location"] = self._deserialize(
-                "str", response.headers.get("Operation-Location")
-            )
-
-            deserialized = response.iter_bytes()
-
-        if response.status_code == 201:
-            response_headers["x-ms-client-request-id"] = self._deserialize(
-                "str", response.headers.get("x-ms-client-request-id")
-            )
-            response_headers["Operation-Location"] = self._deserialize(
-                "str", response.headers.get("Operation-Location")
-            )
+        response_headers["x-ms-client-request-id"] = self._deserialize(
+            "str", response.headers.get("x-ms-client-request-id")
+        )
+        response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location"))
 
-            deserialized = response.iter_bytes()
+        deserialized = response.iter_bytes()
 
         if cls:
             return cls(pipeline_response, deserialized, response_headers)  # type: ignore
@@ -412,15 +367,20 @@ def _create_job_initial(
         return deserialized  # type: ignore
 
     @overload
-    def begin_create_job(
-        self, name: str, resource: _models.DeidentificationJob, *, content_type: str = "application/json", **kwargs: Any
+    def begin_deidentify_documents(
+        self,
+        job_name: str,
+        resource: _models.DeidentificationJob,
+        *,
+        content_type: str = "application/json",
+        **kwargs: Any
     ) -> LROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: ~azure.health.deidentification.models.DeidentificationJob
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
@@ -431,105 +391,18 @@ def begin_create_job(
         :rtype:
          ~azure.core.polling.LROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                resource = {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @overload
-    def begin_create_job(
-        self, name: str, resource: JSON, *, content_type: str = "application/json", **kwargs: Any
+    def begin_deidentify_documents(
+        self, job_name: str, resource: JSON, *, content_type: str = "application/json", **kwargs: Any
     ) -> LROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: JSON
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
@@ -540,63 +413,18 @@ def begin_create_job(
         :rtype:
          ~azure.core.polling.LROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @overload
-    def begin_create_job(
-        self, name: str, resource: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    def begin_deidentify_documents(
+        self, job_name: str, resource: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> LROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
@@ -607,63 +435,18 @@ def begin_create_job(
         :rtype:
          ~azure.core.polling.LROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @distributed_trace
-    def begin_create_job(
-        self, name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
+    def begin_deidentify_documents(
+        self, job_name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
     ) -> LROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Is one of the following types: DeidentificationJob,
          JSON, IO[bytes] Required.
         :type resource: ~azure.health.deidentification.models.DeidentificationJob or JSON or IO[bytes]
@@ -672,93 +455,6 @@ def begin_create_job(
         :rtype:
          ~azure.core.polling.LROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                resource = {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
         _params = kwargs.pop("params", {}) or {}
@@ -769,8 +465,8 @@ def begin_create_job(
         lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
         cont_token: Optional[str] = kwargs.pop("continuation_token", None)
         if cont_token is None:
-            raw_result = self._create_job_initial(
-                name=name,
+            raw_result = self._deidentify_documents_initial(
+                job_name=job_name,
                 resource=resource,
                 content_type=content_type,
                 cls=lambda x, y, z: x,
@@ -797,7 +493,7 @@ def get_long_running_output(pipeline_response):
             return deserialized
 
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
 
         if polling is True:
@@ -820,7 +516,7 @@ def get_long_running_output(pipeline_response):
         )
 
     @distributed_trace
-    def list_jobs(
+    def _list_jobs_internal(
         self, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
     ) -> Iterable["_models.DeidentificationJob"]:
         """List de-identification jobs.
@@ -833,51 +529,6 @@ def list_jobs(
         :return: An iterator like instance of DeidentificationJob
         :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
         _headers = kwargs.pop("headers", {}) or {}
         _params = kwargs.pop("params", {}) or {}
@@ -885,7 +536,7 @@ def list_jobs(
         maxpagesize = kwargs.pop("maxpagesize", None)
         cls: ClsType[List[_models.DeidentificationJob]] = kwargs.pop("cls", None)
 
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -896,7 +547,7 @@ def list_jobs(
         def prepare_request(next_link=None):
             if not next_link:
 
-                _request = build_deidentification_list_jobs_request(
+                _request = build_deidentification_list_jobs_internal_request(
                     maxpagesize=maxpagesize,
                     continuation_token_parameter=continuation_token_parameter,
                     api_version=self._config.api_version,
@@ -904,7 +555,9 @@ def prepare_request(next_link=None):
                     params=_params,
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -922,7 +575,9 @@ def prepare_request(next_link=None):
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -930,7 +585,7 @@ def prepare_request(next_link=None):
 
         def extract_data(pipeline_response):
             deserialized = pipeline_response.http_response.json()
-            list_of_elem = _deserialize(List[_models.DeidentificationJob], deserialized["value"])
+            list_of_elem = _deserialize(List[_models.DeidentificationJob], deserialized.get("value", []))
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -953,58 +608,30 @@ def get_next(next_link=None):
         return ItemPaged(get_next, extract_data)
 
     @distributed_trace
-    def list_job_documents(
-        self, name: str, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
-    ) -> Iterable["_models.DocumentDetails"]:
+    def _list_job_documents_internal(
+        self, job_name: str, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
+    ) -> Iterable["_models.DeidentificationDocumentDetails"]:
         """List processed documents within a job.
 
         Resource list operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :keyword continuation_token_parameter: Token to continue a previous query. Default value is
          None.
         :paramtype continuation_token_parameter: str
-        :return: An iterator like instance of DocumentDetails
-        :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DocumentDetails]
+        :return: An iterator like instance of DeidentificationDocumentDetails
+        :rtype:
+         ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DeidentificationDocumentDetails]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "id": "str",
-                    "input": {
-                        "etag": "str",
-                        "path": "str"
-                    },
-                    "status": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "output": {
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
         _headers = kwargs.pop("headers", {}) or {}
         _params = kwargs.pop("params", {}) or {}
 
         maxpagesize = kwargs.pop("maxpagesize", None)
-        cls: ClsType[List[_models.DocumentDetails]] = kwargs.pop("cls", None)
+        cls: ClsType[List[_models.DeidentificationDocumentDetails]] = kwargs.pop("cls", None)
 
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1015,8 +642,8 @@ def list_job_documents(
         def prepare_request(next_link=None):
             if not next_link:
 
-                _request = build_deidentification_list_job_documents_request(
-                    name=name,
+                _request = build_deidentification_list_job_documents_internal_request(
+                    job_name=job_name,
                     maxpagesize=maxpagesize,
                     continuation_token_parameter=continuation_token_parameter,
                     api_version=self._config.api_version,
@@ -1024,7 +651,9 @@ def prepare_request(next_link=None):
                     params=_params,
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1042,7 +671,9 @@ def prepare_request(next_link=None):
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1050,7 +681,7 @@ def prepare_request(next_link=None):
 
         def extract_data(pipeline_response):
             deserialized = pipeline_response.http_response.json()
-            list_of_elem = _deserialize(List[_models.DocumentDetails], deserialized["value"])
+            list_of_elem = _deserialize(List[_models.DeidentificationDocumentDetails], deserialized.get("value", []))
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.get("nextLink") or None, iter(list_of_elem)
@@ -1073,7 +704,7 @@ def get_next(next_link=None):
         return ItemPaged(get_next, extract_data)
 
     @distributed_trace
-    def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
+    def cancel_job(self, job_name: str, **kwargs: Any) -> _models.DeidentificationJob:
         """Cancel a de-identification job.
 
         Cancels a job that is in progress.
@@ -1083,58 +714,13 @@ def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
 
         If the job is already complete, this will have no effect.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: DeidentificationJob. The DeidentificationJob is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationJob
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1148,13 +734,13 @@ def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
         cls: ClsType[_models.DeidentificationJob] = kwargs.pop("cls", None)
 
         _request = build_deidentification_cancel_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1167,7 +753,10 @@ def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
 
         if response.status_code not in [200]:
             if _stream:
-                response.read()  # Load the body in memory and close the socket
+                try:
+                    response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
@@ -1187,18 +776,18 @@ def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
         return deserialized  # type: ignore
 
     @distributed_trace
-    def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable=inconsistent-return-statements
+    def delete_job(self, job_name: str, **kwargs: Any) -> None:  # pylint: disable=inconsistent-return-statements
         """Delete a de-identification job.
 
         Removes the record of the job from the service. Does not delete any documents.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: None
         :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1212,13 +801,13 @@ def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable=incon
         cls: ClsType[None] = kwargs.pop("cls", None)
 
         _request = build_deidentification_delete_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1242,7 +831,7 @@ def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable=incon
             return cls(pipeline_response, None, response_headers)  # type: ignore
 
     @overload
-    def deidentify(
+    def deidentify_text(
         self, body: _models.DeidentificationContent, *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1257,47 +846,10 @@ def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                body = {
-                    "inputText": "str",
-                    "dataType": "str",
-                    "operation": "str",
-                    "redactionFormat": "str"
-                }
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @overload
-    def deidentify(
+    def deidentify_text(
         self, body: JSON, *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1312,39 +864,10 @@ def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @overload
-    def deidentify(
+    def deidentify_text(
         self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1359,39 +882,10 @@ def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @distributed_trace
-    def deidentify(
+    def deidentify_text(
         self, body: Union[_models.DeidentificationContent, JSON, IO[bytes]], **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1404,45 +898,8 @@ def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                body = {
-                    "inputText": "str",
-                    "dataType": "str",
-                    "operation": "str",
-                    "redactionFormat": "str"
-                }
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1463,7 +920,7 @@ def deidentify(
         else:
             _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
 
-        _request = build_deidentification_deidentify_request(
+        _request = build_deidentification_deidentify_text_request(
             content_type=content_type,
             api_version=self._config.api_version,
             content=_content,
@@ -1471,7 +928,7 @@ def deidentify(
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1484,16 +941,24 @@ def deidentify(
 
         if response.status_code not in [200]:
             if _stream:
-                response.read()  # Load the body in memory and close the socket
+                try:
+                    response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
+        response_headers = {}
+        response_headers["x-ms-client-request-id"] = self._deserialize(
+            "str", response.headers.get("x-ms-client-request-id")
+        )
+
         if _stream:
             deserialized = response.iter_bytes()
         else:
             deserialized = _deserialize(_models.DeidentificationResult, response.json())
 
         if cls:
-            return cls(pipeline_response, deserialized, {})  # type: ignore
+            return cls(pipeline_response, deserialized, response_headers)  # type: ignore
 
         return deserialized  # type: ignore
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_patch.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_patch.py
index f7dd32510333..bb09ee2cbf77 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_patch.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_patch.py
@@ -6,9 +6,41 @@
 
 Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
 """
-from typing import List
+from typing import Any, Iterable, List
+from azure.core.tracing.decorator import distributed_trace
+from azure.health.deidentification.models import DeidentificationDocumentDetails, DeidentificationJob
+from ._client import DeidentificationClient as DeidentificationClientGenerated
 
-__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+__all__: List[str] = [
+    "DeidentificationClient",
+]  # Add all objects you want publicly available to users at this package level
+
+
+class DeidentificationClient(DeidentificationClientGenerated):
+
+    @distributed_trace
+    def list_jobs(self, **kwargs: Any) -> Iterable[DeidentificationJob]:
+        """
+        List de-identification jobs.
+
+        :return: An iterator like instance of DeidentificationJob
+        :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DeidentificationJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        return super()._list_jobs_internal(continuation_token_parameter=None, **kwargs)
+
+    @distributed_trace
+    def list_job_documents(self, job_name: str, **kwargs: Any) -> Iterable[DeidentificationDocumentDetails]:
+        """
+        List processed documents within a job.
+
+        :param job_name: The name of a job. Required.
+        :type job_name: str
+        :return: An iterator like instance of DocumentDetails
+        :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DocumentDetails]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        return super()._list_job_documents_internal(job_name=job_name, continuation_token_parameter=None, **kwargs)
 
 
 def patch_sdk():
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_serialization.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_serialization.py
index 8139854b97bb..eb86ea23c965 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_serialization.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_serialization.py
@@ -1,30 +1,12 @@
+# pylint: disable=line-too-long,useless-suppression,too-many-lines
+# coding=utf-8
 # --------------------------------------------------------------------------
-#
 # Copyright (c) Microsoft Corporation. All rights reserved.
-#
-# The MIT License (MIT)
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the ""Software""), to
-# deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-# IN THE SOFTWARE.
-#
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) Python Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-# pylint: skip-file
 # pyright: reportUnnecessaryTypeIgnoreComment=false
 
 from base64 import b64decode, b64encode
@@ -48,11 +30,8 @@
     IO,
     Mapping,
     Callable,
-    TypeVar,
     MutableMapping,
-    Type,
     List,
-    Mapping,
 )
 
 try:
@@ -62,13 +41,13 @@
 import xml.etree.ElementTree as ET
 
 import isodate  # type: ignore
+from typing_extensions import Self
 
 from azure.core.exceptions import DeserializationError, SerializationError
 from azure.core.serialization import NULL as CoreNull
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
-ModelType = TypeVar("ModelType", bound="Model")
 JSON = MutableMapping[str, Any]
 
 
@@ -91,6 +70,8 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
         :param data: Input, could be bytes or stream (will be decoded with UTF8) or text
         :type data: str or bytes or IO
         :param str content_type: The content type.
+        :return: The deserialized data.
+        :rtype: object
         """
         if hasattr(data, "read"):
             # Assume a stream
@@ -112,7 +93,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
             try:
                 return json.loads(data_as_str)
             except ValueError as err:
-                raise DeserializationError("JSON is invalid: {}".format(err), err)
+                raise DeserializationError("JSON is invalid: {}".format(err), err) from err
         elif "xml" in (content_type or []):
             try:
 
@@ -155,6 +136,11 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]],
         Use bytes and headers to NOT use any requests/aiohttp or whatever
         specific implementation.
         Headers will tested for "content-type"
+
+        :param bytes body_bytes: The body of the response.
+        :param dict headers: The headers of the response.
+        :returns: The deserialized data.
+        :rtype: object
         """
         # Try to use content-type from headers if available
         content_type = None
@@ -179,80 +165,31 @@ def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]],
 except NameError:
     _long_type = int
 
-
-class UTC(datetime.tzinfo):
-    """Time Zone info for handling UTC"""
-
-    def utcoffset(self, dt):
-        """UTF offset for UTC is 0."""
-        return datetime.timedelta(0)
-
-    def tzname(self, dt):
-        """Timestamp representation."""
-        return "Z"
-
-    def dst(self, dt):
-        """No daylight saving for UTC."""
-        return datetime.timedelta(hours=1)
-
-
-try:
-    from datetime import timezone as _FixedOffset  # type: ignore
-except ImportError:  # Python 2.7
-
-    class _FixedOffset(datetime.tzinfo):  # type: ignore
-        """Fixed offset in minutes east from UTC.
-        Copy/pasted from Python doc
-        :param datetime.timedelta offset: offset in timedelta format
-        """
-
-        def __init__(self, offset):
-            self.__offset = offset
-
-        def utcoffset(self, dt):
-            return self.__offset
-
-        def tzname(self, dt):
-            return str(self.__offset.total_seconds() / 3600)
-
-        def __repr__(self):
-            return "<FixedOffset {}>".format(self.tzname(None))
-
-        def dst(self, dt):
-            return datetime.timedelta(0)
-
-        def __getinitargs__(self):
-            return (self.__offset,)
-
-
-try:
-    from datetime import timezone
-
-    TZ_UTC = timezone.utc
-except ImportError:
-    TZ_UTC = UTC()  # type: ignore
+TZ_UTC = datetime.timezone.utc
 
 _FLATTEN = re.compile(r"(?<!\\)\.")
 
 
-def attribute_transformer(key, attr_desc, value):
+def attribute_transformer(key, attr_desc, value):  # pylint: disable=unused-argument
     """A key transformer that returns the Python attribute.
 
     :param str key: The attribute name
     :param dict attr_desc: The attribute metadata
     :param object value: The value
     :returns: A key using attribute name
+    :rtype: str
     """
     return (key, value)
 
 
-def full_restapi_key_transformer(key, attr_desc, value):
+def full_restapi_key_transformer(key, attr_desc, value):  # pylint: disable=unused-argument
     """A key transformer that returns the full RestAPI key path.
 
-    :param str _: The attribute name
+    :param str key: The attribute name
     :param dict attr_desc: The attribute metadata
     :param object value: The value
     :returns: A list of keys using RestAPI syntax.
+    :rtype: list
     """
     keys = _FLATTEN.split(attr_desc["key"])
     return ([_decode_attribute_map_key(k) for k in keys], value)
@@ -265,22 +202,29 @@ def last_restapi_key_transformer(key, attr_desc, value):
     :param dict attr_desc: The attribute metadata
     :param object value: The value
     :returns: The last RestAPI key.
+    :rtype: str
     """
     key, value = full_restapi_key_transformer(key, attr_desc, value)
     return (key[-1], value)
 
 
 def _create_xml_node(tag, prefix=None, ns=None):
-    """Create a XML node."""
+    """Create a XML node.
+
+    :param str tag: The tag name
+    :param str prefix: The prefix
+    :param str ns: The namespace
+    :return: The XML node
+    :rtype: xml.etree.ElementTree.Element
+    """
     if prefix and ns:
         ET.register_namespace(prefix, ns)
     if ns:
         return ET.Element("{" + ns + "}" + tag)
-    else:
-        return ET.Element(tag)
+    return ET.Element(tag)
 
 
-class Model(object):
+class Model:
     """Mixin for all client request body/response body models to support
     serialization and deserialization.
     """
@@ -291,7 +235,7 @@ class Model(object):
 
     def __init__(self, **kwargs: Any) -> None:
         self.additional_properties: Optional[Dict[str, Any]] = {}
-        for k in kwargs:
+        for k in kwargs:  # pylint: disable=consider-using-dict-items
             if k not in self._attribute_map:
                 _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
             elif k in self._validation and self._validation[k].get("readonly", False):
@@ -300,13 +244,23 @@ def __init__(self, **kwargs: Any) -> None:
                 setattr(self, k, kwargs[k])
 
     def __eq__(self, other: Any) -> bool:
-        """Compare objects by comparing all attributes."""
+        """Compare objects by comparing all attributes.
+
+        :param object other: The object to compare
+        :returns: True if objects are equal
+        :rtype: bool
+        """
         if isinstance(other, self.__class__):
             return self.__dict__ == other.__dict__
         return False
 
     def __ne__(self, other: Any) -> bool:
-        """Compare objects by comparing all attributes."""
+        """Compare objects by comparing all attributes.
+
+        :param object other: The object to compare
+        :returns: True if objects are not equal
+        :rtype: bool
+        """
         return not self.__eq__(other)
 
     def __str__(self) -> str:
@@ -326,7 +280,11 @@ def is_xml_model(cls) -> bool:
 
     @classmethod
     def _create_xml_node(cls):
-        """Create XML node."""
+        """Create XML node.
+
+        :returns: The XML node
+        :rtype: xml.etree.ElementTree.Element
+        """
         try:
             xml_map = cls._xml_map  # type: ignore
         except AttributeError:
@@ -346,7 +304,9 @@ def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
         :rtype: dict
         """
         serializer = Serializer(self._infer_class_models())
-        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)  # type: ignore
+        return serializer._serialize(  # type: ignore # pylint: disable=protected-access
+            self, keep_readonly=keep_readonly, **kwargs
+        )
 
     def as_dict(
         self,
@@ -380,12 +340,15 @@ def my_key_transformer(key, attr_desc, value):
 
         If you want XML serialization, you can pass the kwargs is_xml=True.
 
+        :param bool keep_readonly: If you want to serialize the readonly attributes
         :param function key_transformer: A key transformer function.
         :returns: A dict JSON compatible object
         :rtype: dict
         """
         serializer = Serializer(self._infer_class_models())
-        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)  # type: ignore
+        return serializer._serialize(  # type: ignore # pylint: disable=protected-access
+            self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs
+        )
 
     @classmethod
     def _infer_class_models(cls):
@@ -395,30 +358,31 @@ def _infer_class_models(cls):
             client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
             if cls.__name__ not in client_models:
                 raise ValueError("Not Autorest generated code")
-        except Exception:
+        except Exception:  # pylint: disable=broad-exception-caught
             # Assume it's not Autorest generated (tests?). Add ourselves as dependencies.
             client_models = {cls.__name__: cls}
         return client_models
 
     @classmethod
-    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
+    def deserialize(cls, data: Any, content_type: Optional[str] = None) -> Self:
         """Parse a str using the RestAPI syntax and return a model.
 
         :param str data: A str using RestAPI structure. JSON by default.
         :param str content_type: JSON by default, set application/xml if XML.
         :returns: An instance of this model
-        :raises: DeserializationError if something went wrong
+        :raises DeserializationError: if something went wrong
+        :rtype: Self
         """
         deserializer = Deserializer(cls._infer_class_models())
         return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def from_dict(
-        cls: Type[ModelType],
+        cls,
         data: Any,
         key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
         content_type: Optional[str] = None,
-    ) -> ModelType:
+    ) -> Self:
         """Parse a dict using given key extractor return a model.
 
         By default consider key
@@ -426,9 +390,11 @@ def from_dict(
         and last_rest_key_case_insensitive_extractor)
 
         :param dict data: A dict using RestAPI structure
+        :param function key_extractors: A key extractor function.
         :param str content_type: JSON by default, set application/xml if XML.
         :returns: An instance of this model
-        :raises: DeserializationError if something went wrong
+        :raises DeserializationError: if something went wrong
+        :rtype: Self
         """
         deserializer = Deserializer(cls._infer_class_models())
         deserializer.key_extractors = (  # type: ignore
@@ -448,21 +414,25 @@ def _flatten_subtype(cls, key, objects):
             return {}
         result = dict(cls._subtype_map[key])
         for valuetype in cls._subtype_map[key].values():
-            result.update(objects[valuetype]._flatten_subtype(key, objects))
+            result.update(objects[valuetype]._flatten_subtype(key, objects))  # pylint: disable=protected-access
         return result
 
     @classmethod
     def _classify(cls, response, objects):
         """Check the class _subtype_map for any child classes.
         We want to ignore any inherited _subtype_maps.
-        Remove the polymorphic key from the initial data.
+
+        :param dict response: The initial data
+        :param dict objects: The class objects
+        :returns: The class to be used
+        :rtype: class
         """
         for subtype_key in cls.__dict__.get("_subtype_map", {}).keys():
             subtype_value = None
 
             if not isinstance(response, ET.Element):
                 rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
-                subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
+                subtype_value = response.get(rest_api_response_key, None) or response.get(subtype_key, None)
             else:
                 subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response)
             if subtype_value:
@@ -501,11 +471,13 @@ def _decode_attribute_map_key(key):
     inside the received data.
 
     :param str key: A key string from the generated code
+    :returns: The decoded key
+    :rtype: str
     """
     return key.replace("\\.", ".")
 
 
-class Serializer(object):
+class Serializer:  # pylint: disable=too-many-public-methods
     """Request object model serializer."""
 
     basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
@@ -540,7 +512,7 @@ class Serializer(object):
         "multiple": lambda x, y: x % y != 0,
     }
 
-    def __init__(self, classes: Optional[Mapping[str, type]] = None):
+    def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
         self.serialize_type = {
             "iso-8601": Serializer.serialize_iso,
             "rfc-1123": Serializer.serialize_rfc,
@@ -560,13 +532,16 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None):
         self.key_transformer = full_restapi_key_transformer
         self.client_side_validation = True
 
-    def _serialize(self, target_obj, data_type=None, **kwargs):
+    def _serialize(  # pylint: disable=too-many-nested-blocks, too-many-branches, too-many-statements, too-many-locals
+        self, target_obj, data_type=None, **kwargs
+    ):
         """Serialize data into a string according to type.
 
-        :param target_obj: The data to be serialized.
+        :param object target_obj: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str, dict
-        :raises: SerializationError if serialization fails.
+        :raises SerializationError: if serialization fails.
+        :returns: The serialized data.
         """
         key_transformer = kwargs.get("key_transformer", self.key_transformer)
         keep_readonly = kwargs.get("keep_readonly", False)
@@ -592,12 +567,14 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
 
         serialized = {}
         if is_xml_model_serialization:
-            serialized = target_obj._create_xml_node()
+            serialized = target_obj._create_xml_node()  # pylint: disable=protected-access
         try:
-            attributes = target_obj._attribute_map
+            attributes = target_obj._attribute_map  # pylint: disable=protected-access
             for attr, attr_desc in attributes.items():
                 attr_name = attr
-                if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False):
+                if not keep_readonly and target_obj._validation.get(  # pylint: disable=protected-access
+                    attr_name, {}
+                ).get("readonly", False):
                     continue
 
                 if attr_name == "additional_properties" and attr_desc["key"] == "":
@@ -633,7 +610,8 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
                         if isinstance(new_attr, list):
                             serialized.extend(new_attr)  # type: ignore
                         elif isinstance(new_attr, ET.Element):
-                            # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces.
+                            # If the down XML has no XML/Name,
+                            # we MUST replace the tag with the local tag. But keeping the namespaces.
                             if "name" not in getattr(orig_attr, "_xml_map", {}):
                                 splitted_tag = new_attr.tag.split("}")
                                 if len(splitted_tag) == 2:  # Namespace
@@ -664,17 +642,17 @@ def _serialize(self, target_obj, data_type=None, **kwargs):
         except (AttributeError, KeyError, TypeError) as err:
             msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
             raise SerializationError(msg) from err
-        else:
-            return serialized
+        return serialized
 
     def body(self, data, data_type, **kwargs):
         """Serialize data intended for a request body.
 
-        :param data: The data to be serialized.
+        :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: dict
-        :raises: SerializationError if serialization fails.
-        :raises: ValueError if data is None
+        :raises SerializationError: if serialization fails.
+        :raises ValueError: if data is None
+        :returns: The serialized request body
         """
 
         # Just in case this is a dict
@@ -703,7 +681,7 @@ def body(self, data, data_type, **kwargs):
                         attribute_key_case_insensitive_extractor,
                         last_rest_key_case_insensitive_extractor,
                     ]
-                data = deserializer._deserialize(data_type, data)
+                data = deserializer._deserialize(data_type, data)  # pylint: disable=protected-access
             except DeserializationError as err:
                 raise SerializationError("Unable to build a model: " + str(err)) from err
 
@@ -712,11 +690,13 @@ def body(self, data, data_type, **kwargs):
     def url(self, name, data, data_type, **kwargs):
         """Serialize data intended for a URL path.
 
-        :param data: The data to be serialized.
+        :param str name: The name of the URL path parameter.
+        :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :returns: The serialized URL path
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
         """
         try:
             output = self.serialize_data(data, data_type, **kwargs)
@@ -728,21 +708,20 @@ def url(self, name, data, data_type, **kwargs):
                 output = output.replace("{", quote("{")).replace("}", quote("}"))
             else:
                 output = quote(str(output), safe="")
-        except SerializationError:
-            raise TypeError("{} must be type {}.".format(name, data_type))
-        else:
-            return output
+        except SerializationError as exc:
+            raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+        return output
 
     def query(self, name, data, data_type, **kwargs):
         """Serialize data intended for a URL query.
 
-        :param data: The data to be serialized.
+        :param str name: The name of the query parameter.
+        :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
-        :keyword bool skip_quote: Whether to skip quote the serialized result.
-        Defaults to False.
         :rtype: str, list
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
+        :returns: The serialized query parameter
         """
         try:
             # Treat the list aside, since we don't want to encode the div separator
@@ -759,19 +738,20 @@ def query(self, name, data, data_type, **kwargs):
                 output = str(output)
             else:
                 output = quote(str(output), safe="")
-        except SerializationError:
-            raise TypeError("{} must be type {}.".format(name, data_type))
-        else:
-            return str(output)
+        except SerializationError as exc:
+            raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+        return str(output)
 
     def header(self, name, data, data_type, **kwargs):
         """Serialize data intended for a request header.
 
-        :param data: The data to be serialized.
+        :param str name: The name of the header.
+        :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
         :rtype: str
-        :raises: TypeError if serialization fails.
-        :raises: ValueError if data is None
+        :raises TypeError: if serialization fails.
+        :raises ValueError: if data is None
+        :returns: The serialized header
         """
         try:
             if data_type in ["[str]"]:
@@ -780,21 +760,20 @@ def header(self, name, data, data_type, **kwargs):
             output = self.serialize_data(data, data_type, **kwargs)
             if data_type == "bool":
                 output = json.dumps(output)
-        except SerializationError:
-            raise TypeError("{} must be type {}.".format(name, data_type))
-        else:
-            return str(output)
+        except SerializationError as exc:
+            raise TypeError("{} must be type {}.".format(name, data_type)) from exc
+        return str(output)
 
     def serialize_data(self, data, data_type, **kwargs):
         """Serialize generic data according to supplied data type.
 
-        :param data: The data to be serialized.
+        :param object data: The data to be serialized.
         :param str data_type: The type to be serialized from.
-        :param bool required: Whether it's essential that the data not be
-         empty or None
-        :raises: AttributeError if required data is None.
-        :raises: ValueError if data is None
-        :raises: SerializationError if serialization fails.
+        :raises AttributeError: if required data is None.
+        :raises ValueError: if data is None
+        :raises SerializationError: if serialization fails.
+        :returns: The serialized data.
+        :rtype: str, int, float, bool, dict, list
         """
         if data is None:
             raise ValueError("No value for given attribute")
@@ -805,7 +784,7 @@ def serialize_data(self, data, data_type, **kwargs):
             if data_type in self.basic_types.values():
                 return self.serialize_basic(data, data_type, **kwargs)
 
-            elif data_type in self.serialize_type:
+            if data_type in self.serialize_type:
                 return self.serialize_type[data_type](data, **kwargs)
 
             # If dependencies is empty, try with current data class
@@ -821,11 +800,10 @@ def serialize_data(self, data, data_type, **kwargs):
         except (ValueError, TypeError) as err:
             msg = "Unable to serialize value: {!r} as type: {!r}."
             raise SerializationError(msg.format(data, data_type)) from err
-        else:
-            return self._serialize(data, **kwargs)
+        return self._serialize(data, **kwargs)
 
     @classmethod
-    def _get_custom_serializers(cls, data_type, **kwargs):
+    def _get_custom_serializers(cls, data_type, **kwargs):  # pylint: disable=inconsistent-return-statements
         custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type)
         if custom_serializer:
             return custom_serializer
@@ -841,23 +819,26 @@ def serialize_basic(cls, data, data_type, **kwargs):
         - basic_types_serializers dict[str, callable] : If set, use the callable as serializer
         - is_xml bool : If set, use xml_basic_types_serializers
 
-        :param data: Object to be serialized.
+        :param obj data: Object to be serialized.
         :param str data_type: Type of object in the iterable.
+        :rtype: str, int, float, bool
+        :return: serialized object
         """
         custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
         if custom_serializer:
             return custom_serializer(data)
         if data_type == "str":
             return cls.serialize_unicode(data)
-        return eval(data_type)(data)  # nosec
+        return eval(data_type)(data)  # nosec # pylint: disable=eval-used
 
     @classmethod
     def serialize_unicode(cls, data):
         """Special handling for serializing unicode strings in Py2.
         Encode to UTF-8 if unicode, otherwise handle as a str.
 
-        :param data: Object to be serialized.
+        :param str data: Object to be serialized.
         :rtype: str
+        :return: serialized object
         """
         try:  # If I received an enum, return its value
             return data.value
@@ -871,8 +852,7 @@ def serialize_unicode(cls, data):
                 return data
         except NameError:
             return str(data)
-        else:
-            return str(data)
+        return str(data)
 
     def serialize_iter(self, data, iter_type, div=None, **kwargs):
         """Serialize iterable.
@@ -882,15 +862,13 @@ def serialize_iter(self, data, iter_type, div=None, **kwargs):
           serialization_ctxt['type'] should be same as data_type.
         - is_xml bool : If set, serialize as XML
 
-        :param list attr: Object to be serialized.
+        :param list data: Object to be serialized.
         :param str iter_type: Type of object in the iterable.
-        :param bool required: Whether the objects in the iterable must
-         not be None or empty.
         :param str div: If set, this str will be used to combine the elements
          in the iterable into a combined string. Default is 'None'.
-        :keyword bool do_quote: Whether to quote the serialized result of each iterable element.
         Defaults to False.
         :rtype: list, str
+        :return: serialized iterable
         """
         if isinstance(data, str):
             raise SerializationError("Refuse str type as a valid iter type.")
@@ -945,9 +923,8 @@ def serialize_dict(self, attr, dict_type, **kwargs):
 
         :param dict attr: Object to be serialized.
         :param str dict_type: Type of object in the dictionary.
-        :param bool required: Whether the objects in the dictionary must
-         not be None or empty.
         :rtype: dict
+        :return: serialized dictionary
         """
         serialization_ctxt = kwargs.get("serialization_ctxt", {})
         serialized = {}
@@ -971,7 +948,7 @@ def serialize_dict(self, attr, dict_type, **kwargs):
 
         return serialized
 
-    def serialize_object(self, attr, **kwargs):
+    def serialize_object(self, attr, **kwargs):  # pylint: disable=too-many-return-statements
         """Serialize a generic object.
         This will be handled as a dictionary. If object passed in is not
         a basic type (str, int, float, dict, list) it will simply be
@@ -979,6 +956,7 @@ def serialize_object(self, attr, **kwargs):
 
         :param dict attr: Object to be serialized.
         :rtype: dict or str
+        :return: serialized object
         """
         if attr is None:
             return None
@@ -1003,7 +981,7 @@ def serialize_object(self, attr, **kwargs):
             return self.serialize_decimal(attr)
 
         # If it's a model or I know this dependency, serialize as a Model
-        elif obj_type in self.dependencies.values() or isinstance(attr, Model):
+        if obj_type in self.dependencies.values() or isinstance(attr, Model):
             return self._serialize(attr)
 
         if obj_type == dict:
@@ -1034,56 +1012,61 @@ def serialize_enum(attr, enum_obj=None):
         try:
             enum_obj(result)  # type: ignore
             return result
-        except ValueError:
+        except ValueError as exc:
             for enum_value in enum_obj:  # type: ignore
                 if enum_value.value.lower() == str(attr).lower():
                     return enum_value.value
             error = "{!r} is not valid value for enum {!r}"
-            raise SerializationError(error.format(attr, enum_obj))
+            raise SerializationError(error.format(attr, enum_obj)) from exc
 
     @staticmethod
-    def serialize_bytearray(attr, **kwargs):
+    def serialize_bytearray(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize bytearray into base-64 string.
 
-        :param attr: Object to be serialized.
+        :param str attr: Object to be serialized.
         :rtype: str
+        :return: serialized base64
         """
         return b64encode(attr).decode()
 
     @staticmethod
-    def serialize_base64(attr, **kwargs):
+    def serialize_base64(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize str into base-64 string.
 
-        :param attr: Object to be serialized.
+        :param str attr: Object to be serialized.
         :rtype: str
+        :return: serialized base64
         """
         encoded = b64encode(attr).decode("ascii")
         return encoded.strip("=").replace("+", "-").replace("/", "_")
 
     @staticmethod
-    def serialize_decimal(attr, **kwargs):
+    def serialize_decimal(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Decimal object to float.
 
-        :param attr: Object to be serialized.
+        :param decimal attr: Object to be serialized.
         :rtype: float
+        :return: serialized decimal
         """
         return float(attr)
 
     @staticmethod
-    def serialize_long(attr, **kwargs):
+    def serialize_long(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize long (Py2) or int (Py3).
 
-        :param attr: Object to be serialized.
+        :param int attr: Object to be serialized.
         :rtype: int/long
+        :return: serialized long
         """
         return _long_type(attr)
 
     @staticmethod
-    def serialize_date(attr, **kwargs):
+    def serialize_date(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Date object into ISO-8601 formatted string.
 
         :param Date attr: Object to be serialized.
         :rtype: str
+        :return: serialized date
         """
         if isinstance(attr, str):
             attr = isodate.parse_date(attr)
@@ -1091,11 +1074,12 @@ def serialize_date(attr, **kwargs):
         return t
 
     @staticmethod
-    def serialize_time(attr, **kwargs):
+    def serialize_time(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Time object into ISO-8601 formatted string.
 
         :param datetime.time attr: Object to be serialized.
         :rtype: str
+        :return: serialized time
         """
         if isinstance(attr, str):
             attr = isodate.parse_time(attr)
@@ -1105,30 +1089,32 @@ def serialize_time(attr, **kwargs):
         return t
 
     @staticmethod
-    def serialize_duration(attr, **kwargs):
+    def serialize_duration(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize TimeDelta object into ISO-8601 formatted string.
 
         :param TimeDelta attr: Object to be serialized.
         :rtype: str
+        :return: serialized duration
         """
         if isinstance(attr, str):
             attr = isodate.parse_duration(attr)
         return isodate.duration_isoformat(attr)
 
     @staticmethod
-    def serialize_rfc(attr, **kwargs):
+    def serialize_rfc(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Datetime object into RFC-1123 formatted string.
 
         :param Datetime attr: Object to be serialized.
         :rtype: str
-        :raises: TypeError if format invalid.
+        :raises TypeError: if format invalid.
+        :return: serialized rfc
         """
         try:
             if not attr.tzinfo:
                 _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
             utc = attr.utctimetuple()
-        except AttributeError:
-            raise TypeError("RFC1123 object must be valid Datetime object.")
+        except AttributeError as exc:
+            raise TypeError("RFC1123 object must be valid Datetime object.") from exc
 
         return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
             Serializer.days[utc.tm_wday],
@@ -1141,12 +1127,13 @@ def serialize_rfc(attr, **kwargs):
         )
 
     @staticmethod
-    def serialize_iso(attr, **kwargs):
+    def serialize_iso(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Datetime object into ISO-8601 formatted string.
 
         :param Datetime attr: Object to be serialized.
         :rtype: str
-        :raises: SerializationError if format invalid.
+        :raises SerializationError: if format invalid.
+        :return: serialized iso
         """
         if isinstance(attr, str):
             attr = isodate.parse_datetime(attr)
@@ -1172,13 +1159,14 @@ def serialize_iso(attr, **kwargs):
             raise TypeError(msg) from err
 
     @staticmethod
-    def serialize_unix(attr, **kwargs):
+    def serialize_unix(attr, **kwargs):  # pylint: disable=unused-argument
         """Serialize Datetime object into IntTime format.
         This is represented as seconds.
 
         :param Datetime attr: Object to be serialized.
         :rtype: int
-        :raises: SerializationError if format invalid
+        :raises SerializationError: if format invalid
+        :return: serialied unix
         """
         if isinstance(attr, int):
             return attr
@@ -1186,11 +1174,11 @@ def serialize_unix(attr, **kwargs):
             if not attr.tzinfo:
                 _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
             return int(calendar.timegm(attr.utctimetuple()))
-        except AttributeError:
-            raise TypeError("Unix time object must be valid Datetime object.")
+        except AttributeError as exc:
+            raise TypeError("Unix time object must be valid Datetime object.") from exc
 
 
-def rest_key_extractor(attr, attr_desc, data):
+def rest_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument
     key = attr_desc["key"]
     working_data = data
 
@@ -1211,7 +1199,9 @@ def rest_key_extractor(attr, attr_desc, data):
     return working_data.get(key)
 
 
-def rest_key_case_insensitive_extractor(attr, attr_desc, data):
+def rest_key_case_insensitive_extractor(  # pylint: disable=unused-argument, inconsistent-return-statements
+    attr, attr_desc, data
+):
     key = attr_desc["key"]
     working_data = data
 
@@ -1232,17 +1222,29 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data):
         return attribute_key_case_insensitive_extractor(key, None, working_data)
 
 
-def last_rest_key_extractor(attr, attr_desc, data):
-    """Extract the attribute in "data" based on the last part of the JSON path key."""
+def last_rest_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument
+    """Extract the attribute in "data" based on the last part of the JSON path key.
+
+    :param str attr: The attribute to extract
+    :param dict attr_desc: The attribute description
+    :param dict data: The data to extract from
+    :rtype: object
+    :returns: The extracted attribute
+    """
     key = attr_desc["key"]
     dict_keys = _FLATTEN.split(key)
     return attribute_key_extractor(dict_keys[-1], None, data)
 
 
-def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):
+def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument
     """Extract the attribute in "data" based on the last part of the JSON path key.
 
     This is the case insensitive version of "last_rest_key_extractor"
+    :param str attr: The attribute to extract
+    :param dict attr_desc: The attribute description
+    :param dict data: The data to extract from
+    :rtype: object
+    :returns: The extracted attribute
     """
     key = attr_desc["key"]
     dict_keys = _FLATTEN.split(key)
@@ -1279,7 +1281,7 @@ def _extract_name_from_internal_type(internal_type):
     return xml_name
 
 
-def xml_key_extractor(attr, attr_desc, data):
+def xml_key_extractor(attr, attr_desc, data):  # pylint: disable=unused-argument,too-many-return-statements
     if isinstance(data, dict):
         return None
 
@@ -1331,22 +1333,21 @@ def xml_key_extractor(attr, attr_desc, data):
         if is_iter_type:
             if is_wrapped:
                 return None  # is_wrapped no node, we want None
-            else:
-                return []  # not wrapped, assume empty list
+            return []  # not wrapped, assume empty list
         return None  # Assume it's not there, maybe an optional node.
 
     # If is_iter_type and not wrapped, return all found children
     if is_iter_type:
         if not is_wrapped:
             return children
-        else:  # Iter and wrapped, should have found one node only (the wrap one)
-            if len(children) != 1:
-                raise DeserializationError(
-                    "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format(
-                        xml_name
-                    )
+        # Iter and wrapped, should have found one node only (the wrap one)
+        if len(children) != 1:
+            raise DeserializationError(
+                "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format(
+                    xml_name
                 )
-            return list(children[0])  # Might be empty list and that's ok.
+            )
+        return list(children[0])  # Might be empty list and that's ok.
 
     # Here it's not a itertype, we should have found one element only or empty
     if len(children) > 1:
@@ -1354,7 +1355,7 @@ def xml_key_extractor(attr, attr_desc, data):
     return children[0]
 
 
-class Deserializer(object):
+class Deserializer:
     """Response object model deserializer.
 
     :param dict classes: Class type dictionary for deserializing complex types.
@@ -1363,9 +1364,9 @@ class Deserializer(object):
 
     basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
 
-    valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+    valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
 
-    def __init__(self, classes: Optional[Mapping[str, type]] = None):
+    def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None:
         self.deserialize_type = {
             "iso-8601": Deserializer.deserialize_iso,
             "rfc-1123": Deserializer.deserialize_rfc,
@@ -1401,27 +1402,29 @@ def __call__(self, target_obj, response_data, content_type=None):
         :param str target_obj: Target data type to deserialize to.
         :param requests.Response response_data: REST response object.
         :param str content_type: Swagger "produces" if available.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
+        :rtype: object
         """
         data = self._unpack_content(response_data, content_type)
         return self._deserialize(target_obj, data)
 
-    def _deserialize(self, target_obj, data):
+    def _deserialize(self, target_obj, data):  # pylint: disable=inconsistent-return-statements
         """Call the deserializer on a model.
 
         Data needs to be already deserialized as JSON or XML ElementTree
 
         :param str target_obj: Target data type to deserialize to.
         :param object data: Object to deserialize.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
+        :rtype: object
         """
         # This is already a model, go recursive just in case
         if hasattr(data, "_attribute_map"):
             constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")]
             try:
-                for attr, mapconfig in data._attribute_map.items():
+                for attr, mapconfig in data._attribute_map.items():  # pylint: disable=protected-access
                     if attr in constants:
                         continue
                     value = getattr(data, attr)
@@ -1440,13 +1443,13 @@ def _deserialize(self, target_obj, data):
 
         if isinstance(response, str):
             return self.deserialize_data(data, response)
-        elif isinstance(response, type) and issubclass(response, Enum):
+        if isinstance(response, type) and issubclass(response, Enum):
             return self.deserialize_enum(data, response)
 
         if data is None or data is CoreNull:
             return data
         try:
-            attributes = response._attribute_map  # type: ignore
+            attributes = response._attribute_map  # type: ignore # pylint: disable=protected-access
             d_attrs = {}
             for attr, attr_desc in attributes.items():
                 # Check empty string. If it's not empty, someone has a real "additionalProperties"...
@@ -1476,9 +1479,8 @@ def _deserialize(self, target_obj, data):
         except (AttributeError, TypeError, KeyError) as err:
             msg = "Unable to deserialize to object: " + class_name  # type: ignore
             raise DeserializationError(msg) from err
-        else:
-            additional_properties = self._build_additional_properties(attributes, data)
-            return self._instantiate_model(response, d_attrs, additional_properties)
+        additional_properties = self._build_additional_properties(attributes, data)
+        return self._instantiate_model(response, d_attrs, additional_properties)
 
     def _build_additional_properties(self, attribute_map, data):
         if not self.additional_properties_detection:
@@ -1505,6 +1507,8 @@ def _classify_target(self, target, data):
 
         :param str target: The target object type to deserialize to.
         :param str/dict data: The response data to deserialize.
+        :return: The classified target object and its class name.
+        :rtype: tuple
         """
         if target is None:
             return None, None
@@ -1516,7 +1520,7 @@ def _classify_target(self, target, data):
                 return target, target
 
         try:
-            target = target._classify(data, self.dependencies)  # type: ignore
+            target = target._classify(data, self.dependencies)  # type: ignore # pylint: disable=protected-access
         except AttributeError:
             pass  # Target is not a Model, no classify
         return target, target.__class__.__name__  # type: ignore
@@ -1531,10 +1535,12 @@ def failsafe_deserialize(self, target_obj, data, content_type=None):
         :param str target_obj: The target object type to deserialize to.
         :param str/dict data: The response data to deserialize.
         :param str content_type: Swagger "produces" if available.
+        :return: Deserialized object.
+        :rtype: object
         """
         try:
             return self(target_obj, data, content_type=content_type)
-        except:
+        except:  # pylint: disable=bare-except
             _LOGGER.debug(
                 "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
             )
@@ -1552,10 +1558,12 @@ def _unpack_content(raw_data, content_type=None):
 
         If raw_data is something else, bypass all logic and return it directly.
 
-        :param raw_data: Data to be processed.
-        :param content_type: How to parse if raw_data is a string/bytes.
+        :param obj raw_data: Data to be processed.
+        :param str content_type: How to parse if raw_data is a string/bytes.
         :raises JSONDecodeError: If JSON is requested and parsing is impossible.
         :raises UnicodeDecodeError: If bytes is not UTF8
+        :rtype: object
+        :return: Unpacked content.
         """
         # Assume this is enough to detect a Pipeline Response without importing it
         context = getattr(raw_data, "context", {})
@@ -1579,24 +1587,35 @@ def _unpack_content(raw_data, content_type=None):
     def _instantiate_model(self, response, attrs, additional_properties=None):
         """Instantiate a response model passing in deserialized args.
 
-        :param response: The response model class.
-        :param d_attrs: The deserialized response attributes.
+        :param Response response: The response model class.
+        :param dict attrs: The deserialized response attributes.
+        :param dict additional_properties: Additional properties to be set.
+        :rtype: Response
+        :return: The instantiated response model.
         """
         if callable(response):
             subtype = getattr(response, "_subtype_map", {})
             try:
-                readonly = [k for k, v in response._validation.items() if v.get("readonly")]
-                const = [k for k, v in response._validation.items() if v.get("constant")]
+                readonly = [
+                    k
+                    for k, v in response._validation.items()  # pylint: disable=protected-access  # type: ignore
+                    if v.get("readonly")
+                ]
+                const = [
+                    k
+                    for k, v in response._validation.items()  # pylint: disable=protected-access  # type: ignore
+                    if v.get("constant")
+                ]
                 kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const}
                 response_obj = response(**kwargs)
                 for attr in readonly:
                     setattr(response_obj, attr, attrs.get(attr))
                 if additional_properties:
-                    response_obj.additional_properties = additional_properties
+                    response_obj.additional_properties = additional_properties  # type: ignore
                 return response_obj
             except TypeError as err:
                 msg = "Unable to deserialize {} into model {}. ".format(kwargs, response)  # type: ignore
-                raise DeserializationError(msg + str(err))
+                raise DeserializationError(msg + str(err)) from err
         else:
             try:
                 for attr, value in attrs.items():
@@ -1605,15 +1624,16 @@ def _instantiate_model(self, response, attrs, additional_properties=None):
             except Exception as exp:
                 msg = "Unable to populate response model. "
                 msg += "Type: {}, Error: {}".format(type(response), exp)
-                raise DeserializationError(msg)
+                raise DeserializationError(msg) from exp
 
-    def deserialize_data(self, data, data_type):
+    def deserialize_data(self, data, data_type):  # pylint: disable=too-many-return-statements
         """Process data for deserialization according to data type.
 
         :param str data: The response string to be deserialized.
         :param str data_type: The type to deserialize to.
-        :raises: DeserializationError if deserialization fails.
+        :raises DeserializationError: if deserialization fails.
         :return: Deserialized object.
+        :rtype: object
         """
         if data is None:
             return data
@@ -1627,7 +1647,11 @@ def deserialize_data(self, data, data_type):
                 if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
                     return data
 
-                is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
+                is_a_text_parsing_type = lambda x: x not in [  # pylint: disable=unnecessary-lambda-assignment
+                    "object",
+                    "[]",
+                    r"{}",
+                ]
                 if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
                     return None
                 data_val = self.deserialize_type[data_type](data)
@@ -1647,14 +1671,14 @@ def deserialize_data(self, data, data_type):
             msg = "Unable to deserialize response data."
             msg += " Data: {}, {}".format(data, data_type)
             raise DeserializationError(msg) from err
-        else:
-            return self._deserialize(obj_type, data)
+        return self._deserialize(obj_type, data)
 
     def deserialize_iter(self, attr, iter_type):
         """Deserialize an iterable.
 
         :param list attr: Iterable to be deserialized.
         :param str iter_type: The type of object in the iterable.
+        :return: Deserialized iterable.
         :rtype: list
         """
         if attr is None:
@@ -1671,6 +1695,7 @@ def deserialize_dict(self, attr, dict_type):
         :param dict/list attr: Dictionary to be deserialized. Also accepts
          a list of key, value pairs.
         :param str dict_type: The object type of the items in the dictionary.
+        :return: Deserialized dictionary.
         :rtype: dict
         """
         if isinstance(attr, list):
@@ -1681,13 +1706,14 @@ def deserialize_dict(self, attr, dict_type):
             attr = {el.tag: el.text for el in attr}
         return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
 
-    def deserialize_object(self, attr, **kwargs):
+    def deserialize_object(self, attr, **kwargs):  # pylint: disable=too-many-return-statements
         """Deserialize a generic object.
         This will be handled as a dictionary.
 
         :param dict attr: Dictionary to be deserialized.
+        :return: Deserialized object.
         :rtype: dict
-        :raises: TypeError if non-builtin datatype encountered.
+        :raises TypeError: if non-builtin datatype encountered.
         """
         if attr is None:
             return None
@@ -1720,11 +1746,10 @@ def deserialize_object(self, attr, **kwargs):
                     pass
             return deserialized
 
-        else:
-            error = "Cannot deserialize generic object with type: "
-            raise TypeError(error + str(obj_type))
+        error = "Cannot deserialize generic object with type: "
+        raise TypeError(error + str(obj_type))
 
-    def deserialize_basic(self, attr, data_type):
+    def deserialize_basic(self, attr, data_type):  # pylint: disable=too-many-return-statements
         """Deserialize basic builtin data type from string.
         Will attempt to convert to str, int, float and bool.
         This function will also accept '1', '0', 'true' and 'false' as
@@ -1732,8 +1757,9 @@ def deserialize_basic(self, attr, data_type):
 
         :param str attr: response string to be deserialized.
         :param str data_type: deserialization data type.
+        :return: Deserialized basic type.
         :rtype: str, int, float or bool
-        :raises: TypeError if string format is not valid.
+        :raises TypeError: if string format is not valid.
         """
         # If we're here, data is supposed to be a basic type.
         # If it's still an XML node, take the text
@@ -1743,24 +1769,23 @@ def deserialize_basic(self, attr, data_type):
                 if data_type == "str":
                     # None or '', node <a/> is empty string.
                     return ""
-                else:
-                    # None or '', node <a/> with a strong type is None.
-                    # Don't try to model "empty bool" or "empty int"
-                    return None
+                # None or '', node <a/> with a strong type is None.
+                # Don't try to model "empty bool" or "empty int"
+                return None
 
         if data_type == "bool":
             if attr in [True, False, 1, 0]:
                 return bool(attr)
-            elif isinstance(attr, str):
+            if isinstance(attr, str):
                 if attr.lower() in ["true", "1"]:
                     return True
-                elif attr.lower() in ["false", "0"]:
+                if attr.lower() in ["false", "0"]:
                     return False
             raise TypeError("Invalid boolean value: {}".format(attr))
 
         if data_type == "str":
             return self.deserialize_unicode(attr)
-        return eval(data_type)(attr)  # nosec
+        return eval(data_type)(attr)  # nosec # pylint: disable=eval-used
 
     @staticmethod
     def deserialize_unicode(data):
@@ -1768,6 +1793,7 @@ def deserialize_unicode(data):
         as a string.
 
         :param str data: response string to be deserialized.
+        :return: Deserialized string.
         :rtype: str or unicode
         """
         # We might be here because we have an enum modeled as string,
@@ -1781,8 +1807,7 @@ def deserialize_unicode(data):
                 return data
         except NameError:
             return str(data)
-        else:
-            return str(data)
+        return str(data)
 
     @staticmethod
     def deserialize_enum(data, enum_obj):
@@ -1794,6 +1819,7 @@ def deserialize_enum(data, enum_obj):
         :param str data: Response string to be deserialized. If this value is
          None or invalid it will be returned as-is.
         :param Enum enum_obj: Enum object to deserialize to.
+        :return: Deserialized enum object.
         :rtype: Enum
         """
         if isinstance(data, enum_obj) or data is None:
@@ -1804,9 +1830,9 @@ def deserialize_enum(data, enum_obj):
             # Workaround. We might consider remove it in the future.
             try:
                 return list(enum_obj.__members__.values())[data]
-            except IndexError:
+            except IndexError as exc:
                 error = "{!r} is not a valid index for enum {!r}"
-                raise DeserializationError(error.format(data, enum_obj))
+                raise DeserializationError(error.format(data, enum_obj)) from exc
         try:
             return enum_obj(str(data))
         except ValueError:
@@ -1822,8 +1848,9 @@ def deserialize_bytearray(attr):
         """Deserialize string into bytearray.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized bytearray
         :rtype: bytearray
-        :raises: TypeError if string format invalid.
+        :raises TypeError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1834,8 +1861,9 @@ def deserialize_base64(attr):
         """Deserialize base64 encoded string into string.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized base64 string
         :rtype: bytearray
-        :raises: TypeError if string format invalid.
+        :raises TypeError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1849,8 +1877,9 @@ def deserialize_decimal(attr):
         """Deserialize string into Decimal object.
 
         :param str attr: response string to be deserialized.
-        :rtype: Decimal
-        :raises: DeserializationError if string format invalid.
+        :return: Deserialized decimal
+        :raises DeserializationError: if string format invalid.
+        :rtype: decimal
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1865,8 +1894,9 @@ def deserialize_long(attr):
         """Deserialize string into long (Py2) or int (Py3).
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized int
         :rtype: long or int
-        :raises: ValueError if string format invalid.
+        :raises ValueError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1877,8 +1907,9 @@ def deserialize_duration(attr):
         """Deserialize ISO-8601 formatted string into TimeDelta object.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized duration
         :rtype: TimeDelta
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1887,16 +1918,16 @@ def deserialize_duration(attr):
         except (ValueError, OverflowError, AttributeError) as err:
             msg = "Cannot deserialize duration object."
             raise DeserializationError(msg) from err
-        else:
-            return duration
+        return duration
 
     @staticmethod
     def deserialize_date(attr):
         """Deserialize ISO-8601 formatted string into Date object.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized date
         :rtype: Date
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1910,8 +1941,9 @@ def deserialize_time(attr):
         """Deserialize ISO-8601 formatted string into time object.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized time
         :rtype: datetime.time
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1924,31 +1956,32 @@ def deserialize_rfc(attr):
         """Deserialize RFC-1123 formatted string into Datetime object.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized RFC datetime
         :rtype: Datetime
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
         try:
             parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
             date_obj = datetime.datetime(
-                *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
+                *parsed_date[:6], tzinfo=datetime.timezone(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
             )
             if not date_obj.tzinfo:
                 date_obj = date_obj.astimezone(tz=TZ_UTC)
         except ValueError as err:
             msg = "Cannot deserialize to rfc datetime object."
             raise DeserializationError(msg) from err
-        else:
-            return date_obj
+        return date_obj
 
     @staticmethod
     def deserialize_iso(attr):
         """Deserialize ISO-8601 formatted string into Datetime object.
 
         :param str attr: response string to be deserialized.
+        :return: Deserialized ISO datetime
         :rtype: Datetime
-        :raises: DeserializationError if string format invalid.
+        :raises DeserializationError: if string format invalid.
         """
         if isinstance(attr, ET.Element):
             attr = attr.text
@@ -1976,8 +2009,7 @@ def deserialize_iso(attr):
         except (ValueError, OverflowError, AttributeError) as err:
             msg = "Cannot deserialize datetime object."
             raise DeserializationError(msg) from err
-        else:
-            return date_obj
+        return date_obj
 
     @staticmethod
     def deserialize_unix(attr):
@@ -1985,8 +2017,9 @@ def deserialize_unix(attr):
         This is represented as seconds.
 
         :param int attr: Object to be serialized.
+        :return: Deserialized datetime
         :rtype: Datetime
-        :raises: DeserializationError if format invalid
+        :raises DeserializationError: if format invalid
         """
         if isinstance(attr, ET.Element):
             attr = int(attr.text)  # type: ignore
@@ -1996,5 +2029,4 @@ def deserialize_unix(attr):
         except ValueError as err:
             msg = "Cannot deserialize to unix datetime object."
             raise DeserializationError(msg) from err
-        else:
-            return date_obj
+        return date_obj
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_vendor.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_vendor.py
index 6dbcb5c20a91..5af45cbb9df5 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_vendor.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_vendor.py
@@ -11,7 +11,6 @@
 from ._configuration import DeidentificationClientConfiguration
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core import PipelineClient
 
     from ._serialization import Deserializer, Serializer
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_version.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_version.py
index bbcd28b4aa67..0ec13ea52bbf 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_version.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/_version.py
@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.0.0b2"
+VERSION = "1.0.0"
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/__init__.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/__init__.py
index 245e207d364a..432fe8a82dba 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/__init__.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/__init__.py
@@ -5,12 +5,18 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
 
-from ._client import DeidentificationClient
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+
+from ._client import DeidentificationClient  # type: ignore
 
 try:
     from ._patch import __all__ as _patch_all
-    from ._patch import *  # pylint: disable=unused-wildcard-import
+    from ._patch import *
 except ImportError:
     _patch_all = []
 from ._patch import patch_sdk as _patch_sdk
@@ -18,6 +24,6 @@
 __all__ = [
     "DeidentificationClient",
 ]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__])  # pyright: ignore
 
 _patch_sdk()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_client.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_client.py
index b257b9201e01..455ddd37c0e2 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_client.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_client.py
@@ -19,30 +19,27 @@
 from ._operations import DeidentificationClientOperationsMixin
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core.credentials_async import AsyncTokenCredential
 
 
-class DeidentificationClient(
-    DeidentificationClientOperationsMixin
-):  # pylint: disable=client-accepts-api-version-keyword
+class DeidentificationClient(DeidentificationClientOperationsMixin):
     """DeidentificationClient.
 
     :param endpoint: Url of your De-identification Service. Required.
     :type endpoint: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials_async.AsyncTokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is
-     "2024-07-12-preview". Note that overriding this default value may result in unsupported
-     behavior.
+    :keyword api_version: The API version to use for this operation. Default value is "2024-11-15".
+     Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
      Retry-After header is present.
     """
 
     def __init__(self, endpoint: str, credential: "AsyncTokenCredential", **kwargs: Any) -> None:
-        _endpoint = "https://{endpoint}"
+        _endpoint = "{endpoint}"
         self._config = DeidentificationClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
+
         _policies = kwargs.pop("policies", None)
         if _policies is None:
             _policies = [
@@ -88,7 +85,7 @@ def send_request(
 
         request_copy = deepcopy(request)
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
 
         request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_configuration.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_configuration.py
index 3799c4c1d7b2..199a4c5e3aee 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_configuration.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_configuration.py
@@ -13,11 +13,10 @@
 from .._version import VERSION
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core.credentials_async import AsyncTokenCredential
 
 
-class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
+class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-attributes
     """Configuration for DeidentificationClient.
 
     Note that all parameters used to create this instance are saved as instance
@@ -27,14 +26,13 @@ class DeidentificationClientConfiguration:  # pylint: disable=too-many-instance-
     :type endpoint: str
     :param credential: Credential used to authenticate requests to the service. Required.
     :type credential: ~azure.core.credentials_async.AsyncTokenCredential
-    :keyword api_version: The API version to use for this operation. Default value is
-     "2024-07-12-preview". Note that overriding this default value may result in unsupported
-     behavior.
+    :keyword api_version: The API version to use for this operation. Default value is "2024-11-15".
+     Note that overriding this default value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, endpoint: str, credential: "AsyncTokenCredential", **kwargs: Any) -> None:
-        api_version: str = kwargs.pop("api_version", "2024-07-12-preview")
+        api_version: str = kwargs.pop("api_version", "2024-11-15")
 
         if endpoint is None:
             raise ValueError("Parameter 'endpoint' must not be None.")
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/__init__.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/__init__.py
index f30b11092e89..8a3952cdf768 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/__init__.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/__init__.py
@@ -5,15 +5,21 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
 
-from ._operations import DeidentificationClientOperationsMixin
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+
+from ._operations import DeidentificationClientOperationsMixin  # type: ignore
 
 from ._patch import __all__ as _patch_all
-from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import *
 from ._patch import patch_sdk as _patch_sdk
 
 __all__ = [
     "DeidentificationClientOperationsMixin",
 ]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__])  # pyright: ignore
 _patch_sdk()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/_operations.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/_operations.py
index dd3a7c4dbdcb..ee6debeda46b 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/_operations.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_operations/_operations.py
@@ -1,4 +1,4 @@
-# pylint: disable=too-many-lines,too-many-statements
+# pylint: disable=line-too-long,useless-suppression
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
@@ -6,24 +6,10 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+from collections.abc import MutableMapping
 from io import IOBase
 import json
-import sys
-from typing import (
-    Any,
-    AsyncIterable,
-    AsyncIterator,
-    Callable,
-    Dict,
-    IO,
-    List,
-    Optional,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
+from typing import Any, AsyncIterable, AsyncIterator, Callable, Dict, IO, List, Optional, TypeVar, Union, cast, overload
 import urllib.parse
 
 from azure.core.async_paging import AsyncItemPaged, AsyncList
@@ -33,6 +19,8 @@
     ResourceExistsError,
     ResourceNotFoundError,
     ResourceNotModifiedError,
+    StreamClosedError,
+    StreamConsumedError,
     map_error,
 )
 from azure.core.pipeline import PipelineResponse
@@ -47,20 +35,16 @@
 from ..._model_base import SdkJSONEncoder, _deserialize
 from ..._operations._operations import (
     build_deidentification_cancel_job_request,
-    build_deidentification_create_job_request,
-    build_deidentification_deidentify_request,
+    build_deidentification_deidentify_documents_request,
+    build_deidentification_deidentify_text_request,
     build_deidentification_delete_job_request,
     build_deidentification_get_job_request,
-    build_deidentification_list_job_documents_request,
-    build_deidentification_list_jobs_request,
+    build_deidentification_list_job_documents_internal_request,
+    build_deidentification_list_jobs_internal_request,
 )
 from .._vendor import DeidentificationClientMixinABC
 
-if sys.version_info >= (3, 9):
-    from collections.abc import MutableMapping
-else:
-    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
-JSON = MutableMapping[str, Any]  # pylint: disable=unsubscriptable-object
+JSON = MutableMapping[str, Any]
 T = TypeVar("T")
 ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
 
@@ -68,63 +52,18 @@
 class DeidentificationClientOperationsMixin(DeidentificationClientMixinABC):
 
     @distributed_trace_async
-    async def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
+    async def get_job(self, job_name: str, **kwargs: Any) -> _models.DeidentificationJob:
         """Get a de-identification job.
 
         Resource read operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: DeidentificationJob. The DeidentificationJob is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationJob
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -138,13 +77,13 @@ async def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob
         cls: ClsType[_models.DeidentificationJob] = kwargs.pop("cls", None)
 
         _request = build_deidentification_get_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -157,7 +96,10 @@ async def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob
 
         if response.status_code not in [200]:
             if _stream:
-                await response.read()  # Load the body in memory and close the socket
+                try:
+                    await response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
@@ -176,10 +118,10 @@ async def get_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob
 
         return deserialized  # type: ignore
 
-    async def _create_job_initial(
-        self, name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
+    async def _deidentify_documents_initial(
+        self, job_name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
     ) -> AsyncIterator[bytes]:
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -200,8 +142,8 @@ async def _create_job_initial(
         else:
             _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
 
-        _request = build_deidentification_create_job_request(
-            name=name,
+        _request = build_deidentification_deidentify_documents_request(
+            job_name=job_name,
             content_type=content_type,
             api_version=self._config.api_version,
             content=_content,
@@ -209,7 +151,7 @@ async def _create_job_initial(
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -221,30 +163,20 @@ async def _create_job_initial(
         response = pipeline_response.http_response
 
         if response.status_code not in [200, 201]:
-            await response.read()  # Load the body in memory and close the socket
+            try:
+                await response.read()  # Load the body in memory and close the socket
+            except (StreamConsumedError, StreamClosedError):
+                pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
         response_headers = {}
-        if response.status_code == 200:
-            response_headers["x-ms-client-request-id"] = self._deserialize(
-                "str", response.headers.get("x-ms-client-request-id")
-            )
-            response_headers["Operation-Location"] = self._deserialize(
-                "str", response.headers.get("Operation-Location")
-            )
-
-            deserialized = response.iter_bytes()
-
-        if response.status_code == 201:
-            response_headers["x-ms-client-request-id"] = self._deserialize(
-                "str", response.headers.get("x-ms-client-request-id")
-            )
-            response_headers["Operation-Location"] = self._deserialize(
-                "str", response.headers.get("Operation-Location")
-            )
+        response_headers["x-ms-client-request-id"] = self._deserialize(
+            "str", response.headers.get("x-ms-client-request-id")
+        )
+        response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location"))
 
-            deserialized = response.iter_bytes()
+        deserialized = response.iter_bytes()
 
         if cls:
             return cls(pipeline_response, deserialized, response_headers)  # type: ignore
@@ -252,15 +184,20 @@ async def _create_job_initial(
         return deserialized  # type: ignore
 
     @overload
-    async def begin_create_job(
-        self, name: str, resource: _models.DeidentificationJob, *, content_type: str = "application/json", **kwargs: Any
+    async def begin_deidentify_documents(
+        self,
+        job_name: str,
+        resource: _models.DeidentificationJob,
+        *,
+        content_type: str = "application/json",
+        **kwargs: Any
     ) -> AsyncLROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: ~azure.health.deidentification.models.DeidentificationJob
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
@@ -271,105 +208,18 @@ async def begin_create_job(
         :rtype:
          ~azure.core.polling.AsyncLROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                resource = {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @overload
-    async def begin_create_job(
-        self, name: str, resource: JSON, *, content_type: str = "application/json", **kwargs: Any
+    async def begin_deidentify_documents(
+        self, job_name: str, resource: JSON, *, content_type: str = "application/json", **kwargs: Any
     ) -> AsyncLROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: JSON
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
@@ -380,63 +230,18 @@ async def begin_create_job(
         :rtype:
          ~azure.core.polling.AsyncLROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @overload
-    async def begin_create_job(
-        self, name: str, resource: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
+    async def begin_deidentify_documents(
+        self, job_name: str, resource: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> AsyncLROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Required.
         :type resource: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
@@ -447,63 +252,18 @@ async def begin_create_job(
         :rtype:
          ~azure.core.polling.AsyncLROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
 
     @distributed_trace_async
-    async def begin_create_job(
-        self, name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
+    async def begin_deidentify_documents(
+        self, job_name: str, resource: Union[_models.DeidentificationJob, JSON, IO[bytes]], **kwargs: Any
     ) -> AsyncLROPoller[_models.DeidentificationJob]:
         """Create a de-identification job.
 
         Long-running resource create or replace operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :param resource: The resource instance. Is one of the following types: DeidentificationJob,
          JSON, IO[bytes] Required.
         :type resource: ~azure.health.deidentification.models.DeidentificationJob or JSON or IO[bytes]
@@ -512,93 +272,6 @@ async def begin_create_job(
         :rtype:
          ~azure.core.polling.AsyncLROPoller[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                resource = {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
-
-                # response body for status code(s): 201, 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
         _params = kwargs.pop("params", {}) or {}
@@ -609,8 +282,8 @@ async def begin_create_job(
         lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
         cont_token: Optional[str] = kwargs.pop("continuation_token", None)
         if cont_token is None:
-            raw_result = await self._create_job_initial(
-                name=name,
+            raw_result = await self._deidentify_documents_initial(
+                job_name=job_name,
                 resource=resource,
                 content_type=content_type,
                 cls=lambda x, y, z: x,
@@ -637,7 +310,7 @@ def get_long_running_output(pipeline_response):
             return deserialized
 
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
 
         if polling is True:
@@ -661,7 +334,7 @@ def get_long_running_output(pipeline_response):
         )
 
     @distributed_trace
-    def list_jobs(
+    def _list_jobs_internal(
         self, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
     ) -> AsyncIterable["_models.DeidentificationJob"]:
         """List de-identification jobs.
@@ -675,51 +348,6 @@ def list_jobs(
         :rtype:
          ~azure.core.async_paging.AsyncItemPaged[~azure.health.deidentification.models.DeidentificationJob]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
         _headers = kwargs.pop("headers", {}) or {}
         _params = kwargs.pop("params", {}) or {}
@@ -727,7 +355,7 @@ def list_jobs(
         maxpagesize = kwargs.pop("maxpagesize", None)
         cls: ClsType[List[_models.DeidentificationJob]] = kwargs.pop("cls", None)
 
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -738,7 +366,7 @@ def list_jobs(
         def prepare_request(next_link=None):
             if not next_link:
 
-                _request = build_deidentification_list_jobs_request(
+                _request = build_deidentification_list_jobs_internal_request(
                     maxpagesize=maxpagesize,
                     continuation_token_parameter=continuation_token_parameter,
                     api_version=self._config.api_version,
@@ -746,7 +374,9 @@ def prepare_request(next_link=None):
                     params=_params,
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -764,7 +394,9 @@ def prepare_request(next_link=None):
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -772,7 +404,7 @@ def prepare_request(next_link=None):
 
         async def extract_data(pipeline_response):
             deserialized = pipeline_response.http_response.json()
-            list_of_elem = _deserialize(List[_models.DeidentificationJob], deserialized["value"])
+            list_of_elem = _deserialize(List[_models.DeidentificationJob], deserialized.get("value", []))
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -795,59 +427,30 @@ async def get_next(next_link=None):
         return AsyncItemPaged(get_next, extract_data)
 
     @distributed_trace
-    def list_job_documents(
-        self, name: str, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
-    ) -> AsyncIterable["_models.DocumentDetails"]:
+    def _list_job_documents_internal(
+        self, job_name: str, *, continuation_token_parameter: Optional[str] = None, **kwargs: Any
+    ) -> AsyncIterable["_models.DeidentificationDocumentDetails"]:
         """List processed documents within a job.
 
         Resource list operation template.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :keyword continuation_token_parameter: Token to continue a previous query. Default value is
          None.
         :paramtype continuation_token_parameter: str
-        :return: An iterator like instance of DocumentDetails
+        :return: An iterator like instance of DeidentificationDocumentDetails
         :rtype:
-         ~azure.core.async_paging.AsyncItemPaged[~azure.health.deidentification.models.DocumentDetails]
+         ~azure.core.async_paging.AsyncItemPaged[~azure.health.deidentification.models.DeidentificationDocumentDetails]
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "id": "str",
-                    "input": {
-                        "etag": "str",
-                        "path": "str"
-                    },
-                    "status": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "output": {
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
         _headers = kwargs.pop("headers", {}) or {}
         _params = kwargs.pop("params", {}) or {}
 
         maxpagesize = kwargs.pop("maxpagesize", None)
-        cls: ClsType[List[_models.DocumentDetails]] = kwargs.pop("cls", None)
+        cls: ClsType[List[_models.DeidentificationDocumentDetails]] = kwargs.pop("cls", None)
 
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -858,8 +461,8 @@ def list_job_documents(
         def prepare_request(next_link=None):
             if not next_link:
 
-                _request = build_deidentification_list_job_documents_request(
-                    name=name,
+                _request = build_deidentification_list_job_documents_internal_request(
+                    job_name=job_name,
                     maxpagesize=maxpagesize,
                     continuation_token_parameter=continuation_token_parameter,
                     api_version=self._config.api_version,
@@ -867,7 +470,9 @@ def prepare_request(next_link=None):
                     params=_params,
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -885,7 +490,9 @@ def prepare_request(next_link=None):
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
                 path_format_arguments = {
-                    "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+                    "endpoint": self._serialize.url(
+                        "self._config.endpoint", self._config.endpoint, "str", skip_quote=True
+                    ),
                 }
                 _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -893,7 +500,7 @@ def prepare_request(next_link=None):
 
         async def extract_data(pipeline_response):
             deserialized = pipeline_response.http_response.json()
-            list_of_elem = _deserialize(List[_models.DocumentDetails], deserialized["value"])
+            list_of_elem = _deserialize(List[_models.DeidentificationDocumentDetails], deserialized.get("value", []))
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.get("nextLink") or None, AsyncList(list_of_elem)
@@ -916,7 +523,7 @@ async def get_next(next_link=None):
         return AsyncItemPaged(get_next, extract_data)
 
     @distributed_trace_async
-    async def cancel_job(self, name: str, **kwargs: Any) -> _models.DeidentificationJob:
+    async def cancel_job(self, job_name: str, **kwargs: Any) -> _models.DeidentificationJob:
         """Cancel a de-identification job.
 
         Cancels a job that is in progress.
@@ -926,58 +533,13 @@ async def cancel_job(self, name: str, **kwargs: Any) -> _models.Deidentification
 
         If the job is already complete, this will have no effect.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: DeidentificationJob. The DeidentificationJob is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationJob
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "createdAt": "2020-02-20 00:00:00",
-                    "lastUpdatedAt": "2020-02-20 00:00:00",
-                    "name": "str",
-                    "sourceLocation": {
-                        "location": "str",
-                        "prefix": "str",
-                        "extensions": [
-                            "str"
-                        ]
-                    },
-                    "status": "str",
-                    "targetLocation": {
-                        "location": "str",
-                        "prefix": "str"
-                    },
-                    "dataType": "str",
-                    "error": {
-                        "code": "str",
-                        "message": "str",
-                        "details": [
-                            ...
-                        ],
-                        "innererror": {
-                            "code": "str",
-                            "innererror": ...
-                        },
-                        "target": "str"
-                    },
-                    "operation": "str",
-                    "redactionFormat": "str",
-                    "startedAt": "2020-02-20 00:00:00",
-                    "summary": {
-                        "bytesProcessed": 0,
-                        "canceled": 0,
-                        "failed": 0,
-                        "successful": 0,
-                        "total": 0
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -991,13 +553,13 @@ async def cancel_job(self, name: str, **kwargs: Any) -> _models.Deidentification
         cls: ClsType[_models.DeidentificationJob] = kwargs.pop("cls", None)
 
         _request = build_deidentification_cancel_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1010,7 +572,10 @@ async def cancel_job(self, name: str, **kwargs: Any) -> _models.Deidentification
 
         if response.status_code not in [200]:
             if _stream:
-                await response.read()  # Load the body in memory and close the socket
+                try:
+                    await response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
@@ -1030,18 +595,18 @@ async def cancel_job(self, name: str, **kwargs: Any) -> _models.Deidentification
         return deserialized  # type: ignore
 
     @distributed_trace_async
-    async def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable=inconsistent-return-statements
+    async def delete_job(self, job_name: str, **kwargs: Any) -> None:
         """Delete a de-identification job.
 
         Removes the record of the job from the service. Does not delete any documents.
 
-        :param name: The name of a job. Required.
-        :type name: str
+        :param job_name: The name of a job. Required.
+        :type job_name: str
         :return: None
         :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1055,13 +620,13 @@ async def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable
         cls: ClsType[None] = kwargs.pop("cls", None)
 
         _request = build_deidentification_delete_job_request(
-            name=name,
+            job_name=job_name,
             api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1085,7 +650,7 @@ async def delete_job(self, name: str, **kwargs: Any) -> None:  # pylint: disable
             return cls(pipeline_response, None, response_headers)  # type: ignore
 
     @overload
-    async def deidentify(
+    async def deidentify_text(
         self, body: _models.DeidentificationContent, *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1100,47 +665,10 @@ async def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                body = {
-                    "inputText": "str",
-                    "dataType": "str",
-                    "operation": "str",
-                    "redactionFormat": "str"
-                }
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @overload
-    async def deidentify(
+    async def deidentify_text(
         self, body: JSON, *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1155,39 +683,10 @@ async def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @overload
-    async def deidentify(
+    async def deidentify_text(
         self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1202,39 +701,10 @@ async def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
 
     @distributed_trace_async
-    async def deidentify(
+    async def deidentify_text(
         self, body: Union[_models.DeidentificationContent, JSON, IO[bytes]], **kwargs: Any
     ) -> _models.DeidentificationResult:
         """De-identify text.
@@ -1247,45 +717,8 @@ async def deidentify(
         :return: DeidentificationResult. The DeidentificationResult is compatible with MutableMapping
         :rtype: ~azure.health.deidentification.models.DeidentificationResult
         :raises ~azure.core.exceptions.HttpResponseError:
-
-        Example:
-            .. code-block:: python
-
-                # JSON input template you can fill out and use as your body input.
-                body = {
-                    "inputText": "str",
-                    "dataType": "str",
-                    "operation": "str",
-                    "redactionFormat": "str"
-                }
-
-                # response body for status code(s): 200
-                response == {
-                    "outputText": "str",
-                    "taggerResult": {
-                        "entities": [
-                            {
-                                "category": "str",
-                                "length": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "offset": {
-                                    "codePoint": 0,
-                                    "utf16": 0,
-                                    "utf8": 0
-                                },
-                                "confidenceScore": 0.0,
-                                "text": "str"
-                            }
-                        ],
-                        "etag": "str",
-                        "path": "str"
-                    }
-                }
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+        error_map: MutableMapping = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1306,7 +739,7 @@ async def deidentify(
         else:
             _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
 
-        _request = build_deidentification_deidentify_request(
+        _request = build_deidentification_deidentify_text_request(
             content_type=content_type,
             api_version=self._config.api_version,
             content=_content,
@@ -1314,7 +747,7 @@ async def deidentify(
             params=_params,
         )
         path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str"),
+            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
         }
         _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
@@ -1327,16 +760,24 @@ async def deidentify(
 
         if response.status_code not in [200]:
             if _stream:
-                await response.read()  # Load the body in memory and close the socket
+                try:
+                    await response.read()  # Load the body in memory and close the socket
+                except (StreamConsumedError, StreamClosedError):
+                    pass
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             raise HttpResponseError(response=response)
 
+        response_headers = {}
+        response_headers["x-ms-client-request-id"] = self._deserialize(
+            "str", response.headers.get("x-ms-client-request-id")
+        )
+
         if _stream:
             deserialized = response.iter_bytes()
         else:
             deserialized = _deserialize(_models.DeidentificationResult, response.json())
 
         if cls:
-            return cls(pipeline_response, deserialized, {})  # type: ignore
+            return cls(pipeline_response, deserialized, response_headers)  # type: ignore
 
         return deserialized  # type: ignore
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_patch.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_patch.py
index f7dd32510333..62b77226c9f1 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_patch.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_patch.py
@@ -6,9 +6,42 @@
 
 Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize
 """
-from typing import List
+from typing import Any, AsyncIterable, List
 
-__all__: List[str] = []  # Add all objects you want publicly available to users at this package level
+from azure.core.tracing.decorator import distributed_trace
+from azure.health.deidentification.models import DeidentificationDocumentDetails, DeidentificationJob
+from ._client import DeidentificationClient as DeidentificationClientGenerated
+
+__all__: List[str] = [
+    "DeidentificationClient",
+]  # Add all objects you want publicly available to users at this package level
+
+
+class DeidentificationClient(DeidentificationClientGenerated):
+
+    @distributed_trace
+    def list_jobs(self, **kwargs: Any) -> AsyncIterable[DeidentificationJob]:
+        """
+        List de-identification jobs.
+
+        :return: An iterator like instance of DeidentificationJob
+        :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DeidentificationJob]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        return super()._list_jobs_internal(continuation_token_parameter=None, **kwargs)
+
+    @distributed_trace
+    def list_job_documents(self, job_name: str, **kwargs: Any) -> AsyncIterable[DeidentificationDocumentDetails]:
+        """
+        List processed documents within a job.
+
+        :param job_name: The name of a job. Required.
+        :type job_name: str
+        :return: An iterator like instance of DocumentDetails
+        :rtype: ~azure.core.paging.ItemPaged[~azure.health.deidentification.models.DocumentDetails]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        return super()._list_job_documents_internal(job_name=job_name, continuation_token_parameter=None, **kwargs)
 
 
 def patch_sdk():
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_vendor.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_vendor.py
index 39bc7460b3a7..0afc83d417cc 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_vendor.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/aio/_vendor.py
@@ -11,7 +11,6 @@
 from ._configuration import DeidentificationClientConfiguration
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core import AsyncPipelineClient
 
     from .._serialization import Deserializer, Serializer
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/__init__.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/__init__.py
index 2bbbe6e08cab..967fa7fefd8d 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/__init__.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/__init__.py
@@ -5,49 +5,56 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=wrong-import-position
 
-from ._models import DeidentificationContent
-from ._models import DeidentificationJob
-from ._models import DeidentificationResult
-from ._models import DocumentDetails
-from ._models import DocumentLocation
-from ._models import Error
-from ._models import InnerError
-from ._models import JobSummary
-from ._models import PhiEntity
-from ._models import PhiTaggerResult
-from ._models import SourceStorageLocation
-from ._models import StringIndex
-from ._models import TargetStorageLocation
+from typing import TYPE_CHECKING
 
-from ._enums import DocumentDataType
-from ._enums import JobStatus
-from ._enums import OperationState
-from ._enums import OperationType
-from ._enums import PhiCategory
+if TYPE_CHECKING:
+    from ._patch import *  # pylint: disable=unused-wildcard-import
+
+
+from ._models import (  # type: ignore
+    DeidentificationContent,
+    DeidentificationCustomizationOptions,
+    DeidentificationDocumentDetails,
+    DeidentificationDocumentLocation,
+    DeidentificationJob,
+    DeidentificationJobCustomizationOptions,
+    DeidentificationJobSummary,
+    DeidentificationResult,
+    PhiEntity,
+    PhiTaggerResult,
+    SourceStorageLocation,
+    StringIndex,
+    TargetStorageLocation,
+)
+
+from ._enums import (  # type: ignore
+    DeidentificationOperationType,
+    OperationStatus,
+    PhiCategory,
+)
 from ._patch import __all__ as _patch_all
-from ._patch import *  # pylint: disable=unused-wildcard-import
+from ._patch import *
 from ._patch import patch_sdk as _patch_sdk
 
 __all__ = [
     "DeidentificationContent",
+    "DeidentificationCustomizationOptions",
+    "DeidentificationDocumentDetails",
+    "DeidentificationDocumentLocation",
     "DeidentificationJob",
+    "DeidentificationJobCustomizationOptions",
+    "DeidentificationJobSummary",
     "DeidentificationResult",
-    "DocumentDetails",
-    "DocumentLocation",
-    "Error",
-    "InnerError",
-    "JobSummary",
     "PhiEntity",
     "PhiTaggerResult",
     "SourceStorageLocation",
     "StringIndex",
     "TargetStorageLocation",
-    "DocumentDataType",
-    "JobStatus",
-    "OperationState",
-    "OperationType",
+    "DeidentificationOperationType",
+    "OperationStatus",
     "PhiCategory",
 ]
-__all__.extend([p for p in _patch_all if p not in __all__])
+__all__.extend([p for p in _patch_all if p not in __all__])  # pyright: ignore
 _patch_sdk()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_enums.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_enums.py
index c05e0003b5b7..2bf4d7fd505e 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_enums.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_enums.py
@@ -10,31 +10,19 @@
 from azure.core import CaseInsensitiveEnumMeta
 
 
-class DocumentDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
-    """Enum of supported Data Types."""
-
-    PLAINTEXT = "Plaintext"
-    """Plain text data type."""
-
-
-class JobStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
-    """List of statuses a job can have."""
+class DeidentificationOperationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Enum of supported Operation Types."""
 
-    NOT_STARTED = "NotStarted"
-    """Job has been submitted and is waiting to be processed."""
-    RUNNING = "Running"
-    """Job has been started."""
-    SUCCEEDED = "Succeeded"
-    """Job has completed successfully. All documents have succeeded."""
-    PARTIAL_FAILED = "PartialFailed"
-    """Job has completed with at least a single document failing."""
-    FAILED = "Failed"
-    """Job has completed with all documents failing, or a validation failure."""
-    CANCELED = "Canceled"
-    """Job has been canceled after user request."""
+    REDACT = "Redact"
+    """Redact Operation will remove all entities of PHI and replace them with a placeholder value."""
+    SURROGATE = "Surrogate"
+    """Surrogation Operation will replace all entities of PHI with a surrogate value."""
+    TAG = "Tag"
+    """Tag Operation will detect all entities of PHI, their type, and return their locations in the
+    document."""
 
 
-class OperationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+class OperationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """Enum describing allowed operation states."""
 
     NOT_STARTED = "NotStarted"
@@ -49,18 +37,6 @@ class OperationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """The operation has been canceled by the user."""
 
 
-class OperationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
-    """Enum of supported Operation Types."""
-
-    REDACT = "Redact"
-    """Redact Operation will remove all entities of PHI and replace them with a placeholder value."""
-    SURROGATE = "Surrogate"
-    """Surrogation Operation will replace all entities of PHI with a surrogate value."""
-    TAG = "Tag"
-    """Tag Operation will detect all entities of PHI, their type, and return their locations in the
-    document."""
-
-
 class PhiCategory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """List of PHI Entities."""
 
@@ -70,7 +46,7 @@ class PhiCategory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """Account Number."""
     AGE = "Age"
     """Age."""
-    BIO_I_D = "BioID"
+    BIO_ID = "BioID"
     """Biological Identifier, such as a fingerprint or retinal scan."""
     CITY = "City"
     """City."""
@@ -90,9 +66,9 @@ class PhiCategory(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """Health Plan ID Numbers."""
     HOSPITAL = "Hospital"
     """Hospital Name."""
-    I_D_NUM = "IDNum"
+    ID_NUM = "IDNum"
     """Id Number, eg. passport number."""
-    I_P_ADDRESS = "IPAddress"
+    IP_ADDRESS = "IPAddress"
     """IP Address."""
     LICENSE = "License"
     """License, eg. Driver's license or medical license."""
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_models.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_models.py
index 2929c7e9b5d3..9551be3c8845 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_models.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_models.py
@@ -1,261 +1,182 @@
 # coding=utf-8
-# pylint: disable=too-many-lines
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for license information.
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
+# pylint: disable=useless-super-delegation
 
 import datetime
 from typing import Any, List, Mapping, Optional, TYPE_CHECKING, Union, overload
 
+from azure.core.exceptions import ODataV4Format
+
 from .. import _model_base
 from .._model_base import rest_field
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from .. import models as _models
 
 
 class DeidentificationContent(_model_base.Model):
     """Request body for de-identification operation.
 
-    All required parameters must be populated in order to send to server.
-
     :ivar input_text: Input text to de-identify. Required.
     :vartype input_text: str
-    :ivar operation: Operation to perform on the input. Known values are: "Redact", "Surrogate",
-     and "Tag".
-    :vartype operation: str or ~azure.health.deidentification.models.OperationType
-    :ivar data_type: Data type of the input. "Plaintext"
-    :vartype data_type: str or ~azure.health.deidentification.models.DocumentDataType
-    :ivar redaction_format: Format of the redacted output. Only valid when OperationType is
-     "Redact".
-    :vartype redaction_format: str
+    :ivar operation_type: Operation to perform on the input documents. Known values are: "Redact",
+     "Surrogate", and "Tag".
+    :vartype operation_type: str or
+     ~azure.health.deidentification.models.DeidentificationOperationType
+    :ivar customizations: Customization parameters to override default service behaviors.
+    :vartype customizations:
+     ~azure.health.deidentification.models.DeidentificationCustomizationOptions
     """
 
-    input_text: str = rest_field(name="inputText")
+    input_text: str = rest_field(name="inputText", visibility=["read", "create", "update", "delete", "query"])
     """Input text to de-identify. Required."""
-    operation: Optional[Union[str, "_models.OperationType"]] = rest_field()
-    """Operation to perform on the input. Known values are: \"Redact\", \"Surrogate\", and \"Tag\"."""
-    data_type: Optional[Union[str, "_models.DocumentDataType"]] = rest_field(name="dataType")
-    """Data type of the input. \"Plaintext\""""
-    redaction_format: Optional[str] = rest_field(name="redactionFormat")
-    """Format of the redacted output. Only valid when OperationType is \"Redact\"."""
+    operation_type: Optional[Union[str, "_models.DeidentificationOperationType"]] = rest_field(
+        name="operation", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Operation to perform on the input documents. Known values are: \"Redact\", \"Surrogate\", and
+     \"Tag\"."""
+    customizations: Optional["_models.DeidentificationCustomizationOptions"] = rest_field(
+        visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Customization parameters to override default service behaviors."""
 
     @overload
     def __init__(
         self,
         *,
         input_text: str,
-        operation: Optional[Union[str, "_models.OperationType"]] = None,
-        data_type: Optional[Union[str, "_models.DocumentDataType"]] = None,
-        redaction_format: Optional[str] = None,
-    ): ...
+        operation_type: Optional[Union[str, "_models.DeidentificationOperationType"]] = None,
+        customizations: Optional["_models.DeidentificationCustomizationOptions"] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class DeidentificationJob(_model_base.Model):  # pylint: disable=too-many-instance-attributes
-    """A job containing a batch of documents to de-identify.
-
-    Readonly variables are only populated by the server, and will be ignored when sending a request.
+class DeidentificationCustomizationOptions(_model_base.Model):
+    """Customizations options to override default service behaviors for synchronous usage.
 
-    All required parameters must be populated in order to send to server.
-
-    :ivar name: The name of a job. Required.
-    :vartype name: str
-    :ivar source_location: Storage location to perform the operation on. Required.
-    :vartype source_location: ~azure.health.deidentification.models.SourceStorageLocation
-    :ivar target_location: Target location to store output of operation. Required.
-    :vartype target_location: ~azure.health.deidentification.models.TargetStorageLocation
-    :ivar operation: Operation to perform on the input documents. Known values are: "Redact",
-     "Surrogate", and "Tag".
-    :vartype operation: str or ~azure.health.deidentification.models.OperationType
-    :ivar data_type: Data type of the input documents. "Plaintext"
-    :vartype data_type: str or ~azure.health.deidentification.models.DocumentDataType
     :ivar redaction_format: Format of the redacted output. Only valid when Operation is Redact.
+     Please refer to
+     `https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format
+     <https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format>`_ for
+     more details.
     :vartype redaction_format: str
-    :ivar status: Current status of a job. Required. Known values are: "NotStarted", "Running",
-     "Succeeded", "PartialFailed", "Failed", and "Canceled".
-    :vartype status: str or ~azure.health.deidentification.models.JobStatus
-    :ivar error: Error when job fails in it's entirety.
-    :vartype error: ~azure.health.deidentification.models.Error
-    :ivar last_updated_at: Date and time when the job was completed.
-
-     If the job is canceled, this is the time when the job was canceled.
-
-     If the job failed, this is the time when the job failed. Required.
-    :vartype last_updated_at: ~datetime.datetime
-    :ivar created_at: Date and time when the job was created. Required.
-    :vartype created_at: ~datetime.datetime
-    :ivar started_at: Date and time when the job was started.
-    :vartype started_at: ~datetime.datetime
-    :ivar summary: Summary of a job. Exists only when the job is completed.
-    :vartype summary: ~azure.health.deidentification.models.JobSummary
+    :ivar surrogate_locale: Locale in which the output surrogates are written.
+    :vartype surrogate_locale: str
     """
 
-    name: str = rest_field(visibility=["read"])
-    """The name of a job. Required."""
-    source_location: "_models.SourceStorageLocation" = rest_field(name="sourceLocation")
-    """Storage location to perform the operation on. Required."""
-    target_location: "_models.TargetStorageLocation" = rest_field(name="targetLocation")
-    """Target location to store output of operation. Required."""
-    operation: Optional[Union[str, "_models.OperationType"]] = rest_field()
-    """Operation to perform on the input documents. Known values are: \"Redact\", \"Surrogate\", and
-     \"Tag\"."""
-    data_type: Optional[Union[str, "_models.DocumentDataType"]] = rest_field(name="dataType")
-    """Data type of the input documents. \"Plaintext\""""
-    redaction_format: Optional[str] = rest_field(name="redactionFormat")
-    """Format of the redacted output. Only valid when Operation is Redact."""
-    status: Union[str, "_models.JobStatus"] = rest_field(visibility=["read"])
-    """Current status of a job. Required. Known values are: \"NotStarted\", \"Running\",
-     \"Succeeded\", \"PartialFailed\", \"Failed\", and \"Canceled\"."""
-    error: Optional["_models.Error"] = rest_field(visibility=["read"])
-    """Error when job fails in it's entirety."""
-    last_updated_at: datetime.datetime = rest_field(name="lastUpdatedAt", visibility=["read"], format="rfc3339")
-    """Date and time when the job was completed.
-     
-     If the job is canceled, this is the time when the job was canceled.
-     
-     If the job failed, this is the time when the job failed. Required."""
-    created_at: datetime.datetime = rest_field(name="createdAt", visibility=["read"], format="rfc3339")
-    """Date and time when the job was created. Required."""
-    started_at: Optional[datetime.datetime] = rest_field(name="startedAt", visibility=["read"], format="rfc3339")
-    """Date and time when the job was started."""
-    summary: Optional["_models.JobSummary"] = rest_field(visibility=["read"])
-    """Summary of a job. Exists only when the job is completed."""
+    redaction_format: Optional[str] = rest_field(
+        name="redactionFormat", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Format of the redacted output. Only valid when Operation is Redact.
+     Please refer to
+     `https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format
+     <https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format>`_ for
+     more details."""
+    surrogate_locale: Optional[str] = rest_field(
+        name="surrogateLocale", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Locale in which the output surrogates are written."""
 
     @overload
     def __init__(
         self,
         *,
-        source_location: "_models.SourceStorageLocation",
-        target_location: "_models.TargetStorageLocation",
-        operation: Optional[Union[str, "_models.OperationType"]] = None,
-        data_type: Optional[Union[str, "_models.DocumentDataType"]] = None,
         redaction_format: Optional[str] = None,
-    ): ...
+        surrogate_locale: Optional[str] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class DeidentificationResult(_model_base.Model):
-    """Response body for de-identification operation.
-
-    :ivar output_text: Output text after de-identification. Not available for "Tag" operation.
-    :vartype output_text: str
-    :ivar tagger_result: Result of the "Tag" operation. Only available for "Tag" Operation.
-    :vartype tagger_result: ~azure.health.deidentification.models.PhiTaggerResult
-    """
-
-    output_text: Optional[str] = rest_field(name="outputText")
-    """Output text after de-identification. Not available for \"Tag\" operation."""
-    tagger_result: Optional["_models.PhiTaggerResult"] = rest_field(name="taggerResult")
-    """Result of the \"Tag\" operation. Only available for \"Tag\" Operation."""
-
-    @overload
-    def __init__(
-        self,
-        *,
-        output_text: Optional[str] = None,
-        tagger_result: Optional["_models.PhiTaggerResult"] = None,
-    ): ...
-
-    @overload
-    def __init__(self, mapping: Mapping[str, Any]):
-        """
-        :param mapping: raw JSON to initialize the model.
-        :type mapping: Mapping[str, Any]
-        """
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
-        super().__init__(*args, **kwargs)
-
-
-class DocumentDetails(_model_base.Model):
+class DeidentificationDocumentDetails(_model_base.Model):
     """Details of a single document in a job.
 
-    Readonly variables are only populated by the server, and will be ignored when sending a request.
-
-
     :ivar id: Id of the document details. Required.
     :vartype id: str
-    :ivar input: Location for the input. Required.
-    :vartype input: ~azure.health.deidentification.models.DocumentLocation
-    :ivar output: Location for the output.
-    :vartype output: ~azure.health.deidentification.models.DocumentLocation
+    :ivar input_location: Location for the input. Required.
+    :vartype input_location: ~azure.health.deidentification.models.DeidentificationDocumentLocation
+    :ivar output_location: Location for the output.
+    :vartype output_location:
+     ~azure.health.deidentification.models.DeidentificationDocumentLocation
     :ivar status: Status of the document. Required. Known values are: "NotStarted", "Running",
      "Succeeded", "Failed", and "Canceled".
-    :vartype status: str or ~azure.health.deidentification.models.OperationState
+    :vartype status: str or ~azure.health.deidentification.models.OperationStatus
     :ivar error: Error when document fails.
-    :vartype error: ~azure.health.deidentification.models.Error
+    :vartype error: ~azure.core.ODataV4Format
     """
 
     id: str = rest_field(visibility=["read"])
     """Id of the document details. Required."""
-    input: "_models.DocumentLocation" = rest_field()
+    input_location: "_models.DeidentificationDocumentLocation" = rest_field(
+        name="input", visibility=["read", "create", "update", "delete", "query"]
+    )
     """Location for the input. Required."""
-    output: Optional["_models.DocumentLocation"] = rest_field()
+    output_location: Optional["_models.DeidentificationDocumentLocation"] = rest_field(
+        name="output", visibility=["read", "create", "update", "delete", "query"]
+    )
     """Location for the output."""
-    status: Union[str, "_models.OperationState"] = rest_field()
+    status: Union[str, "_models.OperationStatus"] = rest_field(
+        visibility=["read", "create", "update", "delete", "query"]
+    )
     """Status of the document. Required. Known values are: \"NotStarted\", \"Running\", \"Succeeded\",
      \"Failed\", and \"Canceled\"."""
-    error: Optional["_models.Error"] = rest_field()
+    error: Optional[ODataV4Format] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Error when document fails."""
 
     @overload
     def __init__(
         self,
         *,
-        input: "_models.DocumentLocation",
-        status: Union[str, "_models.OperationState"],
-        output: Optional["_models.DocumentLocation"] = None,
-        error: Optional["_models.Error"] = None,
-    ): ...
+        input_location: "_models.DeidentificationDocumentLocation",
+        status: Union[str, "_models.OperationStatus"],
+        output_location: Optional["_models.DeidentificationDocumentLocation"] = None,
+        error: Optional[ODataV4Format] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class DocumentLocation(_model_base.Model):
+class DeidentificationDocumentLocation(_model_base.Model):
     """Location of a document.
 
-    Readonly variables are only populated by the server, and will be ignored when sending a request.
-
-
-    :ivar path: Path of document in storage. Required.
-    :vartype path: str
+    :ivar location: Location of document in storage. Required.
+    :vartype location: str
     :ivar etag: The entity tag for this resource. Required.
     :vartype etag: str
     """
 
-    path: str = rest_field()
-    """Path of document in storage. Required."""
+    location: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
+    """Location of document in storage. Required."""
     etag: str = rest_field(visibility=["read"])
     """The entity tag for this resource. Required."""
 
@@ -263,159 +184,246 @@ class DocumentLocation(_model_base.Model):
     def __init__(
         self,
         *,
-        path: str,
-    ): ...
+        location: str,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class Error(_model_base.Model):
-    """The error object.
+class DeidentificationJob(_model_base.Model):
+    """A job containing a batch of documents to de-identify.
 
-    All required parameters must be populated in order to send to server.
+    :ivar job_name: The name of a job. Required.
+    :vartype job_name: str
+    :ivar operation_type: Operation to perform on the input documents. Known values are: "Redact",
+     "Surrogate", and "Tag".
+    :vartype operation_type: str or
+     ~azure.health.deidentification.models.DeidentificationOperationType
+    :ivar source_location: Storage location to perform the operation on. Required.
+    :vartype source_location: ~azure.health.deidentification.models.SourceStorageLocation
+    :ivar target_location: Target location to store output of operation. Required.
+    :vartype target_location: ~azure.health.deidentification.models.TargetStorageLocation
+    :ivar customizations: Customization parameters to override default service behaviors.
+    :vartype customizations:
+     ~azure.health.deidentification.models.DeidentificationJobCustomizationOptions
+    :ivar status: Current status of a job. Required. Known values are: "NotStarted", "Running",
+     "Succeeded", "Failed", and "Canceled".
+    :vartype status: str or ~azure.health.deidentification.models.OperationStatus
+    :ivar error: Error when job fails in it's entirety.
+    :vartype error: ~azure.core.ODataV4Format
+    :ivar last_updated_at: Date and time when the job was completed.
+
+     If the job is canceled, this is the time when the job was canceled.
 
-    :ivar code: One of a server-defined set of error codes. Required.
-    :vartype code: str
-    :ivar message: A human-readable representation of the error. Required.
-    :vartype message: str
-    :ivar target: The target of the error.
-    :vartype target: str
-    :ivar details: An array of details about specific errors that led to this reported error.
-    :vartype details: list[~azure.health.deidentification.models.Error]
-    :ivar innererror: An object containing more specific information than the current object about
-     the error.
-    :vartype innererror: ~azure.health.deidentification.models.InnerError
+     If the job failed, this is the time when the job failed. Required.
+    :vartype last_updated_at: ~datetime.datetime
+    :ivar created_at: Date and time when the job was created. Required.
+    :vartype created_at: ~datetime.datetime
+    :ivar started_at: Date and time when the job was started.
+    :vartype started_at: ~datetime.datetime
+    :ivar summary: Summary of a job. Exists only when the job is completed.
+    :vartype summary: ~azure.health.deidentification.models.DeidentificationJobSummary
     """
 
-    code: str = rest_field()
-    """One of a server-defined set of error codes. Required."""
-    message: str = rest_field()
-    """A human-readable representation of the error. Required."""
-    target: Optional[str] = rest_field()
-    """The target of the error."""
-    details: Optional[List["_models.Error"]] = rest_field()
-    """An array of details about specific errors that led to this reported error."""
-    innererror: Optional["_models.InnerError"] = rest_field()
-    """An object containing more specific information than the current object about the error."""
+    job_name: str = rest_field(name="name", visibility=["read"])
+    """The name of a job. Required."""
+    operation_type: Optional[Union[str, "_models.DeidentificationOperationType"]] = rest_field(
+        name="operation", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Operation to perform on the input documents. Known values are: \"Redact\", \"Surrogate\", and
+     \"Tag\"."""
+    source_location: "_models.SourceStorageLocation" = rest_field(
+        name="sourceLocation", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Storage location to perform the operation on. Required."""
+    target_location: "_models.TargetStorageLocation" = rest_field(
+        name="targetLocation", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Target location to store output of operation. Required."""
+    customizations: Optional["_models.DeidentificationJobCustomizationOptions"] = rest_field(
+        visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Customization parameters to override default service behaviors."""
+    status: Union[str, "_models.OperationStatus"] = rest_field(visibility=["read"])
+    """Current status of a job. Required. Known values are: \"NotStarted\", \"Running\",
+     \"Succeeded\", \"Failed\", and \"Canceled\"."""
+    error: Optional[ODataV4Format] = rest_field(visibility=["read"])
+    """Error when job fails in it's entirety."""
+    last_updated_at: datetime.datetime = rest_field(name="lastUpdatedAt", visibility=["read"], format="rfc3339")
+    """Date and time when the job was completed.
+     
+     If the job is canceled, this is the time when the job was canceled.
+     
+     If the job failed, this is the time when the job failed. Required."""
+    created_at: datetime.datetime = rest_field(name="createdAt", visibility=["read"], format="rfc3339")
+    """Date and time when the job was created. Required."""
+    started_at: Optional[datetime.datetime] = rest_field(name="startedAt", visibility=["read"], format="rfc3339")
+    """Date and time when the job was started."""
+    summary: Optional["_models.DeidentificationJobSummary"] = rest_field(visibility=["read"])
+    """Summary of a job. Exists only when the job is completed."""
 
     @overload
     def __init__(
         self,
         *,
-        code: str,
-        message: str,
-        target: Optional[str] = None,
-        details: Optional[List["_models.Error"]] = None,
-        innererror: Optional["_models.InnerError"] = None,
-    ): ...
+        source_location: "_models.SourceStorageLocation",
+        target_location: "_models.TargetStorageLocation",
+        operation_type: Optional[Union[str, "_models.DeidentificationOperationType"]] = None,
+        customizations: Optional["_models.DeidentificationJobCustomizationOptions"] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class InnerError(_model_base.Model):
-    """An object containing more specific information about the error. As per Microsoft One API
-    guidelines -
-    https://github.com/Microsoft/api-guidelines/blob/vNext/Guidelines.md#7102-error-condition-responses.
+class DeidentificationJobCustomizationOptions(_model_base.Model):
+    """Customizations options to override default service behaviors for job usage.
 
-    :ivar code: One of a server-defined set of error codes.
-    :vartype code: str
-    :ivar innererror: Inner error.
-    :vartype innererror: ~azure.health.deidentification.models.InnerError
+    :ivar redaction_format: Format of the redacted output. Only valid when Operation is Redact.
+     Please refer to
+     `https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format
+     <https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format>`_ for
+     more details.
+    :vartype redaction_format: str
+    :ivar surrogate_locale: Locale in which the output surrogates are written.
+    :vartype surrogate_locale: str
     """
 
-    code: Optional[str] = rest_field()
-    """One of a server-defined set of error codes."""
-    innererror: Optional["_models.InnerError"] = rest_field()
-    """Inner error."""
+    redaction_format: Optional[str] = rest_field(
+        name="redactionFormat", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Format of the redacted output. Only valid when Operation is Redact.
+     Please refer to
+     `https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format
+     <https://learn.microsoft.com/azure/healthcare-apis/deidentification/redaction-format>`_ for
+     more details."""
+    surrogate_locale: Optional[str] = rest_field(
+        name="surrogateLocale", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Locale in which the output surrogates are written."""
 
     @overload
     def __init__(
         self,
         *,
-        code: Optional[str] = None,
-        innererror: Optional["_models.InnerError"] = None,
-    ): ...
+        redaction_format: Optional[str] = None,
+        surrogate_locale: Optional[str] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class JobSummary(_model_base.Model):
+class DeidentificationJobSummary(_model_base.Model):
     """Summary metrics of a job.
 
-
-    :ivar successful: Number of documents that have completed. Required.
-    :vartype successful: int
-    :ivar failed: Number of documents that have failed. Required.
-    :vartype failed: int
-    :ivar canceled: Number of documents that have been canceled. Required.
-    :vartype canceled: int
-    :ivar total: Number of documents total. Required.
-    :vartype total: int
+    :ivar successful_count: Number of documents that have completed. Required.
+    :vartype successful_count: int
+    :ivar failed_count: Number of documents that have failed. Required.
+    :vartype failed_count: int
+    :ivar canceled_count: Number of documents that have been canceled. Required.
+    :vartype canceled_count: int
+    :ivar total_count: Number of documents total. Required.
+    :vartype total_count: int
     :ivar bytes_processed: Number of bytes processed. Required.
     :vartype bytes_processed: int
     """
 
-    successful: int = rest_field()
+    successful_count: int = rest_field(name="successful", visibility=["read", "create", "update", "delete", "query"])
     """Number of documents that have completed. Required."""
-    failed: int = rest_field()
+    failed_count: int = rest_field(name="failed", visibility=["read", "create", "update", "delete", "query"])
     """Number of documents that have failed. Required."""
-    canceled: int = rest_field()
+    canceled_count: int = rest_field(name="canceled", visibility=["read", "create", "update", "delete", "query"])
     """Number of documents that have been canceled. Required."""
-    total: int = rest_field()
+    total_count: int = rest_field(name="total", visibility=["read", "create", "update", "delete", "query"])
     """Number of documents total. Required."""
-    bytes_processed: int = rest_field(name="bytesProcessed")
+    bytes_processed: int = rest_field(name="bytesProcessed", visibility=["read", "create", "update", "delete", "query"])
     """Number of bytes processed. Required."""
 
     @overload
     def __init__(
         self,
         *,
-        successful: int,
-        failed: int,
-        canceled: int,
-        total: int,
+        successful_count: int,
+        failed_count: int,
+        canceled_count: int,
+        total_count: int,
         bytes_processed: int,
-    ): ...
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+
+class DeidentificationResult(_model_base.Model):
+    """Response body for de-identification operation.
+
+    :ivar output_text: Output text after de-identification. Not available for "Tag" operation.
+    :vartype output_text: str
+    :ivar tagger_result: Result of the "Tag" operation. Only available for "Tag" Operation.
+    :vartype tagger_result: ~azure.health.deidentification.models.PhiTaggerResult
+    """
+
+    output_text: Optional[str] = rest_field(
+        name="outputText", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Output text after de-identification. Not available for \"Tag\" operation."""
+    tagger_result: Optional["_models.PhiTaggerResult"] = rest_field(
+        name="taggerResult", visibility=["read", "create", "update", "delete", "query"]
+    )
+    """Result of the \"Tag\" operation. Only available for \"Tag\" Operation."""
+
+    @overload
+    def __init__(
+        self,
+        *,
+        output_text: Optional[str] = None,
+        tagger_result: Optional["_models.PhiTaggerResult"] = None,
+    ) -> None: ...
+
+    @overload
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
+        """
+        :param mapping: raw JSON to initialize the model.
+        :type mapping: Mapping[str, Any]
+        """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
 class PhiEntity(_model_base.Model):
     """PHI Entity tag in the input.
 
-
     :ivar category: PHI Category of the entity. Required. Known values are: "Unknown", "Account",
      "Age", "BioID", "City", "CountryOrRegion", "Date", "Device", "Doctor", "Email", "Fax",
      "HealthPlan", "Hospital", "IDNum", "IPAddress", "License", "LocationOther", "MedicalRecord",
@@ -432,19 +440,21 @@ class PhiEntity(_model_base.Model):
     :vartype confidence_score: float
     """
 
-    category: Union[str, "_models.PhiCategory"] = rest_field()
+    category: Union[str, "_models.PhiCategory"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """PHI Category of the entity. Required. Known values are: \"Unknown\", \"Account\", \"Age\",
      \"BioID\", \"City\", \"CountryOrRegion\", \"Date\", \"Device\", \"Doctor\", \"Email\", \"Fax\",
      \"HealthPlan\", \"Hospital\", \"IDNum\", \"IPAddress\", \"License\", \"LocationOther\",
      \"MedicalRecord\", \"Organization\", \"Patient\", \"Phone\", \"Profession\",
      \"SocialSecurity\", \"State\", \"Street\", \"Url\", \"Username\", \"Vehicle\", and \"Zip\"."""
-    offset: "_models.StringIndex" = rest_field()
+    offset: "_models.StringIndex" = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Starting index of the location from within the input text. Required."""
-    length: "_models.StringIndex" = rest_field()
+    length: "_models.StringIndex" = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Length of the input text. Required."""
-    text: Optional[str] = rest_field()
+    text: Optional[str] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Text of the entity."""
-    confidence_score: Optional[float] = rest_field(name="confidenceScore")
+    confidence_score: Optional[float] = rest_field(
+        name="confidenceScore", visibility=["read", "create", "update", "delete", "query"]
+    )
     """Confidence score of the category match."""
 
     @overload
@@ -456,63 +466,50 @@ def __init__(
         length: "_models.StringIndex",
         text: Optional[str] = None,
         confidence_score: Optional[float] = None,
-    ): ...
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
 class PhiTaggerResult(_model_base.Model):
     """Result of the "Tag" operation.
 
-
     :ivar entities: List of entities detected in the input. Required.
     :vartype entities: list[~azure.health.deidentification.models.PhiEntity]
-    :ivar path: Path to the document in storage.
-    :vartype path: str
-    :ivar etag: The entity tag for this resource.
-    :vartype etag: str
     """
 
-    entities: List["_models.PhiEntity"] = rest_field()
+    entities: List["_models.PhiEntity"] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """List of entities detected in the input. Required."""
-    path: Optional[str] = rest_field()
-    """Path to the document in storage."""
-    etag: Optional[str] = rest_field()
-    """The entity tag for this resource."""
 
     @overload
     def __init__(
         self,
         *,
         entities: List["_models.PhiEntity"],
-        path: Optional[str] = None,
-        etag: Optional[str] = None,
-    ): ...
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
 class SourceStorageLocation(_model_base.Model):
     """Storage location.
 
-    All required parameters must be populated in order to send to server.
-
     :ivar location: URL to storage location. Required.
     :vartype location: str
     :ivar prefix: Prefix to filter path by. Required.
@@ -521,11 +518,11 @@ class SourceStorageLocation(_model_base.Model):
     :vartype extensions: list[str]
     """
 
-    location: str = rest_field()
+    location: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """URL to storage location. Required."""
-    prefix: str = rest_field()
+    prefix: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """Prefix to filter path by. Required."""
-    extensions: Optional[List[str]] = rest_field()
+    extensions: Optional[List[str]] = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """List of extensions to filter path by."""
 
     @overload
@@ -535,23 +532,22 @@ def __init__(
         location: str,
         prefix: str,
         extensions: Optional[List[str]] = None,
-    ): ...
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
 class StringIndex(_model_base.Model):
     """String index encoding model.
 
-
     :ivar utf8: The offset or length of the substring in UTF-8 encoding. Required.
     :vartype utf8: int
     :ivar utf16: The offset or length of the substring in UTF-16 encoding.
@@ -564,13 +560,13 @@ class StringIndex(_model_base.Model):
     :vartype code_point: int
     """
 
-    utf8: int = rest_field()
+    utf8: int = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """The offset or length of the substring in UTF-8 encoding. Required."""
-    utf16: int = rest_field()
+    utf16: int = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """The offset or length of the substring in UTF-16 encoding.
      
      Primary encoding used by .NET, Java, and JavaScript. Required."""
-    code_point: int = rest_field(name="codePoint")
+    code_point: int = rest_field(name="codePoint", visibility=["read", "create", "update", "delete", "query"])
     """The offset or length of the substring in CodePoint encoding.
      
      Primary encoding used by Python. Required."""
@@ -582,34 +578,54 @@ def __init__(
         utf8: int,
         utf16: int,
         code_point: int,
-    ): ...
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
 class TargetStorageLocation(_model_base.Model):
     """Storage location.
 
-    All required parameters must be populated in order to send to server.
-
     :ivar location: URL to storage location. Required.
     :vartype location: str
-    :ivar prefix: Prefix to filter path by. Required.
+    :ivar prefix: Replaces the input prefix of a file path with the output prefix, preserving the
+     rest of the path structure.
+
+     Example:
+     File full path: documents/user/note.txt
+     Input Prefix: "documents/user/"
+     Output Prefix: "output_docs/"
+
+     Output file: "output_docs/note.txt". Required.
     :vartype prefix: str
+    :ivar overwrite: When set to true during a job, the service will overwrite the output location
+     if it already exists.
+    :vartype overwrite: bool
     """
 
-    location: str = rest_field()
+    location: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
     """URL to storage location. Required."""
-    prefix: str = rest_field()
-    """Prefix to filter path by. Required."""
+    prefix: str = rest_field(visibility=["read", "create", "update", "delete", "query"])
+    """Replaces the input prefix of a file path with the output prefix, preserving the rest of the
+     path structure.
+     
+     Example:
+     File full path: documents/user/note.txt
+     Input Prefix: \"documents/user/\"
+     Output Prefix: \"output_docs/\"
+     
+     Output file: \"output_docs/note.txt\". Required."""
+    overwrite: Optional[bool] = rest_field(visibility=["read", "create", "update", "delete", "query"])
+    """When set to true during a job, the service will overwrite the output location if it already
+     exists."""
 
     @overload
     def __init__(
@@ -617,14 +633,15 @@ def __init__(
         *,
         location: str,
         prefix: str,
-    ): ...
+        overwrite: Optional[bool] = None,
+    ) -> None: ...
 
     @overload
-    def __init__(self, mapping: Mapping[str, Any]):
+    def __init__(self, mapping: Mapping[str, Any]) -> None:
         """
         :param mapping: raw JSON to initialize the model.
         :type mapping: Mapping[str, Any]
         """
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:  # pylint: disable=useless-super-delegation
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_patch.py b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_patch.py
index 807491528291..36869c12d74a 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_patch.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification/models/_patch.py
@@ -9,7 +9,6 @@
 from typing import TYPE_CHECKING, List
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from .. import models as _models
 
 __all__: List[str] = []  # Add all objects you want publicly available to users at this package level
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/pyproject.toml b/sdk/healthdataaiservices/azure-health-deidentification/pyproject.toml
new file mode 100644
index 000000000000..36b0e4cdd8e3
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/pyproject.toml
@@ -0,0 +1,2 @@
+[tool.azure-sdk-build]
+black = true
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/README.md b/sdk/healthdataaiservices/azure-health-deidentification/samples/README.md
index 01c4b46a997c..61bc36dae603 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/README.md
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/README.md
@@ -1,66 +1,71 @@
-# Azure Health Deidentification client library for Python
-Azure Health Deidentification is Microsoft's solution to anonymize unstructured health text.
-
-[Source code](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/azure/health/deidentification)
-<!-- TODO: | [Package (PyPI)](https://pypi.org/project/azure-health-deidentification/) -->
-<!-- TODO: | [API reference documentation](https://aka.ms/azsdk-python-storage-blob-ref) -->
-| [Samples](https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples)
-
+---
+page_type: sample
+languages:
+- python
+products:
+- azure
+- azure-health-data-services
+name: azure-health-deidentification samples for Python
+description: Samples for the azure-health-deidentification client library
+---
+
+# Samples for Azure Health Data Services de-identification service client library for Python
+These code samples show common scenario operations with the Azure Health Data Services de-identification service client library.
+
+| File Name | Description |
+| --- | --- |
+| [deidentify_text_tag.py] and [deidentify_text_tag_async.py] | De-identify text using the tag operation |
+| [deidentify_text_redact.py] and [deidentify_text_redact_async.py] | De-identify text using the redact operation |
+| [deidentify_text_surrogate.py] and [deidentify_text_surrogate_async.py] | De-identify text using the surrogate operation |
+| [deidentify_documents.py] and [deidentify_documents_async.py] | De-identify documents in Azure Storage with an asynchronous job |
+| [list_jobs.py] and [list_jobs_async.py] | List de-identification jobs |
+| [list_job_documents.py] and [list_job_documents_async.py] | List the documents processed by a de-identification job |
 
 ## Getting started
 
 ### Prerequisites
-* Python 3.8 or later is required to use this package. For more details, please read our page on [Azure SDK for Python version support policy](https://github.com/Azure/azure-sdk-for-python/wiki/Azure-SDKs-Python-version-support-policy).
-* You must have an [Azure subscription](https://azure.microsoft.com/free/) and an
-**Azure Deidentification Service** to use this package.
-
-### Install the package
-Install the Azure Health Deidentification client library for Python with [pip](https://pypi.org/project/pip/):
-
-```bash
-pip install azure-health-deidentification
-```
-
-### Create a Deidentification Service
-If you wish to create a new storage account, you can use the
-[Azure Portal](https://learn.microsoft.com/azure/storage/common/storage-quickstart-create-account?tabs=azure-portal).
-
-### Create the client
-In order to create a Deidentification client you must obtain the **Service URL** from your Azure Deidentification Service
-
-```python
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-    print(endpoint)
-    # example: fuf4h4bxg5b0d0dr.api.cac001.deid.azure.com
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, DefaultAzureCredential())
-```
-
-### Deidentify a string
-
-```python
-    body = DeidentificationContent(input_text="Hello, my name is John Smith.")
-
-    result: DeidentificationResult = client.deidentify(body)
-    
-    print(f'Original Text:     "{body.input_text}"')
-    print(f'Deidentified Text: "{result.output_text}"')
-```
-
-## Key concepts
-Operation Modes:
-- Tag: Will return a structure of offset and length with the PHI category of the related text spans.
-- Redact: Will return output text with placeholder stubbed text. ex. `[name]`
-- Surrogate: Will return output text with synthetic replacements.
-  - `My name is John Smith`
-  - `My name is Tom Jones`
-
-## Contributing
-This project welcomes contributions and suggestions.  Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.
-
-When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.
-
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
\ No newline at end of file
+- Python 3.9 or later is required to use this package.
+- You need an [Azure subscription][azure_sub] to use this package.
+- [Deploy the de-identification service][deid_quickstart].
+- [Configure Azure role-based access control (RBAC)][deid_rbac] for the operations you will perform.
+
+## Setup
+1. Install the Azure Health Deidentification client library for Python with [pip](https://pypi.org/project/pip/):
+   
+   ```bash
+   pip install azure-health-deidentification
+   ```
+1. Clone or download this sample repository.
+1. Open the sample folder in Visual Studio Code or your IDE of choice.
+
+## Running the samples
+
+1. Open a terminal window and `cd` to the directory that the samples are saved in.
+2. Set the environment variables specified in the sample file you wish to run.
+3. Follow the usage described in the file, e.g. `python deidentify_text.py`
+
+## Next steps
+
+Check out the [API reference documentation][api_explorer] to learn more about
+what you can do with the Azure Health Data Services de-identification service client library.
+
+<!-- LINKS -->
+[api_explorer]: https://learn.microsoft.com/python/api/overview/azure/health-deidentification
+[azure_sub]: https://azure.microsoft.com/free/
+[deid_quickstart]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/quickstart
+[deid_rbac]: https://learn.microsoft.com/azure/healthcare-apis/deidentification/manage-access-rbac
+
+<!-- Not checked in yet
+[deidentify_text_tag]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_tag.py
+[deidentify_text_redact]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_redact.py
+[deidentify_text_surrogate]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_surrogate.py
+[deidentify_documents]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_documents.py
+[list_jobs]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/list_jobs.py
+[list_job_documents]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/list_job_documents.py
+[deidentify_text_tag_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_tag_async.py
+[deidentify_text_redact_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_redact_async.py
+[deidentify_text_surrogate_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_surrogate_async.py
+[deidentify_documents_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_documents_async.py
+[list_jobs_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_jobs_async.py
+[list_job_documents_async]: https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_job_documents_async.py
+-->
\ No newline at end of file
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_documents_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_documents_async.py
new file mode 100644
index 000000000000..5c0482e966ab
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_documents_async.py
@@ -0,0 +1,73 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_documents_async.py
+
+DESCRIPTION:
+    This sample demonstrates a basic scenario of de-identifying documents in Azure Storage. 
+    Taking a container URI and an input prefix, the sample will create a job and wait for the job to complete.
+
+USAGE:
+    python deidentify_documents_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+    2) AZURE_STORAGE_ACCOUNT_LOCATION - an Azure Storage container endpoint, like "https://<storageaccount>.blob.core.windows.net/<container>".
+    3) INPUT_PREFIX - the prefix of the input document name(s) in the container.
+        For example, providing "folder1" would create a job that would process documents like "https://<storageaccount>.blob.core.windows.net/<container>/folder1/document1.txt".
+"""
+
+
+import asyncio
+from azure.core.polling import AsyncLROPoller
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationJob,
+    SourceStorageLocation,
+    TargetStorageLocation,
+)
+from azure.identity.aio import DefaultAzureCredential
+import os
+import uuid
+
+
+async def deidentify_documents_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
+    inputPrefix = os.environ["INPUT_PREFIX"]
+    outputPrefix = "_output"
+
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
+
+    job = DeidentificationJob(
+        source_location=SourceStorageLocation(
+            location=storage_location,
+            prefix=inputPrefix,
+        ),
+        target_location=TargetStorageLocation(location=storage_location, prefix=outputPrefix, overwrite=True),
+    )
+
+    async with client:
+        lro: AsyncLROPoller = await client.begin_deidentify_documents(jobname, job)
+        finished_job: DeidentificationJob = await lro.result()
+
+        await credential.close()
+
+        print(f"Job Name:   {finished_job.job_name}")
+        print(f"Job Status: {finished_job.status}")  # Succeeded
+        print(f"File Count: {finished_job.summary.total_count if finished_job.summary is not None else 0}")
+
+
+async def main():
+    await deidentify_documents_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_redact_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_redact_async.py
new file mode 100644
index 000000000000..c48e79a2fed1
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_redact_async.py
@@ -0,0 +1,53 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_redact_async.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to redact
+    PHI values in a string.
+
+USAGE:
+    python deidentify_text_redact_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+import asyncio
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity.aio import DefaultAzureCredential
+import os
+
+
+async def deidentify_text_redact_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    async with client:
+        body = DeidentificationContent(
+            input_text="It's great to work at Contoso.", operation_type=DeidentificationOperationType.REDACT
+        )
+        result: DeidentificationResult = await client.deidentify_text(body)
+        print(f'\nOriginal Text:    "{body.input_text}"')
+        print(f'Redacted Text:    "{result.output_text}"')  # Redacted output: "It's great to work at [organization]."
+
+        await credential.close()
+
+
+async def main():
+    await deidentify_text_redact_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_surrogate_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_surrogate_async.py
new file mode 100644
index 000000000000..57c92308e1ed
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_surrogate_async.py
@@ -0,0 +1,51 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_surrogate_async.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to replace
+    PHI in a string with surrogate values.
+
+USAGE:
+    python deidentify_text_surrogate_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+import asyncio
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity.aio import DefaultAzureCredential
+import os
+
+
+async def deidentify_text_surrogate_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    async with client:
+        body = DeidentificationContent(input_text="Hello, my name is John Smith.")
+        result: DeidentificationResult = await client.deidentify_text(body)
+        print(f'\nOriginal Text:    "{body.input_text}"')
+        print(f'Surrogated Text:  "{result.output_text}"')  # Surrogated output: "Hello, my name is [person]."
+
+        await credential.close()
+
+
+async def main():
+    await deidentify_text_surrogate_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_tag_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_tag_async.py
new file mode 100644
index 000000000000..302ce2525d20
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/deidentify_text_tag_async.py
@@ -0,0 +1,62 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_tag_async.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to identify (tag) PHI entities.
+
+USAGE:
+    python deidentify_text_tag_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+import asyncio
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity.aio import DefaultAzureCredential
+import os
+
+
+async def deidentify_text_tag_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    async with client:
+        body = DeidentificationContent(
+            input_text="Hello, I'm Dr. John Smith.", operation_type=DeidentificationOperationType.TAG
+        )
+        result: DeidentificationResult = await client.deidentify_text(body)
+
+        print(f'\nOriginal Text:    "{body.input_text}"')
+
+        if result.tagger_result and result.tagger_result.entities:
+            print(f"Tagged Entities:")
+            for entity in result.tagger_result.entities:
+                print(
+                    f'\tEntity Text: "{entity.text}", Entity Category: "{entity.category}", Offset: "{entity.offset.code_point}", Length: "{entity.length.code_point}"'
+                )
+        else:
+            print("\tNo tagged entities found.")
+
+        await credential.close()
+
+
+async def main():
+    await deidentify_text_tag_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_job_documents_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_job_documents_async.py
new file mode 100644
index 000000000000..47cc3925c046
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_job_documents_async.py
@@ -0,0 +1,81 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: list_job_documents_async.py
+
+DESCRIPTION:
+    This sample demonstrates how to create a job, wait for it to finish, and then list the files associated with the job.
+
+USAGE:
+    python list_job_documents_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+    2) AZURE_STORAGE_ACCOUNT_LOCATION - an Azure Storage container endpoint, like "https://<storageaccount>.blob.core.windows.net/<container>".
+    3) INPUT_PREFIX - the prefix of the input document name(s) in the container.
+        For example, providing "folder1" would create a job that would process documents like "https://<storageaccount>.blob.core.windows.net/<container>/folder1/document1.txt".
+"""
+
+
+import asyncio
+from azure.core.polling import AsyncLROPoller
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationJob,
+    SourceStorageLocation,
+    TargetStorageLocation,
+)
+from azure.identity.aio import DefaultAzureCredential
+import os
+import uuid
+
+
+async def list_job_documents_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
+    inputPrefix = os.environ["INPUT_PREFIX"]
+    outputPrefix = "_output"
+
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
+
+    job = DeidentificationJob(
+        source_location=SourceStorageLocation(
+            location=storage_location,
+            prefix=inputPrefix,
+        ),
+        target_location=TargetStorageLocation(location=storage_location, prefix=outputPrefix, overwrite=True),
+    )
+
+    print(f"Creating job with name: {jobname}")
+    async with client:
+        poller: AsyncLROPoller = await client.begin_deidentify_documents(jobname, job)
+        job = await poller.result()
+        print(f"Job Status: {job.status}")
+
+        files = client.list_job_documents(jobname)
+
+        print("Completed files (Max 10):")
+        filesToLookThrough = 10
+        async for f in files:
+            print(f"\t - {f.input_location.location}")
+
+            filesToLookThrough -= 1
+            if filesToLookThrough <= 0:
+                break
+
+        await credential.close()
+
+
+async def main():
+    await list_job_documents_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_jobs_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_jobs_async.py
new file mode 100644
index 000000000000..74f988b56a8a
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/list_jobs_async.py
@@ -0,0 +1,51 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: list_jobs_async.py
+
+DESCRIPTION:
+    This sample demonstrates how to list the latest jobs in the de-identification service.
+
+USAGE:
+    python list_jobs_async.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+import asyncio
+from azure.health.deidentification.aio import DeidentificationClient
+from azure.identity.aio import DefaultAzureCredential
+import os
+
+
+async def list_jobs_async():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    async with client:
+        jobs = client.list_jobs()
+
+        print("Listing latest 5 jobs:")
+        jobsToLookThrough = 5
+        async for j in jobs:
+            print(f"Job Name: {j.job_name}")
+
+            jobsToLookThrough -= 1
+            if jobsToLookThrough <= 0:
+                break
+
+        await credential.close()
+
+
+async def main():
+    await list_jobs_async()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_create_and_wait_job_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_create_and_wait_job_async.py
deleted file mode 100644
index e1816415c037..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_create_and_wait_job_async.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_create_and_wait_job_async.py
-
-DESCRIPTION:
-    This sample demonstrates the most simple job-based deidentification scenario. 
-    It takes a blob uri as input and an input prefix. It will create a job and wait for the job to complete.
-
-USAGE:
-    python sample_create_and_wait_job_async.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-import asyncio
-
-import uuid
-
-
-async def sample_create_and_wait_job_async():
-    # [START sample_create_and_wait_job_async]
-    import os
-    from azure.identity.aio import DefaultAzureCredential
-    from azure.health.deidentification.aio import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationJob,
-        SourceStorageLocation,
-        TargetStorageLocation,
-    )
-    from azure.core.polling import AsyncLROPoller
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
-    inputPrefix = os.environ["INPUT_PREFIX"]
-    outputPrefix = "_output"
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
-
-    job = DeidentificationJob(
-        source_location=SourceStorageLocation(
-            location=storage_location,
-            prefix=inputPrefix,
-        ),
-        target_location=TargetStorageLocation(
-            location=storage_location, prefix=outputPrefix
-        ),
-    )
-
-    async with client:
-        lro: AsyncLROPoller = await client.begin_create_job(jobname, job)
-        finished_job: DeidentificationJob = await lro.result()
-
-    await credential.close()
-
-    print(f"Job Name: {finished_job.name}")
-    print(f"Job Status: {finished_job.status}")  # Succeeded
-    print(
-        f"File Count: {finished_job.summary.total if finished_job.summary is not None else 0}"
-    )
-    # [END sample_create_and_wait_job_async]
-
-
-async def main():
-    await sample_create_and_wait_job_async()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_job_files_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_job_files_async.py
deleted file mode 100644
index 198153982a6c..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_job_files_async.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_list_job_documents_async.py
-
-DESCRIPTION:
-    This sample demonstrates how to create a job, wait for it to finish, and then list the files associated with the job.
-
-USAGE:
-    python sample_list_job_documents_async.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-
-import asyncio
-import uuid
-
-
-async def sample_list_job_documents_async():
-    # [START sample_list_job_documents_async]
-    import os
-    from azure.identity.aio import DefaultAzureCredential
-    from azure.health.deidentification.aio import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationJob,
-        SourceStorageLocation,
-        TargetStorageLocation,
-    )
-    from azure.core.polling import AsyncLROPoller
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
-    inputPrefix = os.environ["INPUT_PREFIX"]
-    outputPrefix = "_output"
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
-
-    job = DeidentificationJob(
-        source_location=SourceStorageLocation(
-            location=storage_location,
-            prefix=inputPrefix,
-        ),
-        target_location=TargetStorageLocation(
-            location=storage_location, prefix=outputPrefix
-        ),
-    )
-
-    print(f"Creating job with name: {jobname}")
-    async with client:
-        poller: AsyncLROPoller = await client.begin_create_job(jobname, job)
-        job = await poller.result()
-        print(f"Job Status: {job.status}")
-
-        files = client.list_job_documents(job.name)
-
-        print("Completed files (Max 10):")
-        filesToLookThrough = 10
-        async for f in files:
-            print(f"\t - {f.input.path}")
-
-            filesToLookThrough -= 1
-            if filesToLookThrough <= 0:
-                break
-
-    await credential.close()
-    # [END sample_list_job_documents_async]
-
-
-async def main():
-    await sample_list_job_documents_async()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_jobs_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_jobs_async.py
deleted file mode 100644
index 546cff83b471..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_list_jobs_async.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_list_jobs_async.py
-
-DESCRIPTION:
-    This sample demonstrates how to list the latest 5 jobs in the Deidentification Service resource.
-    It will create a job and then list it using the list_jobs method.
-
-USAGE:
-    python sample_list_jobs_async.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-import asyncio
-import uuid
-
-
-async def sample_list_jobs_async():
-    # [START sample_list_jobs_async]
-    import os
-    from azure.identity.aio import DefaultAzureCredential
-    from azure.health.deidentification.aio import DeidentificationClient
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    async with client:
-        jobs = client.list_jobs()
-
-        print("Listing latest 5 jobs:")
-        jobsToLookThrough = 5
-        async for j in jobs:
-            print(f"Job Name: {j.name}")
-
-            jobsToLookThrough -= 1
-            if jobsToLookThrough <= 0:
-                break
-
-    await credential.close()
-    # [END sample_list_jobs_async]
-
-
-async def main():
-    await sample_list_jobs_async()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_realtime_deidentification_async.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_realtime_deidentification_async.py
deleted file mode 100644
index 02e6813c9199..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/async_samples/sample_realtime_deidentification_async.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_realtime_deidentification_async.py
-
-DESCRIPTION:
-    This sample demonstrates the most simple deidentification scenario. It takes in a string of text and will return
-    the deidentified text.
-
-USAGE:
-    python sample_realtime_deidentification_async.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-"""
-import asyncio
-
-
-async def sample_realtime_deidentification_async():
-    # [START realtime_deidentification_async]
-    import os
-    from azure.identity.aio import DefaultAzureCredential
-    from azure.health.deidentification.aio import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationResult,
-        DeidentificationContent,
-    )
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    body = DeidentificationContent(input_text="Hello, my name is John Smith.")
-
-    async with client:
-        result: DeidentificationResult = await client.deidentify(body)
-
-    await credential.close()
-    print(f'Original Text:     "{body.input_text}"')
-    print(f'Deidentified Text: "{result.output_text}"')
-    # [END realtime_deidentification]
-
-
-async def main():
-    await sample_realtime_deidentification_async()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_documents.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_documents.py
new file mode 100644
index 000000000000..8ea4aa893074
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_documents.py
@@ -0,0 +1,66 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_documents.py
+
+DESCRIPTION:
+    This sample demonstrates a basic scenario of de-identifying documents in Azure Storage. 
+    Taking a container URI and an input prefix, the sample will create a job and wait for the job to complete.
+
+USAGE:
+    python deidentify_documents.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+    2) AZURE_STORAGE_ACCOUNT_LOCATION - an Azure Storage container endpoint, like "https://<storageaccount>.blob.core.windows.net/<container>".
+    3) INPUT_PREFIX - the prefix of the input document name(s) in the container. 
+        For example, providing "folder1" would create a job that would process documents like "https://<storageaccount>.blob.core.windows.net/<container>/folder1/document1.txt".
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationJob,
+    SourceStorageLocation,
+    TargetStorageLocation,
+)
+from azure.identity import DefaultAzureCredential
+import os
+import uuid
+
+
+def deidentify_documents():
+    # [START sample]
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
+    inputPrefix = os.environ["INPUT_PREFIX"]
+    outputPrefix = "_output"
+
+    credential = DefaultAzureCredential()
+
+    client = DeidentificationClient(endpoint, credential)
+
+    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
+
+    job = DeidentificationJob(
+        source_location=SourceStorageLocation(
+            location=storage_location,
+            prefix=inputPrefix,
+        ),
+        target_location=TargetStorageLocation(location=storage_location, prefix=outputPrefix, overwrite=True),
+    )
+
+    finished_job: DeidentificationJob = client.begin_deidentify_documents(jobname, job).result(timeout=60)
+
+    print(f"Job Name:   {finished_job.job_name}")
+    print(f"Job Status: {finished_job.status}")
+    print(f"File Count: {finished_job.summary.total_count if finished_job.summary is not None else 0}")
+    # [END sample]
+
+
+if __name__ == "__main__":
+    deidentify_documents()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_redact.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_redact.py
new file mode 100644
index 000000000000..907d86910414
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_redact.py
@@ -0,0 +1,47 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_redact.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to redact
+    PHI values in a string.
+
+USAGE:
+    python deidentify_text_redact.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity import DefaultAzureCredential
+import os
+
+
+def deidentify_text_redact():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    # [START redact]
+    body = DeidentificationContent(
+        input_text="It's great to work at Contoso.", operation_type=DeidentificationOperationType.REDACT
+    )
+    result: DeidentificationResult = client.deidentify_text(body)
+    print(f'\nOriginal Text:        "{body.input_text}"')
+    print(f'Redacted Text:   "{result.output_text}"')  # Redacted output: "It's great to work at [organization]."
+    # [END redact]
+
+
+if __name__ == "__main__":
+    deidentify_text_redact()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_surrogate.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_surrogate.py
new file mode 100644
index 000000000000..34a31f913349
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_surrogate.py
@@ -0,0 +1,45 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_surrogate.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to replace
+    PHI in a string with surrogate values.
+
+USAGE:
+    python deidentify_text_surrogate.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity import DefaultAzureCredential
+import os
+
+
+def deidentify_text_surrogate():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    # [START surrogate]
+    body = DeidentificationContent(input_text="Hello, my name is John Smith.")
+    result: DeidentificationResult = client.deidentify_text(body)
+    print(f'\nOriginal Text:        "{body.input_text}"')
+    print(f'Surrogated Text:   "{result.output_text}"')  # Surrogated output: Hello, my name is <synthetic name>.
+    # [END surrogate]
+
+
+if __name__ == "__main__":
+    deidentify_text_surrogate()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_tag.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_tag.py
new file mode 100644
index 000000000000..49fe97e8e460
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/deidentify_text_tag.py
@@ -0,0 +1,55 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: deidentify_text_tag.py
+
+DESCRIPTION:
+    This sample demonstrates the most simple de-identification scenario, calling the service to identify (tag) PHI entities.
+
+USAGE:
+    python deidentify_text_tag.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+    DeidentificationOperationType,
+    DeidentificationResult,
+)
+from azure.identity import DefaultAzureCredential
+import os
+
+
+def deidentify_text_tag():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    # [START tag]
+    body = DeidentificationContent(
+        input_text="Hello, I'm Dr. John Smith.", operation_type=DeidentificationOperationType.TAG
+    )
+    result: DeidentificationResult = client.deidentify_text(body)
+    print(f'\nOriginal Text:    "{body.input_text}"')
+
+    if result.tagger_result and result.tagger_result.entities:
+        print(f"Tagged Entities:")
+        for entity in result.tagger_result.entities:
+            print(
+                f'\tEntity Text: "{entity.text}", Entity Category: "{entity.category}", Offset: "{entity.offset.code_point}", Length: "{entity.length.code_point}"'
+            )
+    else:
+        print("\tNo tagged entities found.")
+    # [END tag]
+
+
+if __name__ == "__main__":
+    deidentify_text_tag()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/examples.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/examples.py
new file mode 100644
index 000000000000..015b271e15b7
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/examples.py
@@ -0,0 +1,23 @@
+from azure.core.exceptions import AzureError
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationContent,
+)
+from azure.identity import DefaultAzureCredential
+import os
+
+# [START create_client]
+endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+credential = DefaultAzureCredential()
+client = DeidentificationClient(endpoint, credential)
+# [END create_client]
+
+# [START handle_error]
+error_client = DeidentificationClient("https://contoso.deid.azure.com", credential)
+body = DeidentificationContent(input_text="Hello, I'm Dr. John Smith.")
+
+try:
+    error_client.deidentify_text(body)
+except AzureError as e:
+    print("\nError: " + e.message)
+# [END handle_error]
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/list_job_documents.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/list_job_documents.py
new file mode 100644
index 000000000000..3772a6648ab8
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/list_job_documents.py
@@ -0,0 +1,74 @@
+# pylint: disable=line-too-long,useless-suppression
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: list_job_documents.py
+
+DESCRIPTION:
+    This sample demonstrates how to create a job, wait for it to finish, and then list the files associated with the job.
+
+USAGE:
+    python list_job_documents.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+    2) AZURE_STORAGE_ACCOUNT_LOCATION - an Azure Storage container endpoint, like "https://<storageaccount>.blob.core.windows.net/<container>".
+    3) INPUT_PREFIX - the prefix of the input document name(s) in the container.
+        For example, providing "folder1" would create a job that would process documents like "https://<storageaccount>.blob.core.windows.net/<container>/folder1/document1.txt".
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.health.deidentification.models import (
+    DeidentificationJob,
+    SourceStorageLocation,
+    TargetStorageLocation,
+)
+from azure.identity import DefaultAzureCredential
+import os
+import uuid
+
+
+def list_job_documents():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
+    inputPrefix = os.environ["INPUT_PREFIX"]
+    outputPrefix = "_output"
+
+    credential = DefaultAzureCredential()
+
+    client = DeidentificationClient(endpoint, credential)
+
+    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
+
+    job = DeidentificationJob(
+        source_location=SourceStorageLocation(
+            location=storage_location,
+            prefix=inputPrefix,
+        ),
+        target_location=TargetStorageLocation(location=storage_location, prefix=outputPrefix, overwrite=True),
+    )
+
+    print(f"Creating job with name: {jobname}")
+
+    job = client.begin_deidentify_documents(jobname, job).result(timeout=60)
+
+    print(f"Job Status: {job.status}")
+
+    files = client.list_job_documents(jobname)
+
+    print("Completed files (Max 10):")
+    filesToLookThrough = 10
+    for f in files:
+        print(f"\t - {f.input_location.location}")
+
+        filesToLookThrough -= 1
+        if filesToLookThrough <= 0:
+            break
+
+
+if __name__ == "__main__":
+    list_job_documents()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/list_jobs.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/list_jobs.py
new file mode 100644
index 000000000000..e83fc0090c34
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/samples/list_jobs.py
@@ -0,0 +1,43 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+"""
+FILE: list_jobs.py
+
+DESCRIPTION:
+    This sample demonstrates how to list the latest jobs in the de-identification service.
+
+USAGE:
+    python list_jobs.py
+
+    Set the environment variables with your own values before running the sample:
+    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the service URL endpoint for a de-identification service.
+"""
+
+
+from azure.health.deidentification import DeidentificationClient
+from azure.identity import DefaultAzureCredential
+import os
+
+
+def list_jobs():
+    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
+    credential = DefaultAzureCredential()
+    client = DeidentificationClient(endpoint, credential)
+
+    jobs = client.list_jobs()
+
+    print("Listing latest 5 jobs:")
+    jobsToLookThrough = 5
+    for j in jobs:
+        print(f"Job Name: {j.job_name}")
+
+        jobsToLookThrough -= 1
+        if jobsToLookThrough <= 0:
+            break
+
+
+if __name__ == "__main__":
+    list_jobs()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_create_and_wait_job.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_create_and_wait_job.py
deleted file mode 100644
index 1c63c38cd86d..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_create_and_wait_job.py
+++ /dev/null
@@ -1,75 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_create_and_wait_job.py
-
-DESCRIPTION:
-    This sample demonstrates the most simple job-based deidentification scenario. 
-    It takes a blob uri as input and an input prefix. It will create a job and wait for the job to complete.
-
-USAGE:
-    python sample_create_and_wait_job.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-
-
-import uuid
-
-
-def sample_create_and_wait_job():
-    # [START sample_create_and_wait_job]
-    import os
-    from azure.identity import DefaultAzureCredential
-    from azure.health.deidentification import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationJob,
-        SourceStorageLocation,
-        TargetStorageLocation,
-    )
-    from azure.core.polling import LROPoller
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
-    inputPrefix = os.environ["INPUT_PREFIX"]
-    outputPrefix = "_output"
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
-
-    job = DeidentificationJob(
-        source_location=SourceStorageLocation(
-            location=storage_location,
-            prefix=inputPrefix,
-        ),
-        target_location=TargetStorageLocation(
-            location=storage_location, prefix=outputPrefix
-        ),
-    )
-
-    lro: LROPoller = client.begin_create_job(jobname, job)
-    lro.wait(timeout=60)
-
-    finished_job: DeidentificationJob = lro.result()
-    print(f"Job Name: {finished_job.name}")
-    print(f"Job Status: {finished_job.status}")
-    print(
-        f"File Count: {finished_job.summary.total if finished_job.summary is not None else 0}"
-    )
-    # [END sample_create_and_wait_job]
-
-
-if __name__ == "__main__":
-    sample_create_and_wait_job()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_job_files.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_job_files.py
deleted file mode 100644
index 438ebfaa267a..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_job_files.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_list_job_documents.py
-
-DESCRIPTION:
-    This sample demonstrates how to create a job, wait for it to finish, and then list the files associated with the job.
-
-USAGE:
-    python sample_list_job_documents.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-
-
-import uuid
-
-
-def sample_list_job_documents():
-    # [START sample_list_job_documents]
-    import os
-    from azure.identity import DefaultAzureCredential
-    from azure.health.deidentification import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationJob,
-        SourceStorageLocation,
-        TargetStorageLocation,
-    )
-    from azure.core.polling import LROPoller
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    storage_location = os.environ["AZURE_STORAGE_ACCOUNT_LOCATION"]
-    inputPrefix = os.environ["INPUT_PREFIX"]
-    outputPrefix = "_output"
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    jobname = f"sample-job-{uuid.uuid4().hex[:8]}"
-
-    job = DeidentificationJob(
-        source_location=SourceStorageLocation(
-            location=storage_location,
-            prefix=inputPrefix,
-        ),
-        target_location=TargetStorageLocation(
-            location=storage_location, prefix=outputPrefix
-        ),
-    )
-
-    print(f"Creating job with name: {jobname}")
-    poller: LROPoller = client.begin_create_job(jobname, job)
-    poller.wait(timeout=60)
-
-    job = poller.result()
-    print(f"Job Status: {job.status}")
-
-    files = client.list_job_documents(job.name)
-
-    print("Completed files (Max 10):")
-    filesToLookThrough = 10
-    for f in files:
-        print(f"\t - {f.input.path}")
-
-        filesToLookThrough -= 1
-        if filesToLookThrough <= 0:
-            break
-
-    # [END sample_list_job_documents]
-
-
-if __name__ == "__main__":
-    sample_list_job_documents()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_jobs.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_jobs.py
deleted file mode 100644
index 4eb70c5c7af0..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_list_jobs.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_list_jobs.py
-
-DESCRIPTION:
-    This sample demonstrates how to list the latest 5 jobs in the Deidentification Service resource.
-    It will create a job and then list it using the list_jobs method.
-
-USAGE:
-    python sample_list_jobs.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-    2) AZURE_STORAGE_ACCOUNT_LOCATION - the location of the storage account where the input and output files are stored.
-        This is an Azure Storage url to a container which must be configured with Managed Identity..
-    3) INPUT_PREFIX - the prefix of the input files in the storage account.
-"""
-
-
-import uuid
-
-
-def sample_list_jobs():
-    # [START sample_list_jobs]
-    import os
-    from azure.identity import DefaultAzureCredential
-    from azure.health.deidentification import DeidentificationClient
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    jobs = client.list_jobs()
-
-    print("Listing latest 5 jobs:")
-    jobsToLookThrough = 5
-    for j in jobs:
-        print(f"Job Name: {j.name}")
-
-        jobsToLookThrough -= 1
-        if jobsToLookThrough <= 0:
-            break
-
-    # [END sample_list_jobs]
-
-
-if __name__ == "__main__":
-    sample_list_jobs()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_realtime_deidentification.py b/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_realtime_deidentification.py
deleted file mode 100644
index 8ebef8c1af61..000000000000
--- a/sdk/healthdataaiservices/azure-health-deidentification/samples/sample_realtime_deidentification.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-"""
-FILE: sample_realtime_deidentification.py
-
-DESCRIPTION:
-    This sample demonstrates the most simple deidentification scenario. It takes in a string of text and will return
-    the deidentified text.
-
-USAGE:
-    python sample_realtime_deidentification.py
-
-    Set the environment variables with your own values before running the sample:
-    1) AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT - the endpoint to your Deidentification Service resource.
-"""
-
-
-def sample_realtime_deidentification():
-    # [START realtime_deidentification]
-    import os
-    from azure.identity import DefaultAzureCredential
-    from azure.health.deidentification import DeidentificationClient
-    from azure.health.deidentification.models import (
-        DeidentificationResult,
-        DeidentificationContent,
-        OperationType,
-        DocumentDataType,
-    )
-
-    endpoint = os.environ["AZURE_HEALTH_DEIDENTIFICATION_ENDPOINT"]
-    endpoint = endpoint.replace("https://", "")
-
-    credential = DefaultAzureCredential()
-
-    client = DeidentificationClient(endpoint, credential)
-
-    body = DeidentificationContent(input_text="Hello, my name is John Smith.")
-
-    result: DeidentificationResult = client.deidentify(body)
-    print(f'Original Text:     "{body.input_text}"')
-    print(f'Deidentified Text: "{result.output_text}"')
-    # [END realtime_deidentification]
-
-
-if __name__ == "__main__":
-    sample_realtime_deidentification()
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/sdk_packaging.toml b/sdk/healthdataaiservices/azure-health-deidentification/sdk_packaging.toml
new file mode 100644
index 000000000000..e7687fdae93b
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/sdk_packaging.toml
@@ -0,0 +1,2 @@
+[packaging]
+auto_update = false
\ No newline at end of file
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/setup.py b/sdk/healthdataaiservices/azure-health-deidentification/setup.py
index 9ca62adf44ad..1fd15892a972 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/setup.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/setup.py
@@ -5,7 +5,7 @@
 # Code generated by Microsoft (R) Python Code Generator.
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
-# coding: utf-8
+
 
 import os
 import re
@@ -29,7 +29,7 @@
 setup(
     name=PACKAGE_NAME,
     version=version,
-    description="Microsoft {} Client Library for Python".format(PACKAGE_PPRINT_NAME),
+    description="Microsoft Corporation {} Client Library for Python".format(PACKAGE_PPRINT_NAME),
     long_description=open("README.md", "r").read(),
     long_description_content_type="text/markdown",
     license="MIT License",
@@ -42,7 +42,6 @@
         "Programming Language :: Python",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
@@ -67,5 +66,5 @@
         "azure-core>=1.30.0",
         "typing-extensions>=4.6.0",
     ],
-    python_requires=">=3.8",
+    python_requires=">=3.9",
 )
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/test-resources-post.ps1 b/sdk/healthdataaiservices/azure-health-deidentification/test-resources-post.ps1
index 5595a7cc37f4..0b76325cae5b 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/test-resources-post.ps1
+++ b/sdk/healthdataaiservices/azure-health-deidentification/test-resources-post.ps1
@@ -1,11 +1,11 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
-# This script is used to set up SIP Configuration domains for Azure Communication Services SIP Routing SDK GA tests
+# This script is used to set up test resources for the Azure Health Data Services de-identification service.
 
 # It is invoked by the https://github.com/Azure/azure-sdk-for-net/blob/main/eng/New-TestResources.ps1
 # script after the ARM template, defined in https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/storage/test-resources.json,
-# is finished being deployed. The ARM template is responsible for creating the Storage accounts needed for live tests.
+# is finished being deployed. The ARM template is responsible for creating the storage account and permissions needed for live tests.
 
 param (
     [hashtable] $DeploymentOutputs,
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/test-resources.bicep b/sdk/healthdataaiservices/azure-health-deidentification/test-resources.bicep
index ea6642750209..2e55882f6482 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/test-resources.bicep
+++ b/sdk/healthdataaiservices/azure-health-deidentification/test-resources.bicep
@@ -1,9 +1,3 @@
-// "id": "/subscriptions/d12535ed-5958-4ce6-8350-b17b3af1d6b1/resourceGroups/oro-billing-exhaust-test/providers/Microsoft.HealthDataAIServices/DeidServices/deid-billing-test",
-// "name": "deid-billing-test",
-// "type": "microsoft.healthdataaiservices/deidservices",
-// "location": "East US 2 EUAP",
-// "tags": {},
-
 @minLength(10)
 param testApplicationOid string
 
@@ -15,10 +9,8 @@ param baseName string
 param location string = resourceGroup().location
 
 @description('The location of the resource. By default, this is the same as the resource group.')
-param deidLocation string = 'eastus2euap'
-param deidLocationShort string = 'eup'
-
-param deploymentTime string = utcNow('u')
+param deidLocation string = 'westus2'
+param deidLocationShort string = 'wus2'
 
 var realtimeDataUserRoleId = 'bb6577c4-ea0a-40b2-8962-ea18cb8ecd4e'
 var batchDataOwnerRoleId = '8a90fa6b-6997-4a07-8a95-30633a7c97b9'
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/conftest.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/conftest.py
index e7f366daf096..e9cfd1be9ffc 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/conftest.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/conftest.py
@@ -2,8 +2,7 @@
 import pytest
 import os
 from devtools_testutils import (
-    add_body_key_sanitizer,
-    add_general_string_sanitizer,
+    add_uri_regex_sanitizer,
     remove_batch_sanitizers,
     test_proxy,
 )
@@ -23,15 +22,17 @@ def start_proxy(test_proxy, patch_sleep, patch_async_sleep):
 @pytest.fixture(scope="session", autouse=True)
 def create_session_uniquifier():
     if (
-        os.environ.get("AZURE_TEST_RUN_LIVE", "false").lower()
-        == "true"  # Don't override uniquifier by default
+        os.environ.get("AZURE_TEST_RUN_LIVE", "false").lower() == "true"  # Don't override uniquifier by default
         and os.environ.get("AZURE_SKIP_LIVE_RECORDING", "false").lower() != "true"
+        and os.environ.get("AZURE_TEST_KEEP_UNIQUIFIER", "false").lower() != "true"
     ):
+        print("Creating new uniquifier for live test run.")
         uniquifier = uuid.uuid4().hex[:6]
         os.environ["HEALTHDATAAISERVICES_UNIQUIFIER"] = uniquifier
         with open(uniquifier_file, "w") as file:
             file.write(uniquifier)
     else:
+        print("Using existing")
         with open(uniquifier_file, "r") as file:
             uniquifier = file.read()
             os.environ["HEALTHDATAAISERVICES_UNIQUIFIER"] = uniquifier
@@ -43,13 +44,4 @@ def add_sanitizers(test_proxy):
     # $..id
     # uri sanitization in favor of substitution
     remove_batch_sanitizers(["AZSDK3493", "AZSDK3430", "AZSDK4001"])
-    account_name = os.environ.get(
-        "HEALTHDATAAISERVICES_STORAGE_ACCOUNT_NAME", "Not Found."
-    )
-    container_name = os.environ.get(
-        "HEALTHDATAAISERVICES_STORAGE_CONTAINER_NAME", "Not Found."
-    )
-    add_body_key_sanitizer(
-        json_path="..location",
-        value=f"https://{account_name}.blob.core.windows.net:443/{container_name}",
-    )
+    add_uri_regex_sanitizer(regex='continuationToken=[^&"}]*', value="continuationToken=Sanitized")
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/data/example_patient_1/row-2-data.txt b/sdk/healthdataaiservices/azure-health-deidentification/tests/data/example_patient_1/row-2-data.txt
new file mode 100644
index 000000000000..6fc315d75c92
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/data/example_patient_1/row-2-data.txt
@@ -0,0 +1,54 @@
+"CHIEF COMPLAINT
+
+Follow-up of chronic problems.
+
+HISTORY OF PRESENT ILLNESS
+
+Brian White is a 58-year-old male with a past medical history significant for congestive heart failure and hypertension, who presents today for follow-up of his chronic problems.
+
+The patient states he has been feeling out of sorts lately. He is not sure if it is due to the change in the seasons or due to performing lots of projects and some construction on his home. He reports fatigue and lightheadedness. This has been going on for about 5 weeks. While exerting energy, he has experienced some shortness of breath and chest cramps. The patient also notes a slight cough, but he is not sure if it is just the change in seasons.
+
+He feels bloated every once in a while. His diet has been a little bit of a struggle. They had construction on their kitchen begin over Labor Day weekend, and have been eating less healthy food as a result.
+
+Regarding his heart failure, he has been pretty good with his salt intake. He has been pretty good about his diet since the last year and is staying on top of that as much as possible. The patient has continued to utilize Lasix daily.
+
+For his hypertension, this has been well controlled with lisinopril 20 mg a day. He has continued to monitor his blood pressure regularly.
+
+The patient did the review of systems sheet when he checked in. He denies weight gain, swelling in the lower extremities, fevers, chills, dizziness, nausea, vomiting, and diarrhea.
+
+REVIEW OF SYSTEMS
+
+ Constitutional: Endorses fatigue. Denies fevers, chills, or weight loss.
+ Cardiovascular: Endorses chest pain or dyspnea on exertion.
+ Respiratory: Endorses cough and shortness of breath.
+ Gastrointestinal: Endorses bloating.
+
+PHYSICAL EXAMINATION
+
+ Neck: JVD 8 cm.
+ Respiratory: Rales bilateral bases.
+ Cardiovascular: 3/6 systolic ejection murmur.
+ Musculoskeletal: 1+ pitting edema bilateral lower extremities.
+
+RESULTS
+
+X-ray of the chest demonstrates a mild amount of fluid in the lungs.
+
+Echocardiogram demonstrates decreased ejection fraction of 45% and mild mitral regurgitation.
+
+ASSESSMENT AND PLAN
+
+Brian White is a 58-year-old male with a past medical history significant for congestive heart failure and hypertension, who presents today for follow up of his chronic problems.
+
+Congestive heart failure.
+ Medical Reasoning: The patient reports increased fatigue, dizziness, and chest discomfort on exertion. He also exhibits some jugular venous distention, lung base crackles, and lower extremity edema on exam today. He has been compliant with his current medications but admits to dietary indiscretion lately. His recent echocardiogram demonstrated a reduced ejection fraction of 45%, as well as mitral regurgitation.
+ Additional Testing: We will order a repeat echocardiogram.
+ Medical Treatment: Increase Lasix to 80 mg daily.
+ Patient Education and Counseling: I advised the patient to monitor and record his daily weight and report those to me via the patient portal. He will contact me should he continue to experience any dyspnea.
+
+Hypertension.
+ Medical Reasoning: This is well controlled based on home monitoring.
+ Medical Treatment: Continue lisinopril 20 mg daily.
+ Patient Education and Counseling: I advised him to monitor and record his blood pressures at home and report these to me via the patient portal.
+
+Patient Agreements: The patient understands and agrees with the recommended medical treatment plan."
\ No newline at end of file
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/deid_base_test_case.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/deid_base_test_case.py
index 383e72676898..cb9bb597f468 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/deid_base_test_case.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/deid_base_test_case.py
@@ -35,13 +35,9 @@ class DeidBaseTestCase(AzureRecordedTestCase):
 
     def make_client(self, endpoint) -> DeidentificationClient:
         credential = self.get_credential(DeidentificationClient)
+        connection_verify = not "localhost" in endpoint
         client = self.create_client_from_credential(
-            DeidentificationClient,
-            credential=credential,
-            # Client library expects just hostname
-            endpoint=endpoint.replace("https://", ""),
-            # TODO: test-proxy not playing well with SSL verification
-            # connection_verify=False,
+            DeidentificationClient, credential=credential, endpoint=endpoint, connection_verify=connection_verify
         )
         return client
 
@@ -50,10 +46,8 @@ def make_client_async(self, endpoint) -> DeidentificationClientAsync:
         client = self.create_client_from_credential(
             DeidentificationClientAsync,
             credential=credential,
-            # Client library expects just hostname
-            endpoint=endpoint.replace("https://", ""),
-            # TODO: test-proxy not playing well with SSL verification
-            connection_verify=False,
+            endpoint=endpoint,
+            connection_verify=False,  # If not set, the test proxy overwrites the endpoint to localhost:5001
         )
         return client
 
@@ -66,7 +60,15 @@ def generate_job_name(self) -> str:
     def get_storage_location(self, kwargs):
         storage_name: str = kwargs.pop("healthdataaiservices_storage_account_name")
         container_name: str = kwargs.pop("healthdataaiservices_storage_container_name")
-        storage_location = (
-            f"https://{storage_name}.blob.core.windows.net/{container_name}"
-        )
+        storage_location = f"https://{storage_name}.blob.core.windows.net/{container_name}"
+        sas_uri = os.environ.get("HEALTHDATAAISERVICES_SAS_URI", "")
+        if (
+            os.environ.get("AZURE_TEST_RUN_LIVE", "false").lower() == "true"  # Don't override uniquifier by default
+            and os.environ.get("AZURE_SKIP_LIVE_RECORDING", "false").lower() != "true"
+        ):
+            if sas_uri != "" and os.environ:
+                print(f"Using SAS URI: {sas_uri}")
+                return sas_uri
+
+        print(f"Using storage location: {storage_location}")
         return storage_location
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete.py
index cf2516fb7a8c..9274dab6f955 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete.py
@@ -26,27 +26,24 @@ def test_create_cancel_delete(self, **kwargs):
                 location=storage_location,
                 prefix="example_patient_1",
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.SURROGATE,
         )
 
-        client.begin_create_job(jobname, job)
+        client.begin_deidentify_documents(jobname, job)
 
         job = client.get_job(jobname)
-        while job.status == JobStatus.NOT_STARTED:
+        while job.status == OperationStatus.NOT_STARTED:
             self.sleep(2)
             job = client.get_job(jobname)
 
         assert job.error is None, "Job should not have an error"
-        assert job.status == JobStatus.RUNNING, "Job should be running"
+        assert job.status == OperationStatus.RUNNING, "Job should be running"
 
         job = client.cancel_job(jobname)
 
         assert job.error is None, "Job should not have an error after cancelling"
-        assert job.status == JobStatus.CANCELED, "Job should be cancelled"
+        assert job.status == OperationStatus.CANCELED, "Job should be cancelled"
 
         client.delete_job(jobname)
 
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete_async.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete_async.py
index ccf32214ba37..630b005b8c69 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete_async.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_delete_async.py
@@ -27,25 +27,23 @@ async def test_create_cancel_delete_async(self, **kwargs):
                 location=storage_location,
                 prefix="example_patient_1",
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
         )
 
-        await client.begin_create_job(jobname, job)
+        await client.begin_deidentify_documents(jobname, job)
 
         job = await client.get_job(jobname)
-        while job.status == JobStatus.NOT_STARTED:
+        while job.status == OperationStatus.NOT_STARTED:
             self.sleep(2)
             job = await client.get_job(jobname)
 
         assert job.error is None, "Job should not have an error"
-        assert job.status == JobStatus.RUNNING, "Job should be running"
+        assert job.status == OperationStatus.RUNNING, "Job should be running"
 
         job = await client.cancel_job(jobname)
 
         assert job.error is None, "Job should not have an error after cancelling"
-        assert job.status == JobStatus.CANCELED, "Job should be cancelled"
+        assert job.status == OperationStatus.CANCELED, "Job should be cancelled"
 
         await client.delete_job(jobname)
 
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list.py
index 9cb3fedf0d5c..489e7c8ff480 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list.py
@@ -24,29 +24,30 @@ def test_create_list(self, **kwargs):
                 location=storage_location,
                 prefix=inputPrefix,
             ),
-            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH),
-            operation=OperationType.TAG,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.REDACT,
+            customizations=DeidentificationJobCustomizationOptions(redaction_format="[{type}]"),
         )
 
-        client.begin_create_job(jobname, job)
+        client.begin_deidentify_documents(jobname, job)
         jobs = client.list_jobs()
 
         job = None
         jobsToLookThrough = 10
         for j in jobs:
             jobsToLookThrough -= 1
-            if j.name == jobname:
+            if j.job_name == jobname:
                 job = j
                 break
             elif jobsToLookThrough <= 0:
                 raise Exception("Job not found in list_jobs")
 
-        assert job.name == jobname
-        assert job.status == JobStatus.NOT_STARTED or job.status == JobStatus.RUNNING
-        assert job.operation == OperationType.TAG
+        assert job is not None
+        assert job.job_name == jobname
+        assert job.status == OperationStatus.NOT_STARTED or job.status == OperationStatus.RUNNING
+        assert job.operation_type == DeidentificationOperationType.REDACT
         assert job.error is None
-        assert job.summary is None
         assert job.created_at is not None
         assert job.last_updated_at is not None
-        assert job.redaction_format is None
+        assert job.customizations is not None
+        assert job.customizations.redaction_format == "[{type}]"
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list_async.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list_async.py
index 51383e5313a7..3e2fe503a761 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list_async.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_list_async.py
@@ -25,31 +25,28 @@ async def test_create_list_async(self, **kwargs):
                 location=storage_location,
                 prefix=inputPrefix,
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
-            operation=OperationType.TAG,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.TAG,
         )
 
-        await client.begin_create_job(jobname, job)
-        jobs = client.list_jobs()
+        await client.begin_deidentify_documents(jobname, job)
+        jobs = client.list_jobs(maxpagesize=1)
 
         job = None
         jobsToLookThrough = 10
         async for j in jobs:
             jobsToLookThrough -= 1
-            if j.name == jobname:
+            if j.job_name == jobname:
                 job = j
                 break
             elif jobsToLookThrough <= 0:
                 raise Exception("Job not found in list_jobs")
 
-        assert job.name == jobname
-        assert job.status == JobStatus.NOT_STARTED or job.status == JobStatus.RUNNING
-        assert job.operation == OperationType.TAG
+        assert job is not None
+        assert job.job_name == jobname
+        assert job.status == OperationStatus.NOT_STARTED or job.status == OperationStatus.RUNNING
+        assert job.operation_type == DeidentificationOperationType.TAG
         assert job.error is None
-        assert job.summary is None
         assert job.created_at is not None
         assert job.last_updated_at is not None
-        assert job.redaction_format is None
+        assert job.customizations is not None
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish.py
index 79954337cf3b..a36395ed3731 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish.py
@@ -12,7 +12,7 @@ class TestHealthDeidentificationCreateJobWaitUntil(DeidBaseTestCase):
     @recorded_by_proxy
     def test_create_wait_finish(self, **kwargs):
         endpoint: str = kwargs.pop("healthdataaiservices_deid_service_endpoint")
-        inputPrefix = "example_patient_1"
+        input_prefix = "example_patient_1"
         storage_location: str = self.get_storage_location(kwargs)
         client = self.make_client(endpoint)
         assert client is not None
@@ -22,39 +22,38 @@ def test_create_wait_finish(self, **kwargs):
         job = DeidentificationJob(
             source_location=SourceStorageLocation(
                 location=storage_location,
-                prefix=inputPrefix,
+                prefix=input_prefix,
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.SURROGATE,
         )
 
-        lro: LROPoller = client.begin_create_job(jobname, job)
+        lro: LROPoller = client.begin_deidentify_documents(jobname, job)
         lro.wait(timeout=60)
 
         finished_job: DeidentificationJob = lro.result()
 
-        assert finished_job.status == JobStatus.SUCCEEDED
-        assert finished_job.name == jobname
-        assert finished_job.operation == OperationType.SURROGATE
-        assert finished_job.data_type == DocumentDataType.PLAINTEXT
-        assert finished_job.summary.total == 2
-        assert finished_job.summary.successful == 2
-        assert finished_job.summary.failed == 0
-        assert finished_job.started_at > finished_job.created_at
+        assert finished_job.status == OperationStatus.SUCCEEDED
+        assert finished_job.job_name == jobname
+        assert finished_job.operation_type == DeidentificationOperationType.SURROGATE
+        assert finished_job.summary is not None
+        assert finished_job.summary.total_count == 3
+        assert finished_job.summary.successful_count == 3
+        assert finished_job.summary.failed_count == 0
+        assert finished_job.started_at is not None and finished_job.started_at > finished_job.created_at
         assert finished_job.last_updated_at > finished_job.started_at
-        assert finished_job.redaction_format is None
+        assert finished_job.customizations is not None
+        assert finished_job.customizations.surrogate_locale == "en-US"
         assert finished_job.error is None
-        assert finished_job.source_location.prefix == inputPrefix
+        assert finished_job.source_location.prefix == input_prefix
 
         files = client.list_job_documents(jobname)
         count = 0
         for my_file in files:
             assert len(my_file.id) == 36  # GUID
-            assert my_file.input.path.startswith(inputPrefix)
-            assert my_file.status == OperationState.SUCCEEDED
-            assert my_file.output.path.startswith(self.OUTPUT_PATH)
+            assert input_prefix in my_file.input_location.location
+            assert my_file.status == OperationStatus.SUCCEEDED
+            assert my_file.output_location is not None
+            assert self.OUTPUT_PATH in my_file.output_location.location
             count += 1
-        assert count == 2, f"Expected 2 files, found {count}"
+        assert count == 3, f"Expected 3 files, found {count}"
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish_async.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish_async.py
index 97af65c1d224..def9a186a6bc 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish_async.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_create_wait_finish_async.py
@@ -14,7 +14,7 @@ class TestHealthDeidentificationCreateJobWaitUntil(DeidBaseTestCase):
     @recorded_by_proxy_async
     async def test_create_wait_finish_async(self, **kwargs):
         endpoint: str = kwargs.pop("healthdataaiservices_deid_service_endpoint")
-        inputPrefix = "example_patient_1"
+        input_prefix = "example_patient_1"
         storage_location: str = self.get_storage_location(kwargs)
         client = self.make_client_async(endpoint)
         assert client is not None
@@ -24,39 +24,39 @@ async def test_create_wait_finish_async(self, **kwargs):
         job = DeidentificationJob(
             source_location=SourceStorageLocation(
                 location=storage_location,
-                prefix=inputPrefix,
+                prefix=input_prefix,
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.SURROGATE,
         )
 
-        lro: AsyncLROPoller = await client.begin_create_job(jobname, job)
-        lro.wait()
+        lro: AsyncLROPoller = await client.begin_deidentify_documents(jobname, job)
+        await lro.wait()
 
         finished_job: DeidentificationJob = await lro.result()
 
-        assert finished_job.status == JobStatus.SUCCEEDED
-        assert finished_job.name == jobname
-        assert finished_job.operation == OperationType.SURROGATE
-        assert finished_job.data_type == DocumentDataType.PLAINTEXT
-        assert finished_job.summary.total == 2
-        assert finished_job.summary.successful == 2
-        assert finished_job.summary.failed == 0
+        assert finished_job.status == OperationStatus.SUCCEEDED
+        assert finished_job.job_name == jobname
+        assert finished_job.operation_type == DeidentificationOperationType.SURROGATE
+        assert finished_job.summary is not None
+        assert finished_job.summary.total_count == 3
+        assert finished_job.summary.successful_count == 3
+        assert finished_job.summary.failed_count == 0
+        assert finished_job.started_at is not None
         assert finished_job.started_at > finished_job.created_at
         assert finished_job.last_updated_at > finished_job.started_at
-        assert finished_job.redaction_format is None
+        assert finished_job.customizations is not None
+        assert finished_job.customizations.surrogate_locale == "en-US"
         assert finished_job.error is None
-        assert finished_job.source_location.prefix == inputPrefix
+        assert finished_job.source_location.prefix == input_prefix
 
         files = client.list_job_documents(jobname)
         count = 0
         async for my_file in files:
             assert len(my_file.id) == 36  # GUID
-            assert my_file.input.path.startswith(inputPrefix)
-            assert my_file.status == OperationState.SUCCEEDED
-            assert my_file.output.path.startswith(self.OUTPUT_PATH)
+            assert input_prefix in my_file.input_location.location
+            assert my_file.status == OperationStatus.SUCCEEDED
+            assert my_file.output_location is not None
+            assert self.OUTPUT_PATH in my_file.output_location.location
             count += 1
-        assert count == 2, f"Expected 2 files, found {count}"
+        assert count == 3, f"Expected 3 files, found {count}"
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws.py
index ff0daaad26d6..328db5d2777c 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws.py
@@ -28,18 +28,18 @@ def test_exception_throws(self, **kwargs):
                 location=storage_location,
                 prefix="no_files_in_this_folder",
             ),
-            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH),
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.SURROGATE,
         )
 
-        lro: LROPoller = client.begin_create_job(jobname, job)
+        lro: LROPoller = client.begin_deidentify_documents(jobname, job)
         with pytest.raises(HttpResponseError):
             lro.wait(timeout=60)
 
         job = client.get_job(jobname)
 
-        assert job.status == JobStatus.FAILED
+        assert job.status == OperationStatus.FAILED
         assert job.error is not None
-        assert job.error.code == "JobValidationError"
+        assert job.error.code == "EmptyJob"
+        assert job.error.message is not None
         assert len(job.error.message) > 10
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws_async.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws_async.py
index 2f1858a2ce9e..5e5bb47cd7ef 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws_async.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_exception_throws_async.py
@@ -29,20 +29,18 @@ async def test_exception_throws_async(self, **kwargs):
                 location=storage_location,
                 prefix="no_files_in_this_folder",
             ),
-            target_location=TargetStorageLocation(
-                location=storage_location, prefix=self.OUTPUT_PATH
-            ),
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.SURROGATE,
         )
 
-        lro: AsyncLROPoller = await client.begin_create_job(jobname, job)
+        lro: AsyncLROPoller = await client.begin_deidentify_documents(jobname, job)
         with pytest.raises(HttpResponseError):
             await lro.wait()
 
         job = await client.get_job(jobname)
 
-        assert job.status == JobStatus.FAILED
+        assert job.status == OperationStatus.FAILED
         assert job.error is not None
-        assert job.error.code == "JobValidationError"
+        assert job.error.code == "EmptyJob"
+        assert job.error.message is not None
         assert len(job.error.message) > 10
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world.py
index 32e700227510..1f1e291d8496 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world.py
@@ -2,7 +2,6 @@
 from devtools_testutils import (
     recorded_by_proxy,
 )
-import pytest
 
 from azure.health.deidentification.models import *
 
@@ -15,12 +14,10 @@ def test_hello_world(self, healthdataaiservices_deid_service_endpoint):
         assert client is not None
 
         content = DeidentificationContent(
-            input_text="Hello, my name is John Smith.",
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            input_text="Hello, my name is John Smith.", operation_type=DeidentificationOperationType.SURROGATE
         )
 
-        result: DeidentificationResult = client.deidentify(content)
+        result: DeidentificationResult = client.deidentify_text(content)
 
         assert result is not None
         assert result.output_text is not None
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world_async.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world_async.py
index 6506850de0f8..771b694b4864 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world_async.py
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_hello_world_async.py
@@ -16,12 +16,10 @@ async def test_hello_world_async(self, healthdataaiservices_deid_service_endpoin
         assert client is not None
 
         content = DeidentificationContent(
-            input_text="Hello, my name is John Smith.",
-            operation=OperationType.SURROGATE,
-            data_type=DocumentDataType.PLAINTEXT,
+            input_text="Hello, my name is John Smith.", operation_type=DeidentificationOperationType.SURROGATE
         )
 
-        result: DeidentificationResult = await client.deidentify(content)
+        result: DeidentificationResult = await client.deidentify_text(content)
 
         assert result is not None
         assert result.output_text is not None
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/test_list_job_docs_pagination.py b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_list_job_docs_pagination.py
new file mode 100644
index 000000000000..ddb7f06ca83f
--- /dev/null
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/test_list_job_docs_pagination.py
@@ -0,0 +1,66 @@
+from deid_base_test_case import *
+from devtools_testutils import (
+    recorded_by_proxy,
+)
+
+from azure.health.deidentification.models import *
+from azure.core.paging import ItemPaged
+
+
+class TestHealthDeidentificationCreateAndListJob(DeidBaseTestCase):
+    @BatchEnv()
+    @recorded_by_proxy
+    def test_list_job_docs_pagination(self, **kwargs):
+        """
+        This test is verifying that pagination is working as expected.
+        The nextLink is being obfuscated by the SDK so we want to verify it is being used and not ignored
+        """
+        endpoint: str = kwargs.pop("healthdataaiservices_deid_service_endpoint")
+        inputPrefix = "example_patient_1"
+        storage_location: str = self.get_storage_location(kwargs)
+        client = self.make_client(endpoint)
+        assert client is not None
+
+        jobname = self.generate_job_name()
+
+        job = DeidentificationJob(
+            source_location=SourceStorageLocation(
+                location=storage_location,
+                prefix=inputPrefix,
+            ),
+            target_location=TargetStorageLocation(location=storage_location, prefix=self.OUTPUT_PATH, overwrite=True),
+            operation_type=DeidentificationOperationType.REDACT,
+            customizations=DeidentificationJobCustomizationOptions(redaction_format="[{type}]"),
+        )
+
+        client.begin_deidentify_documents(jobname, job).result(180)
+        job_documents = client.list_job_documents(job_name=jobname, maxpagesize=2)
+
+        _get_next = job_documents._args[0]  # type: ignore
+        _extract_data = job_documents._args[1]  # type: ignore
+
+        job_documents_paged = ItemPaged(
+            get_next=_get_next,
+            extract_data=_extract_data,
+        )
+
+        job_ids = []
+
+        # Verify the first page contains our maxpagesize of 2
+        page_iterator = job_documents_paged.by_page()
+        first_page = next(page_iterator)
+        first_page_items = list(first_page)
+        assert len(first_page_items) == 2, f"Expected 2 items in the first page, found {len(first_page_items)}"
+        job_ids.extend(item.id for item in first_page_items)
+
+        # Verify there are no duplicates
+        assert len(set(job_ids)) == 2
+
+        # Verify the second page has the remaining 1 item
+        second_page = next(page_iterator)
+        second_page_items = list(second_page)
+        assert len(second_page_items) == 1, f"Expected 1 item in the second page, found {len(second_page_items)}"
+        job_ids.extend(item.id for item in second_page_items)
+
+        # Verify the total count and uniqueness of job IDs
+        assert len(set(job_ids)) == 3, "Each job ID should be unique"
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tests/uniquifier.conf b/sdk/healthdataaiservices/azure-health-deidentification/tests/uniquifier.conf
index 5ceb18d86ac6..c7a63308e6ed 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tests/uniquifier.conf
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tests/uniquifier.conf
@@ -1 +1 @@
-10ea88
\ No newline at end of file
+49b1c2
\ No newline at end of file
diff --git a/sdk/healthdataaiservices/azure-health-deidentification/tsp-location.yaml b/sdk/healthdataaiservices/azure-health-deidentification/tsp-location.yaml
index 090caaf79c28..d55f86c96999 100644
--- a/sdk/healthdataaiservices/azure-health-deidentification/tsp-location.yaml
+++ b/sdk/healthdataaiservices/azure-health-deidentification/tsp-location.yaml
@@ -1,5 +1,4 @@
 directory: specification/healthdataaiservices/HealthDataAIServices.DeidServices
-commit: 2771da5baeee73dfd70b2a5f2813a55549c2aa73
-additionalDirectories: []
+commit: 42908ffeb55cef58948bd789114d3b43bf0f59bd
 repo: Azure/azure-rest-api-specs
-
+additionalDirectories: 
diff --git a/sdk/healthdataaiservices/tests.yml b/sdk/healthdataaiservices/tests.yml
index 64b083802a0d..3d14c7be85d1 100644
--- a/sdk/healthdataaiservices/tests.yml
+++ b/sdk/healthdataaiservices/tests.yml
@@ -3,7 +3,13 @@ trigger: none
 extends:
   template: ../../eng/pipelines/templates/stages/archetype-sdk-tests.yml
   parameters:
+    BuildTargetingString: azure-health-deidentification
     ServiceDirectory: healthdataaiservices
+    Clouds: Public
+    CloudConfig:
+      Public:
+        MatrixReplace:
+          - TestSamples=.*/true
     EnvVars:
       AZURE_SKIP_LIVE_RECORDING: 'True'
       AZURE_TEST_RUN_LIVE: 'true'