azure-mgmt-storage 21.1.0b1__py3-none-any.whl → 21.2.1__py3-none-any.whl

azure/mgmt/storage/aio/_storage_management_client.py

@@ -11,7 +11,9 @@
 
 from typing import Any, Optional, TYPE_CHECKING
 
+from azure.core.pipeline import policies
 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
 
@@ -53,7 +55,7 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
     :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
     """
 
-    DEFAULT_API_VERSION = '2022-09-01'
+    DEFAULT_API_VERSION = '2023-05-01'
     _PROFILE_TAG = "azure.mgmt.storage.StorageManagementClient"
     LATEST_PROFILE = ProfileDefinition({
         _PROFILE_TAG: {
@@ -72,8 +74,28 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
         profile: KnownProfiles = KnownProfiles.default,
         **kwargs: Any
     ) -> None:
+        if api_version:
+            kwargs.setdefault('api_version', api_version)
         self._config = StorageManagementClientConfiguration(credential, subscription_id, **kwargs)
-        self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+        _policies = kwargs.pop("policies", None)
+        if _policies is None:
+            _policies = [
+                policies.RequestIdPolicy(**kwargs),
+                self._config.headers_policy,
+                self._config.user_agent_policy,
+                self._config.proxy_policy,
+                policies.ContentDecodePolicy(**kwargs),
+                AsyncARMAutoResourceProviderRegistrationPolicy(),
+                self._config.redirect_policy,
+                self._config.retry_policy,
+                self._config.authentication_policy,
+                self._config.custom_hook_policy,
+                self._config.logging_policy,
+                policies.DistributedTracingPolicy(**kwargs),
+                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
+                self._config.http_logging_policy,
+            ]
+        self._client = AsyncARMPipelineClient(base_url=base_url, policies=_policies, **kwargs)
         super(StorageManagementClient, self).__init__(
             api_version=api_version,
             profile=profile
@@ -107,6 +129,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :mod:`v2021_09_01.models<azure.mgmt.storage.v2021_09_01.models>`
            * 2022-05-01: :mod:`v2022_05_01.models<azure.mgmt.storage.v2022_05_01.models>`
            * 2022-09-01: :mod:`v2022_09_01.models<azure.mgmt.storage.v2022_09_01.models>`
+           * 2023-01-01: :mod:`v2023_01_01.models<azure.mgmt.storage.v2023_01_01.models>`
+           * 2023-05-01: :mod:`v2023_05_01.models<azure.mgmt.storage.v2023_05_01.models>`
         """
         if api_version == '2015-06-15':
             from ..v2015_06_15 import models
@@ -168,6 +192,12 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
         elif api_version == '2022-09-01':
             from ..v2022_09_01 import models
             return models
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01 import models
+            return models
+        elif api_version == '2023-05-01':
+            from ..v2023_05_01 import models
+            return models
         raise ValueError("API version {} is not available".format(api_version))
 
     @property
@@ -189,6 +219,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2021_09_01.aio.operations.BlobContainersOperations>`
            * 2022-05-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2022_05_01.aio.operations.BlobContainersOperations>`
            * 2022-09-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2022_09_01.aio.operations.BlobContainersOperations>`
+           * 2023-01-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2023_01_01.aio.operations.BlobContainersOperations>`
+           * 2023-05-01: :class:`BlobContainersOperations<azure.mgmt.storage.v2023_05_01.aio.operations.BlobContainersOperations>`
         """
         api_version = self._get_api_version('blob_containers')
         if api_version == '2018-02-01':
@@ -221,10 +253,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import BlobContainersOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import BlobContainersOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import BlobContainersOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -240,6 +276,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.BlobInventoryPoliciesOperations>`
            * 2022-05-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.BlobInventoryPoliciesOperations>`
            * 2022-09-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.BlobInventoryPoliciesOperations>`
+           * 2023-01-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.BlobInventoryPoliciesOperations>`
+           * 2023-05-01: :class:`BlobInventoryPoliciesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.BlobInventoryPoliciesOperations>`
         """
         api_version = self._get_api_version('blob_inventory_policies')
         if api_version == '2019-06-01':
