diracx-client 0.0.1a11__py3-none-any.whl → 0.0.1a13__py3-none-any.whl

diracx/client/aio/operations/_operations.py

@@ -1,24 +1,36 @@
-# pylint: disable=too-many-lines
+# pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 # --------------------------------------------------------------------------
-# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.1, generator: @autorest/python@6.4.11)
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.2, generator: @autorest/python@6.13.9)
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 from io import IOBase
 import sys
-from typing import Any, Callable, Dict, IO, List, Optional, TypeVar, Union, overload
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    IO,
+    List,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
 
+from azure.core import MatchConditions
 from azure.core.exceptions import (
     ClientAuthenticationError,
     HttpResponseError,
     ResourceExistsError,
+    ResourceModifiedError,
     ResourceNotFoundError,
     ResourceNotModifiedError,
     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_async import distributed_trace_async
 from azure.core.utils import case_insensitive_dict
 
@@ -34,8 +46,11 @@ from ...operations._operations import (
     build_auth_revoke_refresh_token_request,
     build_auth_userinfo_request,
     build_config_serve_config_request,
+    build_jobs_assign_sandbox_to_job_request,
     build_jobs_delete_bulk_jobs_request,
     build_jobs_delete_single_job_request,
+    build_jobs_get_job_sandbox_request,
+    build_jobs_get_job_sandboxes_request,
     build_jobs_get_job_status_bulk_request,
     build_jobs_get_job_status_history_bulk_request,
     build_jobs_get_sandbox_file_request,
@@ -55,6 +70,8 @@ from ...operations._operations import (
     build_jobs_set_single_job_status_request,
     build_jobs_submit_bulk_jobs_request,
     build_jobs_summary_request,
+    build_jobs_unassign_bulk_jobs_sandboxes_request,
+    build_jobs_unassign_job_sandboxes_request,
     build_well_known_installation_metadata_request,
     build_well_known_openid_configuration_request,
 )
@@ -96,13 +113,13 @@ class WellKnownOperations:
     async def openid_configuration(self, **kwargs: Any) -> Any:
         """Openid Configuration.
 
-        Openid Configuration.
+        OpenID Connect discovery endpoint.
 
         :return: any
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -115,22 +132,24 @@ class WellKnownOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_well_known_openid_configuration_request(
+        _request = build_well_known_openid_configuration_request(
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -139,21 +158,21 @@ class WellKnownOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def installation_metadata(self, **kwargs: Any) -> _models.Metadata:
         """Installation Metadata.
 
-        Installation Metadata.
+        Get metadata about the dirac installation.
 
         :return: Metadata
         :rtype: ~client.models.Metadata
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -166,22 +185,24 @@ class WellKnownOperations:
 
         cls: ClsType[_models.Metadata] = kwargs.pop("cls", None)
 
-        request = build_well_known_installation_metadata_request(
+        _request = build_well_known_installation_metadata_request(
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -190,12 +211,12 @@ class WellKnownOperations:
         deserialized = self._deserialize("Metadata", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
 
-class AuthOperations:
+class AuthOperations:  # pylint: disable=abstract-class-instantiated
     """
     .. warning::
         **DO NOT** instantiate this class directly.
@@ -215,6 +236,7 @@ class AuthOperations:
         self._deserialize = (
             input_args.pop(0) if input_args else kwargs.pop("deserializer")
         )
+
         raise_if_not_implemented(
             self.__class__,
             [
@@ -241,7 +263,7 @@ class AuthOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -254,23 +276,25 @@ class AuthOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_auth_do_device_flow_request(
+        _request = build_auth_do_device_flow_request(
             user_code=user_code,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -279,13 +303,13 @@ class AuthOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def initiate_device_flow(
-        self, *, client_id: str, scope: str, audience: str, **kwargs: Any
+        self, *, client_id: str, scope: str, **kwargs: Any
     ) -> _models.InitiateDeviceFlowResponse:
         """Initiate Device Flow.
 
@@ -301,13 +325,11 @@ class AuthOperations:
         :paramtype client_id: str
         :keyword scope: Required.
         :paramtype scope: str
-        :keyword audience: Required.
-        :paramtype audience: str
         :return: InitiateDeviceFlowResponse
         :rtype: ~client.models.InitiateDeviceFlowResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -320,25 +342,26 @@ class AuthOperations:
 
         cls: ClsType[_models.InitiateDeviceFlowResponse] = kwargs.pop("cls", None)
 
-        request = build_auth_initiate_device_flow_request(
+        _request = build_auth_initiate_device_flow_request(
             client_id=client_id,
             scope=scope,
-            audience=audience,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -349,9 +372,9 @@ class AuthOperations:
         )
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def finish_device_flow(self, *, code: str, state: str, **kwargs: Any) -> Any:
@@ -371,7 +394,7 @@ class AuthOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -384,24 +407,26 @@ class AuthOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_auth_finish_device_flow_request(
+        _request = build_auth_finish_device_flow_request(
             code=code,
             state=state,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -410,21 +435,21 @@ class AuthOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def finished(self, **kwargs: Any) -> Any:
         """Finished.
 
-        Finished.
+        This is the final step of the device flow.
 
         :return: any
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -437,22 +462,24 @@ class AuthOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_auth_finished_request(
+        _request = build_auth_finished_request(
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -461,21 +488,22 @@ class AuthOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_refresh_tokens(self, **kwargs: Any) -> List[Any]:
         """Get Refresh Tokens.
 
-        Get Refresh Tokens.
+        Get all refresh tokens for the user. If the user has the ``proxy_management`` property, then
+        the subject is not used to filter the refresh tokens.
 
         :return: list of any
         :rtype: list[any]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -488,22 +516,24 @@ class AuthOperations:
 
         cls: ClsType[List[Any]] = kwargs.pop("cls", None)
 
-        request = build_auth_get_refresh_tokens_request(
+        _request = build_auth_get_refresh_tokens_request(
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -512,15 +542,16 @@ class AuthOperations:
         deserialized = self._deserialize("[object]", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def revoke_refresh_token(self, jti: str, **kwargs: Any) -> str:
         """Revoke Refresh Token.
 
-        Revoke Refresh Token.
+        Revoke a refresh token. If the user has the ``proxy_management`` property, then
+        the subject is not used to filter the refresh tokens.
 
         :param jti: Required.
         :type jti: str
@@ -528,7 +559,7 @@ class AuthOperations:
         :rtype: str
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -541,23 +572,25 @@ class AuthOperations:
 
         cls: ClsType[str] = kwargs.pop("cls", None)
 
-        request = build_auth_revoke_refresh_token_request(
+        _request = build_auth_revoke_refresh_token_request(
             jti=jti,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -566,17 +599,70 @@ class AuthOperations:
         deserialized = self._deserialize("str", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def userinfo(self, **kwargs: Any) -> _models.UserInfoResponse:
+        """Userinfo.
+
+        Get information about the user's identity.
+
+        :return: UserInfoResponse
+        :rtype: ~client.models.UserInfoResponse
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[_models.UserInfoResponse] = kwargs.pop("cls", None)
+
+        _request = build_auth_userinfo_request(
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("UserInfoResponse", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def authorization_flow(
         self,
         *,
-        response_type: Union[str, _models.Enum3],
+        response_type: Union[str, _models.Enum0],
         code_challenge: str,
-        code_challenge_method: Union[str, _models.Enum4],
+        code_challenge_method: Union[str, _models.Enum1],
         client_id: str,
         redirect_uri: str,
         scope: str,
@@ -585,14 +671,20 @@ class AuthOperations:
     ) -> Any:
         """Authorization Flow.
 
-        Authorization Flow.
+        Initiate the authorization flow.
+        It will redirect to the actual OpenID server (IAM, CheckIn) to
+        perform a authorization code flow.
+
+        We set the user details obtained from the user authorize flow in a cookie
+        to be able to map the authorization flow with the corresponding
+        user authorize flow.
 
         :keyword response_type: "code" Required.
-        :paramtype response_type: str or ~client.models.Enum3
+        :paramtype response_type: str or ~client.models.Enum0
         :keyword code_challenge: Required.
         :paramtype code_challenge: str
         :keyword code_challenge_method: "S256" Required.
-        :paramtype code_challenge_method: str or ~client.models.Enum4
+        :paramtype code_challenge_method: str or ~client.models.Enum1
         :keyword client_id: Required.
         :paramtype client_id: str
         :keyword redirect_uri: Required.
@@ -605,7 +697,7 @@ class AuthOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -618,7 +710,7 @@ class AuthOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_auth_authorization_flow_request(
+        _request = build_auth_authorization_flow_request(
             response_type=response_type,
             code_challenge=code_challenge,
             code_challenge_method=code_challenge_method,
@@ -629,18 +721,20 @@ class AuthOperations:
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -649,9 +743,9 @@ class AuthOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def authorization_flow_complete(
@@ -659,7 +753,13 @@ class AuthOperations:
     ) -> Any:
         """Authorization Flow Complete.
 
-        Authorization Flow Complete.
+        Complete the authorization flow.
+
+        The user is redirected back to the DIRAC auth service after completing the IAM's authorization
+        flow.
+        We retrieve the original flow details from the decrypted state and store the ID token requested
+        from the IAM.
+        The user is then redirected to the client's redirect URI.
 
         :keyword code: Required.
         :paramtype code: str
@@ -669,7 +769,7 @@ class AuthOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -682,24 +782,26 @@ class AuthOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_auth_authorization_flow_complete_request(
+        _request = build_auth_authorization_flow_complete_request(
             code=code,
             state=state,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -708,60 +810,9 @@ class AuthOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
-
-        return deserialized
-
-    @distributed_trace_async
-    async def userinfo(self, **kwargs: Any) -> _models.UserInfoResponse:
-        """Userinfo.
-
-        Userinfo.
-
-        :return: UserInfoResponse
-        :rtype: ~client.models.UserInfoResponse
-        :raises ~azure.core.exceptions.HttpResponseError:
-        """
-        error_map = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
-        error_map.update(kwargs.pop("error_map", {}) or {})
-
-        _headers = kwargs.pop("headers", {}) or {}
-        _params = kwargs.pop("params", {}) or {}
-
-        cls: ClsType[_models.UserInfoResponse] = kwargs.pop("cls", None)
-
-        request = build_auth_userinfo_request(
-            headers=_headers,
-            params=_params,
-        )
-        request.url = self._client.format_url(request.url)
-
-        _stream = False
-        pipeline_response: PipelineResponse = (
-            await self._client._pipeline.run(  # pylint: disable=protected-access
-                request, stream=_stream, **kwargs
-            )
-        )
-
-        response = pipeline_response.http_response
-
-        if response.status_code not in [200]:
-            map_error(
-                status_code=response.status_code, response=response, error_map=error_map
-            )
-            raise HttpResponseError(response=response)
-
-        deserialized = self._deserialize("UserInfoResponse", pipeline_response)
-
-        if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
 
 class ConfigOperations:
@@ -789,8 +840,9 @@ class ConfigOperations:
     async def serve_config(
         self,
         *,
-        if_none_match: Optional[str] = None,
         if_modified_since: Optional[str] = None,
+        etag: Optional[str] = None,
+        match_condition: Optional[MatchConditions] = None,
         **kwargs: Any,
     ) -> Any:
         """Serve Config.
@@ -802,20 +854,29 @@ class ConfigOperations:
         If If-Modified-Since is given and is newer than latest,
             return 304: this is to avoid flip/flopping.
 
-        :keyword if_none_match: Default value is None.
-        :paramtype if_none_match: str
         :keyword if_modified_since: Default value is None.
         :paramtype if_modified_since: str
+        :keyword etag: check if resource is changed. Set None to skip checking etag. Default value is
+         None.
+        :paramtype etag: str
+        :keyword match_condition: The match condition to use upon the etag. Default value is None.
+        :paramtype match_condition: ~azure.core.MatchConditions
         :return: any
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
             304: ResourceNotModifiedError,
         }
+        if match_condition == MatchConditions.IfNotModified:
+            error_map[412] = ResourceModifiedError
+        elif match_condition == MatchConditions.IfPresent:
+            error_map[412] = ResourceNotFoundError
+        elif match_condition == MatchConditions.IfMissing:
+            error_map[412] = ResourceExistsError
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -823,24 +884,27 @@ class ConfigOperations:
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_config_serve_config_request(
-            if_none_match=if_none_match,
+        _request = build_config_serve_config_request(
             if_modified_since=if_modified_since,
+            etag=etag,
+            match_condition=match_condition,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -849,9 +913,9 @@ class ConfigOperations:
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
 
 class JobsOperations:  # pylint: disable=too-many-public-methods
@@ -895,7 +959,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: ~client.models.SandboxDownloadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -908,23 +972,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[_models.SandboxDownloadResponse] = kwargs.pop("cls", None)
 
-        request = build_jobs_get_sandbox_file_request(
+        _request = build_jobs_get_sandbox_file_request(
             pfn=pfn,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -933,9 +999,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("SandboxDownloadResponse", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def initiate_sandbox_upload(
@@ -967,7 +1033,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @overload
     async def initiate_sandbox_upload(
-        self, body: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> _models.SandboxUploadResponse:
         """Initiate Sandbox Upload.
 
@@ -980,7 +1046,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         should be used to upload the sandbox to the storage backend.
 
         :param body: Required.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
@@ -991,7 +1057,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @distributed_trace_async
     async def initiate_sandbox_upload(
-        self, body: Union[_models.SandboxInfo, IO], **kwargs: Any
+        self, body: Union[_models.SandboxInfo, IO[bytes]], **kwargs: Any
     ) -> _models.SandboxUploadResponse:
         """Initiate Sandbox Upload.
 
@@ -1003,16 +1069,13 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         If the sandbox does not exist in the database then the "url" and "fields"
         should be used to upload the sandbox to the storage backend.
 
-        :param body: Is either a SandboxInfo type or a IO type. Required.
-        :type body: ~client.models.SandboxInfo or IO
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
+        :param body: Is either a SandboxInfo type or a IO[bytes] type. Required.
+        :type body: ~client.models.SandboxInfo or IO[bytes]
         :return: SandboxUploadResponse
         :rtype: ~client.models.SandboxUploadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1036,25 +1099,27 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         else:
             _json = self._serialize.body(body, "SandboxInfo")
 
-        request = build_jobs_initiate_sandbox_upload_request(
+        _request = build_jobs_initiate_sandbox_upload_request(
             content_type=content_type,
             json=_json,
             content=_content,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1063,9 +1128,307 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("SandboxUploadResponse", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def unassign_bulk_jobs_sandboxes(
+        self, *, jobs_ids: List[int], **kwargs: Any
+    ) -> Any:
+        """Unassign Bulk Jobs Sandboxes.
+
+        Delete bulk jobs sandbox mapping.
+
+        :keyword jobs_ids: Required.
+        :paramtype jobs_ids: list[int]
+        :return: any
+        :rtype: any
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[Any] = kwargs.pop("cls", None)
+
+        _request = build_jobs_unassign_bulk_jobs_sandboxes_request(
+            jobs_ids=jobs_ids,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("object", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def get_job_sandboxes(
+        self, job_id: int, **kwargs: Any
+    ) -> Dict[str, List[Any]]:
+        """Get Job Sandboxes.
+
+        Get input and output sandboxes of given job.
+
+        :param job_id: Required.
+        :type job_id: int
+        :return: dict mapping str to list of any
+        :rtype: dict[str, list[any]]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[Dict[str, List[Any]]] = kwargs.pop("cls", None)
+
+        _request = build_jobs_get_job_sandboxes_request(
+            job_id=job_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("{[object]}", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def unassign_job_sandboxes(self, job_id: int, **kwargs: Any) -> Any:
+        """Unassign Job Sandboxes.
+
+        Delete single job sandbox mapping.
+
+        :param job_id: Required.
+        :type job_id: int
+        :return: any
+        :rtype: any
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[Any] = kwargs.pop("cls", None)
+
+        _request = build_jobs_unassign_job_sandboxes_request(
+            job_id=job_id,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("object", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def get_job_sandbox(
+        self, job_id: int, sandbox_type: Union[str, _models.SandboxType], **kwargs: Any
+    ) -> List[Any]:
+        """Get Job Sandbox.
+
+        Get input or output sandbox of given job.
+
+        :param job_id: Required.
+        :type job_id: int
+        :param sandbox_type: Known values are: "input" and "output". Required.
+        :type sandbox_type: str or ~client.models.SandboxType
+        :return: list of any
+        :rtype: list[any]
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = kwargs.pop("headers", {}) or {}
+        _params = kwargs.pop("params", {}) or {}
+
+        cls: ClsType[List[Any]] = kwargs.pop("cls", None)
+
+        _request = build_jobs_get_job_sandbox_request(
+            job_id=job_id,
+            sandbox_type=sandbox_type,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("[object]", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
+
+        return deserialized  # type: ignore
+
+    @distributed_trace_async
+    async def assign_sandbox_to_job(self, job_id: int, body: str, **kwargs: Any) -> Any:
+        """Assign Sandbox To Job.
+
+        Mapp the pfn as output sandbox to job.
+
+        :param job_id: Required.
+        :type job_id: int
+        :param body: Required.
+        :type body: str
+        :return: any
+        :rtype: any
+        :raises ~azure.core.exceptions.HttpResponseError:
+        """
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
+            401: ClientAuthenticationError,
+            404: ResourceNotFoundError,
+            409: ResourceExistsError,
+            304: ResourceNotModifiedError,
+        }
+        error_map.update(kwargs.pop("error_map", {}) or {})
+
+        _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
+        _params = kwargs.pop("params", {}) or {}
+
+        content_type: str = kwargs.pop(
+            "content_type", _headers.pop("Content-Type", "application/json")
+        )
+        cls: ClsType[Any] = kwargs.pop("cls", None)
+
+        _content = self._serialize.body(body, "str")
+
+        _request = build_jobs_assign_sandbox_to_job_request(
+            job_id=job_id,
+            content_type=content_type,
+            content=_content,
+            headers=_headers,
+            params=_params,
+        )
+        _request.url = self._client.format_url(_request.url)
+
+        _stream = False
+        pipeline_response: PipelineResponse = (
+            await self._client._pipeline.run(  # pylint: disable=protected-access
+                _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
+            )
+            raise HttpResponseError(response=response)
+
+        deserialized = self._deserialize("object", pipeline_response)
+
+        if cls:
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def submit_bulk_jobs(
@@ -1087,14 +1450,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @overload
     async def submit_bulk_jobs(
-        self, body: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> List[_models.InsertedJob]:
         """Submit Bulk Jobs.
 
         Submit Bulk Jobs.
 
         :param body: Required.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
@@ -1105,22 +1468,19 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @distributed_trace_async
     async def submit_bulk_jobs(
-        self, body: Union[List[str], IO], **kwargs: Any
+        self, body: Union[List[str], IO[bytes]], **kwargs: Any
     ) -> List[_models.InsertedJob]:
         """Submit Bulk Jobs.
 
         Submit Bulk Jobs.
 
-        :param body: Is either a [str] type or a IO type. Required.
-        :type body: list[str] or IO
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
+        :param body: Is either a [str] type or a IO[bytes] type. Required.
+        :type body: list[str] or IO[bytes]
         :return: list of InsertedJob
         :rtype: list[~client.models.InsertedJob]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1144,25 +1504,27 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         else:
             _json = self._serialize.body(body, "[str]")
 
-        request = build_jobs_submit_bulk_jobs_request(
+        _request = build_jobs_submit_bulk_jobs_request(
             content_type=content_type,
             json=_json,
             content=_content,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1171,9 +1533,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("[InsertedJob]", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def delete_bulk_jobs(self, *, job_ids: List[int], **kwargs: Any) -> Any:
@@ -1187,7 +1549,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1200,23 +1562,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_delete_bulk_jobs_request(
+        _request = build_jobs_delete_bulk_jobs_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1225,9 +1589,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def kill_bulk_jobs(self, *, job_ids: List[int], **kwargs: Any) -> Any:
@@ -1241,7 +1605,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1254,23 +1618,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_kill_bulk_jobs_request(
+        _request = build_jobs_kill_bulk_jobs_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1279,9 +1645,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def remove_bulk_jobs(self, *, job_ids: List[int], **kwargs: Any) -> Any:
@@ -1299,7 +1665,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1312,23 +1678,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_remove_bulk_jobs_request(
+        _request = build_jobs_remove_bulk_jobs_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1337,9 +1705,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_job_status_bulk(
@@ -1355,7 +1723,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: dict[str, ~client.models.LimitedJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1370,23 +1738,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             "cls", None
         )
 
-        request = build_jobs_get_job_status_bulk_request(
+        _request = build_jobs_get_job_status_bulk_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1395,9 +1765,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{LimitedJobStatusReturn}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def set_job_status_bulk(
@@ -1427,7 +1797,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     @overload
     async def set_job_status_bulk(
         self,
-        body: IO,
+        body: IO[bytes],
         *,
         force: bool = False,
         content_type: str = "application/json",
@@ -1438,7 +1808,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         Set Job Status Bulk.
 
         :param body: Required.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
@@ -1452,7 +1822,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     @distributed_trace_async
     async def set_job_status_bulk(
         self,
-        body: Union[Dict[str, Dict[str, _models.JobStatusUpdate]], IO],
+        body: Union[Dict[str, Dict[str, _models.JobStatusUpdate]], IO[bytes]],
         *,
         force: bool = False,
         **kwargs: Any,
@@ -1461,18 +1831,15 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         Set Job Status Bulk.
 
-        :param body: Is either a {str: {str: JobStatusUpdate}} type or a IO type. Required.
-        :type body: dict[str, dict[str, ~client.models.JobStatusUpdate]] or IO
+        :param body: Is either a {str: {str: JobStatusUpdate}} type or a IO[bytes] type. Required.
+        :type body: dict[str, dict[str, ~client.models.JobStatusUpdate]] or IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
         :rtype: dict[str, ~client.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1496,7 +1863,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         else:
             _json = self._serialize.body(body, "{{JobStatusUpdate}}")
 
-        request = build_jobs_set_job_status_bulk_request(
+        _request = build_jobs_set_job_status_bulk_request(
             force=force,
             content_type=content_type,
             json=_json,
@@ -1504,18 +1871,20 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1524,9 +1893,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{SetJobStatusReturn}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_job_status_history_bulk(
@@ -1542,7 +1911,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: dict[str, list[~client.models.JobStatusReturn]]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1555,23 +1924,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Dict[str, List[_models.JobStatusReturn]]] = kwargs.pop("cls", None)
 
-        request = build_jobs_get_job_status_history_bulk_request(
+        _request = build_jobs_get_job_status_history_bulk_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1580,9 +1951,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{[JobStatusReturn]}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def reschedule_bulk_jobs(self, *, job_ids: List[int], **kwargs: Any) -> Any:
@@ -1596,7 +1967,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1609,23 +1980,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_reschedule_bulk_jobs_request(
+        _request = build_jobs_reschedule_bulk_jobs_request(
             job_ids=job_ids,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1634,9 +2007,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def reschedule_single_job(self, job_id: int, **kwargs: Any) -> Any:
@@ -1650,7 +2023,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1663,23 +2036,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_reschedule_single_job_request(
+        _request = build_jobs_reschedule_single_job_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1688,9 +2063,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def search(
@@ -1725,7 +2100,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     @overload
     async def search(
         self,
-        body: Optional[IO] = None,
+        body: Optional[IO[bytes]] = None,
         *,
         page: int = 0,
         per_page: int = 100,
@@ -1739,7 +2114,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         **TODO: Add more docs**.
 
         :param body: Default value is None.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword page: Default value is 0.
         :paramtype page: int
         :keyword per_page: Default value is 100.
@@ -1755,7 +2130,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     @distributed_trace_async
     async def search(
         self,
-        body: Optional[Union[_models.JobSearchParams, IO]] = None,
+        body: Optional[Union[_models.JobSearchParams, IO[bytes]]] = None,
         *,
         page: int = 0,
         per_page: int = 100,
@@ -1767,20 +2142,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         **TODO: Add more docs**.
 
-        :param body: Is either a JobSearchParams type or a IO type. Default value is None.
-        :type body: ~client.models.JobSearchParams or IO
+        :param body: Is either a JobSearchParams type or a IO[bytes] type. Default value is None.
+        :type body: ~client.models.JobSearchParams or IO[bytes]
         :keyword page: Default value is 0.
         :paramtype page: int
         :keyword per_page: Default value is 100.
         :paramtype per_page: int
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
         :return: list of JSON
         :rtype: list[JSON]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1807,7 +2179,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             else:
                 _json = None
 
-        request = build_jobs_search_request(
+        _request = build_jobs_search_request(
             page=page,
             per_page=per_page,
             content_type=content_type,
@@ -1816,18 +2188,20 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1836,9 +2210,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("[object]", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def summary(
@@ -1864,14 +2238,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @overload
     async def summary(
-        self, body: IO, *, content_type: str = "application/json", **kwargs: Any
+        self, body: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
     ) -> Any:
         """Summary.
 
         Show information suitable for plotting.
 
         :param body: Required.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
          Default value is "application/json".
         :paramtype content_type: str
@@ -1882,22 +2256,19 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
     @distributed_trace_async
     async def summary(
-        self, body: Union[_models.JobSummaryParams, IO], **kwargs: Any
+        self, body: Union[_models.JobSummaryParams, IO[bytes]], **kwargs: Any
     ) -> Any:
         """Summary.
 
         Show information suitable for plotting.
 
-        :param body: Is either a JobSummaryParams type or a IO type. Required.
-        :type body: ~client.models.JobSummaryParams or IO
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
+        :param body: Is either a JobSummaryParams type or a IO[bytes] type. Required.
+        :type body: ~client.models.JobSummaryParams or IO[bytes]
         :return: any
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1921,25 +2292,27 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         else:
             _json = self._serialize.body(body, "JobSummaryParams")
 
-        request = build_jobs_summary_request(
+        _request = build_jobs_summary_request(
             content_type=content_type,
             json=_json,
             content=_content,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -1948,9 +2321,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_single_job(self, job_id: int, **kwargs: Any) -> Any:
@@ -1964,7 +2337,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -1977,23 +2350,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_get_single_job_request(
+        _request = build_jobs_get_single_job_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2002,9 +2377,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def delete_single_job(self, job_id: int, **kwargs: Any) -> Any:
@@ -2018,7 +2393,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2031,23 +2406,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_delete_single_job_request(
+        _request = build_jobs_delete_single_job_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2056,9 +2433,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def set_single_job_properties(
@@ -2078,7 +2455,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2096,7 +2473,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         _json = self._serialize.body(body, "object")
 
-        request = build_jobs_set_single_job_properties_request(
+        _request = build_jobs_set_single_job_properties_request(
             job_id=job_id,
             update_timestamp=update_timestamp,
             content_type=content_type,
@@ -2104,18 +2481,20 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2124,9 +2503,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def kill_single_job(self, job_id: int, **kwargs: Any) -> Any:
@@ -2140,7 +2519,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2153,23 +2532,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_kill_single_job_request(
+        _request = build_jobs_kill_single_job_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2178,9 +2559,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def remove_single_job(self, job_id: int, **kwargs: Any) -> Any:
@@ -2198,7 +2579,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2211,23 +2592,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Any] = kwargs.pop("cls", None)
 
-        request = build_jobs_remove_single_job_request(
+        _request = build_jobs_remove_single_job_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2236,9 +2619,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("object", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_single_job_status(
@@ -2254,7 +2637,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: dict[str, ~client.models.LimitedJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2269,23 +2652,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             "cls", None
         )
 
-        request = build_jobs_get_single_job_status_request(
+        _request = build_jobs_get_single_job_status_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2294,9 +2679,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{LimitedJobStatusReturn}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @overload
     async def set_single_job_status(
@@ -2330,7 +2715,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     async def set_single_job_status(
         self,
         job_id: int,
-        body: IO,
+        body: IO[bytes],
         *,
         force: bool = False,
         content_type: str = "application/json",
@@ -2343,7 +2728,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :param body: Required.
-        :type body: IO
+        :type body: IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
         :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
@@ -2358,7 +2743,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     async def set_single_job_status(
         self,
         job_id: int,
-        body: Union[Dict[str, _models.JobStatusUpdate], IO],
+        body: Union[Dict[str, _models.JobStatusUpdate], IO[bytes]],
         *,
         force: bool = False,
         **kwargs: Any,
@@ -2369,18 +2754,15 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         :param job_id: Required.
         :type job_id: int
-        :param body: Is either a {str: JobStatusUpdate} type or a IO type. Required.
-        :type body: dict[str, ~client.models.JobStatusUpdate] or IO
+        :param body: Is either a {str: JobStatusUpdate} type or a IO[bytes] type. Required.
+        :type body: dict[str, ~client.models.JobStatusUpdate] or IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
-        :keyword content_type: Body Parameter content-type. Known values are: 'application/json'.
-         Default value is None.
-        :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
         :rtype: dict[str, ~client.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2404,7 +2786,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         else:
             _json = self._serialize.body(body, "{JobStatusUpdate}")
 
-        request = build_jobs_set_single_job_status_request(
+        _request = build_jobs_set_single_job_status_request(
             job_id=job_id,
             force=force,
             content_type=content_type,
@@ -2413,18 +2795,20 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2433,9 +2817,9 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{SetJobStatusReturn}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore
 
     @distributed_trace_async
     async def get_single_job_status_history(
@@ -2451,7 +2835,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: dict[str, list[~client.models.JobStatusReturn]]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map = {
+        error_map: MutableMapping[int, Type[HttpResponseError]] = {
             401: ClientAuthenticationError,
             404: ResourceNotFoundError,
             409: ResourceExistsError,
@@ -2464,23 +2848,25 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
 
         cls: ClsType[Dict[str, List[_models.JobStatusReturn]]] = kwargs.pop("cls", None)
 
-        request = build_jobs_get_single_job_status_history_request(
+        _request = build_jobs_get_single_job_status_history_request(
             job_id=job_id,
             headers=_headers,
             params=_params,
         )
-        request.url = self._client.format_url(request.url)
+        _request.url = self._client.format_url(_request.url)
 
         _stream = False
         pipeline_response: PipelineResponse = (
             await 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:
+                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
             )
@@ -2489,6 +2875,6 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         deserialized = self._deserialize("{[JobStatusReturn]}", pipeline_response)
 
         if cls:
-            return cls(pipeline_response, deserialized, {})
+            return cls(pipeline_response, deserialized, {})  # type: ignore
 
-        return deserialized
+        return deserialized  # type: ignore