azure-mgmt-storage 22.2.0__py3-none-any.whl → 23.0.0__py3-none-any.whl

azure/mgmt/storage/aio/_storage_management_client.py

@@ -1,83 +1,143 @@
 # coding=utf-8
 # --------------------------------------------------------------------------
 # Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-#
+# Licensed under the MIT License. See License.txt in the project root for license information.
 # Code generated by Microsoft (R) AutoRest Code Generator.
-# Changes may cause incorrect behavior and will be lost if the code is
-# regenerated.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-from typing import Any, Optional, TYPE_CHECKING
+from copy import deepcopy
+from typing import Any, Awaitable, Optional, TYPE_CHECKING, cast
 from typing_extensions import Self
 
 from azure.core.pipeline import policies
+from azure.core.rest import AsyncHttpResponse, HttpRequest
+from azure.core.settings import settings
 from azure.mgmt.core import AsyncARMPipelineClient
 from azure.mgmt.core.policies import AsyncARMAutoResourceProviderRegistrationPolicy
-from azure.profiles import KnownProfiles, ProfileDefinition
-from azure.profiles.multiapiclient import MultiApiClientMixin
+from azure.mgmt.core.tools import get_arm_endpoints
 
-from .._serialization import Deserializer, Serializer
+from .. import models as _models
+from .._utils.serialization import Deserializer, Serializer
 from ._configuration import StorageManagementClientConfiguration
+from .operations import (
+    BlobContainersOperations,
+    BlobInventoryPoliciesOperations,
+    BlobServicesOperations,
+    DeletedAccountsOperations,
+    EncryptionScopesOperations,
+    FileServicesOperations,
+    FileSharesOperations,
+    LocalUsersOperations,
+    ManagementPoliciesOperations,
+    NetworkSecurityPerimeterConfigurationsOperations,
+    ObjectReplicationPoliciesOperations,
+    Operations,
+    PrivateEndpointConnectionsOperations,
+    PrivateLinkResourcesOperations,
+    QueueOperations,
+    QueueServicesOperations,
+    SkusOperations,
+    StorageAccountsOperations,
+    StorageTaskAssignmentInstancesReportOperations,
+    StorageTaskAssignmentsInstancesReportOperations,
+    StorageTaskAssignmentsOperations,
+    TableOperations,
+    TableServicesOperations,
+    UsagesOperations,
+)
 
 if TYPE_CHECKING:
-    # pylint: disable=unused-import,ungrouped-imports
     from azure.core.credentials_async import AsyncTokenCredential
 
-class _SDKClient(object):
-    def __init__(self, *args, **kwargs):
-        """This is a fake class to support current implemetation of MultiApiClientMixin."
-        Will be removed in final version of multiapi azure-core based client
-        """
-        pass
 