@@ -262,10 +300,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import BlobInventoryPoliciesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import BlobInventoryPoliciesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import BlobInventoryPoliciesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -284,6 +326,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.BlobServicesOperations>`
            * 2022-05-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.BlobServicesOperations>`
            * 2022-09-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.BlobServicesOperations>`
+           * 2023-01-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.BlobServicesOperations>`
+           * 2023-05-01: :class:`BlobServicesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.BlobServicesOperations>`
         """
         api_version = self._get_api_version('blob_services')
         if api_version == '2018-07-01':
@@ -312,10 +356,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import BlobServicesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import BlobServicesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import BlobServicesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -330,6 +378,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2021_09_01.aio.operations.DeletedAccountsOperations>`
            * 2022-05-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2022_05_01.aio.operations.DeletedAccountsOperations>`
            * 2022-09-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2022_09_01.aio.operations.DeletedAccountsOperations>`
+           * 2023-01-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2023_01_01.aio.operations.DeletedAccountsOperations>`
+           * 2023-05-01: :class:`DeletedAccountsOperations<azure.mgmt.storage.v2023_05_01.aio.operations.DeletedAccountsOperations>`
         """
         api_version = self._get_api_version('deleted_accounts')
         if api_version == '2020-08-01-preview':
@@ -350,10 +400,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import DeletedAccountsOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import DeletedAccountsOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import DeletedAccountsOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -369,6 +423,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.EncryptionScopesOperations>`
            * 2022-05-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.EncryptionScopesOperations>`
            * 2022-09-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.EncryptionScopesOperations>`
+           * 2023-01-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.EncryptionScopesOperations>`
+           * 2023-05-01: :class:`EncryptionScopesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.EncryptionScopesOperations>`
         """
         api_version = self._get_api_version('encryption_scopes')
         if api_version == '2019-06-01':
@@ -391,10 +447,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import EncryptionScopesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import EncryptionScopesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import EncryptionScopesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -411,6 +471,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`FileServicesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.FileServicesOperations>`
            * 2022-05-01: :class:`FileServicesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.FileServicesOperations>`
            * 2022-09-01: :class:`FileServicesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.FileServicesOperations>`
+           * 2023-01-01: :class:`FileServicesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.FileServicesOperations>`
+           * 2023-05-01: :class:`FileServicesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.FileServicesOperations>`
         """
         api_version = self._get_api_version('file_services')
         if api_version == '2019-04-01':
@@ -435,10 +497,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import FileServicesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import FileServicesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import FileServicesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -455,6 +521,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`FileSharesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.FileSharesOperations>`
            * 2022-05-01: :class:`FileSharesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.FileSharesOperations>`
            * 2022-09-01: :class:`FileSharesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.FileSharesOperations>`
+           * 2023-01-01: :class:`FileSharesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.FileSharesOperations>`
+           * 2023-05-01: :class:`FileSharesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.FileSharesOperations>`
         """
         api_version = self._get_api_version('file_shares')
         if api_version == '2019-04-01':
@@ -479,10 +547,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import FileSharesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import FileSharesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import FileSharesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -492,6 +564,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2021_09_01.aio.operations.LocalUsersOperations>`
            * 2022-05-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2022_05_01.aio.operations.LocalUsersOperations>`
            * 2022-09-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2022_09_01.aio.operations.LocalUsersOperations>`
+           * 2023-01-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2023_01_01.aio.operations.LocalUsersOperations>`
+           * 2023-05-01: :class:`LocalUsersOperations<azure.mgmt.storage.v2023_05_01.aio.operations.LocalUsersOperations>`
         """
         api_version = self._get_api_version('local_users')
         if api_version == '2021-08-01':
@@ -502,16 +576,20 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import LocalUsersOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import LocalUsersOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import LocalUsersOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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:
 
