diff --git a/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md b/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md
index c6467c67fead..3c0464d462c5 100644
--- a/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md
+++ b/sdk/keyvault/azure-keyvault-certificates/CHANGELOG.md
@@ -3,6 +3,7 @@
 ## 4.8.0b4 (Unreleased)
 
 ### Features Added
+- Added support for service API version `7.5`
 
 ### Breaking Changes
 
@@ -12,6 +13,9 @@
 - Python 3.7 is no longer supported. Please use Python version 3.8 or later.
 - `asyncio` is no longer directly referenced by the library
   ([#33819](https://github.com/Azure/azure-sdk-for-python/pull/33819))
+- Key Vault API version `7.5` is now the default
+- Updated minimum `azure-core` version to 1.29.5
+- Dropped `azure-common` requirement
 
 ## 4.8.0b3 (2023-11-03)
 
diff --git a/sdk/keyvault/azure-keyvault-certificates/assets.json b/sdk/keyvault/azure-keyvault-certificates/assets.json
index 23f0d6b03877..016347d1e38a 100644
--- a/sdk/keyvault/azure-keyvault-certificates/assets.json
+++ b/sdk/keyvault/azure-keyvault-certificates/assets.json
@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "python",
   "TagPrefix": "python/keyvault/azure-keyvault-certificates",
-  "Tag": "python/keyvault/azure-keyvault-certificates_89cddcd729"
+  "Tag": "python/keyvault/azure-keyvault-certificates_1cf731dd01"
 }
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/__init__.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/__init__.py
index 1414715b988c..1e535724e551 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/__init__.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/__init__.py
@@ -6,7 +6,7 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from ._key_vault_client import KeyVaultClient
+from ._client import KeyVaultClient
 
 try:
     from ._patch import __all__ as _patch_all
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_key_vault_client.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_client.py
similarity index 62%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_key_vault_client.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_client.py
index 9d423f1627ad..28ee625036e6 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_key_vault_client.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_client.py
@@ -10,40 +10,59 @@
 from typing import Any
 
 from azure.core import PipelineClient
+from azure.core.pipeline import policies
 from azure.core.rest import HttpRequest, HttpResponse
 
 from . import models as _models
 from ._configuration import KeyVaultClientConfiguration
+from ._operations import KeyVaultClientOperationsMixin
 from ._serialization import Deserializer, Serializer
-from .operations import KeyVaultClientOperationsMixin
 
 
 class KeyVaultClient(KeyVaultClientOperationsMixin):  # pylint: disable=client-accepts-api-version-keyword
     """The key vault client performs cryptographic key operations and vault operations against the Key
     Vault service.
 
-    :keyword api_version: Api Version. Default value is "7.5-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
+    :keyword api_version: Api Version. Default value is "7.5". Note that overriding this default
+     value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, **kwargs: Any) -> None:  # pylint: disable=missing-client-constructor-parameter-credential
         _endpoint = "{vaultBaseUrl}"
         self._config = KeyVaultClientConfiguration(**kwargs)
-        self._client: PipelineClient = PipelineClient(base_url=_endpoint, config=self._config, **kwargs)
-
-        client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)}
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                policies.RequestIdPolicy(**kwargs),
+                self._config.headers_policy,
+                self._config.user_agent_policy,
+                self._config.proxy_policy,
+                policies.ContentDecodePolicy(**kwargs),
+                self._config.redirect_policy,
+                self._config.retry_policy,
+                self._config.authentication_policy,
+                self._config.custom_hook_policy,
+                self._config.logging_policy,
+                policies.DistributedTracingPolicy(**kwargs),
+                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+                self._config.http_logging_policy,
+            ]
+        self._client: PipelineClient = PipelineClient(base_url=_endpoint, policies=_policies, **kwargs)
+
+        client_models = {k: v for k, v in _models._models.__dict__.items() if isinstance(v, type)}
+        client_models.update({k: v for k, v in _models.__dict__.items() if isinstance(v, type)})
         self._serialize = Serializer(client_models)
         self._deserialize = Deserializer(client_models)
         self._serialize.client_side_validation = False
 
-    def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse:
+    def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse:
         """Runs the network request through the client's chained policies.
 
         >>> from azure.core.rest import HttpRequest
         >>> request = HttpRequest("GET", "https://www.example.org/")
         <HttpRequest [GET], url: 'https://www.example.org/'>
-        >>> response = client._send_request(request)
+        >>> response = client.send_request(request)
         <HttpResponse: 200 OK>
 
         For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request
@@ -57,7 +76,7 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse:
 
         request_copy = deepcopy(request)
         request_copy.url = self._client.format_url(request_copy.url)
-        return self._client.send_request(request_copy, **kwargs)
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
 
     def close(self) -> None:
         self._client.close()
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_configuration.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_configuration.py
index 5b9bfa5f7717..c7b4428506e3 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_configuration.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_configuration.py
@@ -8,29 +8,28 @@
 
 from typing import Any
 
-from azure.core.configuration import Configuration
 from azure.core.pipeline import policies
 
 VERSION = "unknown"
 
 
-class KeyVaultClientConfiguration(Configuration):  # pylint: disable=too-many-instance-attributes
+class KeyVaultClientConfiguration:  # pylint: disable=too-many-instance-attributes
     """Configuration for KeyVaultClient.
 
     Note that all parameters used to create this instance are saved as instance
     attributes.
 
-    :keyword api_version: Api Version. Default value is "7.5-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
+    :keyword api_version: Api Version. Default value is "7.5". Note that overriding this default
+     value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        super(KeyVaultClientConfiguration, self).__init__(**kwargs)
-        api_version: str = kwargs.pop("api_version", "7.5-preview.1")
+        api_version: str = kwargs.pop("api_version", "7.5")
 
         self.api_version = api_version
         kwargs.setdefault("sdk_moniker", "keyvault/{}".format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
         self._configure(**kwargs)
 
     def _configure(self, **kwargs: Any) -> None:
@@ -39,7 +38,7 @@ def _configure(self, **kwargs: Any) -> None:
         self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
         self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
         self.http_logging_policy = kwargs.get("http_logging_policy") or policies.HttpLoggingPolicy(**kwargs)
-        self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
         self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs)
+        self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
         self.authentication_policy = kwargs.get("authentication_policy")
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/__init__.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/__init__.py
similarity index 91%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/__init__.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/__init__.py
index 15aeb155c95e..29ea96fccbfe 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/__init__.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/__init__.py
@@ -6,7 +6,7 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from ._key_vault_client_operations import KeyVaultClientOperationsMixin
+from ._operations import KeyVaultClientOperationsMixin
 
 from ._patch import __all__ as _patch_all
 from ._patch import *  # pylint: disable=unused-wildcard-import
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/_operations.py
similarity index 73%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/_key_vault_client_operations.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/_operations.py
index 40d8e8050c5b..5954f8a304d9 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/_key_vault_client_operations.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/_operations.py
@@ -1,4 +1,4 @@
-# pylint: disable=too-many-lines
+# pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
@@ -20,14 +20,13 @@
 )
 from azure.core.paging import ItemPaged
 from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import HttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import HttpRequest, HttpResponse
 from azure.core.tracing.decorator import distributed_trace
 from azure.core.utils import case_insensitive_dict
 
 from .. import models as _models
 from .._serialization import Serializer
-from .._vendor import KeyVaultClientMixinABC, _convert_request
+from .._vendor import KeyVaultClientMixinABC
 
 T = TypeVar("T")
 ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
@@ -36,17 +35,17 @@
 _SERIALIZER.client_side_validation = False
 
 
-def build_get_certificates_request(
+def build_key_vault_get_certificates_request(
     *, maxresults: Optional[int] = None, include_pending: Optional[bool] = 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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates")
+    _url = "/certificates"
 
     # Construct parameters
     if maxresults is not None:
@@ -61,15 +60,17 @@ def build_get_certificates_request(
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_delete_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_delete_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}")
+    _url = "/certificates/{certificate-name}"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -85,16 +86,16 @@ def build_delete_certificate_request(certificate_name: str, **kwargs: Any) -> Ht
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_set_certificate_contacts_request(**kwargs: Any) -> HttpRequest:
+def build_key_vault_set_certificate_contacts_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 {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/contacts")
+    _url = "/certificates/contacts"
 
     # Construct parameters
     _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -107,15 +108,15 @@ def build_set_certificate_contacts_request(**kwargs: Any) -> HttpRequest:
     return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_contacts_request(**kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_contacts_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 {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/contacts")
+    _url = "/certificates/contacts"
 
     # Construct parameters
     _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -126,15 +127,15 @@ def build_get_certificate_contacts_request(**kwargs: Any) -> HttpRequest:
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_delete_certificate_contacts_request(**kwargs: Any) -> HttpRequest:  # pylint: disable=name-too-long
+def build_key_vault_delete_certificate_contacts_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 {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/contacts")
+    _url = "/certificates/contacts"
 
     # Construct parameters
     _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -145,15 +146,17 @@ def build_delete_certificate_contacts_request(**kwargs: Any) -> HttpRequest:  #
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_issuers_request(*, maxresults: Optional[int] = None, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_issuers_request(  # pylint: disable=name-too-long
+    *, maxresults: Optional[int] = 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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/issuers")
+    _url = "/certificates/issuers"
 
     # Construct parameters
     if maxresults is not None:
@@ -166,16 +169,18 @@ def build_get_certificate_issuers_request(*, maxresults: Optional[int] = None, *
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_set_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_set_certificate_issuer_request(  # pylint: disable=name-too-long
+    issuer_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/issuers/{issuer-name}")
+    _url = "/certificates/issuers/{issuer-name}"
     path_format_arguments = {
         "issuer-name": _SERIALIZER.url("issuer_name", issuer_name, "str"),
     }
@@ -193,16 +198,18 @@ def build_set_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> Htt
     return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_update_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_update_certificate_issuer_request(  # pylint: disable=name-too-long
+    issuer_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/issuers/{issuer-name}")
+    _url = "/certificates/issuers/{issuer-name}"
     path_format_arguments = {
         "issuer-name": _SERIALIZER.url("issuer_name", issuer_name, "str"),
     }
@@ -220,15 +227,17 @@ def build_update_certificate_issuer_request(issuer_name: str, **kwargs: Any) ->
     return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_issuer_request(  # pylint: disable=name-too-long
+    issuer_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/issuers/{issuer-name}")
+    _url = "/certificates/issuers/{issuer-name}"
     path_format_arguments = {
         "issuer-name": _SERIALIZER.url("issuer_name", issuer_name, "str"),
     }
@@ -244,15 +253,17 @@ def build_get_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> Htt
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_delete_certificate_issuer_request(issuer_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_delete_certificate_issuer_request(  # pylint: disable=name-too-long
+    issuer_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/issuers/{issuer-name}")
+    _url = "/certificates/issuers/{issuer-name}"
     path_format_arguments = {
         "issuer-name": _SERIALIZER.url("issuer_name", issuer_name, "str"),
     }
@@ -268,16 +279,18 @@ def build_delete_certificate_issuer_request(issuer_name: str, **kwargs: Any) ->
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_create_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_create_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/create")
+    _url = "/certificates/{certificate-name}/create"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str", pattern=r"^[0-9a-zA-Z-]+$"),
     }
@@ -295,16 +308,18 @@ def build_create_certificate_request(certificate_name: str, **kwargs: Any) -> Ht
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_import_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_import_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/import")
+    _url = "/certificates/{certificate-name}/import"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str", pattern=r"^[0-9a-zA-Z-]+$"),
     }
@@ -322,17 +337,17 @@ def build_import_certificate_request(certificate_name: str, **kwargs: Any) -> Ht
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_versions_request(
+def build_key_vault_get_certificate_versions_request(  # pylint: disable=name-too-long
     certificate_name: str, *, maxresults: Optional[int] = 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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/versions")
+    _url = "/certificates/{certificate-name}/versions"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -350,15 +365,17 @@ def build_get_certificate_versions_request(
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_policy_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_policy_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/policy")
+    _url = "/certificates/{certificate-name}/policy"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -374,16 +391,18 @@ def build_get_certificate_policy_request(certificate_name: str, **kwargs: Any) -
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_update_certificate_policy_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_update_certificate_policy_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/policy")
+    _url = "/certificates/{certificate-name}/policy"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -401,16 +420,18 @@ def build_update_certificate_policy_request(certificate_name: str, **kwargs: Any
     return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_update_certificate_request(certificate_name: str, certificate_version: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_update_certificate_request(  # pylint: disable=name-too-long
+    certificate_name: str, certificate_version: 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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/{certificate-version}")
+    _url = "/certificates/{certificate-name}/{certificate-version}"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
         "certificate-version": _SERIALIZER.url("certificate_version", certificate_version, "str"),
@@ -429,15 +450,17 @@ def build_update_certificate_request(certificate_name: str, certificate_version:
     return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_request(certificate_name: str, certificate_version: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_request(
+    certificate_name: str, certificate_version: 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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/{certificate-version}")
+    _url = "/certificates/{certificate-name}/{certificate-version}"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
         "certificate-version": _SERIALIZER.url("certificate_version", certificate_version, "str"),
@@ -454,18 +477,18 @@ def build_get_certificate_request(certificate_name: str, certificate_version: st
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_update_certificate_operation_request(  # pylint: disable=name-too-long
+def build_key_vault_update_certificate_operation_request(  # pylint: disable=name-too-long
     certificate_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/pending")
+    _url = "/certificates/{certificate-name}/pending"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -483,15 +506,17 @@ def build_update_certificate_operation_request(  # pylint: disable=name-too-long
     return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_certificate_operation_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_certificate_operation_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/pending")
+    _url = "/certificates/{certificate-name}/pending"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -507,17 +532,17 @@ def build_get_certificate_operation_request(certificate_name: str, **kwargs: Any
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_delete_certificate_operation_request(  # pylint: disable=name-too-long
+def build_key_vault_delete_certificate_operation_request(  # pylint: disable=name-too-long
     certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/pending")
+    _url = "/certificates/{certificate-name}/pending"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -533,16 +558,18 @@ def build_delete_certificate_operation_request(  # pylint: disable=name-too-long
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_merge_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_merge_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/pending/merge")
+    _url = "/certificates/{certificate-name}/pending/merge"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -560,15 +587,17 @@ def build_merge_certificate_request(certificate_name: str, **kwargs: Any) -> Htt
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_backup_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_backup_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/{certificate-name}/backup")
+    _url = "/certificates/{certificate-name}/backup"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -584,16 +613,16 @@ def build_backup_certificate_request(certificate_name: str, **kwargs: Any) -> Ht
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_restore_certificate_request(**kwargs: Any) -> HttpRequest:
+def build_key_vault_restore_certificate_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 {})
 
-    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5-preview.1"))
     content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/certificates/restore")
+    _url = "/certificates/restore"
 
     # Construct parameters
     _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
@@ -606,17 +635,17 @@ def build_restore_certificate_request(**kwargs: Any) -> HttpRequest:
     return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_deleted_certificates_request(
+def build_key_vault_get_deleted_certificates_request(  # pylint: disable=name-too-long
     *, maxresults: Optional[int] = None, include_pending: Optional[bool] = 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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/deletedcertificates")
+    _url = "/deletedcertificates"
 
     # Construct parameters
     if maxresults is not None:
@@ -631,15 +660,17 @@ def build_get_deleted_certificates_request(
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_get_deleted_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_get_deleted_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/deletedcertificates/{certificate-name}")
+    _url = "/deletedcertificates/{certificate-name}"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -655,15 +686,17 @@ def build_get_deleted_certificate_request(certificate_name: str, **kwargs: Any)
     return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_purge_deleted_certificate_request(certificate_name: str, **kwargs: Any) -> HttpRequest:
+def build_key_vault_purge_deleted_certificate_request(  # pylint: disable=name-too-long
+    certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/deletedcertificates/{certificate-name}")
+    _url = "/deletedcertificates/{certificate-name}"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -679,17 +712,17 @@ def build_purge_deleted_certificate_request(certificate_name: str, **kwargs: Any
     return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs)
 
 
-def build_recover_deleted_certificate_request(  # pylint: disable=name-too-long
+def build_key_vault_recover_deleted_certificate_request(  # pylint: disable=name-too-long
     certificate_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", "7.5-preview.1"))
+    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "7.5"))
     accept = _headers.pop("Accept", "application/json")
 
     # Construct URL
-    _url = kwargs.pop("template_url", "/deletedcertificates/{certificate-name}/recover")
+    _url = "/deletedcertificates/{certificate-name}/recover"
     path_format_arguments = {
         "certificate-name": _SERIALIZER.url("certificate_name", certificate_name, "str"),
     }
@@ -710,6 +743,7 @@ class KeyVaultClientOperationsMixin(KeyVaultClientMixinABC):  # pylint: disable=
     def get_certificates(
         self,
         vault_base_url: str,
+        *,
         maxresults: Optional[int] = None,
         include_pending: Optional[bool] = None,
         **kwargs: Any
@@ -721,22 +755,22 @@ def get_certificates(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :param include_pending: Specifies whether to include certificates which are not completely
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :keyword include_pending: Specifies whether to include certificates which are not completely
          provisioned. Default value is None.
-        :type include_pending: bool
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateItem or the result of cls(response)
-        :rtype: ~azure.core.paging.ItemPaged[~key_vault_client.models.CertificateItem]
+        :paramtype include_pending: bool
+        :return: An iterator like instance of CertificateItem
+        :rtype: ~azure.core.paging.ItemPaged[~azure.keyvault.v7_5.models.CertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -749,19 +783,17 @@ def get_certificates(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificates_request(
+                _request = build_key_vault_get_certificates_request(
                     maxresults=maxresults,
                     include_pending=include_pending,
-                    api_version=api_version,
-                    template_url=self.get_certificates.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -773,34 +805,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, iter(list_of_elem)
 
         def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -809,8 +844,6 @@ def get_next(next_link=None):
 
         return ItemPaged(get_next, extract_data)
 
-    get_certificates.metadata = {"url": "/certificates"}
-
     @distributed_trace
     def delete_certificate(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -825,9 +858,8 @@ def delete_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: DeletedCertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.DeletedCertificateBundle
+        :return: DeletedCertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.DeletedCertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -839,32 +871,31 @@ def delete_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.DeletedCertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_request(
+        _request = build_key_vault_delete_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.delete_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -872,11 +903,9 @@ def delete_certificate(
         deserialized = self._deserialize("DeletedCertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    delete_certificate.metadata = {"url": "/certificates/{certificate-name}"}
+        return deserialized  # type: ignore
 
     @overload
     def set_certificate_contacts(
@@ -890,19 +919,18 @@ def set_certificate_contacts(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param contacts: The contacts for the key vault certificate. Required.
-        :type contacts: ~key_vault_client.models.Contacts
+        :type contacts: ~azure.keyvault.v7_5.models.Contacts
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @overload
     def set_certificate_contacts(
-        self, vault_base_url: str, contacts: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, vault_base_url: str, contacts: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.Contacts:
         """Sets the certificate contacts for the specified key vault.
 
@@ -912,19 +940,18 @@ def set_certificate_contacts(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param contacts: The contacts for the key vault certificate. Required.
-        :type contacts: IO
+        :type contacts: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @distributed_trace
     def set_certificate_contacts(
-        self, vault_base_url: str, contacts: Union[_models.Contacts, IO], **kwargs: Any
+        self, vault_base_url: str, contacts: Union[_models.Contacts, IO[bytes]], **kwargs: Any
     ) -> _models.Contacts:
         """Sets the certificate contacts for the specified key vault.
 
@@ -933,15 +960,14 @@ def set_certificate_contacts(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param contacts: The contacts for the key vault certificate. Is either a Contacts type or a IO
-         type. Required.
-        :type contacts: ~key_vault_client.models.Contacts or IO
+        :param contacts: The contacts for the key vault certificate. Is either a Contacts type or a
+         IO[bytes] type. Required.
+        :type contacts: ~azure.keyvault.v7_5.models.Contacts or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -953,9 +979,8 @@ def set_certificate_contacts(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
@@ -967,29 +992,29 @@ def set_certificate_contacts(
         else:
             _json = self._serialize.body(contacts, "Contacts")
 
-        request = build_set_certificate_contacts_request(
-            api_version=api_version,
+        _request = build_key_vault_set_certificate_contacts_request(
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.set_certificate_contacts.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -997,11 +1022,9 @@ def set_certificate_contacts(
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    set_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _models.Contacts:
@@ -1012,9 +1035,8 @@ def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _model
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1026,31 +1048,30 @@ def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _model
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_contacts_request(
-            api_version=api_version,
-            template_url=self.get_certificate_contacts.metadata["url"],
+        _request = build_key_vault_get_certificate_contacts_request(
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1058,11 +1079,9 @@ def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _model
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    get_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _models.Contacts:
@@ -1073,9 +1092,8 @@ def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _mo
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1087,31 +1105,30 @@ def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _mo
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_contacts_request(
-            api_version=api_version,
-            template_url=self.delete_certificate_contacts.metadata["url"],
+        _request = build_key_vault_delete_certificate_contacts_request(
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1119,15 +1136,13 @@ def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _mo
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    delete_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_issuers(
-        self, vault_base_url: str, maxresults: Optional[int] = None, **kwargs: Any
+        self, vault_base_url: str, *, maxresults: Optional[int] = None, **kwargs: Any
     ) -> Iterable["_models.CertificateIssuerItem"]:
         """List certificate issuers for a specified key vault.
 
@@ -1137,20 +1152,19 @@ def get_certificate_issuers(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateIssuerItem or the result of
-         cls(response)
-        :rtype: ~azure.core.paging.ItemPaged[~key_vault_client.models.CertificateIssuerItem]
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :return: An iterator like instance of CertificateIssuerItem
+        :rtype: ~azure.core.paging.ItemPaged[~azure.keyvault.v7_5.models.CertificateIssuerItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateIssuerListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateIssuerListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -1163,18 +1177,16 @@ def get_certificate_issuers(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificate_issuers_request(
+                _request = build_key_vault_get_certificate_issuers_request(
                     maxresults=maxresults,
-                    api_version=api_version,
-                    template_url=self.get_certificate_issuers.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -1186,34 +1198,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateIssuerListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateIssuerListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, iter(list_of_elem)
 
         def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -1222,8 +1237,6 @@ def get_next(next_link=None):
 
         return ItemPaged(get_next, extract_data)
 
-    get_certificate_issuers.metadata = {"url": "/certificates/issuers"}
-
     @overload
     def set_certificate_issuer(
         self,
@@ -1246,13 +1259,12 @@ def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerSetParameters
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerSetParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1261,7 +1273,7 @@ def set_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: IO,
+        parameter: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1278,13 +1290,12 @@ def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Required.
-        :type parameter: IO
+        :type parameter: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1293,7 +1304,7 @@ def set_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: Union[_models.CertificateIssuerSetParameters, IO],
+        parameter: Union[_models.CertificateIssuerSetParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.IssuerBundle:
         """Sets the specified certificate issuer.
@@ -1308,14 +1319,13 @@ def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Is either a CertificateIssuerSetParameters
-         type or a IO type. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerSetParameters or IO
+         type or a IO[bytes] type. Required.
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerSetParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1327,9 +1337,8 @@ def set_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
@@ -1341,30 +1350,30 @@ def set_certificate_issuer(
         else:
             _json = self._serialize.body(parameter, "CertificateIssuerSetParameters")
 
-        request = build_set_certificate_issuer_request(
+        _request = build_key_vault_set_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.set_certificate_issuer.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1372,11 +1381,9 @@ def set_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    set_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @overload
     def update_certificate_issuer(
@@ -1398,13 +1405,12 @@ def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerUpdateParameters
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerUpdateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1413,7 +1419,7 @@ def update_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: IO,
+        parameter: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1428,13 +1434,12 @@ def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Required.
-        :type parameter: IO
+        :type parameter: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1443,7 +1448,7 @@ def update_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: Union[_models.CertificateIssuerUpdateParameters, IO],
+        parameter: Union[_models.CertificateIssuerUpdateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.IssuerBundle:
         """Updates the specified certificate issuer.
@@ -1456,14 +1461,13 @@ def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Is either a
-         CertificateIssuerUpdateParameters type or a IO type. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerUpdateParameters or IO
+         CertificateIssuerUpdateParameters type or a IO[bytes] type. Required.
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerUpdateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1475,9 +1479,8 @@ def update_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
@@ -1489,30 +1492,30 @@ def update_certificate_issuer(
         else:
             _json = self._serialize.body(parameter, "CertificateIssuerUpdateParameters")
 
-        request = build_update_certificate_issuer_request(
+        _request = build_key_vault_update_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_issuer.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1520,11 +1523,9 @@ def update_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    update_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwargs: Any) -> _models.IssuerBundle:
@@ -1538,9 +1539,8 @@ def get_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwargs
         :type vault_base_url: str
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1552,32 +1552,31 @@ def get_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwargs
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_issuer_request(
+        _request = build_key_vault_get_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
-            template_url=self.get_certificate_issuer.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1585,11 +1584,9 @@ def get_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwargs
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def delete_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwargs: Any) -> _models.IssuerBundle:
@@ -1602,9 +1599,8 @@ def delete_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwa
         :type vault_base_url: str
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1616,32 +1612,31 @@ def delete_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwa
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_issuer_request(
+        _request = build_key_vault_delete_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
-            template_url=self.delete_certificate_issuer.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1649,11 +1644,9 @@ def delete_certificate_issuer(self, vault_base_url: str, issuer_name: str, **kwa
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    delete_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @overload
     def create_certificate(
@@ -1677,13 +1670,12 @@ def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateCreateParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateCreateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1692,7 +1684,7 @@ def create_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1709,13 +1701,12 @@ def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1724,7 +1715,7 @@ def create_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateCreateParameters, IO],
+        parameters: Union[_models.CertificateCreateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateOperation:
         """Creates a new certificate.
@@ -1739,14 +1730,13 @@ def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Is either a
-         CertificateCreateParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateCreateParameters or IO
+         CertificateCreateParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateCreateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1758,9 +1748,8 @@ def create_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
@@ -1772,30 +1761,30 @@ def create_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateCreateParameters")
 
-        request = build_create_certificate_request(
+        _request = build_key_vault_create_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.create_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [202]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1803,11 +1792,9 @@ def create_certificate(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    create_certificate.metadata = {"url": "/certificates/{certificate-name}/create"}
+        return deserialized  # type: ignore
 
     @overload
     def import_certificate(
@@ -1833,13 +1820,12 @@ def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateImportParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateImportParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1848,7 +1834,7 @@ def import_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1867,13 +1853,12 @@ def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1882,7 +1867,7 @@ def import_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateImportParameters, IO],
+        parameters: Union[_models.CertificateImportParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Imports a certificate into a specified key vault.
@@ -1899,14 +1884,13 @@ def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Is either a
-         CertificateImportParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateImportParameters or IO
+         CertificateImportParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateImportParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1918,9 +1902,8 @@ def import_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -1932,30 +1915,30 @@ def import_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateImportParameters")
 
-        request = build_import_certificate_request(
+        _request = build_key_vault_import_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.import_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1963,15 +1946,13 @@ def import_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    import_certificate.metadata = {"url": "/certificates/{certificate-name}/import"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_versions(
-        self, vault_base_url: str, certificate_name: str, maxresults: Optional[int] = None, **kwargs: Any
+        self, vault_base_url: str, certificate_name: str, *, maxresults: Optional[int] = None, **kwargs: Any
     ) -> Iterable["_models.CertificateItem"]:
         """List the versions of a certificate.
 
@@ -1982,19 +1963,19 @@ def get_certificate_versions(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateItem or the result of cls(response)
-        :rtype: ~azure.core.paging.ItemPaged[~key_vault_client.models.CertificateItem]
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :return: An iterator like instance of CertificateItem
+        :rtype: ~azure.core.paging.ItemPaged[~azure.keyvault.v7_5.models.CertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -2007,19 +1988,17 @@ def get_certificate_versions(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificate_versions_request(
+                _request = build_key_vault_get_certificate_versions_request(
                     certificate_name=certificate_name,
                     maxresults=maxresults,
-                    api_version=api_version,
-                    template_url=self.get_certificate_versions.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -2031,34 +2010,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, iter(list_of_elem)
 
         def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -2067,8 +2049,6 @@ def get_next(next_link=None):
 
         return ItemPaged(get_next, extract_data)
 
-    get_certificate_versions.metadata = {"url": "/certificates/{certificate-name}/versions"}
-
     @distributed_trace
     def get_certificate_policy(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -2082,9 +2062,8 @@ def get_certificate_policy(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate in a given key vault. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2096,32 +2075,31 @@ def get_certificate_policy(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificatePolicy] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_policy_request(
+        _request = build_key_vault_get_certificate_policy_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_certificate_policy.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2129,11 +2107,9 @@ def get_certificate_policy(
         deserialized = self._deserialize("CertificatePolicy", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate_policy.metadata = {"url": "/certificates/{certificate-name}/policy"}
+        return deserialized  # type: ignore
 
     @overload
     def update_certificate_policy(
@@ -2155,13 +2131,12 @@ def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Required.
-        :type certificate_policy: ~key_vault_client.models.CertificatePolicy
+        :type certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2170,7 +2145,7 @@ def update_certificate_policy(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_policy: IO,
+        certificate_policy: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -2185,13 +2160,12 @@ def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Required.
-        :type certificate_policy: IO
+        :type certificate_policy: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2200,7 +2174,7 @@ def update_certificate_policy(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_policy: Union[_models.CertificatePolicy, IO],
+        certificate_policy: Union[_models.CertificatePolicy, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificatePolicy:
         """Updates the policy for a certificate.
@@ -2213,14 +2187,13 @@ def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Is either a CertificatePolicy type
-         or a IO type. Required.
-        :type certificate_policy: ~key_vault_client.models.CertificatePolicy or IO
+         or a IO[bytes] type. Required.
+        :type certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2232,9 +2205,8 @@ def update_certificate_policy(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificatePolicy] = kwargs.pop("cls", None)
 
@@ -2246,30 +2218,30 @@ def update_certificate_policy(
         else:
             _json = self._serialize.body(certificate_policy, "CertificatePolicy")
 
-        request = build_update_certificate_policy_request(
+        _request = build_key_vault_update_certificate_policy_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_policy.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2277,11 +2249,9 @@ def update_certificate_policy(
         deserialized = self._deserialize("CertificatePolicy", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    update_certificate_policy.metadata = {"url": "/certificates/{certificate-name}/policy"}
+        return deserialized  # type: ignore
 
     @overload
     def update_certificate(
@@ -2307,13 +2277,12 @@ def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Required.
-        :type parameters: ~key_vault_client.models.CertificateUpdateParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateUpdateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2323,7 +2292,7 @@ def update_certificate(
         vault_base_url: str,
         certificate_name: str,
         certificate_version: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -2341,13 +2310,12 @@ def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2357,7 +2325,7 @@ def update_certificate(
         vault_base_url: str,
         certificate_name: str,
         certificate_version: str,
-        parameters: Union[_models.CertificateUpdateParameters, IO],
+        parameters: Union[_models.CertificateUpdateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Updates the specified attributes associated with the given certificate.
@@ -2373,14 +2341,13 @@ def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Is either a
-         CertificateUpdateParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateUpdateParameters or IO
+         CertificateUpdateParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateUpdateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2392,9 +2359,8 @@ def update_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -2406,31 +2372,31 @@ def update_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateUpdateParameters")
 
-        request = build_update_certificate_request(
+        _request = build_key_vault_update_certificate_request(
             certificate_name=certificate_name,
             certificate_version=certificate_version,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2438,11 +2404,9 @@ def update_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    update_certificate.metadata = {"url": "/certificates/{certificate-name}/{certificate-version}"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate(
@@ -2460,9 +2424,8 @@ def get_certificate(
         :param certificate_version: The version of the certificate. This URI fragment is optional. If
          not specified, the latest version of the certificate is returned. Required.
         :type certificate_version: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2474,33 +2437,32 @@ def get_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_request(
+        _request = build_key_vault_get_certificate_request(
             certificate_name=certificate_name,
             certificate_version=certificate_version,
-            api_version=api_version,
-            template_url=self.get_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2508,11 +2470,9 @@ def get_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate.metadata = {"url": "/certificates/{certificate-name}/{certificate-version}"}
+        return deserialized  # type: ignore
 
     @overload
     def update_certificate_operation(
@@ -2534,13 +2494,12 @@ def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Required.
-        :type certificate_operation: ~key_vault_client.models.CertificateOperationUpdateParameter
+        :type certificate_operation: ~azure.keyvault.v7_5.models.CertificateOperationUpdateParameter
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2549,7 +2508,7 @@ def update_certificate_operation(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_operation: IO,
+        certificate_operation: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -2564,13 +2523,12 @@ def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Required.
-        :type certificate_operation: IO
+        :type certificate_operation: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2579,7 +2537,7 @@ def update_certificate_operation(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_operation: Union[_models.CertificateOperationUpdateParameter, IO],
+        certificate_operation: Union[_models.CertificateOperationUpdateParameter, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateOperation:
         """Updates a certificate operation.
@@ -2592,14 +2550,14 @@ def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Is either a
-         CertificateOperationUpdateParameter type or a IO type. Required.
-        :type certificate_operation: ~key_vault_client.models.CertificateOperationUpdateParameter or IO
+         CertificateOperationUpdateParameter type or a IO[bytes] type. Required.
+        :type certificate_operation: ~azure.keyvault.v7_5.models.CertificateOperationUpdateParameter or
+         IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2611,9 +2569,8 @@ def update_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
@@ -2625,30 +2582,30 @@ def update_certificate_operation(
         else:
             _json = self._serialize.body(certificate_operation, "CertificateOperationUpdateParameter")
 
-        request = build_update_certificate_operation_request(
+        _request = build_key_vault_update_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_operation.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2656,11 +2613,9 @@ def update_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    update_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_operation(
@@ -2675,9 +2630,8 @@ def get_certificate_operation(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2689,32 +2643,31 @@ def get_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_operation_request(
+        _request = build_key_vault_get_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_certificate_operation.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2722,11 +2675,9 @@ def get_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def delete_certificate_operation(
@@ -2742,9 +2693,8 @@ def delete_certificate_operation(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2756,32 +2706,31 @@ def delete_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_operation_request(
+        _request = build_key_vault_delete_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.delete_certificate_operation.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2789,11 +2738,9 @@ def delete_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    delete_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @overload
     def merge_certificate(
@@ -2816,13 +2763,12 @@ def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateMergeParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateMergeParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2831,7 +2777,7 @@ def merge_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -2847,13 +2793,12 @@ def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2862,7 +2807,7 @@ def merge_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateMergeParameters, IO],
+        parameters: Union[_models.CertificateMergeParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Merges a certificate or a certificate chain with a key pair existing on the server.
@@ -2876,14 +2821,13 @@ def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Is either a CertificateMergeParameters
-         type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateMergeParameters or IO
+         type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateMergeParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2895,9 +2839,8 @@ def merge_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -2909,30 +2852,30 @@ def merge_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateMergeParameters")
 
-        request = build_merge_certificate_request(
+        _request = build_key_vault_merge_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.merge_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [201]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2940,11 +2883,9 @@ def merge_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    merge_certificate.metadata = {"url": "/certificates/{certificate-name}/pending/merge"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def backup_certificate(
@@ -2960,9 +2901,8 @@ def backup_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: BackupCertificateResult or the result of cls(response)
-        :rtype: ~key_vault_client.models.BackupCertificateResult
+        :return: BackupCertificateResult
+        :rtype: ~azure.keyvault.v7_5.models.BackupCertificateResult
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2974,32 +2914,31 @@ def backup_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.BackupCertificateResult] = kwargs.pop("cls", None)
 
-        request = build_backup_certificate_request(
+        _request = build_key_vault_backup_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.backup_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -3007,11 +2946,9 @@ def backup_certificate(
         deserialized = self._deserialize("BackupCertificateResult", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    backup_certificate.metadata = {"url": "/certificates/{certificate-name}/backup"}
+        return deserialized  # type: ignore
 
     @overload
     def restore_certificate(
@@ -3030,19 +2967,18 @@ def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateRestoreParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateRestoreParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @overload
     def restore_certificate(
-        self, vault_base_url: str, parameters: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, vault_base_url: str, parameters: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.CertificateBundle:
         """Restores a backed up certificate to a vault.
 
@@ -3052,19 +2988,18 @@ def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @distributed_trace
     def restore_certificate(
-        self, vault_base_url: str, parameters: Union[_models.CertificateRestoreParameters, IO], **kwargs: Any
+        self, vault_base_url: str, parameters: Union[_models.CertificateRestoreParameters, IO[bytes]], **kwargs: Any
     ) -> _models.CertificateBundle:
         """Restores a backed up certificate to a vault.
 
@@ -3074,14 +3009,13 @@ def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Is either a
-         CertificateRestoreParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateRestoreParameters or IO
+         CertificateRestoreParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateRestoreParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -3093,9 +3027,8 @@ def restore_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -3107,29 +3040,29 @@ def restore_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateRestoreParameters")
 
-        request = build_restore_certificate_request(
-            api_version=api_version,
+        _request = build_key_vault_restore_certificate_request(
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.restore_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -3137,16 +3070,15 @@ def restore_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    restore_certificate.metadata = {"url": "/certificates/restore"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_deleted_certificates(
         self,
         vault_base_url: str,
+        *,
         maxresults: Optional[int] = None,
         include_pending: Optional[bool] = None,
         **kwargs: Any
@@ -3160,23 +3092,22 @@ def get_deleted_certificates(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :param include_pending: Specifies whether to include certificates which are not completely
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :keyword include_pending: Specifies whether to include certificates which are not completely
          provisioned. Default value is None.
-        :type include_pending: bool
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either DeletedCertificateItem or the result of
-         cls(response)
-        :rtype: ~azure.core.paging.ItemPaged[~key_vault_client.models.DeletedCertificateItem]
+        :paramtype include_pending: bool
+        :return: An iterator like instance of DeletedCertificateItem
+        :rtype: ~azure.core.paging.ItemPaged[~azure.keyvault.v7_5.models.DeletedCertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.DeletedCertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.DeletedCertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -3189,19 +3120,17 @@ def get_deleted_certificates(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_deleted_certificates_request(
+                _request = build_key_vault_get_deleted_certificates_request(
                     maxresults=maxresults,
                     include_pending=include_pending,
-                    api_version=api_version,
-                    template_url=self.get_deleted_certificates.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -3213,34 +3142,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         def extract_data(pipeline_response):
-            deserialized = self._deserialize("DeletedCertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.DeletedCertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, iter(list_of_elem)
 
         def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -3249,8 +3181,6 @@ def get_next(next_link=None):
 
         return ItemPaged(get_next, extract_data)
 
-    get_deleted_certificates.metadata = {"url": "/deletedcertificates"}
-
     @distributed_trace
     def get_deleted_certificate(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -3265,9 +3195,8 @@ def get_deleted_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: DeletedCertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.DeletedCertificateBundle
+        :return: DeletedCertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.DeletedCertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -3279,32 +3208,31 @@ def get_deleted_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.DeletedCertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_get_deleted_certificate_request(
+        _request = build_key_vault_get_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -3312,11 +3240,9 @@ def get_deleted_certificate(
         deserialized = self._deserialize("DeletedCertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def purge_deleted_certificate(  # pylint: disable=inconsistent-return-statements
@@ -3332,8 +3258,7 @@ def purge_deleted_certificate(  # pylint: disable=inconsistent-return-statements
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: None or the result of cls(response)
+        :return: None
         :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
@@ -3346,40 +3271,37 @@ def purge_deleted_certificate(  # pylint: disable=inconsistent-return-statements
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[None] = kwargs.pop("cls", None)
 
-        request = build_purge_deleted_certificate_request(
+        _request = build_key_vault_purge_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.purge_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [204]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
 
         if cls:
-            return cls(pipeline_response, None, {})
-
-    purge_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}"}
+            return cls(pipeline_response, None, {})  # type: ignore
 
     @distributed_trace
     def recover_deleted_certificate(
@@ -3396,9 +3318,8 @@ def recover_deleted_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the deleted certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -3410,32 +3331,31 @@ def recover_deleted_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_recover_deleted_certificate_request(
+        _request = build_key_vault_recover_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.recover_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = self._client._pipeline.run(  # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -3443,8 +3363,6 @@ def recover_deleted_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    recover_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}/recover"}
+        return deserialized  # type: ignore
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/_patch.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/_patch.py
similarity index 100%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/_patch.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_operations/_patch.py
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_serialization.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_serialization.py
index 9f3e29b11388..baa661cb82d2 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_serialization.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_serialization.py
@@ -63,8 +63,8 @@
 
 import isodate  # type: ignore
 
-from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
-from azure.core.serialization import NULL as AzureCoreNull
+from azure.core.exceptions import DeserializationError, SerializationError
+from azure.core.serialization import NULL as CoreNull
 
 _BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
 
@@ -124,7 +124,7 @@ def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type:
                     pass
 
                 return ET.fromstring(data_as_str)  # nosec
-            except ET.ParseError:
+            except ET.ParseError as err:
                 # It might be because the server has an issue, and returned JSON with
                 # content-type XML....
                 # So let's try a JSON load, and if it's still broken
@@ -143,7 +143,7 @@ def _json_attemp(data):
                 # The function hack is because Py2.7 messes up with exception
                 # context otherwise.
                 _LOGGER.critical("Wasn't XML not JSON, failing")
-                raise_with_traceback(DeserializationError, "XML is invalid")
+                raise DeserializationError("XML is invalid") from err
         raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
 
     @classmethod
@@ -295,7 +295,7 @@ class Model(object):
     _validation: Dict[str, Dict[str, Any]] = {}
 
     def __init__(self, **kwargs: Any) -> None:
-        self.additional_properties: Dict[str, Any] = {}
+        self.additional_properties: Optional[Dict[str, Any]] = {}
         for k in kwargs:
             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__)
@@ -340,7 +340,7 @@ def _create_xml_node(cls):
         return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
 
     def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
-        """Return the JSON that would be sent to azure from this model.
+        """Return the JSON that would be sent to server from this model.
 
         This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
 
@@ -351,7 +351,7 @@ 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)
+        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)  # type: ignore
 
     def as_dict(
         self,
@@ -390,7 +390,7 @@ def my_key_transformer(key, attr_desc, value):
         :rtype: dict
         """
         serializer = Serializer(self._infer_class_models())
-        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)
+        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)  # type: ignore
 
     @classmethod
     def _infer_class_models(cls):
@@ -415,7 +415,7 @@ def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = N
         :raises: DeserializationError if something went wrong
         """
         deserializer = Deserializer(cls._infer_class_models())
-        return deserializer(cls.__name__, data, content_type=content_type)
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def from_dict(
@@ -445,7 +445,7 @@ def from_dict(
             if key_extractors is None
             else key_extractors
         )
-        return deserializer(cls.__name__, data, content_type=content_type)
+        return deserializer(cls.__name__, data, content_type=content_type)  # type: ignore
 
     @classmethod
     def _flatten_subtype(cls, key, objects):
@@ -668,7 +668,7 @@ 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_with_traceback(SerializationError, msg, err)
+            raise SerializationError(msg) from err
         else:
             return serialized
 
@@ -710,7 +710,7 @@ def body(self, data, data_type, **kwargs):
                     ]
                 data = deserializer._deserialize(data_type, data)
             except DeserializationError as err:
-                raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err)
+                raise SerializationError("Unable to build a model: " + str(err)) from err
 
         return self._serialize(data, data_type, **kwargs)
 
@@ -730,7 +730,6 @@ def url(self, name, data, data_type, **kwargs):
 
             if kwargs.get("skip_quote") is True:
                 output = str(output)
-                # https://github.com/Azure/autorest.python/issues/2063
                 output = output.replace("{", quote("{")).replace("}", quote("}"))
             else:
                 output = quote(str(output), safe="")
@@ -746,7 +745,7 @@ def query(self, name, data, data_type, **kwargs):
         :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
+        :rtype: str, list
         :raises: TypeError if serialization fails.
         :raises: ValueError if data is None
         """
@@ -755,7 +754,7 @@ def query(self, name, data, data_type, **kwargs):
             if data_type.startswith("["):
                 internal_data_type = data_type[1:-1]
                 do_quote = not kwargs.get("skip_quote", False)
-                return str(self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs))
+                return self.serialize_iter(data, internal_data_type, do_quote=do_quote, **kwargs)
 
             # Not a list, regular serialization
             output = self.serialize_data(data, data_type, **kwargs)
@@ -806,7 +805,7 @@ def serialize_data(self, data, data_type, **kwargs):
             raise ValueError("No value for given attribute")
 
         try:
-            if data is AzureCoreNull:
+            if data is CoreNull:
                 return None
             if data_type in self.basic_types.values():
                 return self.serialize_basic(data, data_type, **kwargs)
@@ -826,7 +825,7 @@ def serialize_data(self, data, data_type, **kwargs):
 
         except (ValueError, TypeError) as err:
             msg = "Unable to serialize value: {!r} as type: {!r}."
-            raise_with_traceback(SerializationError, msg.format(data, data_type), err)
+            raise SerializationError(msg.format(data, data_type)) from err
         else:
             return self._serialize(data, **kwargs)
 
@@ -1172,10 +1171,10 @@ def serialize_iso(attr, **kwargs):
             return date + microseconds + "Z"
         except (ValueError, OverflowError) as err:
             msg = "Unable to serialize datetime object."
-            raise_with_traceback(SerializationError, msg, err)
+            raise SerializationError(msg) from err
         except AttributeError as err:
             msg = "ISO-8601 object must be valid Datetime object."
-            raise_with_traceback(TypeError, msg, err)
+            raise TypeError(msg) from err
 
     @staticmethod
     def serialize_unix(attr, **kwargs):
@@ -1211,7 +1210,6 @@ def rest_key_extractor(attr, attr_desc, data):
         if working_data is None:
             # If at any point while following flatten JSON path see None, it means
             # that all properties under are None as well
-            # https://github.com/Azure/msrest-for-python/issues/197
             return None
         key = ".".join(dict_keys[1:])
 
@@ -1232,7 +1230,6 @@ def rest_key_case_insensitive_extractor(attr, attr_desc, data):
         if working_data is None:
             # If at any point while following flatten JSON path see None, it means
             # that all properties under are None as well
-            # https://github.com/Azure/msrest-for-python/issues/197
             return None
         key = ".".join(dict_keys[1:])
 
@@ -1483,7 +1480,7 @@ def _deserialize(self, target_obj, data):
                 d_attrs[attr] = value
         except (AttributeError, TypeError, KeyError) as err:
             msg = "Unable to deserialize to object: " + class_name  # type: ignore
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             additional_properties = self._build_additional_properties(attributes, data)
             return self._instantiate_model(response, d_attrs, additional_properties)
@@ -1654,7 +1651,7 @@ def deserialize_data(self, data, data_type):
         except (ValueError, TypeError, AttributeError) as err:
             msg = "Unable to deserialize response data."
             msg += " Data: {}, {}".format(data, data_type)
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             return self._deserialize(obj_type, data)
 
@@ -1810,7 +1807,6 @@ def deserialize_enum(data, enum_obj):
             data = data.value
         if isinstance(data, int):
             # Workaround. We might consider remove it in the future.
-            # https://github.com/Azure/azure-rest-api-specs/issues/141
             try:
                 return list(enum_obj.__members__.values())[data]
             except IndexError:
@@ -1864,10 +1860,10 @@ def deserialize_decimal(attr):
         if isinstance(attr, ET.Element):
             attr = attr.text
         try:
-            return decimal.Decimal(attr)  # type: ignore
+            return decimal.Decimal(str(attr))  # type: ignore
         except decimal.DecimalException as err:
             msg = "Invalid decimal {}".format(attr)
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
 
     @staticmethod
     def deserialize_long(attr):
@@ -1895,7 +1891,7 @@ def deserialize_duration(attr):
             duration = isodate.parse_duration(attr)
         except (ValueError, OverflowError, AttributeError) as err:
             msg = "Cannot deserialize duration object."
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             return duration
 
@@ -1947,7 +1943,7 @@ def deserialize_rfc(attr):
                 date_obj = date_obj.astimezone(tz=TZ_UTC)
         except ValueError as err:
             msg = "Cannot deserialize to rfc datetime object."
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             return date_obj
 
@@ -1984,7 +1980,7 @@ def deserialize_iso(attr):
                 raise OverflowError("Hit max or min date")
         except (ValueError, OverflowError, AttributeError) as err:
             msg = "Cannot deserialize datetime object."
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             return date_obj
 
@@ -2000,9 +1996,10 @@ def deserialize_unix(attr):
         if isinstance(attr, ET.Element):
             attr = int(attr.text)  # type: ignore
         try:
+            attr = int(attr)
             date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC)
         except ValueError as err:
             msg = "Cannot deserialize to unix datetime object."
-            raise_with_traceback(DeserializationError, msg, err)
+            raise DeserializationError(msg) from err
         else:
             return date_obj
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_vendor.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_vendor.py
index a6bd460be3fc..db923753c642 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_vendor.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/_vendor.py
@@ -8,8 +8,6 @@
 from abc import ABC
 from typing import TYPE_CHECKING
 
-from azure.core.pipeline.transport import HttpRequest
-
 from ._configuration import KeyVaultClientConfiguration
 
 if TYPE_CHECKING:
@@ -19,14 +17,6 @@
     from ._serialization import Deserializer, Serializer
 
 
-def _convert_request(request, files=None):
-    data = request.content if not files else None
-    request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data)
-    if files:
-        request.set_formdata_body(files)
-    return request
-
-
 class KeyVaultClientMixinABC(ABC):
     """DO NOT use this class. It is for internal typing use only."""
 
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/__init__.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/__init__.py
index 1414715b988c..1e535724e551 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/__init__.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/__init__.py
@@ -6,7 +6,7 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from ._key_vault_client import KeyVaultClient
+from ._client import KeyVaultClient
 
 try:
     from ._patch import __all__ as _patch_all
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_key_vault_client.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_client.py
similarity index 62%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_key_vault_client.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_client.py
index 3dc4b695557f..f017310ad823 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_key_vault_client.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_client.py
@@ -10,40 +10,61 @@
 from typing import Any, Awaitable
 
 from azure.core import AsyncPipelineClient
+from azure.core.pipeline import policies
 from azure.core.rest import AsyncHttpResponse, HttpRequest
 
 from .. import models as _models
 from .._serialization import Deserializer, Serializer
 from ._configuration import KeyVaultClientConfiguration
-from .operations import KeyVaultClientOperationsMixin
+from ._operations import KeyVaultClientOperationsMixin
 
 
 class KeyVaultClient(KeyVaultClientOperationsMixin):  # pylint: disable=client-accepts-api-version-keyword
     """The key vault client performs cryptographic key operations and vault operations against the Key
     Vault service.
 
-    :keyword api_version: Api Version. Default value is "7.5-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
+    :keyword api_version: Api Version. Default value is "7.5". Note that overriding this default
+     value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, **kwargs: Any) -> None:  # pylint: disable=missing-client-constructor-parameter-credential
         _endpoint = "{vaultBaseUrl}"
         self._config = KeyVaultClientConfiguration(**kwargs)
-        self._client: AsyncPipelineClient = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs)
-
-        client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)}
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                policies.RequestIdPolicy(**kwargs),
+                self._config.headers_policy,
+                self._config.user_agent_policy,
+                self._config.proxy_policy,
+                policies.ContentDecodePolicy(**kwargs),
+                self._config.redirect_policy,
+                self._config.retry_policy,
+                self._config.authentication_policy,
+                self._config.custom_hook_policy,
+                self._config.logging_policy,
+                policies.DistributedTracingPolicy(**kwargs),
+                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+                self._config.http_logging_policy,
+            ]
+        self._client: AsyncPipelineClient = AsyncPipelineClient(base_url=_endpoint, policies=_policies, **kwargs)
+
+        client_models = {k: v for k, v in _models._models.__dict__.items() if isinstance(v, type)}
+        client_models.update({k: v for k, v in _models.__dict__.items() if isinstance(v, type)})
         self._serialize = Serializer(client_models)
         self._deserialize = Deserializer(client_models)
         self._serialize.client_side_validation = False
 
-    def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]:
+    def send_request(
+        self, request: HttpRequest, *, stream: bool = False, **kwargs: Any
+    ) -> Awaitable[AsyncHttpResponse]:
         """Runs the network request through the client's chained policies.
 
         >>> from azure.core.rest import HttpRequest
         >>> request = HttpRequest("GET", "https://www.example.org/")
         <HttpRequest [GET], url: 'https://www.example.org/'>
-        >>> response = await client._send_request(request)
+        >>> response = await client.send_request(request)
         <AsyncHttpResponse: 200 OK>
 
         For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request
@@ -57,7 +78,7 @@ def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncH
 
         request_copy = deepcopy(request)
         request_copy.url = self._client.format_url(request_copy.url)
-        return self._client.send_request(request_copy, **kwargs)
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
 
     async def close(self) -> None:
         await self._client.close()
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_configuration.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_configuration.py
index 15e0fb38b540..8dd6125e8e1d 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_configuration.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_configuration.py
@@ -8,29 +8,28 @@
 
 from typing import Any
 
-from azure.core.configuration import Configuration
 from azure.core.pipeline import policies
 
 VERSION = "unknown"
 
 
-class KeyVaultClientConfiguration(Configuration):  # pylint: disable=too-many-instance-attributes
+class KeyVaultClientConfiguration:  # pylint: disable=too-many-instance-attributes
     """Configuration for KeyVaultClient.
 
     Note that all parameters used to create this instance are saved as instance
     attributes.
 
-    :keyword api_version: Api Version. Default value is "7.5-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
+    :keyword api_version: Api Version. Default value is "7.5". Note that overriding this default
+     value may result in unsupported behavior.
     :paramtype api_version: str
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        super(KeyVaultClientConfiguration, self).__init__(**kwargs)
-        api_version: str = kwargs.pop("api_version", "7.5-preview.1")
+        api_version: str = kwargs.pop("api_version", "7.5")
 
         self.api_version = api_version
         kwargs.setdefault("sdk_moniker", "keyvault/{}".format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
         self._configure(**kwargs)
 
     def _configure(self, **kwargs: Any) -> None:
@@ -39,7 +38,7 @@ def _configure(self, **kwargs: Any) -> None:
         self.proxy_policy = kwargs.get("proxy_policy") or policies.ProxyPolicy(**kwargs)
         self.logging_policy = kwargs.get("logging_policy") or policies.NetworkTraceLoggingPolicy(**kwargs)
         self.http_logging_policy = kwargs.get("http_logging_policy") or policies.HttpLoggingPolicy(**kwargs)
-        self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
         self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs)
         self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs)
+        self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs)
         self.authentication_policy = kwargs.get("authentication_policy")
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/__init__.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/__init__.py
similarity index 91%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/__init__.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/__init__.py
index 15aeb155c95e..29ea96fccbfe 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/__init__.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/__init__.py
@@ -6,7 +6,7 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from ._key_vault_client_operations import KeyVaultClientOperationsMixin
+from ._operations import KeyVaultClientOperationsMixin
 
 from ._patch import __all__ as _patch_all
 from ._patch import *  # pylint: disable=unused-wildcard-import
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/_key_vault_client_operations.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/_operations.py
similarity index 71%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/_key_vault_client_operations.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/_operations.py
index 2a74adb900f1..729afcf8a10a 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/operations/_key_vault_client_operations.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/_operations.py
@@ -1,4 +1,4 @@
-# pylint: disable=too-many-lines
+# pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
@@ -20,42 +20,40 @@
     map_error,
 )
 from azure.core.pipeline import PipelineResponse
-from azure.core.pipeline.transport import AsyncHttpResponse
-from azure.core.rest import HttpRequest
+from azure.core.rest import AsyncHttpResponse, HttpRequest
 from azure.core.tracing.decorator import distributed_trace
 from azure.core.tracing.decorator_async import distributed_trace_async
 from azure.core.utils import case_insensitive_dict
 
 from ... import models as _models
-from ..._vendor import _convert_request
-from ...operations._key_vault_client_operations import (
-    build_backup_certificate_request,
-    build_create_certificate_request,
-    build_delete_certificate_contacts_request,
-    build_delete_certificate_issuer_request,
-    build_delete_certificate_operation_request,
-    build_delete_certificate_request,
-    build_get_certificate_contacts_request,
-    build_get_certificate_issuer_request,
-    build_get_certificate_issuers_request,
-    build_get_certificate_operation_request,
-    build_get_certificate_policy_request,
-    build_get_certificate_request,
-    build_get_certificate_versions_request,
-    build_get_certificates_request,
-    build_get_deleted_certificate_request,
-    build_get_deleted_certificates_request,
-    build_import_certificate_request,
-    build_merge_certificate_request,
-    build_purge_deleted_certificate_request,
-    build_recover_deleted_certificate_request,
-    build_restore_certificate_request,
-    build_set_certificate_contacts_request,
-    build_set_certificate_issuer_request,
-    build_update_certificate_issuer_request,
-    build_update_certificate_operation_request,
-    build_update_certificate_policy_request,
-    build_update_certificate_request,
+from ..._operations._operations import (
+    build_key_vault_backup_certificate_request,
+    build_key_vault_create_certificate_request,
+    build_key_vault_delete_certificate_contacts_request,
+    build_key_vault_delete_certificate_issuer_request,
+    build_key_vault_delete_certificate_operation_request,
+    build_key_vault_delete_certificate_request,
+    build_key_vault_get_certificate_contacts_request,
+    build_key_vault_get_certificate_issuer_request,
+    build_key_vault_get_certificate_issuers_request,
+    build_key_vault_get_certificate_operation_request,
+    build_key_vault_get_certificate_policy_request,
+    build_key_vault_get_certificate_request,
+    build_key_vault_get_certificate_versions_request,
+    build_key_vault_get_certificates_request,
+    build_key_vault_get_deleted_certificate_request,
+    build_key_vault_get_deleted_certificates_request,
+    build_key_vault_import_certificate_request,
+    build_key_vault_merge_certificate_request,
+    build_key_vault_purge_deleted_certificate_request,
+    build_key_vault_recover_deleted_certificate_request,
+    build_key_vault_restore_certificate_request,
+    build_key_vault_set_certificate_contacts_request,
+    build_key_vault_set_certificate_issuer_request,
+    build_key_vault_update_certificate_issuer_request,
+    build_key_vault_update_certificate_operation_request,
+    build_key_vault_update_certificate_policy_request,
+    build_key_vault_update_certificate_request,
 )
 from .._vendor import KeyVaultClientMixinABC
 
@@ -68,6 +66,7 @@ class KeyVaultClientOperationsMixin(KeyVaultClientMixinABC):  # pylint: disable=
     def get_certificates(
         self,
         vault_base_url: str,
+        *,
         maxresults: Optional[int] = None,
         include_pending: Optional[bool] = None,
         **kwargs: Any
@@ -79,22 +78,22 @@ def get_certificates(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :param include_pending: Specifies whether to include certificates which are not completely
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :keyword include_pending: Specifies whether to include certificates which are not completely
          provisioned. Default value is None.
-        :type include_pending: bool
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateItem or the result of cls(response)
-        :rtype: ~azure.core.async_paging.AsyncItemPaged[~key_vault_client.models.CertificateItem]
+        :paramtype include_pending: bool
+        :return: An iterator like instance of CertificateItem
+        :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.keyvault.v7_5.models.CertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -107,19 +106,17 @@ def get_certificates(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificates_request(
+                _request = build_key_vault_get_certificates_request(
                     maxresults=maxresults,
                     include_pending=include_pending,
-                    api_version=api_version,
-                    template_url=self.get_certificates.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -131,34 +128,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         async def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, AsyncList(list_of_elem)
 
         async def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    await response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -167,8 +167,6 @@ async def get_next(next_link=None):
 
         return AsyncItemPaged(get_next, extract_data)
 
-    get_certificates.metadata = {"url": "/certificates"}
-
     @distributed_trace_async
     async def delete_certificate(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -183,9 +181,8 @@ async def delete_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: DeletedCertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.DeletedCertificateBundle
+        :return: DeletedCertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.DeletedCertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -197,32 +194,31 @@ async def delete_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.DeletedCertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_request(
+        _request = build_key_vault_delete_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.delete_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -230,11 +226,9 @@ async def delete_certificate(
         deserialized = self._deserialize("DeletedCertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    delete_certificate.metadata = {"url": "/certificates/{certificate-name}"}
+        return deserialized  # type: ignore
 
     @overload
     async def set_certificate_contacts(
@@ -248,19 +242,18 @@ async def set_certificate_contacts(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param contacts: The contacts for the key vault certificate. Required.
-        :type contacts: ~key_vault_client.models.Contacts
+        :type contacts: ~azure.keyvault.v7_5.models.Contacts
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @overload
     async def set_certificate_contacts(
-        self, vault_base_url: str, contacts: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, vault_base_url: str, contacts: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.Contacts:
         """Sets the certificate contacts for the specified key vault.
 
@@ -270,19 +263,18 @@ async def set_certificate_contacts(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param contacts: The contacts for the key vault certificate. Required.
-        :type contacts: IO
+        :type contacts: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @distributed_trace_async
     async def set_certificate_contacts(
-        self, vault_base_url: str, contacts: Union[_models.Contacts, IO], **kwargs: Any
+        self, vault_base_url: str, contacts: Union[_models.Contacts, IO[bytes]], **kwargs: Any
     ) -> _models.Contacts:
         """Sets the certificate contacts for the specified key vault.
 
@@ -291,15 +283,14 @@ async def set_certificate_contacts(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param contacts: The contacts for the key vault certificate. Is either a Contacts type or a IO
-         type. Required.
-        :type contacts: ~key_vault_client.models.Contacts or IO
+        :param contacts: The contacts for the key vault certificate. Is either a Contacts type or a
+         IO[bytes] type. Required.
+        :type contacts: ~azure.keyvault.v7_5.models.Contacts or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -311,9 +302,8 @@ async def set_certificate_contacts(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
@@ -325,29 +315,29 @@ async def set_certificate_contacts(
         else:
             _json = self._serialize.body(contacts, "Contacts")
 
-        request = build_set_certificate_contacts_request(
-            api_version=api_version,
+        _request = build_key_vault_set_certificate_contacts_request(
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.set_certificate_contacts.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -355,11 +345,9 @@ async def set_certificate_contacts(
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    set_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _models.Contacts:
@@ -370,9 +358,8 @@ async def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) ->
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -384,31 +371,30 @@ async def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) ->
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_contacts_request(
-            api_version=api_version,
-            template_url=self.get_certificate_contacts.metadata["url"],
+        _request = build_key_vault_get_certificate_contacts_request(
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -416,11 +402,9 @@ async def get_certificate_contacts(self, vault_base_url: str, **kwargs: Any) ->
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any) -> _models.Contacts:
@@ -431,9 +415,8 @@ async def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any)
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: Contacts or the result of cls(response)
-        :rtype: ~key_vault_client.models.Contacts
+        :return: Contacts
+        :rtype: ~azure.keyvault.v7_5.models.Contacts
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -445,31 +428,30 @@ async def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any)
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.Contacts] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_contacts_request(
-            api_version=api_version,
-            template_url=self.delete_certificate_contacts.metadata["url"],
+        _request = build_key_vault_delete_certificate_contacts_request(
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -477,15 +459,13 @@ async def delete_certificate_contacts(self, vault_base_url: str, **kwargs: Any)
         deserialized = self._deserialize("Contacts", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    delete_certificate_contacts.metadata = {"url": "/certificates/contacts"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_issuers(
-        self, vault_base_url: str, maxresults: Optional[int] = None, **kwargs: Any
+        self, vault_base_url: str, *, maxresults: Optional[int] = None, **kwargs: Any
     ) -> AsyncIterable["_models.CertificateIssuerItem"]:
         """List certificate issuers for a specified key vault.
 
@@ -495,20 +475,20 @@ def get_certificate_issuers(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateIssuerItem or the result of
-         cls(response)
-        :rtype: ~azure.core.async_paging.AsyncItemPaged[~key_vault_client.models.CertificateIssuerItem]
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :return: An iterator like instance of CertificateIssuerItem
+        :rtype:
+         ~azure.core.async_paging.AsyncItemPaged[~azure.keyvault.v7_5.models.CertificateIssuerItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateIssuerListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateIssuerListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -521,18 +501,16 @@ def get_certificate_issuers(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificate_issuers_request(
+                _request = build_key_vault_get_certificate_issuers_request(
                     maxresults=maxresults,
-                    api_version=api_version,
-                    template_url=self.get_certificate_issuers.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -544,34 +522,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         async def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateIssuerListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateIssuerListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, AsyncList(list_of_elem)
 
         async def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    await response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -580,8 +561,6 @@ async def get_next(next_link=None):
 
         return AsyncItemPaged(get_next, extract_data)
 
-    get_certificate_issuers.metadata = {"url": "/certificates/issuers"}
-
     @overload
     async def set_certificate_issuer(
         self,
@@ -604,13 +583,12 @@ async def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerSetParameters
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerSetParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -619,7 +597,7 @@ async def set_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: IO,
+        parameter: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -636,13 +614,12 @@ async def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Required.
-        :type parameter: IO
+        :type parameter: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -651,7 +628,7 @@ async def set_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: Union[_models.CertificateIssuerSetParameters, IO],
+        parameter: Union[_models.CertificateIssuerSetParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.IssuerBundle:
         """Sets the specified certificate issuer.
@@ -666,14 +643,13 @@ async def set_certificate_issuer(
          identifiable or sensitive information. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer set parameter. Is either a CertificateIssuerSetParameters
-         type or a IO type. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerSetParameters or IO
+         type or a IO[bytes] type. Required.
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerSetParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -685,9 +661,8 @@ async def set_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
@@ -699,30 +674,30 @@ async def set_certificate_issuer(
         else:
             _json = self._serialize.body(parameter, "CertificateIssuerSetParameters")
 
-        request = build_set_certificate_issuer_request(
+        _request = build_key_vault_set_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.set_certificate_issuer.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -730,11 +705,9 @@ async def set_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    set_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @overload
     async def update_certificate_issuer(
@@ -756,13 +729,12 @@ async def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerUpdateParameters
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerUpdateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -771,7 +743,7 @@ async def update_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: IO,
+        parameter: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -786,13 +758,12 @@ async def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Required.
-        :type parameter: IO
+        :type parameter: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -801,7 +772,7 @@ async def update_certificate_issuer(
         self,
         vault_base_url: str,
         issuer_name: str,
-        parameter: Union[_models.CertificateIssuerUpdateParameters, IO],
+        parameter: Union[_models.CertificateIssuerUpdateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.IssuerBundle:
         """Updates the specified certificate issuer.
@@ -814,14 +785,13 @@ async def update_certificate_issuer(
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
         :param parameter: Certificate issuer update parameter. Is either a
-         CertificateIssuerUpdateParameters type or a IO type. Required.
-        :type parameter: ~key_vault_client.models.CertificateIssuerUpdateParameters or IO
+         CertificateIssuerUpdateParameters type or a IO[bytes] type. Required.
+        :type parameter: ~azure.keyvault.v7_5.models.CertificateIssuerUpdateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -833,9 +803,8 @@ async def update_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
@@ -847,30 +816,30 @@ async def update_certificate_issuer(
         else:
             _json = self._serialize.body(parameter, "CertificateIssuerUpdateParameters")
 
-        request = build_update_certificate_issuer_request(
+        _request = build_key_vault_update_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_issuer.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -878,11 +847,9 @@ async def update_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    update_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_certificate_issuer(
@@ -898,9 +865,8 @@ async def get_certificate_issuer(
         :type vault_base_url: str
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -912,32 +878,31 @@ async def get_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_issuer_request(
+        _request = build_key_vault_get_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
-            template_url=self.get_certificate_issuer.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -945,11 +910,9 @@ async def get_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    get_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def delete_certificate_issuer(
@@ -964,9 +927,8 @@ async def delete_certificate_issuer(
         :type vault_base_url: str
         :param issuer_name: The name of the issuer. Required.
         :type issuer_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: IssuerBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.IssuerBundle
+        :return: IssuerBundle
+        :rtype: ~azure.keyvault.v7_5.models.IssuerBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -978,32 +940,31 @@ async def delete_certificate_issuer(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.IssuerBundle] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_issuer_request(
+        _request = build_key_vault_delete_certificate_issuer_request(
             issuer_name=issuer_name,
-            api_version=api_version,
-            template_url=self.delete_certificate_issuer.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1011,11 +972,9 @@ async def delete_certificate_issuer(
         deserialized = self._deserialize("IssuerBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    delete_certificate_issuer.metadata = {"url": "/certificates/issuers/{issuer-name}"}
+        return deserialized  # type: ignore
 
     @overload
     async def create_certificate(
@@ -1039,13 +998,12 @@ async def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateCreateParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateCreateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1054,7 +1012,7 @@ async def create_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1071,13 +1029,12 @@ async def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1086,7 +1043,7 @@ async def create_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateCreateParameters, IO],
+        parameters: Union[_models.CertificateCreateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateOperation:
         """Creates a new certificate.
@@ -1101,14 +1058,13 @@ async def create_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to create a certificate. Is either a
-         CertificateCreateParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateCreateParameters or IO
+         CertificateCreateParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateCreateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1120,9 +1076,8 @@ async def create_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
@@ -1134,30 +1089,30 @@ async def create_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateCreateParameters")
 
-        request = build_create_certificate_request(
+        _request = build_key_vault_create_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.create_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [202]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1165,11 +1120,9 @@ async def create_certificate(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    create_certificate.metadata = {"url": "/certificates/{certificate-name}/create"}
+        return deserialized  # type: ignore
 
     @overload
     async def import_certificate(
@@ -1195,13 +1148,12 @@ async def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateImportParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateImportParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1210,7 +1162,7 @@ async def import_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1229,13 +1181,12 @@ async def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1244,7 +1195,7 @@ async def import_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateImportParameters, IO],
+        parameters: Union[_models.CertificateImportParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Imports a certificate into a specified key vault.
@@ -1261,14 +1212,13 @@ async def import_certificate(
          personally identifiable or sensitive information. Required.
         :type certificate_name: str
         :param parameters: The parameters to import the certificate. Is either a
-         CertificateImportParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateImportParameters or IO
+         CertificateImportParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateImportParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1280,9 +1230,8 @@ async def import_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -1294,30 +1243,30 @@ async def import_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateImportParameters")
 
-        request = build_import_certificate_request(
+        _request = build_key_vault_import_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.import_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1325,15 +1274,13 @@ async def import_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    import_certificate.metadata = {"url": "/certificates/{certificate-name}/import"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_certificate_versions(
-        self, vault_base_url: str, certificate_name: str, maxresults: Optional[int] = None, **kwargs: Any
+        self, vault_base_url: str, certificate_name: str, *, maxresults: Optional[int] = None, **kwargs: Any
     ) -> AsyncIterable["_models.CertificateItem"]:
         """List the versions of a certificate.
 
@@ -1344,19 +1291,19 @@ def get_certificate_versions(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either CertificateItem or the result of cls(response)
-        :rtype: ~azure.core.async_paging.AsyncItemPaged[~key_vault_client.models.CertificateItem]
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :return: An iterator like instance of CertificateItem
+        :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.keyvault.v7_5.models.CertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.CertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.CertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -1369,19 +1316,17 @@ def get_certificate_versions(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_certificate_versions_request(
+                _request = build_key_vault_get_certificate_versions_request(
                     certificate_name=certificate_name,
                     maxresults=maxresults,
-                    api_version=api_version,
-                    template_url=self.get_certificate_versions.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -1393,34 +1338,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         async def extract_data(pipeline_response):
-            deserialized = self._deserialize("CertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.CertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, AsyncList(list_of_elem)
 
         async def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    await response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -1429,8 +1377,6 @@ async def get_next(next_link=None):
 
         return AsyncItemPaged(get_next, extract_data)
 
-    get_certificate_versions.metadata = {"url": "/certificates/{certificate-name}/versions"}
-
     @distributed_trace_async
     async def get_certificate_policy(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -1444,9 +1390,8 @@ async def get_certificate_policy(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate in a given key vault. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1458,32 +1403,31 @@ async def get_certificate_policy(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificatePolicy] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_policy_request(
+        _request = build_key_vault_get_certificate_policy_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_certificate_policy.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1491,11 +1435,9 @@ async def get_certificate_policy(
         deserialized = self._deserialize("CertificatePolicy", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    get_certificate_policy.metadata = {"url": "/certificates/{certificate-name}/policy"}
+        return deserialized  # type: ignore
 
     @overload
     async def update_certificate_policy(
@@ -1517,13 +1459,12 @@ async def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Required.
-        :type certificate_policy: ~key_vault_client.models.CertificatePolicy
+        :type certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1532,7 +1473,7 @@ async def update_certificate_policy(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_policy: IO,
+        certificate_policy: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1547,13 +1488,12 @@ async def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Required.
-        :type certificate_policy: IO
+        :type certificate_policy: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1562,7 +1502,7 @@ async def update_certificate_policy(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_policy: Union[_models.CertificatePolicy, IO],
+        certificate_policy: Union[_models.CertificatePolicy, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificatePolicy:
         """Updates the policy for a certificate.
@@ -1575,14 +1515,13 @@ async def update_certificate_policy(
         :param certificate_name: The name of the certificate in the given vault. Required.
         :type certificate_name: str
         :param certificate_policy: The policy for the certificate. Is either a CertificatePolicy type
-         or a IO type. Required.
-        :type certificate_policy: ~key_vault_client.models.CertificatePolicy or IO
+         or a IO[bytes] type. Required.
+        :type certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificatePolicy or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificatePolicy
+        :return: CertificatePolicy
+        :rtype: ~azure.keyvault.v7_5.models.CertificatePolicy
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1594,9 +1533,8 @@ async def update_certificate_policy(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificatePolicy] = kwargs.pop("cls", None)
 
@@ -1608,30 +1546,30 @@ async def update_certificate_policy(
         else:
             _json = self._serialize.body(certificate_policy, "CertificatePolicy")
 
-        request = build_update_certificate_policy_request(
+        _request = build_key_vault_update_certificate_policy_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_policy.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1639,11 +1577,9 @@ async def update_certificate_policy(
         deserialized = self._deserialize("CertificatePolicy", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    update_certificate_policy.metadata = {"url": "/certificates/{certificate-name}/policy"}
+        return deserialized  # type: ignore
 
     @overload
     async def update_certificate(
@@ -1669,13 +1605,12 @@ async def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Required.
-        :type parameters: ~key_vault_client.models.CertificateUpdateParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateUpdateParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1685,7 +1620,7 @@ async def update_certificate(
         vault_base_url: str,
         certificate_name: str,
         certificate_version: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1703,13 +1638,12 @@ async def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1719,7 +1653,7 @@ async def update_certificate(
         vault_base_url: str,
         certificate_name: str,
         certificate_version: str,
-        parameters: Union[_models.CertificateUpdateParameters, IO],
+        parameters: Union[_models.CertificateUpdateParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Updates the specified attributes associated with the given certificate.
@@ -1735,14 +1669,13 @@ async def update_certificate(
         :param certificate_version: The version of the certificate. Required.
         :type certificate_version: str
         :param parameters: The parameters for certificate update. Is either a
-         CertificateUpdateParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateUpdateParameters or IO
+         CertificateUpdateParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateUpdateParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1754,9 +1687,8 @@ async def update_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -1768,31 +1700,31 @@ async def update_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateUpdateParameters")
 
-        request = build_update_certificate_request(
+        _request = build_key_vault_update_certificate_request(
             certificate_name=certificate_name,
             certificate_version=certificate_version,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1800,11 +1732,9 @@ async def update_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    update_certificate.metadata = {"url": "/certificates/{certificate-name}/{certificate-version}"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_certificate(
@@ -1822,9 +1752,8 @@ async def get_certificate(
         :param certificate_version: The version of the certificate. This URI fragment is optional. If
          not specified, the latest version of the certificate is returned. Required.
         :type certificate_version: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1836,33 +1765,32 @@ async def get_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_request(
+        _request = build_key_vault_get_certificate_request(
             certificate_name=certificate_name,
             certificate_version=certificate_version,
-            api_version=api_version,
-            template_url=self.get_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -1870,11 +1798,9 @@ async def get_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    get_certificate.metadata = {"url": "/certificates/{certificate-name}/{certificate-version}"}
+        return deserialized  # type: ignore
 
     @overload
     async def update_certificate_operation(
@@ -1896,13 +1822,12 @@ async def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Required.
-        :type certificate_operation: ~key_vault_client.models.CertificateOperationUpdateParameter
+        :type certificate_operation: ~azure.keyvault.v7_5.models.CertificateOperationUpdateParameter
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1911,7 +1836,7 @@ async def update_certificate_operation(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_operation: IO,
+        certificate_operation: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -1926,13 +1851,12 @@ async def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Required.
-        :type certificate_operation: IO
+        :type certificate_operation: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1941,7 +1865,7 @@ async def update_certificate_operation(
         self,
         vault_base_url: str,
         certificate_name: str,
-        certificate_operation: Union[_models.CertificateOperationUpdateParameter, IO],
+        certificate_operation: Union[_models.CertificateOperationUpdateParameter, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateOperation:
         """Updates a certificate operation.
@@ -1954,14 +1878,14 @@ async def update_certificate_operation(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param certificate_operation: The certificate operation response. Is either a
-         CertificateOperationUpdateParameter type or a IO type. Required.
-        :type certificate_operation: ~key_vault_client.models.CertificateOperationUpdateParameter or IO
+         CertificateOperationUpdateParameter type or a IO[bytes] type. Required.
+        :type certificate_operation: ~azure.keyvault.v7_5.models.CertificateOperationUpdateParameter or
+         IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -1973,9 +1897,8 @@ async def update_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
@@ -1987,30 +1910,30 @@ async def update_certificate_operation(
         else:
             _json = self._serialize.body(certificate_operation, "CertificateOperationUpdateParameter")
 
-        request = build_update_certificate_operation_request(
+        _request = build_key_vault_update_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.update_certificate_operation.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2018,11 +1941,9 @@ async def update_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    update_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_certificate_operation(
@@ -2037,9 +1958,8 @@ async def get_certificate_operation(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2051,32 +1971,31 @@ async def get_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
-        request = build_get_certificate_operation_request(
+        _request = build_key_vault_get_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_certificate_operation.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2084,11 +2003,9 @@ async def get_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def delete_certificate_operation(
@@ -2104,9 +2021,8 @@ async def delete_certificate_operation(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateOperation or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateOperation
+        :return: CertificateOperation
+        :rtype: ~azure.keyvault.v7_5.models.CertificateOperation
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2118,32 +2034,31 @@ async def delete_certificate_operation(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateOperation] = kwargs.pop("cls", None)
 
-        request = build_delete_certificate_operation_request(
+        _request = build_key_vault_delete_certificate_operation_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.delete_certificate_operation.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2151,11 +2066,9 @@ async def delete_certificate_operation(
         deserialized = self._deserialize("CertificateOperation", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    delete_certificate_operation.metadata = {"url": "/certificates/{certificate-name}/pending"}
+        return deserialized  # type: ignore
 
     @overload
     async def merge_certificate(
@@ -2178,13 +2091,12 @@ async def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateMergeParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateMergeParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2193,7 +2105,7 @@ async def merge_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: IO,
+        parameters: IO[bytes],
         *,
         content_type: str = "application/json",
         **kwargs: Any
@@ -2209,13 +2121,12 @@ async def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2224,7 +2135,7 @@ async def merge_certificate(
         self,
         vault_base_url: str,
         certificate_name: str,
-        parameters: Union[_models.CertificateMergeParameters, IO],
+        parameters: Union[_models.CertificateMergeParameters, IO[bytes]],
         **kwargs: Any
     ) -> _models.CertificateBundle:
         """Merges a certificate or a certificate chain with a key pair existing on the server.
@@ -2238,14 +2149,13 @@ async def merge_certificate(
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
         :param parameters: The parameters to merge certificate. Is either a CertificateMergeParameters
-         type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateMergeParameters or IO
+         type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateMergeParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2257,9 +2167,8 @@ async def merge_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -2271,30 +2180,30 @@ async def merge_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateMergeParameters")
 
-        request = build_merge_certificate_request(
+        _request = build_key_vault_merge_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.merge_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [201]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2302,11 +2211,9 @@ async def merge_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    merge_certificate.metadata = {"url": "/certificates/{certificate-name}/pending/merge"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def backup_certificate(
@@ -2322,9 +2229,8 @@ async def backup_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: BackupCertificateResult or the result of cls(response)
-        :rtype: ~key_vault_client.models.BackupCertificateResult
+        :return: BackupCertificateResult
+        :rtype: ~azure.keyvault.v7_5.models.BackupCertificateResult
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2336,32 +2242,31 @@ async def backup_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.BackupCertificateResult] = kwargs.pop("cls", None)
 
-        request = build_backup_certificate_request(
+        _request = build_key_vault_backup_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.backup_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2369,11 +2274,9 @@ async def backup_certificate(
         deserialized = self._deserialize("BackupCertificateResult", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
-
-    backup_certificate.metadata = {"url": "/certificates/{certificate-name}/backup"}
+        return deserialized  # type: ignore
 
     @overload
     async def restore_certificate(
@@ -2392,19 +2295,18 @@ async def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Required.
-        :type parameters: ~key_vault_client.models.CertificateRestoreParameters
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateRestoreParameters
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @overload
     async def restore_certificate(
-        self, vault_base_url: str, parameters: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, vault_base_url: str, parameters: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.CertificateBundle:
         """Restores a backed up certificate to a vault.
 
@@ -2414,19 +2316,18 @@ async def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Required.
-        :type parameters: IO
+        :type parameters: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
     @distributed_trace_async
     async def restore_certificate(
-        self, vault_base_url: str, parameters: Union[_models.CertificateRestoreParameters, IO], **kwargs: Any
+        self, vault_base_url: str, parameters: Union[_models.CertificateRestoreParameters, IO[bytes]], **kwargs: Any
     ) -> _models.CertificateBundle:
         """Restores a backed up certificate to a vault.
 
@@ -2436,14 +2337,13 @@ async def restore_certificate(
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
         :param parameters: The parameters to restore the certificate. Is either a
-         CertificateRestoreParameters type or a IO type. Required.
-        :type parameters: ~key_vault_client.models.CertificateRestoreParameters or IO
+         CertificateRestoreParameters type or a IO[bytes] type. Required.
+        :type parameters: ~azure.keyvault.v7_5.models.CertificateRestoreParameters or IO[bytes]
         :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
          Default value is None.
         :paramtype content_type: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2455,9 +2355,8 @@ async def restore_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
@@ -2469,29 +2368,29 @@ async def restore_certificate(
         else:
             _json = self._serialize.body(parameters, "CertificateRestoreParameters")
 
-        request = build_restore_certificate_request(
-            api_version=api_version,
+        _request = build_key_vault_restore_certificate_request(
             content_type=content_type,
+            api_version=self._config.api_version,
             json=_json,
             content=_content,
-            template_url=self.restore_certificate.metadata["url"],
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2499,16 +2398,15 @@ async def restore_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    restore_certificate.metadata = {"url": "/certificates/restore"}
+        return deserialized  # type: ignore
 
     @distributed_trace
     def get_deleted_certificates(
         self,
         vault_base_url: str,
+        *,
         maxresults: Optional[int] = None,
         include_pending: Optional[bool] = None,
         **kwargs: Any
@@ -2522,24 +2420,23 @@ def get_deleted_certificates(
 
         :param vault_base_url: The vault name, for example https://myvault.vault.azure.net. Required.
         :type vault_base_url: str
-        :param maxresults: Maximum number of results to return in a page. If not specified the service
-         will return up to 25 results. Default value is None.
-        :type maxresults: int
-        :param include_pending: Specifies whether to include certificates which are not completely
+        :keyword maxresults: Maximum number of results to return in a page. If not specified the
+         service will return up to 25 results. Default value is None.
+        :paramtype maxresults: int
+        :keyword include_pending: Specifies whether to include certificates which are not completely
          provisioned. Default value is None.
-        :type include_pending: bool
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: An iterator like instance of either DeletedCertificateItem or the result of
-         cls(response)
+        :paramtype include_pending: bool
+        :return: An iterator like instance of DeletedCertificateItem
         :rtype:
-         ~azure.core.async_paging.AsyncItemPaged[~key_vault_client.models.DeletedCertificateItem]
+         ~azure.core.async_paging.AsyncItemPaged[~azure.keyvault.v7_5.models.DeletedCertificateItem]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
-        cls: ClsType[_models.DeletedCertificateListResult] = kwargs.pop("cls", None)
+        cls: ClsType[_models._models.DeletedCertificateListResult] = kwargs.pop(  # pylint: disable=protected-access
+            "cls", None
+        )
 
         error_map = {
             401: ClientAuthenticationError,
@@ -2552,19 +2449,17 @@ def get_deleted_certificates(
         def prepare_request(next_link=None):
             if not next_link:
 
-                request = build_get_deleted_certificates_request(
+                _request = build_key_vault_get_deleted_certificates_request(
                     maxresults=maxresults,
                     include_pending=include_pending,
-                    api_version=api_version,
-                    template_url=self.get_deleted_certificates.metadata["url"],
+                    api_version=self._config.api_version,
                     headers=_headers,
                     params=_params,
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
             else:
                 # make call to next link with the client's api-version
@@ -2576,34 +2471,37 @@ def prepare_request(next_link=None):
                     }
                 )
                 _next_request_params["api-version"] = self._config.api_version
-                request = HttpRequest(
+                _request = HttpRequest(
                     "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
                 )
-                request = _convert_request(request)
                 path_format_arguments = {
                     "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
                 }
-                request.url = self._client.format_url(request.url, **path_format_arguments)
-                request.method = "GET"
-            return request
+                _request.url = self._client.format_url(_request.url, **path_format_arguments)
+
+            return _request
 
         async def extract_data(pipeline_response):
-            deserialized = self._deserialize("DeletedCertificateListResult", pipeline_response)
+            deserialized = self._deserialize(
+                _models._models.DeletedCertificateListResult, pipeline_response  # pylint: disable=protected-access
+            )
             list_of_elem = deserialized.value
             if cls:
                 list_of_elem = cls(list_of_elem)  # type: ignore
             return deserialized.next_link or None, AsyncList(list_of_elem)
 
         async def get_next(next_link=None):
-            request = prepare_request(next_link)
+            _request = prepare_request(next_link)
 
             _stream = False
             pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
+                _request, stream=_stream, **kwargs
             )
             response = pipeline_response.http_response
 
             if response.status_code not in [200]:
+                if _stream:
+                    await response.read()  # Load the body in memory and close the socket
                 map_error(status_code=response.status_code, response=response, error_map=error_map)
                 error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
                 raise HttpResponseError(response=response, model=error)
@@ -2612,8 +2510,6 @@ async def get_next(next_link=None):
 
         return AsyncItemPaged(get_next, extract_data)
 
-    get_deleted_certificates.metadata = {"url": "/deletedcertificates"}
-
     @distributed_trace_async
     async def get_deleted_certificate(
         self, vault_base_url: str, certificate_name: str, **kwargs: Any
@@ -2628,9 +2524,8 @@ async def get_deleted_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: DeletedCertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.DeletedCertificateBundle
+        :return: DeletedCertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.DeletedCertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2642,32 +2537,31 @@ async def get_deleted_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.DeletedCertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_get_deleted_certificate_request(
+        _request = build_key_vault_get_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.get_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2675,11 +2569,9 @@ async def get_deleted_certificate(
         deserialized = self._deserialize("DeletedCertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    get_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}"}
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def purge_deleted_certificate(  # pylint: disable=inconsistent-return-statements
@@ -2695,8 +2587,7 @@ async def purge_deleted_certificate(  # pylint: disable=inconsistent-return-stat
         :type vault_base_url: str
         :param certificate_name: The name of the certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: None or the result of cls(response)
+        :return: None
         :rtype: None
         :raises ~azure.core.exceptions.HttpResponseError:
         """
@@ -2709,40 +2600,37 @@ async def purge_deleted_certificate(  # pylint: disable=inconsistent-return-stat
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[None] = kwargs.pop("cls", None)
 
-        request = build_purge_deleted_certificate_request(
+        _request = build_key_vault_purge_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.purge_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [204]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
 
         if cls:
-            return cls(pipeline_response, None, {})
-
-    purge_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}"}
+            return cls(pipeline_response, None, {})  # type: ignore
 
     @distributed_trace_async
     async def recover_deleted_certificate(
@@ -2759,9 +2647,8 @@ async def recover_deleted_certificate(
         :type vault_base_url: str
         :param certificate_name: The name of the deleted certificate. Required.
         :type certificate_name: str
-        :keyword callable cls: A custom type or function that will be passed the direct response
-        :return: CertificateBundle or the result of cls(response)
-        :rtype: ~key_vault_client.models.CertificateBundle
+        :return: CertificateBundle
+        :rtype: ~azure.keyvault.v7_5.models.CertificateBundle
         :raises ~azure.core.exceptions.HttpResponseError:
         """
         error_map = {
@@ -2773,32 +2660,31 @@ async def recover_deleted_certificate(
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
-        _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
 
-        api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
         cls: ClsType[_models.CertificateBundle] = kwargs.pop("cls", None)
 
-        request = build_recover_deleted_certificate_request(
+        _request = build_key_vault_recover_deleted_certificate_request(
             certificate_name=certificate_name,
-            api_version=api_version,
-            template_url=self.recover_deleted_certificate.metadata["url"],
+            api_version=self._config.api_version,
             headers=_headers,
             params=_params,
         )
-        request = _convert_request(request)
         path_format_arguments = {
             "vaultBaseUrl": self._serialize.url("vault_base_url", vault_base_url, "str", skip_quote=True),
         }
-        request.url = self._client.format_url(request.url, **path_format_arguments)
+        _request.url = self._client.format_url(_request.url, **path_format_arguments)
 
         _stream = False
         pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
-            request, stream=_stream, **kwargs
+            _request, stream=_stream, **kwargs
         )
 
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
+            if _stream:
+                await response.read()  # Load the body in memory and close the socket
             map_error(status_code=response.status_code, response=response, error_map=error_map)
             error = self._deserialize.failsafe_deserialize(_models.KeyVaultError, pipeline_response)
             raise HttpResponseError(response=response, model=error)
@@ -2806,8 +2692,6 @@ async def recover_deleted_certificate(
         deserialized = self._deserialize("CertificateBundle", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-    recover_deleted_certificate.metadata = {"url": "/deletedcertificates/{certificate-name}/recover"}
+        return deserialized  # type: ignore
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/_patch.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/_patch.py
similarity index 100%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/operations/_patch.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_operations/_patch.py
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_vendor.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_vendor.py
index 111bdf8bf447..92c6d827acd9 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_vendor.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/aio/_vendor.py
@@ -8,8 +8,6 @@
 from abc import ABC
 from typing import TYPE_CHECKING
 
-from azure.core.pipeline.transport import HttpRequest
-
 from ._configuration import KeyVaultClientConfiguration
 
 if TYPE_CHECKING:
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/__init__.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/__init__.py
index 55e9c8be4840..1e114ae06f4d 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/__init__.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/__init__.py
@@ -6,51 +6,48 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from ._models_py3 import Action
-from ._models_py3 import AdministratorDetails
-from ._models_py3 import Attributes
-from ._models_py3 import BackupCertificateResult
-from ._models_py3 import CertificateAttributes
-from ._models_py3 import CertificateBundle
-from ._models_py3 import CertificateCreateParameters
-from ._models_py3 import CertificateImportParameters
-from ._models_py3 import CertificateIssuerItem
-from ._models_py3 import CertificateIssuerListResult
-from ._models_py3 import CertificateIssuerSetParameters
-from ._models_py3 import CertificateIssuerUpdateParameters
-from ._models_py3 import CertificateItem
-from ._models_py3 import CertificateListResult
-from ._models_py3 import CertificateMergeParameters
-from ._models_py3 import CertificateOperation
-from ._models_py3 import CertificateOperationUpdateParameter
-from ._models_py3 import CertificatePolicy
-from ._models_py3 import CertificateRestoreParameters
-from ._models_py3 import CertificateUpdateParameters
-from ._models_py3 import Contact
-from ._models_py3 import Contacts
-from ._models_py3 import DeletedCertificateBundle
-from ._models_py3 import DeletedCertificateItem
-from ._models_py3 import DeletedCertificateListResult
-from ._models_py3 import Error
-from ._models_py3 import IssuerAttributes
-from ._models_py3 import IssuerBundle
-from ._models_py3 import IssuerCredentials
-from ._models_py3 import IssuerParameters
-from ._models_py3 import KeyProperties
-from ._models_py3 import KeyVaultError
-from ._models_py3 import LifetimeAction
-from ._models_py3 import OrganizationDetails
-from ._models_py3 import PendingCertificateSigningRequestResult
-from ._models_py3 import SecretProperties
-from ._models_py3 import SubjectAlternativeNames
-from ._models_py3 import Trigger
-from ._models_py3 import X509CertificateProperties
+from ._models import Action
+from ._models import AdministratorDetails
+from ._models import Attributes
+from ._models import BackupCertificateResult
+from ._models import CertificateAttributes
+from ._models import CertificateBundle
+from ._models import CertificateCreateParameters
+from ._models import CertificateImportParameters
+from ._models import CertificateIssuerItem
+from ._models import CertificateIssuerSetParameters
+from ._models import CertificateIssuerUpdateParameters
+from ._models import CertificateItem
+from ._models import CertificateMergeParameters
+from ._models import CertificateOperation
+from ._models import CertificateOperationUpdateParameter
+from ._models import CertificatePolicy
+from ._models import CertificateRestoreParameters
+from ._models import CertificateUpdateParameters
+from ._models import Contact
+from ._models import Contacts
+from ._models import DeletedCertificateBundle
+from ._models import DeletedCertificateItem
+from ._models import Error
+from ._models import IssuerAttributes
+from ._models import IssuerBundle
+from ._models import IssuerCredentials
+from ._models import IssuerParameters
+from ._models import KeyProperties
+from ._models import KeyVaultError
+from ._models import LifetimeAction
+from ._models import OrganizationDetails
+from ._models import PendingCertificateSigningRequestResult
+from ._models import SecretProperties
+from ._models import SubjectAlternativeNames
+from ._models import Trigger
+from ._models import X509CertificateProperties
 
-from ._key_vault_client_enums import ActionType
-from ._key_vault_client_enums import DeletionRecoveryLevel
-from ._key_vault_client_enums import JsonWebKeyCurveName
-from ._key_vault_client_enums import JsonWebKeyType
-from ._key_vault_client_enums import KeyUsageType
+from ._enums import ActionType
+from ._enums import DeletionRecoveryLevel
+from ._enums import JsonWebKeyCurveName
+from ._enums import JsonWebKeyType
+from ._enums import KeyUsageType
 from ._patch import __all__ as _patch_all
 from ._patch import *  # pylint: disable=unused-wildcard-import
 from ._patch import patch_sdk as _patch_sdk
@@ -65,11 +62,9 @@
     "CertificateCreateParameters",
     "CertificateImportParameters",
     "CertificateIssuerItem",
-    "CertificateIssuerListResult",
     "CertificateIssuerSetParameters",
     "CertificateIssuerUpdateParameters",
     "CertificateItem",
-    "CertificateListResult",
     "CertificateMergeParameters",
     "CertificateOperation",
     "CertificateOperationUpdateParameter",
@@ -80,7 +75,6 @@
     "Contacts",
     "DeletedCertificateBundle",
     "DeletedCertificateItem",
-    "DeletedCertificateListResult",
     "Error",
     "IssuerAttributes",
     "IssuerBundle",
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_key_vault_client_enums.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_enums.py
similarity index 61%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_key_vault_client_enums.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_enums.py
index f4de625609fa..da3e1193bf96 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_key_vault_client_enums.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_enums.py
@@ -25,40 +25,40 @@ class DeletionRecoveryLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
 
     PURGEABLE = "Purgeable"
     """Denotes a vault state in which deletion is an irreversible operation, without the possibility
-    #: for recovery. This level corresponds to no protection being available against a Delete
-    #: operation; the data is irretrievably lost upon accepting a Delete operation at the entity level
-    #: or higher (vault, resource group, subscription etc.)"""
+    for recovery. This level corresponds to no protection being available against a Delete
+    operation; the data is irretrievably lost upon accepting a Delete operation at the entity level
+    or higher (vault, resource group, subscription etc.)"""
     RECOVERABLE_PURGEABLE = "Recoverable+Purgeable"
     """Denotes a vault state in which deletion is recoverable, and which also permits immediate and
-    #: permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted entity
-    #: during the retention interval (90 days), unless a Purge operation is requested, or the
-    #: subscription is cancelled. System wil permanently delete it after 90 days, if not recovered"""
+    permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted entity
+    during the retention interval (90 days), unless a Purge operation is requested, or the
+    subscription is cancelled. System wil permanently delete it after 90 days, if not recovered"""
     RECOVERABLE = "Recoverable"
     """Denotes a vault state in which deletion is recoverable without the possibility for immediate
-    #: and permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted
-    #: entity during the retention interval(90 days) and while the subscription is still available.
-    #: System wil permanently delete it after 90 days, if not recovered"""
+    and permanent deletion (i.e. purge). This level guarantees the recoverability of the deleted
+    entity during the retention interval(90 days) and while the subscription is still available.
+    System wil permanently delete it after 90 days, if not recovered"""
     RECOVERABLE_PROTECTED_SUBSCRIPTION = "Recoverable+ProtectedSubscription"
     """Denotes a vault and subscription state in which deletion is recoverable within retention
-    #: interval (90 days), immediate and permanent deletion (i.e. purge) is not permitted, and in
-    #: which the subscription itself  cannot be permanently canceled. System wil permanently delete it
-    #: after 90 days, if not recovered"""
+    interval (90 days), immediate and permanent deletion (i.e. purge) is not permitted, and in
+    which the subscription itself  cannot be permanently canceled. System wil permanently delete it
+    after 90 days, if not recovered"""
     CUSTOMIZED_RECOVERABLE_PURGEABLE = "CustomizedRecoverable+Purgeable"
     """Denotes a vault state in which deletion is recoverable, and which also permits immediate and
-    #: permanent deletion (i.e. purge when 7<= SoftDeleteRetentionInDays < 90). This level guarantees
-    #: the recoverability of the deleted entity during the retention interval, unless a Purge
-    #: operation is requested, or the subscription is cancelled."""
+    permanent deletion (i.e. purge when 7<= SoftDeleteRetentionInDays < 90). This level guarantees
+    the recoverability of the deleted entity during the retention interval, unless a Purge
+    operation is requested, or the subscription is cancelled."""
     CUSTOMIZED_RECOVERABLE = "CustomizedRecoverable"
     """Denotes a vault state in which deletion is recoverable without the possibility for immediate
-    #: and permanent deletion (i.e. purge when 7<= SoftDeleteRetentionInDays < 90).This level
-    #: guarantees the recoverability of the deleted entity during the retention interval and while the
-    #: subscription is still available."""
+    and permanent deletion (i.e. purge when 7<= SoftDeleteRetentionInDays < 90).This level
+    guarantees the recoverability of the deleted entity during the retention interval and while the
+    subscription is still available."""
     CUSTOMIZED_RECOVERABLE_PROTECTED_SUBSCRIPTION = "CustomizedRecoverable+ProtectedSubscription"
     """Denotes a vault and subscription state in which deletion is recoverable, immediate and
-    #: permanent deletion (i.e. purge) is not permitted, and in which the subscription itself cannot
-    #: be permanently canceled when 7<= SoftDeleteRetentionInDays < 90. This level guarantees the
-    #: recoverability of the deleted entity during the retention interval, and also reflects the fact
-    #: that the subscription itself cannot be cancelled."""
+    permanent deletion (i.e. purge) is not permitted, and in which the subscription itself cannot
+    be permanently canceled when 7<= SoftDeleteRetentionInDays < 90. This level guarantees the
+    recoverability of the deleted entity during the retention interval, and also reflects the fact
+    that the subscription itself cannot be cancelled."""
 
 
 class JsonWebKeyCurveName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models_py3.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py
similarity index 90%
rename from sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models_py3.py
rename to sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py
index 0a4bdfa78b81..52b773d33b03 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models_py3.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_generated/models/_models.py
@@ -21,7 +21,7 @@ class Action(_serialization.Model):
     """The action that will be executed.
 
     :ivar action_type: The type of the action. Known values are: "EmailContacts" and "AutoRenew".
-    :vartype action_type: str or ~key_vault_client.models.ActionType
+    :vartype action_type: str or ~azure.keyvault.v7_5.models.ActionType
     """
 
     _attribute_map = {
@@ -32,7 +32,7 @@ def __init__(self, *, action_type: Optional[Union[str, "_models.ActionType"]] =
         """
         :keyword action_type: The type of the action. Known values are: "EmailContacts" and
          "AutoRenew".
-        :paramtype action_type: str or ~key_vault_client.models.ActionType
+        :paramtype action_type: str or ~azure.keyvault.v7_5.models.ActionType
         """
         super().__init__(**kwargs)
         self.action_type = action_type
@@ -185,7 +185,7 @@ class CertificateAttributes(Attributes):
      retention interval. Known values are: "Purgeable", "Recoverable+Purgeable", "Recoverable",
      "Recoverable+ProtectedSubscription", "CustomizedRecoverable+Purgeable",
      "CustomizedRecoverable", and "CustomizedRecoverable+ProtectedSubscription".
-    :vartype recovery_level: str or ~key_vault_client.models.DeletionRecoveryLevel
+    :vartype recovery_level: str or ~azure.keyvault.v7_5.models.DeletionRecoveryLevel
     """
 
     _validation = {
@@ -240,14 +240,14 @@ class CertificateBundle(_serialization.Model):
     :ivar x509_thumbprint: Thumbprint of the certificate.
     :vartype x509_thumbprint: bytes
     :ivar policy: The management policy.
-    :vartype policy: ~key_vault_client.models.CertificatePolicy
+    :vartype policy: ~azure.keyvault.v7_5.models.CertificatePolicy
     :ivar cer: CER contents of x509 certificate.
     :vartype cer: bytes
     :ivar content_type: The content type of the secret. eg. 'application/x-pem-file' or
      'application/x-pkcs12',.
     :vartype content_type: str
     :ivar attributes: The certificate attributes.
-    :vartype attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     """
@@ -288,7 +288,7 @@ def __init__(
          'application/x-pkcs12',.
         :paramtype content_type: str
         :keyword attributes: The certificate attributes.
-        :paramtype attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         """
@@ -308,9 +308,9 @@ class CertificateCreateParameters(_serialization.Model):
     """The certificate create parameters.
 
     :ivar certificate_policy: The management policy for the certificate.
-    :vartype certificate_policy: ~key_vault_client.models.CertificatePolicy
+    :vartype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
     :ivar certificate_attributes: The attributes of the certificate (optional).
-    :vartype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     """
@@ -331,9 +331,9 @@ def __init__(
     ) -> None:
         """
         :keyword certificate_policy: The management policy for the certificate.
-        :paramtype certificate_policy: ~key_vault_client.models.CertificatePolicy
+        :paramtype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
         :keyword certificate_attributes: The attributes of the certificate (optional).
-        :paramtype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         """
@@ -346,7 +346,7 @@ def __init__(
 class CertificateImportParameters(_serialization.Model):
     """The certificate import parameters.
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
 
     :ivar base64_encoded_certificate: Base64 encoded representation of the certificate object to
      import. This certificate needs to contain the private key. Required.
@@ -355,9 +355,9 @@ class CertificateImportParameters(_serialization.Model):
      for encryption.
     :vartype password: str
     :ivar certificate_policy: The management policy for the certificate.
-    :vartype certificate_policy: ~key_vault_client.models.CertificatePolicy
+    :vartype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
     :ivar certificate_attributes: The attributes of the certificate (optional).
-    :vartype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     """
@@ -392,9 +392,9 @@ def __init__(
          used for encryption.
         :paramtype password: str
         :keyword certificate_policy: The management policy for the certificate.
-        :paramtype certificate_policy: ~key_vault_client.models.CertificatePolicy
+        :paramtype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
         :keyword certificate_attributes: The attributes of the certificate (optional).
-        :paramtype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         """
@@ -445,7 +445,7 @@ class CertificateIssuerListResult(_serialization.Model):
 
     :ivar value: A response message containing a list of certificate issuers in the key vault along
      with a link to the next page of certificate issuers.
-    :vartype value: list[~key_vault_client.models.CertificateIssuerItem]
+    :vartype value: list[~azure.keyvault.v7_5.models.CertificateIssuerItem]
     :ivar next_link: The URL to get the next set of certificate issuers.
     :vartype next_link: str
     """
@@ -470,16 +470,16 @@ def __init__(self, **kwargs: Any) -> None:
 class CertificateIssuerSetParameters(_serialization.Model):
     """The certificate issuer set parameters.
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
 
     :ivar provider: The issuer provider. Required.
     :vartype provider: str
     :ivar credentials: The credentials to be used for the issuer.
-    :vartype credentials: ~key_vault_client.models.IssuerCredentials
+    :vartype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
     :ivar organization_details: Details of the organization as provided to the issuer.
-    :vartype organization_details: ~key_vault_client.models.OrganizationDetails
+    :vartype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
     :ivar attributes: Attributes of the issuer object.
-    :vartype attributes: ~key_vault_client.models.IssuerAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
     """
 
     _validation = {
@@ -506,11 +506,11 @@ def __init__(
         :keyword provider: The issuer provider. Required.
         :paramtype provider: str
         :keyword credentials: The credentials to be used for the issuer.
-        :paramtype credentials: ~key_vault_client.models.IssuerCredentials
+        :paramtype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
         :keyword organization_details: Details of the organization as provided to the issuer.
-        :paramtype organization_details: ~key_vault_client.models.OrganizationDetails
+        :paramtype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
         :keyword attributes: Attributes of the issuer object.
-        :paramtype attributes: ~key_vault_client.models.IssuerAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
         """
         super().__init__(**kwargs)
         self.provider = provider
@@ -525,11 +525,11 @@ class CertificateIssuerUpdateParameters(_serialization.Model):
     :ivar provider: The issuer provider.
     :vartype provider: str
     :ivar credentials: The credentials to be used for the issuer.
-    :vartype credentials: ~key_vault_client.models.IssuerCredentials
+    :vartype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
     :ivar organization_details: Details of the organization as provided to the issuer.
-    :vartype organization_details: ~key_vault_client.models.OrganizationDetails
+    :vartype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
     :ivar attributes: Attributes of the issuer object.
-    :vartype attributes: ~key_vault_client.models.IssuerAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
     """
 
     _attribute_map = {
@@ -552,11 +552,11 @@ def __init__(
         :keyword provider: The issuer provider.
         :paramtype provider: str
         :keyword credentials: The credentials to be used for the issuer.
-        :paramtype credentials: ~key_vault_client.models.IssuerCredentials
+        :paramtype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
         :keyword organization_details: Details of the organization as provided to the issuer.
-        :paramtype organization_details: ~key_vault_client.models.OrganizationDetails
+        :paramtype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
         :keyword attributes: Attributes of the issuer object.
-        :paramtype attributes: ~key_vault_client.models.IssuerAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
         """
         super().__init__(**kwargs)
         self.provider = provider
@@ -571,7 +571,7 @@ class CertificateItem(_serialization.Model):
     :ivar id: Certificate identifier.
     :vartype id: str
     :ivar attributes: The certificate management attributes.
-    :vartype attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     :ivar x509_thumbprint: Thumbprint of the certificate.
@@ -598,7 +598,7 @@ def __init__(
         :keyword id: Certificate identifier.
         :paramtype id: str
         :keyword attributes: The certificate management attributes.
-        :paramtype attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         :keyword x509_thumbprint: Thumbprint of the certificate.
@@ -618,7 +618,7 @@ class CertificateListResult(_serialization.Model):
 
     :ivar value: A response message containing a list of certificates in the key vault along with a
      link to the next page of certificates.
-    :vartype value: list[~key_vault_client.models.CertificateItem]
+    :vartype value: list[~azure.keyvault.v7_5.models.CertificateItem]
     :ivar next_link: The URL to get the next set of certificates.
     :vartype next_link: str
     """
@@ -643,12 +643,12 @@ def __init__(self, **kwargs: Any) -> None:
 class CertificateMergeParameters(_serialization.Model):
     """The certificate merge parameters.
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
 
     :ivar x509_certificates: The certificate or the certificate chain to merge. Required.
     :vartype x509_certificates: list[bytes]
     :ivar certificate_attributes: The attributes of the certificate (optional).
-    :vartype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     """
@@ -675,7 +675,7 @@ def __init__(
         :keyword x509_certificates: The certificate or the certificate chain to merge. Required.
         :paramtype x509_certificates: list[bytes]
         :keyword certificate_attributes: The attributes of the certificate (optional).
-        :paramtype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         """
@@ -693,7 +693,7 @@ class CertificateOperation(_serialization.Model):
     :ivar id: The certificate id.
     :vartype id: str
     :ivar issuer_parameters: Parameters for the issuer of the X509 component of a certificate.
-    :vartype issuer_parameters: ~key_vault_client.models.IssuerParameters
+    :vartype issuer_parameters: ~azure.keyvault.v7_5.models.IssuerParameters
     :ivar csr: The certificate signing request (CSR) that is being used in the certificate
      operation.
     :vartype csr: bytes
@@ -705,7 +705,7 @@ class CertificateOperation(_serialization.Model):
     :ivar status_details: The status details of the certificate operation.
     :vartype status_details: str
     :ivar error: Error encountered, if any, during the certificate operation.
-    :vartype error: ~key_vault_client.models.Error
+    :vartype error: ~azure.keyvault.v7_5.models.Error
     :ivar target: Location which contains the result of the certificate operation.
     :vartype target: str
     :ivar request_id: Identifier for the certificate operation.
@@ -743,7 +743,7 @@ def __init__(
     ) -> None:
         """
         :keyword issuer_parameters: Parameters for the issuer of the X509 component of a certificate.
-        :paramtype issuer_parameters: ~key_vault_client.models.IssuerParameters
+        :paramtype issuer_parameters: ~azure.keyvault.v7_5.models.IssuerParameters
         :keyword csr: The certificate signing request (CSR) that is being used in the certificate
          operation.
         :paramtype csr: bytes
@@ -755,7 +755,7 @@ def __init__(
         :keyword status_details: The status details of the certificate operation.
         :paramtype status_details: str
         :keyword error: Error encountered, if any, during the certificate operation.
-        :paramtype error: ~key_vault_client.models.Error
+        :paramtype error: ~azure.keyvault.v7_5.models.Error
         :keyword target: Location which contains the result of the certificate operation.
         :paramtype target: str
         :keyword request_id: Identifier for the certificate operation.
@@ -776,7 +776,7 @@ def __init__(
 class CertificateOperationUpdateParameter(_serialization.Model):
     """The certificate operation update parameters.
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
 
     :ivar cancellation_requested: Indicates if cancellation was requested on the certificate
      operation. Required.
@@ -809,18 +809,18 @@ class CertificatePolicy(_serialization.Model):
     :ivar id: The certificate id.
     :vartype id: str
     :ivar key_properties: Properties of the key backing a certificate.
-    :vartype key_properties: ~key_vault_client.models.KeyProperties
+    :vartype key_properties: ~azure.keyvault.v7_5.models.KeyProperties
     :ivar secret_properties: Properties of the secret backing a certificate.
-    :vartype secret_properties: ~key_vault_client.models.SecretProperties
+    :vartype secret_properties: ~azure.keyvault.v7_5.models.SecretProperties
     :ivar x509_certificate_properties: Properties of the X509 component of a certificate.
-    :vartype x509_certificate_properties: ~key_vault_client.models.X509CertificateProperties
+    :vartype x509_certificate_properties: ~azure.keyvault.v7_5.models.X509CertificateProperties
     :ivar lifetime_actions: Actions that will be performed by Key Vault over the lifetime of a
      certificate.
-    :vartype lifetime_actions: list[~key_vault_client.models.LifetimeAction]
+    :vartype lifetime_actions: list[~azure.keyvault.v7_5.models.LifetimeAction]
     :ivar issuer_parameters: Parameters for the issuer of the X509 component of a certificate.
-    :vartype issuer_parameters: ~key_vault_client.models.IssuerParameters
+    :vartype issuer_parameters: ~azure.keyvault.v7_5.models.IssuerParameters
     :ivar attributes: The certificate attributes.
-    :vartype attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     """
 
     _validation = {
@@ -850,18 +850,18 @@ def __init__(
     ) -> None:
         """
         :keyword key_properties: Properties of the key backing a certificate.
-        :paramtype key_properties: ~key_vault_client.models.KeyProperties
+        :paramtype key_properties: ~azure.keyvault.v7_5.models.KeyProperties
         :keyword secret_properties: Properties of the secret backing a certificate.
-        :paramtype secret_properties: ~key_vault_client.models.SecretProperties
+        :paramtype secret_properties: ~azure.keyvault.v7_5.models.SecretProperties
         :keyword x509_certificate_properties: Properties of the X509 component of a certificate.
-        :paramtype x509_certificate_properties: ~key_vault_client.models.X509CertificateProperties
+        :paramtype x509_certificate_properties: ~azure.keyvault.v7_5.models.X509CertificateProperties
         :keyword lifetime_actions: Actions that will be performed by Key Vault over the lifetime of a
          certificate.
-        :paramtype lifetime_actions: list[~key_vault_client.models.LifetimeAction]
+        :paramtype lifetime_actions: list[~azure.keyvault.v7_5.models.LifetimeAction]
         :keyword issuer_parameters: Parameters for the issuer of the X509 component of a certificate.
-        :paramtype issuer_parameters: ~key_vault_client.models.IssuerParameters
+        :paramtype issuer_parameters: ~azure.keyvault.v7_5.models.IssuerParameters
         :keyword attributes: The certificate attributes.
-        :paramtype attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         """
         super().__init__(**kwargs)
         self.id = None
@@ -876,7 +876,7 @@ def __init__(
 class CertificateRestoreParameters(_serialization.Model):
     """The certificate restore parameters.
 
-    All required parameters must be populated in order to send to Azure.
+    All required parameters must be populated in order to send to server.
 
     :ivar certificate_bundle_backup: The backup blob associated with a certificate bundle.
      Required.
@@ -905,9 +905,9 @@ class CertificateUpdateParameters(_serialization.Model):
     """The certificate update parameters.
 
     :ivar certificate_policy: The management policy for the certificate.
-    :vartype certificate_policy: ~key_vault_client.models.CertificatePolicy
+    :vartype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
     :ivar certificate_attributes: The attributes of the certificate (optional).
-    :vartype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     """
@@ -928,9 +928,9 @@ def __init__(
     ) -> None:
         """
         :keyword certificate_policy: The management policy for the certificate.
-        :paramtype certificate_policy: ~key_vault_client.models.CertificatePolicy
+        :paramtype certificate_policy: ~azure.keyvault.v7_5.models.CertificatePolicy
         :keyword certificate_attributes: The attributes of the certificate (optional).
-        :paramtype certificate_attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype certificate_attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         """
@@ -987,7 +987,7 @@ class Contacts(_serialization.Model):
     :ivar id: Identifier for the contacts collection.
     :vartype id: str
     :ivar contact_list: The contact list for the vault certificates.
-    :vartype contact_list: list[~key_vault_client.models.Contact]
+    :vartype contact_list: list[~azure.keyvault.v7_5.models.Contact]
     """
 
     _validation = {
@@ -1002,7 +1002,7 @@ class Contacts(_serialization.Model):
     def __init__(self, *, contact_list: Optional[List["_models.Contact"]] = None, **kwargs: Any) -> None:
         """
         :keyword contact_list: The contact list for the vault certificates.
-        :paramtype contact_list: list[~key_vault_client.models.Contact]
+        :paramtype contact_list: list[~azure.keyvault.v7_5.models.Contact]
         """
         super().__init__(**kwargs)
         self.id = None
@@ -1024,14 +1024,14 @@ class DeletedCertificateBundle(CertificateBundle):  # pylint: disable=too-many-i
     :ivar x509_thumbprint: Thumbprint of the certificate.
     :vartype x509_thumbprint: bytes
     :ivar policy: The management policy.
-    :vartype policy: ~key_vault_client.models.CertificatePolicy
+    :vartype policy: ~azure.keyvault.v7_5.models.CertificatePolicy
     :ivar cer: CER contents of x509 certificate.
     :vartype cer: bytes
     :ivar content_type: The content type of the secret. eg. 'application/x-pem-file' or
      'application/x-pkcs12',.
     :vartype content_type: str
     :ivar attributes: The certificate attributes.
-    :vartype attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     :ivar recovery_id: The url of the recovery object, used to identify and recover the deleted
@@ -1085,7 +1085,7 @@ def __init__(
          'application/x-pkcs12',.
         :paramtype content_type: str
         :keyword attributes: The certificate attributes.
-        :paramtype attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         :keyword recovery_id: The url of the recovery object, used to identify and recover the deleted
@@ -1106,7 +1106,7 @@ class DeletedCertificateItem(CertificateItem):
     :ivar id: Certificate identifier.
     :vartype id: str
     :ivar attributes: The certificate management attributes.
-    :vartype attributes: ~key_vault_client.models.CertificateAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
     :ivar tags: Application specific metadata in the form of key-value pairs.
     :vartype tags: dict[str, str]
     :ivar x509_thumbprint: Thumbprint of the certificate.
@@ -1149,7 +1149,7 @@ def __init__(
         :keyword id: Certificate identifier.
         :paramtype id: str
         :keyword attributes: The certificate management attributes.
-        :paramtype attributes: ~key_vault_client.models.CertificateAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.CertificateAttributes
         :keyword tags: Application specific metadata in the form of key-value pairs.
         :paramtype tags: dict[str, str]
         :keyword x509_thumbprint: Thumbprint of the certificate.
@@ -1171,7 +1171,7 @@ class DeletedCertificateListResult(_serialization.Model):
 
     :ivar value: A response message containing a list of deleted certificates in the vault along
      with a link to the next page of deleted certificates.
-    :vartype value: list[~key_vault_client.models.DeletedCertificateItem]
+    :vartype value: list[~azure.keyvault.v7_5.models.DeletedCertificateItem]
     :ivar next_link: The URL to get the next set of deleted certificates.
     :vartype next_link: str
     """
@@ -1203,7 +1203,7 @@ class Error(_serialization.Model):
     :ivar message: The error message.
     :vartype message: str
     :ivar inner_error: The key vault server error.
-    :vartype inner_error: ~key_vault_client.models.Error
+    :vartype inner_error: ~azure.keyvault.v7_5.models.Error
     """
 
     _validation = {
@@ -1271,11 +1271,11 @@ class IssuerBundle(_serialization.Model):
     :ivar provider: The issuer provider.
     :vartype provider: str
     :ivar credentials: The credentials to be used for the issuer.
-    :vartype credentials: ~key_vault_client.models.IssuerCredentials
+    :vartype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
     :ivar organization_details: Details of the organization as provided to the issuer.
-    :vartype organization_details: ~key_vault_client.models.OrganizationDetails
+    :vartype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
     :ivar attributes: Attributes of the issuer object.
-    :vartype attributes: ~key_vault_client.models.IssuerAttributes
+    :vartype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
     """
 
     _validation = {
@@ -1303,11 +1303,11 @@ def __init__(
         :keyword provider: The issuer provider.
         :paramtype provider: str
         :keyword credentials: The credentials to be used for the issuer.
-        :paramtype credentials: ~key_vault_client.models.IssuerCredentials
+        :paramtype credentials: ~azure.keyvault.v7_5.models.IssuerCredentials
         :keyword organization_details: Details of the organization as provided to the issuer.
-        :paramtype organization_details: ~key_vault_client.models.OrganizationDetails
+        :paramtype organization_details: ~azure.keyvault.v7_5.models.OrganizationDetails
         :keyword attributes: Attributes of the issuer object.
-        :paramtype attributes: ~key_vault_client.models.IssuerAttributes
+        :paramtype attributes: ~azure.keyvault.v7_5.models.IssuerAttributes
         """
         super().__init__(**kwargs)
         self.id = None
@@ -1396,14 +1396,14 @@ class KeyProperties(_serialization.Model):
     :vartype exportable: bool
     :ivar key_type: The type of key pair to be used for the certificate. Known values are: "EC",
      "EC-HSM", "RSA", "RSA-HSM", "oct", and "oct-HSM".
-    :vartype key_type: str or ~key_vault_client.models.JsonWebKeyType
+    :vartype key_type: str or ~azure.keyvault.v7_5.models.JsonWebKeyType
     :ivar key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA.
     :vartype key_size: int
     :ivar reuse_key: Indicates if the same key pair will be used on certificate renewal.
     :vartype reuse_key: bool
     :ivar curve: Elliptic curve name. For valid values, see JsonWebKeyCurveName. Known values are:
      "P-256", "P-384", "P-521", and "P-256K".
-    :vartype curve: str or ~key_vault_client.models.JsonWebKeyCurveName
+    :vartype curve: str or ~azure.keyvault.v7_5.models.JsonWebKeyCurveName
     """
 
     _attribute_map = {
@@ -1430,14 +1430,14 @@ def __init__(
         :paramtype exportable: bool
         :keyword key_type: The type of key pair to be used for the certificate. Known values are: "EC",
          "EC-HSM", "RSA", "RSA-HSM", "oct", and "oct-HSM".
-        :paramtype key_type: str or ~key_vault_client.models.JsonWebKeyType
+        :paramtype key_type: str or ~azure.keyvault.v7_5.models.JsonWebKeyType
         :keyword key_size: The key size in bits. For example: 2048, 3072, or 4096 for RSA.
         :paramtype key_size: int
         :keyword reuse_key: Indicates if the same key pair will be used on certificate renewal.
         :paramtype reuse_key: bool
         :keyword curve: Elliptic curve name. For valid values, see JsonWebKeyCurveName. Known values
          are: "P-256", "P-384", "P-521", and "P-256K".
-        :paramtype curve: str or ~key_vault_client.models.JsonWebKeyCurveName
+        :paramtype curve: str or ~azure.keyvault.v7_5.models.JsonWebKeyCurveName
         """
         super().__init__(**kwargs)
         self.exportable = exportable
@@ -1453,7 +1453,7 @@ class KeyVaultError(_serialization.Model):
     Variables are only populated by the server, and will be ignored when sending a request.
 
     :ivar error: The key vault server error.
-    :vartype error: ~key_vault_client.models.Error
+    :vartype error: ~azure.keyvault.v7_5.models.Error
     """
 
     _validation = {
@@ -1474,9 +1474,9 @@ class LifetimeAction(_serialization.Model):
     """Action and its trigger that will be performed by Key Vault over the lifetime of a certificate.
 
     :ivar trigger: The condition that will execute the action.
-    :vartype trigger: ~key_vault_client.models.Trigger
+    :vartype trigger: ~azure.keyvault.v7_5.models.Trigger
     :ivar action: The action that will be executed.
-    :vartype action: ~key_vault_client.models.Action
+    :vartype action: ~azure.keyvault.v7_5.models.Action
     """
 
     _attribute_map = {
@@ -1489,9 +1489,9 @@ def __init__(
     ) -> None:
         """
         :keyword trigger: The condition that will execute the action.
-        :paramtype trigger: ~key_vault_client.models.Trigger
+        :paramtype trigger: ~azure.keyvault.v7_5.models.Trigger
         :keyword action: The action that will be executed.
-        :paramtype action: ~key_vault_client.models.Action
+        :paramtype action: ~azure.keyvault.v7_5.models.Action
         """
         super().__init__(**kwargs)
         self.trigger = trigger
@@ -1504,7 +1504,7 @@ class OrganizationDetails(_serialization.Model):
     :ivar id: Id of the organization.
     :vartype id: str
     :ivar admin_details: Details of the organization administrator.
-    :vartype admin_details: list[~key_vault_client.models.AdministratorDetails]
+    :vartype admin_details: list[~azure.keyvault.v7_5.models.AdministratorDetails]
     """
 
     _attribute_map = {
@@ -1523,7 +1523,7 @@ def __init__(
         :keyword id: Id of the organization.
         :paramtype id: str
         :keyword admin_details: Details of the organization administrator.
-        :paramtype admin_details: list[~key_vault_client.models.AdministratorDetails]
+        :paramtype admin_details: list[~azure.keyvault.v7_5.models.AdministratorDetails]
         """
         super().__init__(**kwargs)
         self.id = id
@@ -1658,9 +1658,9 @@ class X509CertificateProperties(_serialization.Model):
     :ivar ekus: The enhanced key usage.
     :vartype ekus: list[str]
     :ivar subject_alternative_names: The subject alternative names.
-    :vartype subject_alternative_names: ~key_vault_client.models.SubjectAlternativeNames
+    :vartype subject_alternative_names: ~azure.keyvault.v7_5.models.SubjectAlternativeNames
     :ivar key_usage: Defines how the certificate's key may be used.
-    :vartype key_usage: list[str or ~key_vault_client.models.KeyUsageType]
+    :vartype key_usage: list[str or ~azure.keyvault.v7_5.models.KeyUsageType]
     :ivar validity_in_months: The duration that the certificate is valid in months.
     :vartype validity_in_months: int
     """
@@ -1693,9 +1693,9 @@ def __init__(
         :keyword ekus: The enhanced key usage.
         :paramtype ekus: list[str]
         :keyword subject_alternative_names: The subject alternative names.
-        :paramtype subject_alternative_names: ~key_vault_client.models.SubjectAlternativeNames
+        :paramtype subject_alternative_names: ~azure.keyvault.v7_5.models.SubjectAlternativeNames
         :keyword key_usage: Defines how the certificate's key may be used.
-        :paramtype key_usage: list[str or ~key_vault_client.models.KeyUsageType]
+        :paramtype key_usage: list[str or ~azure.keyvault.v7_5.models.KeyUsageType]
         :keyword validity_in_months: The duration that the certificate is valid in months.
         :paramtype validity_in_months: int
         """
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/async_challenge_auth_policy.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/async_challenge_auth_policy.py
index 3c2ef95e3176..6fc8f7892ac8 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/async_challenge_auth_policy.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/async_challenge_auth_policy.py
@@ -14,6 +14,7 @@
 protocol again.
 """
 
+from copy import deepcopy
 import time
 from typing import Any, Optional
 from urllib.parse import urlparse
@@ -22,6 +23,7 @@
 from azure.core.credentials_async import AsyncTokenCredential
 from azure.core.pipeline import PipelineRequest, PipelineResponse
 from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy
+from azure.core.rest import HttpRequest
 
 from . import http_challenge_cache as ChallengeCache
 from .challenge_auth_policy import _enforce_tls, _update_challenge
@@ -39,6 +41,7 @@ def __init__(self, credential: AsyncTokenCredential, *scopes: str, **kwargs: Any
         self._credential = credential
         self._token: Optional[AccessToken] = None
         self._verify_challenge_resource = kwargs.pop("verify_challenge_resource", True)
+        self._request_copy: Optional[HttpRequest] = None
 
     async def on_request(self, request: PipelineRequest) -> None:
         _enforce_tls(request)
@@ -60,12 +63,17 @@ async def on_request(self, request: PipelineRequest) -> None:
 
         # else: discover authentication information by eliciting a challenge from Key Vault. Remove any request data,
         # saving it for later. Key Vault will reject the request as unauthorized and respond with a challenge.
-        # on_challenge will parse that challenge, reattach any body removed here, authorize the request, and tell
-        # super to send it again.
-        if request.http_request.body:
-            request.context["key_vault_request_data"] = request.http_request.body
-            request.http_request.set_json_body(None)
-            request.http_request.headers["Content-Length"] = "0"
+        # on_challenge will parse that challenge, use the original request including the body, authorize the
+        # request, and tell super to send it again.
+        if request.http_request.content:
+            self._request_copy = request.http_request
+            bodiless_request = HttpRequest(
+                method=request.http_request.method,
+                url=request.http_request.url,
+                headers=deepcopy(request.http_request.headers),
+            )
+            bodiless_request.headers["Content-Length"] = "0"
+            request.http_request = bodiless_request
 
 
     async def on_challenge(self, request: PipelineRequest, response: PipelineResponse) -> bool:
@@ -89,8 +97,9 @@ async def on_challenge(self, request: PipelineRequest, response: PipelineRespons
                     "See https://aka.ms/azsdk/blog/vault-uri for more information."
                 )
 
-        body = request.context.pop("key_vault_request_data", None)
-        request.http_request.set_text_body(body)  # no-op when text is None
+        # If we had created a request copy in on_request, use it now to send along the original body content
+        if self._request_copy:
+            request.http_request = self._request_copy
 
         # The tenant parsed from AD FS challenges is "adfs"; we don't actually need a tenant for AD FS authentication
         # For AD FS we skip cross-tenant authentication per https://github.com/Azure/azure-sdk-for-python/issues/28648
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/challenge_auth_policy.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/challenge_auth_policy.py
index 7cd10de68a86..41ed3fe794b8 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/challenge_auth_policy.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/challenge_auth_policy.py
@@ -14,6 +14,7 @@
 protocol again.
 """
 
+from copy import deepcopy
 import time
 from typing import Any, Optional
 from urllib.parse import urlparse
@@ -22,6 +23,7 @@
 from azure.core.exceptions import ServiceRequestError
 from azure.core.pipeline import PipelineRequest, PipelineResponse
 from azure.core.pipeline.policies import BearerTokenCredentialPolicy
+from azure.core.rest import HttpRequest
 
 from .http_challenge import HttpChallenge
 from . import http_challenge_cache as ChallengeCache
@@ -68,6 +70,7 @@ def __init__(self, credential: TokenCredential, *scopes: str, **kwargs: Any) ->
         self._credential = credential
         self._token: Optional[AccessToken] = None
         self._verify_challenge_resource = kwargs.pop("verify_challenge_resource", True)
+        self._request_copy: Optional[HttpRequest] = None
 
     def on_request(self, request: PipelineRequest) -> None:
         _enforce_tls(request)
@@ -89,12 +92,17 @@ def on_request(self, request: PipelineRequest) -> None:
 
         # else: discover authentication information by eliciting a challenge from Key Vault. Remove any request data,
         # saving it for later. Key Vault will reject the request as unauthorized and respond with a challenge.
-        # on_challenge will parse that challenge, reattach any body removed here, authorize the request, and tell
-        # super to send it again.
-        if request.http_request.body:
-            request.context["key_vault_request_data"] = request.http_request.body
-            request.http_request.set_json_body(None)
-            request.http_request.headers["Content-Length"] = "0"
+        # on_challenge will parse that challenge, use the original request including the body, authorize the
+        # request, and tell super to send it again.
+        if request.http_request.content:
+            self._request_copy = request.http_request
+            bodiless_request = HttpRequest(
+                method=request.http_request.method,
+                url=request.http_request.url,
+                headers=deepcopy(request.http_request.headers),
+            )
+            bodiless_request.headers["Content-Length"] = "0"
+            request.http_request = bodiless_request
 
     def on_challenge(self, request: PipelineRequest, response: PipelineResponse) -> bool:
         try:
@@ -117,8 +125,9 @@ def on_challenge(self, request: PipelineRequest, response: PipelineResponse) ->
                     "See https://aka.ms/azsdk/blog/vault-uri for more information."
                 )
 
-        body = request.context.pop("key_vault_request_data", None)
-        request.http_request.set_text_body(body)  # no-op when text is None
+        # If we had created a request copy in on_request, use it now to send along the original body content
+        if self._request_copy:
+            request.http_request = self._request_copy
 
         # The tenant parsed from AD FS challenges is "adfs"; we don't actually need a tenant for AD FS authentication
         # For AD FS we skip cross-tenant authentication per https://github.com/Azure/azure-sdk-for-python/issues/28648
diff --git a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/client_base.py b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/client_base.py
index 323118523b54..0be6566ce508 100644
--- a/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/client_base.py
+++ b/sdk/keyvault/azure-keyvault-certificates/azure/keyvault/certificates/_shared/client_base.py
@@ -24,7 +24,7 @@ class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     """Key Vault API versions supported by this package"""
 
     #: this is the default version
-    V7_5_PREVIEW_1 = "7.5-preview.1"
+    V7_5 = "7.5"
     V7_4 = "7.4"
     V7_3 = "7.3"
     V7_2 = "7.2"
@@ -33,7 +33,7 @@ class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     V2016_10_01 = "2016-10-01"
 
 
-DEFAULT_VERSION = ApiVersion.V7_5_PREVIEW_1
+DEFAULT_VERSION = ApiVersion.V7_5
 
 _SERIALIZER = Serializer()
 _SERIALIZER.client_side_validation = False
diff --git a/sdk/keyvault/azure-keyvault-certificates/setup.py b/sdk/keyvault/azure-keyvault-certificates/setup.py
index 2a7ed9053096..7c72b1a28c68 100644
--- a/sdk/keyvault/azure-keyvault-certificates/setup.py
+++ b/sdk/keyvault/azure-keyvault-certificates/setup.py
@@ -68,8 +68,7 @@
     ),
     python_requires=">=3.8",
     install_requires=[
-        "azure-common~=1.1",
-        "azure-core<2.0.0,>=1.24.0",
+        "azure-core<2.0.0,>=1.29.5",
         "isodate>=0.6.1",
         "typing-extensions>=4.0.1",
     ],