-class StorageManagementClient(MultiApiClientMixin, _SDKClient):
+class StorageManagementClient:  # pylint: disable=too-many-instance-attributes
     """The Azure Storage Management API.
 
-    This ready contains multiple API versions, to help you deal with all of the Azure clouds
-    (Azure Stack, Azure Government, Azure China, etc.).
-    By default, it uses the latest API version available on public Azure.
-    For production, you should stick to a particular api-version and/or profile.
-    The profile sets a mapping between an operation group and its API version.
-    The api-version parameter sets the default API version if the operation
-    group is not described in the profile.
-
+    :ivar blob_services: BlobServicesOperations operations
+    :vartype blob_services: azure.mgmt.storage.aio.operations.BlobServicesOperations
+    :ivar blob_containers: BlobContainersOperations operations
+    :vartype blob_containers: azure.mgmt.storage.aio.operations.BlobContainersOperations
+    :ivar file_services: FileServicesOperations operations
+    :vartype file_services: azure.mgmt.storage.aio.operations.FileServicesOperations
+    :ivar file_shares: FileSharesOperations operations
+    :vartype file_shares: azure.mgmt.storage.aio.operations.FileSharesOperations
+    :ivar queue_services: QueueServicesOperations operations
+    :vartype queue_services: azure.mgmt.storage.aio.operations.QueueServicesOperations
+    :ivar queue: QueueOperations operations
+    :vartype queue: azure.mgmt.storage.aio.operations.QueueOperations
+    :ivar operations: Operations operations
+    :vartype operations: azure.mgmt.storage.aio.operations.Operations
+    :ivar skus: SkusOperations operations
+    :vartype skus: azure.mgmt.storage.aio.operations.SkusOperations
+    :ivar storage_accounts: StorageAccountsOperations operations
+    :vartype storage_accounts: azure.mgmt.storage.aio.operations.StorageAccountsOperations
+    :ivar deleted_accounts: DeletedAccountsOperations operations
+    :vartype deleted_accounts: azure.mgmt.storage.aio.operations.DeletedAccountsOperations
+    :ivar usages: UsagesOperations operations
+    :vartype usages: azure.mgmt.storage.aio.operations.UsagesOperations
+    :ivar management_policies: ManagementPoliciesOperations operations
+    :vartype management_policies: azure.mgmt.storage.aio.operations.ManagementPoliciesOperations
+    :ivar blob_inventory_policies: BlobInventoryPoliciesOperations operations
+    :vartype blob_inventory_policies:
+     azure.mgmt.storage.aio.operations.BlobInventoryPoliciesOperations
+    :ivar private_endpoint_connections: PrivateEndpointConnectionsOperations operations
+    :vartype private_endpoint_connections:
+     azure.mgmt.storage.aio.operations.PrivateEndpointConnectionsOperations
+    :ivar private_link_resources: PrivateLinkResourcesOperations operations
+    :vartype private_link_resources:
+     azure.mgmt.storage.aio.operations.PrivateLinkResourcesOperations
+    :ivar object_replication_policies: ObjectReplicationPoliciesOperations operations
+    :vartype object_replication_policies:
+     azure.mgmt.storage.aio.operations.ObjectReplicationPoliciesOperations
+    :ivar local_users: LocalUsersOperations operations
+    :vartype local_users: azure.mgmt.storage.aio.operations.LocalUsersOperations
+    :ivar encryption_scopes: EncryptionScopesOperations operations
+    :vartype encryption_scopes: azure.mgmt.storage.aio.operations.EncryptionScopesOperations
+    :ivar table_services: TableServicesOperations operations
+    :vartype table_services: azure.mgmt.storage.aio.operations.TableServicesOperations
+    :ivar table: TableOperations operations
+    :vartype table: azure.mgmt.storage.aio.operations.TableOperations
+    :ivar network_security_perimeter_configurations:
+     NetworkSecurityPerimeterConfigurationsOperations operations
+    :vartype network_security_perimeter_configurations:
+     azure.mgmt.storage.aio.operations.NetworkSecurityPerimeterConfigurationsOperations
+    :ivar storage_task_assignments: StorageTaskAssignmentsOperations operations
+    :vartype storage_task_assignments:
+     azure.mgmt.storage.aio.operations.StorageTaskAssignmentsOperations
+    :ivar storage_task_assignments_instances_report:
+     StorageTaskAssignmentsInstancesReportOperations operations
+    :vartype storage_task_assignments_instances_report:
+     azure.mgmt.storage.aio.operations.StorageTaskAssignmentsInstancesReportOperations
+    :ivar storage_task_assignment_instances_report: StorageTaskAssignmentInstancesReportOperations
+     operations
+    :vartype storage_task_assignment_instances_report:
+     azure.mgmt.storage.aio.operations.StorageTaskAssignmentInstancesReportOperations
     :param credential: Credential needed for the client to connect to Azure. Required.
     :type credential: ~azure.core.credentials_async.AsyncTokenCredential
     :param subscription_id: The ID of the target subscription. Required.
     :type subscription_id: str
-    :param api_version: API version to use if no profile is provided, or if missing in profile.
-    :type api_version: str
-    :param base_url: Service URL
+    :param base_url: Service URL. Default value is None.
     :type base_url: str
-    :param profile: A profile definition, from KnownProfiles to dict.
-    :type profile: azure.profiles.KnownProfiles
-    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
+    :keyword api_version: Api Version. Default value is "2024-01-01". Note that overriding this
+     default value may result in unsupported behavior.
+    :paramtype api_version: str
+    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
+     Retry-After header is present.
     """
 