-           * 2018-07-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_07_01.aio.operations.ManagementPoliciesOperations>`
+           * 2018-03-01-preview: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_03_01_preview.aio.operations.ManagementPoliciesOperations>`
            * 2018-11-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2018_11_01.aio.operations.ManagementPoliciesOperations>`
            * 2019-04-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_04_01.aio.operations.ManagementPoliciesOperations>`
            * 2019-06-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2019_06_01.aio.operations.ManagementPoliciesOperations>`
@@ -524,10 +602,12 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.ManagementPoliciesOperations>`
            * 2022-05-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.ManagementPoliciesOperations>`
            * 2022-09-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.ManagementPoliciesOperations>`
+           * 2023-01-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.ManagementPoliciesOperations>`
+           * 2023-05-01: :class:`ManagementPoliciesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.ManagementPoliciesOperations>`
         """
         api_version = self._get_api_version('management_policies')
-        if api_version == '2018-07-01':
-            from ..v2018_07_01.aio.operations import ManagementPoliciesOperations as OperationClass
+        if api_version == '2018-03-01-preview':
+            from ..v2018_03_01_preview.aio.operations import ManagementPoliciesOperations as OperationClass
         elif api_version == '2018-11-01':
             from ..v2018_11_01.aio.operations import ManagementPoliciesOperations as OperationClass
         elif api_version == '2019-04-01':
@@ -552,10 +632,28 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import ManagementPoliciesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import ManagementPoliciesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import ManagementPoliciesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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:
+
+           * 2023-05-01: :class:`NetworkSecurityPerimeterConfigurationsOperations<azure.mgmt.storage.v2023_05_01.aio.operations.NetworkSecurityPerimeterConfigurationsOperations>`
+        """
+        api_version = self._get_api_version('network_security_perimeter_configurations')
+        if api_version == '2023-05-01':
+            from ..v2023_05_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):
@@ -571,6 +669,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.ObjectReplicationPoliciesOperations>`
            * 2022-05-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.ObjectReplicationPoliciesOperations>`
            * 2022-09-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.ObjectReplicationPoliciesOperations>`
+           * 2023-01-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.ObjectReplicationPoliciesOperations>`
+           * 2023-05-01: :class:`ObjectReplicationPoliciesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.ObjectReplicationPoliciesOperations>`
         """
         api_version = self._get_api_version('object_replication_policies')
         if api_version == '2019-06-01':
@@ -593,10 +693,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import ObjectReplicationPoliciesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import ObjectReplicationPoliciesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import ObjectReplicationPoliciesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def operations(self):
@@ -619,6 +723,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`Operations<azure.mgmt.storage.v2021_09_01.aio.operations.Operations>`
            * 2022-05-01: :class:`Operations<azure.mgmt.storage.v2022_05_01.aio.operations.Operations>`
            * 2022-09-01: :class:`Operations<azure.mgmt.storage.v2022_09_01.aio.operations.Operations>`
+           * 2023-01-01: :class:`Operations<azure.mgmt.storage.v2023_01_01.aio.operations.Operations>`
+           * 2023-05-01: :class:`Operations<azure.mgmt.storage.v2023_05_01.aio.operations.Operations>`
         """
         api_version = self._get_api_version('operations')
         if api_version == '2017-06-01':
@@ -655,10 +761,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import Operations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import Operations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import Operations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -674,6 +784,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2021_09_01.aio.operations.PrivateEndpointConnectionsOperations>`
            * 2022-05-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2022_05_01.aio.operations.PrivateEndpointConnectionsOperations>`
            * 2022-09-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2022_09_01.aio.operations.PrivateEndpointConnectionsOperations>`