-    DEFAULT_API_VERSION = '2024-01-01'
-    _PROFILE_TAG = "azure.mgmt.storage.StorageManagementClient"
-    LATEST_PROFILE = ProfileDefinition({
-        _PROFILE_TAG: {
-            None: DEFAULT_API_VERSION,
-            'usage': '2017-10-01',
-        }},
-        _PROFILE_TAG + " latest"
-    )
-
     def __init__(
-        self,
-        credential: "AsyncTokenCredential",
-        subscription_id: str,
-        api_version: Optional[str] = None,
-        base_url: str = "https://management.azure.com",
-        profile: KnownProfiles = KnownProfiles.default,
-        **kwargs: Any
+        self, credential: "AsyncTokenCredential", subscription_id: str, base_url: Optional[str] = None, **kwargs: Any
     ) -> None:
-        if api_version:
-            kwargs.setdefault('api_version', api_version)
-        self._config = StorageManagementClientConfiguration(credential, subscription_id, **kwargs)
+        _cloud = kwargs.pop("cloud_setting", None) or settings.current.azure_cloud  # type: ignore
+        _endpoints = get_arm_endpoints(_cloud)
+        if not base_url:
+            base_url = _endpoints["resource_manager"]
+        credential_scopes = kwargs.pop("credential_scopes", _endpoints["credential_scopes"])
+        self._config = StorageManagementClientConfiguration(
+            credential=credential, subscription_id=subscription_id, credential_scopes=credential_scopes, **kwargs
+        )
+
         _policies = kwargs.pop("policies", None)
         if _policies is None:
             _policies = [
@@ -96,462 +156,93 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
                 policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
                 self._config.http_logging_policy,
             ]
-        self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs)
-        super(StorageManagementClient, self).__init__(
-            api_version=api_version,
-            profile=profile
+        self._client: AsyncARMPipelineClient = AsyncARMPipelineClient(
+            base_url=cast(str, base_url), policies=_policies, **kwargs
         )
 
-    @classmethod
-    def _models_dict(cls, api_version):
-        return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
-
-    @classmethod
-    def models(cls, api_version=DEFAULT_API_VERSION):
-        """Module depends on the API version:
-
-           * 2016-01-01: :mod:`v2016_01_01.models<azure.mgmt.storage.v2016_01_01.models>`
-           * 2017-10-01: :mod:`v2017_10_01.models<azure.mgmt.storage.v2017_10_01.models>`
-           * 2019-06-01: :mod:`v2019_06_01.models<azure.mgmt.storage.v2019_06_01.models>`
-           * 2024-01-01: :mod:`v2024_01_01.models<azure.mgmt.storage.v2024_01_01.models>`
-        """
-        if api_version == '2016-01-01':
-            from ..v2016_01_01 import models
-            return models
-        elif api_version == '2017-10-01':
-            from ..v2017_10_01 import models
-            return models
-        elif api_version == '2019-06-01':
-            from ..v2019_06_01 import models
-            return models
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01 import models
-            return models
-        raise ValueError("API version {} is not available".format(api_version))
-
-    @property
-    def blob_containers(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2019_06_01.aio.operations.BlobContainersOperations>`
-           * 2024-01-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2024_01_01.aio.operations.BlobContainersOperations>`
-        """
-        api_version = self._get_api_version('blob_containers')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import BlobContainersOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import BlobContainersOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'blob_containers'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def blob_inventory_policies(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.BlobInventoryPoliciesOperations>`
-           * 2024-01-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.BlobInventoryPoliciesOperations>`
-        """
-        api_version = self._get_api_version('blob_inventory_policies')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import BlobInventoryPoliciesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import BlobInventoryPoliciesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'blob_inventory_policies'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def blob_services(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.BlobServicesOperations>`
-           * 2024-01-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.BlobServicesOperations>`
-        """
-        api_version = self._get_api_version('blob_services')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import BlobServicesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import BlobServicesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'blob_services'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def deleted_accounts(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2024_01_01.aio.operations.DeletedAccountsOperations>`
-        """
-        api_version = self._get_api_version('deleted_accounts')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import DeletedAccountsOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'deleted_accounts'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def encryption_scopes(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.EncryptionScopesOperations>`
-           * 2024-01-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.EncryptionScopesOperations>`
-        """
-        api_version = self._get_api_version('encryption_scopes')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import EncryptionScopesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import EncryptionScopesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'encryption_scopes'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def file_services(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`FileServicesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.FileServicesOperations>`
-           * 2024-01-01: :class:`FileServicesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.FileServicesOperations>`
-        """
-        api_version = self._get_api_version('file_services')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import FileServicesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import FileServicesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'file_services'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def file_shares(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`FileSharesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.FileSharesOperations>`
-           * 2024-01-01: :class:`FileSharesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.FileSharesOperations>`
-        """
-        api_version = self._get_api_version('file_shares')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import FileSharesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import FileSharesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'file_shares'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def local_users(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2024_01_01.aio.operations.LocalUsersOperations>`
-        """
-        api_version = self._get_api_version('local_users')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import LocalUsersOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'local_users'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def management_policies(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.ManagementPoliciesOperations>`
-           * 2024-01-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.ManagementPoliciesOperations>`
-        """
-        api_version = self._get_api_version('management_policies')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import ManagementPoliciesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import ManagementPoliciesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'management_policies'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def network_security_perimeter_configurations(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`NetworkSecurityPerimeterConfigurationsOperations<azure.mgmt.storage.v2024_01_01.aio.operations.NetworkSecurityPerimeterConfigurationsOperations>`
-        """
-        api_version = self._get_api_version('network_security_perimeter_configurations')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import NetworkSecurityPerimeterConfigurationsOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'network_security_perimeter_configurations'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def object_replication_policies(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.ObjectReplicationPoliciesOperations>`
-           * 2024-01-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.ObjectReplicationPoliciesOperations>`
-        """
-        api_version = self._get_api_version('object_replication_policies')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import ObjectReplicationPoliciesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import ObjectReplicationPoliciesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'object_replication_policies'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def operations(self):
-        """Instance depends on the API version:
-
-           * 2017-10-01: :class:`Operations<azure.mgmt.storage.v2017_10_01.aio.operations.Operations>`
-           * 2019-06-01: :class:`Operations<azure.mgmt.storage.v2019_06_01.aio.operations.Operations>`
-           * 2024-01-01: :class:`Operations<azure.mgmt.storage.v2024_01_01.aio.operations.Operations>`
-        """
-        api_version = self._get_api_version('operations')
-        if api_version == '2017-10-01':
-            from ..v2017_10_01.aio.operations import Operations as OperationClass
-        elif api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import Operations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import Operations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'operations'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def private_endpoint_connections(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2019_06_01.aio.operations.PrivateEndpointConnectionsOperations>`
-           * 2024-01-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2024_01_01.aio.operations.PrivateEndpointConnectionsOperations>`
-        """
-        api_version = self._get_api_version('private_endpoint_connections')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'private_endpoint_connections'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def private_link_resources(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.PrivateLinkResourcesOperations>`
-           * 2024-01-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.PrivateLinkResourcesOperations>`
-        """
-        api_version = self._get_api_version('private_link_resources')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import PrivateLinkResourcesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import PrivateLinkResourcesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'private_link_resources'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def queue(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`QueueOperations<azure.mgmt.storage.v2019_06_01.aio.operations.QueueOperations>`
-           * 2024-01-01: :class:`QueueOperations<azure.mgmt.storage.v2024_01_01.aio.operations.QueueOperations>`
-        """
-        api_version = self._get_api_version('queue')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import QueueOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import QueueOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'queue'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def queue_services(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.QueueServicesOperations>`
-           * 2024-01-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.QueueServicesOperations>`
-        """
-        api_version = self._get_api_version('queue_services')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import QueueServicesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import QueueServicesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'queue_services'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def skus(self):
-        """Instance depends on the API version:
-
-           * 2017-10-01: :class:`SkusOperations<azure.mgmt.storage.v2017_10_01.aio.operations.SkusOperations>`
-           * 2019-06-01: :class:`SkusOperations<azure.mgmt.storage.v2019_06_01.aio.operations.SkusOperations>`
-           * 2024-01-01: :class:`SkusOperations<azure.mgmt.storage.v2024_01_01.aio.operations.SkusOperations>`
-        """
-        api_version = self._get_api_version('skus')
-        if api_version == '2017-10-01':
-            from ..v2017_10_01.aio.operations import SkusOperations as OperationClass
-        elif api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import SkusOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import SkusOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'skus'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def storage_accounts(self):
-        """Instance depends on the API version:
-
-           * 2016-01-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2016_01_01.aio.operations.StorageAccountsOperations>`
-           * 2017-10-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2017_10_01.aio.operations.StorageAccountsOperations>`
-           * 2019-06-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2019_06_01.aio.operations.StorageAccountsOperations>`
-           * 2024-01-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2024_01_01.aio.operations.StorageAccountsOperations>`
-        """
-        api_version = self._get_api_version('storage_accounts')
-        if api_version == '2016-01-01':
-            from ..v2016_01_01.aio.operations import StorageAccountsOperations as OperationClass
-        elif api_version == '2017-10-01':
-            from ..v2017_10_01.aio.operations import StorageAccountsOperations as OperationClass
-        elif api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import StorageAccountsOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import StorageAccountsOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'storage_accounts'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def storage_task_assignment_instances_report(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`StorageTaskAssignmentInstancesReportOperations<azure.mgmt.storage.v2024_01_01.aio.operations.StorageTaskAssignmentInstancesReportOperations>`
-        """
-        api_version = self._get_api_version('storage_task_assignment_instances_report')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import StorageTaskAssignmentInstancesReportOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'storage_task_assignment_instances_report'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def storage_task_assignments(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`StorageTaskAssignmentsOperations<azure.mgmt.storage.v2024_01_01.aio.operations.StorageTaskAssignmentsOperations>`
-        """
-        api_version = self._get_api_version('storage_task_assignments')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import StorageTaskAssignmentsOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'storage_task_assignments'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def storage_task_assignments_instances_report(self):
-        """Instance depends on the API version:
-
-           * 2024-01-01: :class:`StorageTaskAssignmentsInstancesReportOperations<azure.mgmt.storage.v2024_01_01.aio.operations.StorageTaskAssignmentsInstancesReportOperations>`
-        """
-        api_version = self._get_api_version('storage_task_assignments_instances_report')
-        if api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import StorageTaskAssignmentsInstancesReportOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'storage_task_assignments_instances_report'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def table(self):
-        """Instance depends on the API version:
-
-           * 2019-06-01: :class:`TableOperations<azure.mgmt.storage.v2019_06_01.aio.operations.TableOperations>`
-           * 2024-01-01: :class:`TableOperations<azure.mgmt.storage.v2024_01_01.aio.operations.TableOperations>`
-        """
-        api_version = self._get_api_version('table')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import TableOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import TableOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'table'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
+        client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)}
+        self._serialize = Serializer(client_models)
+        self._deserialize = Deserializer(client_models)
+        self._serialize.client_side_validation = False
+        self.blob_services = BlobServicesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.blob_containers = BlobContainersOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.file_services = FileServicesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.file_shares = FileSharesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.queue_services = QueueServicesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.queue = QueueOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.operations = Operations(self._client, self._config, self._serialize, self._deserialize)
+        self.skus = SkusOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.storage_accounts = StorageAccountsOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.deleted_accounts = DeletedAccountsOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.usages = UsagesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.management_policies = ManagementPoliciesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.blob_inventory_policies = BlobInventoryPoliciesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.private_endpoint_connections = PrivateEndpointConnectionsOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.private_link_resources = PrivateLinkResourcesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.object_replication_policies = ObjectReplicationPoliciesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.local_users = LocalUsersOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.encryption_scopes = EncryptionScopesOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.table_services = TableServicesOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.table = TableOperations(self._client, self._config, self._serialize, self._deserialize)
+        self.network_security_perimeter_configurations = NetworkSecurityPerimeterConfigurationsOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.storage_task_assignments = StorageTaskAssignmentsOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.storage_task_assignments_instances_report = StorageTaskAssignmentsInstancesReportOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
+        self.storage_task_assignment_instances_report = StorageTaskAssignmentInstancesReportOperations(
+            self._client, self._config, self._serialize, self._deserialize
+        )
 
-    @property
-    def table_services(self):
-        """Instance depends on the API version:
+    def _send_request(
+        self, request: HttpRequest, *, stream: bool = False, **kwargs: Any
+    ) -> Awaitable[AsyncHttpResponse]:
+        """Runs the network request through the client's chained policies.
 
-           * 2019-06-01: :class:`TableServicesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.TableServicesOperations>`
-           * 2024-01-01: :class:`TableServicesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.TableServicesOperations>`
-        """
-        api_version = self._get_api_version('table_services')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import TableServicesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import TableServicesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'table_services'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
+        >>> from azure.core.rest import HttpRequest
+        >>> request = HttpRequest("GET", "https://www.example.org/")
+        <HttpRequest [GET], url: 'https://www.example.org/'>
+        >>> response = await client._send_request(request)
+        <AsyncHttpResponse: 200 OK>
 
-    @property
-    def usage(self):
-        """Instance depends on the API version:
+        For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request
 
-           * 2016-01-01: :class:`UsageOperations<azure.mgmt.storage.v2016_01_01.aio.operations.UsageOperations>`
-           * 2017-10-01: :class:`UsageOperations<azure.mgmt.storage.v2017_10_01.aio.operations.UsageOperations>`
+        :param request: The network request you want to make. Required.
+        :type request: ~azure.core.rest.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.rest.AsyncHttpResponse
         """
-        api_version = self._get_api_version('usage')
-        if api_version == '2016-01-01':
-            from ..v2016_01_01.aio.operations import UsageOperations as OperationClass
-        elif api_version == '2017-10-01':
-            from ..v2017_10_01.aio.operations import UsageOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'usage'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
-
-    @property
-    def usages(self):
-        """Instance depends on the API version:
 
-           * 2019-06-01: :class:`UsagesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.UsagesOperations>`
-           * 2024-01-01: :class:`UsagesOperations<azure.mgmt.storage.v2024_01_01.aio.operations.UsagesOperations>`
-        """
-        api_version = self._get_api_version('usages')
-        if api_version == '2019-06-01':
-            from ..v2019_06_01.aio.operations import UsagesOperations as OperationClass
-        elif api_version == '2024-01-01':
-            from ..v2024_01_01.aio.operations import UsagesOperations as OperationClass
-        else:
-            raise ValueError("API version {} does not have operation group 'usages'".format(api_version))
-        self._config.api_version = api_version
-        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
+        request_copy = deepcopy(request)
+        request_copy.url = self._client.format_url(request_copy.url)
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
 
-    async def close(self):
+    async def close(self) -> None:
         await self._client.close()
-    async def __aenter__(self):
+
+    async def __aenter__(self) -> Self:
         await self._client.__aenter__()
         return self
-    async def __aexit__(self, *exc_details):
+
+    async def __aexit__(self, *exc_details: Any) -> None:
         await self._client.__aexit__(*exc_details)