+           * 2023-01-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2023_01_01.aio.operations.PrivateEndpointConnectionsOperations>`
+           * 2023-05-01: :class:`PrivateEndpointConnectionsOperations<azure.mgmt.storage.v2023_05_01.aio.operations.PrivateEndpointConnectionsOperations>`
         """
         api_version = self._get_api_version('private_endpoint_connections')
         if api_version == '2019-06-01':
@@ -696,10 +808,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import PrivateEndpointConnectionsOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -715,6 +831,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.PrivateLinkResourcesOperations>`
            * 2022-05-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.PrivateLinkResourcesOperations>`
            * 2022-09-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.PrivateLinkResourcesOperations>`
+           * 2023-01-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.PrivateLinkResourcesOperations>`
+           * 2023-05-01: :class:`PrivateLinkResourcesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.PrivateLinkResourcesOperations>`
         """
         api_version = self._get_api_version('private_link_resources')
         if api_version == '2019-06-01':
@@ -737,10 +855,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import PrivateLinkResourcesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import PrivateLinkResourcesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import PrivateLinkResourcesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def queue(self):
@@ -756,6 +878,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`QueueOperations<azure.mgmt.storage.v2021_09_01.aio.operations.QueueOperations>`
            * 2022-05-01: :class:`QueueOperations<azure.mgmt.storage.v2022_05_01.aio.operations.QueueOperations>`
            * 2022-09-01: :class:`QueueOperations<azure.mgmt.storage.v2022_09_01.aio.operations.QueueOperations>`
+           * 2023-01-01: :class:`QueueOperations<azure.mgmt.storage.v2023_01_01.aio.operations.QueueOperations>`
+           * 2023-05-01: :class:`QueueOperations<azure.mgmt.storage.v2023_05_01.aio.operations.QueueOperations>`
         """
         api_version = self._get_api_version('queue')
         if api_version == '2019-06-01':
@@ -778,10 +902,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import QueueOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import QueueOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import QueueOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -797,6 +925,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.QueueServicesOperations>`
            * 2022-05-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.QueueServicesOperations>`
            * 2022-09-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.QueueServicesOperations>`
+           * 2023-01-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.QueueServicesOperations>`
+           * 2023-05-01: :class:`QueueServicesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.QueueServicesOperations>`
         """
         api_version = self._get_api_version('queue_services')
         if api_version == '2019-06-01':
@@ -819,10 +949,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import QueueServicesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import QueueServicesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import QueueServicesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def skus(self):
@@ -845,6 +979,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`SkusOperations<azure.mgmt.storage.v2021_09_01.aio.operations.SkusOperations>`
            * 2022-05-01: :class:`SkusOperations<azure.mgmt.storage.v2022_05_01.aio.operations.SkusOperations>`
            * 2022-09-01: :class:`SkusOperations<azure.mgmt.storage.v2022_09_01.aio.operations.SkusOperations>`
+           * 2023-01-01: :class:`SkusOperations<azure.mgmt.storage.v2023_01_01.aio.operations.SkusOperations>`
+           * 2023-05-01: :class:`SkusOperations<azure.mgmt.storage.v2023_05_01.aio.operations.SkusOperations>`
         """
         api_version = self._get_api_version('skus')
         if api_version == '2017-06-01':
@@ -881,10 +1017,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import SkusOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import SkusOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import SkusOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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):
@@ -910,6 +1050,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2021_09_01.aio.operations.StorageAccountsOperations>`
            * 2022-05-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2022_05_01.aio.operations.StorageAccountsOperations>`
            * 2022-09-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2022_09_01.aio.operations.StorageAccountsOperations>`
+           * 2023-01-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2023_01_01.aio.operations.StorageAccountsOperations>`
+           * 2023-05-01: :class:`StorageAccountsOperations<azure.mgmt.storage.v2023_05_01.aio.operations.StorageAccountsOperations>`
         """
         api_version = self._get_api_version('storage_accounts')
         if api_version == '2015-06-15':
@@ -952,10 +1094,56 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import StorageAccountsOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import StorageAccountsOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import StorageAccountsOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        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:
+
+           * 2023-05-01: :class:`StorageTaskAssignmentInstancesReportOperations<azure.mgmt.storage.v2023_05_01.aio.operations.StorageTaskAssignmentInstancesReportOperations>`
+        """
+        api_version = self._get_api_version('storage_task_assignment_instances_report')
+        if api_version == '2023-05-01':
+            from ..v2023_05_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:
+
+           * 2023-05-01: :class:`StorageTaskAssignmentsOperations<azure.mgmt.storage.v2023_05_01.aio.operations.StorageTaskAssignmentsOperations>`
+        """
+        api_version = self._get_api_version('storage_task_assignments')
+        if api_version == '2023-05-01':
+            from ..v2023_05_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:
+
+           * 2023-05-01: :class:`StorageTaskAssignmentsInstancesReportOperations<azure.mgmt.storage.v2023_05_01.aio.operations.StorageTaskAssignmentsInstancesReportOperations>`
+        """
+        api_version = self._get_api_version('storage_task_assignments_instances_report')
+        if api_version == '2023-05-01':
+            from ..v2023_05_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):
@@ -971,6 +1159,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`TableOperations<azure.mgmt.storage.v2021_09_01.aio.operations.TableOperations>`
            * 2022-05-01: :class:`TableOperations<azure.mgmt.storage.v2022_05_01.aio.operations.TableOperations>`
            * 2022-09-01: :class:`TableOperations<azure.mgmt.storage.v2022_09_01.aio.operations.TableOperations>`
+           * 2023-01-01: :class:`TableOperations<azure.mgmt.storage.v2023_01_01.aio.operations.TableOperations>`
+           * 2023-05-01: :class:`TableOperations<azure.mgmt.storage.v2023_05_01.aio.operations.TableOperations>`
         """
         api_version = self._get_api_version('table')
         if api_version == '2019-06-01':
@@ -993,10 +1183,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import TableOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import TableOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import TableOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def table_services(self):
@@ -1012,6 +1206,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`TableServicesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.TableServicesOperations>`
            * 2022-05-01: :class:`TableServicesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.TableServicesOperations>`
            * 2022-09-01: :class:`TableServicesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.TableServicesOperations>`
+           * 2023-01-01: :class:`TableServicesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.TableServicesOperations>`
+           * 2023-05-01: :class:`TableServicesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.TableServicesOperations>`
         """
         api_version = self._get_api_version('table_services')
         if api_version == '2019-06-01':
@@ -1034,10 +1230,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import TableServicesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import TableServicesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import TableServicesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def usage(self):
@@ -1066,7 +1266,7 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
         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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     @property
     def usages(self):
@@ -1086,6 +1286,8 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
            * 2021-09-01: :class:`UsagesOperations<azure.mgmt.storage.v2021_09_01.aio.operations.UsagesOperations>`
            * 2022-05-01: :class:`UsagesOperations<azure.mgmt.storage.v2022_05_01.aio.operations.UsagesOperations>`
            * 2022-09-01: :class:`UsagesOperations<azure.mgmt.storage.v2022_09_01.aio.operations.UsagesOperations>`
+           * 2023-01-01: :class:`UsagesOperations<azure.mgmt.storage.v2023_01_01.aio.operations.UsagesOperations>`
+           * 2023-05-01: :class:`UsagesOperations<azure.mgmt.storage.v2023_05_01.aio.operations.UsagesOperations>`
         """
         api_version = self._get_api_version('usages')
         if api_version == '2018-03-01-preview':
@@ -1116,10 +1318,14 @@ class StorageManagementClient(MultiApiClientMixin, _SDKClient):
             from ..v2022_05_01.aio.operations import UsagesOperations as OperationClass
         elif api_version == '2022-09-01':
             from ..v2022_09_01.aio.operations import UsagesOperations as OperationClass
+        elif api_version == '2023-01-01':
+            from ..v2023_01_01.aio.operations import UsagesOperations as OperationClass
+        elif api_version == '2023-05-01':
+            from ..v2023_05_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)))
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)), api_version)
 
     async def close(self):
         await self._client.close()