text: # 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.
  # Code generated by Microsoft (R) AutoRest Code Generator.
  # Changes may cause incorrect behavior and will be lost if the code is regenerated.
  # --------------------------------------------------------------------------
  
  import datetime
  from typing import Dict, List, Optional, Union
  
  from azure.core.exceptions import HttpResponseError
  import msrest.serialization
  
  from ._storage_management_client_enums import *
  
  
  class AccountSasParameters(msrest.serialization.Model):
      """The parameters to list SAS credentials of a storage account.
  
      All required parameters must be populated in order to send to Azure.
  
      :param services: Required. The signed services accessible with the account SAS. Possible values
       include: Blob (b), Queue (q), Table (t), File (f). Possible values include: "b", "q", "t", "f".
      :type services: str or ~azure.mgmt.storage.v2021_01_01.models.Services
      :param resource_types: Required. The signed resource types that are accessible with the account
       SAS. Service (s): Access to service-level APIs; Container (c): Access to container-level APIs;
       Object (o): Access to object-level APIs for blobs, queue messages, table entities, and files.
       Possible values include: "s", "c", "o".
      :type resource_types: str or ~azure.mgmt.storage.v2021_01_01.models.SignedResourceTypes
      :param permissions: Required. The signed permissions for the account SAS. Possible values
       include: Read (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process
       (p). Possible values include: "r", "d", "w", "l", "a", "c", "u", "p".
      :type permissions: str or ~azure.mgmt.storage.v2021_01_01.models.Permissions
      :param ip_address_or_range: An IP address or a range of IP addresses from which to accept
       requests.
      :type ip_address_or_range: str
      :param protocols: The protocol permitted for a request made with the account SAS. Possible
       values include: "https,http", "https".
      :type protocols: str or ~azure.mgmt.storage.v2021_01_01.models.HttpProtocol
      :param shared_access_start_time: The time at which the SAS becomes valid.
      :type shared_access_start_time: ~datetime.datetime
      :param shared_access_expiry_time: Required. The time at which the shared access signature
       becomes invalid.
      :type shared_access_expiry_time: ~datetime.datetime
      :param key_to_sign: The key to sign the account SAS token with.
      :type key_to_sign: str
      """
  
      _validation = {
          'services': {'required': True},
          'resource_types': {'required': True},
          'permissions': {'required': True},
          'shared_access_expiry_time': {'required': True},
      }
  
      _attribute_map = {
          'services': {'key': 'signedServices', 'type': 'str'},
          'resource_types': {'key': 'signedResourceTypes', 'type': 'str'},
          'permissions': {'key': 'signedPermission', 'type': 'str'},
          'ip_address_or_range': {'key': 'signedIp', 'type': 'str'},
          'protocols': {'key': 'signedProtocol', 'type': 'str'},
          'shared_access_start_time': {'key': 'signedStart', 'type': 'iso-8601'},
          'shared_access_expiry_time': {'key': 'signedExpiry', 'type': 'iso-8601'},
          'key_to_sign': {'key': 'keyToSign', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          services: Union[str, "Services"],
          resource_types: Union[str, "SignedResourceTypes"],
          permissions: Union[str, "Permissions"],
          shared_access_expiry_time: datetime.datetime,
          ip_address_or_range: Optional[str] = None,
          protocols: Optional[Union[str, "HttpProtocol"]] = None,
          shared_access_start_time: Optional[datetime.datetime] = None,
          key_to_sign: Optional[str] = None,
          **kwargs
      ):
          super(AccountSasParameters, self).__init__(**kwargs)
          self.services = services
          self.resource_types = resource_types
          self.permissions = permissions
          self.ip_address_or_range = ip_address_or_range
          self.protocols = protocols
          self.shared_access_start_time = shared_access_start_time
          self.shared_access_expiry_time = shared_access_expiry_time
          self.key_to_sign = key_to_sign
  
  
  class ActiveDirectoryProperties(msrest.serialization.Model):
      """Settings properties for Active Directory (AD).
  
      All required parameters must be populated in order to send to Azure.
  
      :param domain_name: Required. Specifies the primary domain that the AD DNS server is
       authoritative for.
      :type domain_name: str
      :param net_bios_domain_name: Required. Specifies the NetBIOS domain name.
      :type net_bios_domain_name: str
      :param forest_name: Required. Specifies the Active Directory forest to get.
      :type forest_name: str
      :param domain_guid: Required. Specifies the domain GUID.
      :type domain_guid: str
      :param domain_sid: Required. Specifies the security identifier (SID).
      :type domain_sid: str
      :param azure_storage_sid: Required. Specifies the security identifier (SID) for Azure Storage.
      :type azure_storage_sid: str
      """
  
      _validation = {
          'domain_name': {'required': True},
          'net_bios_domain_name': {'required': True},
          'forest_name': {'required': True},
          'domain_guid': {'required': True},
          'domain_sid': {'required': True},
          'azure_storage_sid': {'required': True},
      }
  
      _attribute_map = {
          'domain_name': {'key': 'domainName', 'type': 'str'},
          'net_bios_domain_name': {'key': 'netBiosDomainName', 'type': 'str'},
          'forest_name': {'key': 'forestName', 'type': 'str'},
          'domain_guid': {'key': 'domainGuid', 'type': 'str'},
          'domain_sid': {'key': 'domainSid', 'type': 'str'},
          'azure_storage_sid': {'key': 'azureStorageSid', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          domain_name: str,
          net_bios_domain_name: str,
          forest_name: str,
          domain_guid: str,
          domain_sid: str,
          azure_storage_sid: str,
          **kwargs
      ):
          super(ActiveDirectoryProperties, self).__init__(**kwargs)
          self.domain_name = domain_name
          self.net_bios_domain_name = net_bios_domain_name
          self.forest_name = forest_name
          self.domain_guid = domain_guid
          self.domain_sid = domain_sid
          self.azure_storage_sid = azure_storage_sid
  
  
  class Resource(msrest.serialization.Model):
      """Common fields that are returned in the response for all Azure Resource Manager resources.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(Resource, self).__init__(**kwargs)
          self.id = None
          self.name = None
          self.type = None
  
  
  class AzureEntityResource(Resource):
      """The resource model definition for an Azure Resource Manager resource with an etag.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(AzureEntityResource, self).__init__(**kwargs)
          self.etag = None
  
  
  class AzureFilesIdentityBasedAuthentication(msrest.serialization.Model):
      """Settings for Azure Files identity based authentication.
  
      All required parameters must be populated in order to send to Azure.
  
      :param directory_service_options: Required. Indicates the directory service used. Possible
       values include: "None", "AADDS", "AD".
      :type directory_service_options: str or
       ~azure.mgmt.storage.v2021_01_01.models.DirectoryServiceOptions
      :param active_directory_properties: Required if choose AD.
      :type active_directory_properties:
       ~azure.mgmt.storage.v2021_01_01.models.ActiveDirectoryProperties
      """
  
      _validation = {
          'directory_service_options': {'required': True},
      }
  
      _attribute_map = {
          'directory_service_options': {'key': 'directoryServiceOptions', 'type': 'str'},
          'active_directory_properties': {'key': 'activeDirectoryProperties', 'type': 'ActiveDirectoryProperties'},
      }
  
      def __init__(
          self,
          *,
          directory_service_options: Union[str, "DirectoryServiceOptions"],
          active_directory_properties: Optional["ActiveDirectoryProperties"] = None,
          **kwargs
      ):
          super(AzureFilesIdentityBasedAuthentication, self).__init__(**kwargs)
          self.directory_service_options = directory_service_options
          self.active_directory_properties = active_directory_properties
  
  
  class BlobContainer(AzureEntityResource):
      """Properties of the blob container, including Id, resource name, resource type, Etag.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      :ivar version: The version of the deleted blob container.
      :vartype version: str
      :ivar deleted: Indicates whether the blob container was deleted.
      :vartype deleted: bool
      :ivar deleted_time: Blob container deletion time.
      :vartype deleted_time: ~datetime.datetime
      :ivar remaining_retention_days: Remaining retention days for soft deleted blob container.
      :vartype remaining_retention_days: int
      :param default_encryption_scope: Default the container to use specified encryption scope for
       all writes.
      :type default_encryption_scope: str
      :param deny_encryption_scope_override: Block override of encryption scope from the container
       default.
      :type deny_encryption_scope_override: bool
      :param public_access: Specifies whether data in the container may be accessed publicly and the
       level of access. Possible values include: "Container", "Blob", "None".
      :type public_access: str or ~azure.mgmt.storage.v2021_01_01.models.PublicAccess
      :ivar last_modified_time: Returns the date and time the container was last modified.
      :vartype last_modified_time: ~datetime.datetime
      :ivar lease_status: The lease status of the container. Possible values include: "Locked",
       "Unlocked".
      :vartype lease_status: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseStatus
      :ivar lease_state: Lease state of the container. Possible values include: "Available",
       "Leased", "Expired", "Breaking", "Broken".
      :vartype lease_state: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseState
      :ivar lease_duration: Specifies whether the lease on a container is of infinite or fixed
       duration, only when the container is leased. Possible values include: "Infinite", "Fixed".
      :vartype lease_duration: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseDuration
      :param metadata: A name-value pair to associate with the container as metadata.
      :type metadata: dict[str, str]
      :ivar immutability_policy: The ImmutabilityPolicy property of the container.
      :vartype immutability_policy:
       ~azure.mgmt.storage.v2021_01_01.models.ImmutabilityPolicyProperties
      :ivar legal_hold: The LegalHold property of the container.
      :vartype legal_hold: ~azure.mgmt.storage.v2021_01_01.models.LegalHoldProperties
      :ivar has_legal_hold: The hasLegalHold public property is set to true by SRP if there are at
       least one existing tag. The hasLegalHold public property is set to false by SRP if all existing
       legal hold tags are cleared out. There can be a maximum of 1000 blob containers with
       hasLegalHold=true for a given account.
      :vartype has_legal_hold: bool
      :ivar has_immutability_policy: The hasImmutabilityPolicy public property is set to true by SRP
       if ImmutabilityPolicy has been created for this container. The hasImmutabilityPolicy public
       property is set to false by SRP if ImmutabilityPolicy has not been created for this container.
      :vartype has_immutability_policy: bool
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
          'version': {'readonly': True},
          'deleted': {'readonly': True},
          'deleted_time': {'readonly': True},
          'remaining_retention_days': {'readonly': True},
          'last_modified_time': {'readonly': True},
          'lease_status': {'readonly': True},
          'lease_state': {'readonly': True},
          'lease_duration': {'readonly': True},
          'immutability_policy': {'readonly': True},
          'legal_hold': {'readonly': True},
          'has_legal_hold': {'readonly': True},
          'has_immutability_policy': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
          'version': {'key': 'properties.version', 'type': 'str'},
          'deleted': {'key': 'properties.deleted', 'type': 'bool'},
          'deleted_time': {'key': 'properties.deletedTime', 'type': 'iso-8601'},
          'remaining_retention_days': {'key': 'properties.remainingRetentionDays', 'type': 'int'},
          'default_encryption_scope': {'key': 'properties.defaultEncryptionScope', 'type': 'str'},
          'deny_encryption_scope_override': {'key': 'properties.denyEncryptionScopeOverride', 'type': 'bool'},
          'public_access': {'key': 'properties.publicAccess', 'type': 'str'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'lease_status': {'key': 'properties.leaseStatus', 'type': 'str'},
          'lease_state': {'key': 'properties.leaseState', 'type': 'str'},
          'lease_duration': {'key': 'properties.leaseDuration', 'type': 'str'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
          'immutability_policy': {'key': 'properties.immutabilityPolicy', 'type': 'ImmutabilityPolicyProperties'},
          'legal_hold': {'key': 'properties.legalHold', 'type': 'LegalHoldProperties'},
          'has_legal_hold': {'key': 'properties.hasLegalHold', 'type': 'bool'},
          'has_immutability_policy': {'key': 'properties.hasImmutabilityPolicy', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          default_encryption_scope: Optional[str] = None,
          deny_encryption_scope_override: Optional[bool] = None,
          public_access: Optional[Union[str, "PublicAccess"]] = None,
          metadata: Optional[Dict[str, str]] = None,
          **kwargs
      ):
          super(BlobContainer, self).__init__(**kwargs)
          self.version = None
          self.deleted = None
          self.deleted_time = None
          self.remaining_retention_days = None
          self.default_encryption_scope = default_encryption_scope
          self.deny_encryption_scope_override = deny_encryption_scope_override
          self.public_access = public_access
          self.last_modified_time = None
          self.lease_status = None
          self.lease_state = None
          self.lease_duration = None
          self.metadata = metadata
          self.immutability_policy = None
          self.legal_hold = None
          self.has_legal_hold = None
          self.has_immutability_policy = None
  
  
  class BlobInventoryPolicy(Resource):
      """The storage account blob inventory policy.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar system_data: Metadata pertaining to creation and last modification of the resource.
      :vartype system_data: ~azure.mgmt.storage.v2021_01_01.models.SystemData
      :ivar last_modified_time: Returns the last modified date and time of the blob inventory policy.
      :vartype last_modified_time: ~datetime.datetime
      :param policy: The storage account blob inventory policy object. It is composed of policy
       rules.
      :type policy: ~azure.mgmt.storage.v2021_01_01.models.BlobInventoryPolicySchema
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'system_data': {'readonly': True},
          'last_modified_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'system_data': {'key': 'systemData', 'type': 'SystemData'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'policy': {'key': 'properties.policy', 'type': 'BlobInventoryPolicySchema'},
      }
  
      def __init__(
          self,
          *,
          policy: Optional["BlobInventoryPolicySchema"] = None,
          **kwargs
      ):
          super(BlobInventoryPolicy, self).__init__(**kwargs)
          self.system_data = None
          self.last_modified_time = None
          self.policy = policy
  
  
  class BlobInventoryPolicyDefinition(msrest.serialization.Model):
      """An object that defines the blob inventory rule. Each definition consists of a set of filters.
  
      All required parameters must be populated in order to send to Azure.
  
      :param filters: Required. An object that defines the filter set.
      :type filters: ~azure.mgmt.storage.v2021_01_01.models.BlobInventoryPolicyFilter
      """
  
      _validation = {
          'filters': {'required': True},
      }
  
      _attribute_map = {
          'filters': {'key': 'filters', 'type': 'BlobInventoryPolicyFilter'},
      }
  
      def __init__(
          self,
          *,
          filters: "BlobInventoryPolicyFilter",
          **kwargs
      ):
          super(BlobInventoryPolicyDefinition, self).__init__(**kwargs)
          self.filters = filters
  
  
  class BlobInventoryPolicyFilter(msrest.serialization.Model):
      """An object that defines the blob inventory rule filter conditions.
  
      All required parameters must be populated in order to send to Azure.
  
      :param prefix_match: An array of strings for blob prefixes to be matched.
      :type prefix_match: list[str]
      :param blob_types: Required. An array of predefined enum values. Valid values include
       blockBlob, appendBlob, pageBlob. Hns accounts does not support pageBlobs.
      :type blob_types: list[str]
      :param include_blob_versions: Includes blob versions in blob inventory when value set to true.
      :type include_blob_versions: bool
      :param include_snapshots: Includes blob snapshots in blob inventory when value set to true.
      :type include_snapshots: bool
      """
  
      _validation = {
          'blob_types': {'required': True},
      }
  
      _attribute_map = {
          'prefix_match': {'key': 'prefixMatch', 'type': '[str]'},
          'blob_types': {'key': 'blobTypes', 'type': '[str]'},
          'include_blob_versions': {'key': 'includeBlobVersions', 'type': 'bool'},
          'include_snapshots': {'key': 'includeSnapshots', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          blob_types: List[str],
          prefix_match: Optional[List[str]] = None,
          include_blob_versions: Optional[bool] = None,
          include_snapshots: Optional[bool] = None,
          **kwargs
      ):
          super(BlobInventoryPolicyFilter, self).__init__(**kwargs)
          self.prefix_match = prefix_match
          self.blob_types = blob_types
          self.include_blob_versions = include_blob_versions
          self.include_snapshots = include_snapshots
  
  
  class BlobInventoryPolicyRule(msrest.serialization.Model):
      """An object that wraps the blob inventory rule. Each rule is uniquely defined by name.
  
      All required parameters must be populated in order to send to Azure.
  
      :param enabled: Required. Rule is enabled when set to true.
      :type enabled: bool
      :param name: Required. A rule name can contain any combination of alpha numeric characters.
       Rule name is case-sensitive. It must be unique within a policy.
      :type name: str
      :param definition: Required. An object that defines the blob inventory policy rule.
      :type definition: ~azure.mgmt.storage.v2021_01_01.models.BlobInventoryPolicyDefinition
      """
  
      _validation = {
          'enabled': {'required': True},
          'name': {'required': True},
          'definition': {'required': True},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'name': {'key': 'name', 'type': 'str'},
          'definition': {'key': 'definition', 'type': 'BlobInventoryPolicyDefinition'},
      }
  
      def __init__(
          self,
          *,
          enabled: bool,
          name: str,
          definition: "BlobInventoryPolicyDefinition",
          **kwargs
      ):
          super(BlobInventoryPolicyRule, self).__init__(**kwargs)
          self.enabled = enabled
          self.name = name
          self.definition = definition
  
  
  class BlobInventoryPolicySchema(msrest.serialization.Model):
      """The storage account blob inventory policy rules.
  
      All required parameters must be populated in order to send to Azure.
  
      :param enabled: Required. Policy is enabled if set to true.
      :type enabled: bool
      :param destination: Required. Container name where blob inventory files are stored. Must be
       pre-created.
      :type destination: str
      :param type: Required. The valid value is Inventory. Possible values include: "Inventory".
      :type type: str or ~azure.mgmt.storage.v2021_01_01.models.InventoryRuleType
      :param rules: Required. The storage account blob inventory policy rules. The rule is applied
       when it is enabled.
      :type rules: list[~azure.mgmt.storage.v2021_01_01.models.BlobInventoryPolicyRule]
      """
  
      _validation = {
          'enabled': {'required': True},
          'destination': {'required': True},
          'type': {'required': True},
          'rules': {'required': True},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'destination': {'key': 'destination', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'rules': {'key': 'rules', 'type': '[BlobInventoryPolicyRule]'},
      }
  
      def __init__(
          self,
          *,
          enabled: bool,
          destination: str,
          type: Union[str, "InventoryRuleType"],
          rules: List["BlobInventoryPolicyRule"],
          **kwargs
      ):
          super(BlobInventoryPolicySchema, self).__init__(**kwargs)
          self.enabled = enabled
          self.destination = destination
          self.type = type
          self.rules = rules
  
  
  class BlobRestoreParameters(msrest.serialization.Model):
      """Blob restore parameters.
  
      All required parameters must be populated in order to send to Azure.
  
      :param time_to_restore: Required. Restore blob to the specified time.
      :type time_to_restore: ~datetime.datetime
      :param blob_ranges: Required. Blob ranges to restore.
      :type blob_ranges: list[~azure.mgmt.storage.v2021_01_01.models.BlobRestoreRange]
      """
  
      _validation = {
          'time_to_restore': {'required': True},
          'blob_ranges': {'required': True},
      }
  
      _attribute_map = {
          'time_to_restore': {'key': 'timeToRestore', 'type': 'iso-8601'},
          'blob_ranges': {'key': 'blobRanges', 'type': '[BlobRestoreRange]'},
      }
  
      def __init__(
          self,
          *,
          time_to_restore: datetime.datetime,
          blob_ranges: List["BlobRestoreRange"],
          **kwargs
      ):
          super(BlobRestoreParameters, self).__init__(**kwargs)
          self.time_to_restore = time_to_restore
          self.blob_ranges = blob_ranges
  
  
  class BlobRestoreRange(msrest.serialization.Model):
      """Blob range.
  
      All required parameters must be populated in order to send to Azure.
  
      :param start_range: Required. Blob start range. This is inclusive. Empty means account start.
      :type start_range: str
      :param end_range: Required. Blob end range. This is exclusive. Empty means account end.
      :type end_range: str
      """
  
      _validation = {
          'start_range': {'required': True},
          'end_range': {'required': True},
      }
  
      _attribute_map = {
          'start_range': {'key': 'startRange', 'type': 'str'},
          'end_range': {'key': 'endRange', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          start_range: str,
          end_range: str,
          **kwargs
      ):
          super(BlobRestoreRange, self).__init__(**kwargs)
          self.start_range = start_range
          self.end_range = end_range
  
  
  class BlobRestoreStatus(msrest.serialization.Model):
      """Blob restore status.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar status: The status of blob restore progress. Possible values are: - InProgress: Indicates
       that blob restore is ongoing. - Complete: Indicates that blob restore has been completed
       successfully. - Failed: Indicates that blob restore is failed. Possible values include:
       "InProgress", "Complete", "Failed".
      :vartype status: str or ~azure.mgmt.storage.v2021_01_01.models.BlobRestoreProgressStatus
      :ivar failure_reason: Failure reason when blob restore is failed.
      :vartype failure_reason: str
      :ivar restore_id: Id for tracking blob restore request.
      :vartype restore_id: str
      :ivar parameters: Blob restore request parameters.
      :vartype parameters: ~azure.mgmt.storage.v2021_01_01.models.BlobRestoreParameters
      """
  
      _validation = {
          'status': {'readonly': True},
          'failure_reason': {'readonly': True},
          'restore_id': {'readonly': True},
          'parameters': {'readonly': True},
      }
  
      _attribute_map = {
          'status': {'key': 'status', 'type': 'str'},
          'failure_reason': {'key': 'failureReason', 'type': 'str'},
          'restore_id': {'key': 'restoreId', 'type': 'str'},
          'parameters': {'key': 'parameters', 'type': 'BlobRestoreParameters'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(BlobRestoreStatus, self).__init__(**kwargs)
          self.status = None
          self.failure_reason = None
          self.restore_id = None
          self.parameters = None
  
  
  class BlobServiceItems(msrest.serialization.Model):
      """BlobServiceItems.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of blob services returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.BlobServiceProperties]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[BlobServiceProperties]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(BlobServiceItems, self).__init__(**kwargs)
          self.value = None
  
  
  class BlobServiceProperties(Resource):
      """The properties of a storage account’s Blob service.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar sku: Sku name and tier.
      :vartype sku: ~azure.mgmt.storage.v2021_01_01.models.Sku
      :param cors: Specifies CORS rules for the Blob service. You can include up to five CorsRule
       elements in the request. If no CorsRule elements are included in the request body, all CORS
       rules will be deleted, and CORS will be disabled for the Blob service.
      :type cors: ~azure.mgmt.storage.v2021_01_01.models.CorsRules
      :param default_service_version: DefaultServiceVersion indicates the default version to use for
       requests to the Blob service if an incoming request’s version is not specified. Possible values
       include version 2008-10-27 and all more recent versions.
      :type default_service_version: str
      :param delete_retention_policy: The blob service properties for blob soft delete.
      :type delete_retention_policy: ~azure.mgmt.storage.v2021_01_01.models.DeleteRetentionPolicy
      :param is_versioning_enabled: Versioning is enabled if set to true.
      :type is_versioning_enabled: bool
      :param automatic_snapshot_policy_enabled: Deprecated in favor of isVersioningEnabled property.
      :type automatic_snapshot_policy_enabled: bool
      :param change_feed: The blob service properties for change feed events.
      :type change_feed: ~azure.mgmt.storage.v2021_01_01.models.ChangeFeed
      :param restore_policy: The blob service properties for blob restore policy.
      :type restore_policy: ~azure.mgmt.storage.v2021_01_01.models.RestorePolicyProperties
      :param container_delete_retention_policy: The blob service properties for container soft
       delete.
      :type container_delete_retention_policy:
       ~azure.mgmt.storage.v2021_01_01.models.DeleteRetentionPolicy
      :param last_access_time_tracking_policy: The blob service property to configure last access
       time based tracking policy.
      :type last_access_time_tracking_policy:
       ~azure.mgmt.storage.v2021_01_01.models.LastAccessTimeTrackingPolicy
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'sku': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'sku': {'key': 'sku', 'type': 'Sku'},
          'cors': {'key': 'properties.cors', 'type': 'CorsRules'},
          'default_service_version': {'key': 'properties.defaultServiceVersion', 'type': 'str'},
          'delete_retention_policy': {'key': 'properties.deleteRetentionPolicy', 'type': 'DeleteRetentionPolicy'},
          'is_versioning_enabled': {'key': 'properties.isVersioningEnabled', 'type': 'bool'},
          'automatic_snapshot_policy_enabled': {'key': 'properties.automaticSnapshotPolicyEnabled', 'type': 'bool'},
          'change_feed': {'key': 'properties.changeFeed', 'type': 'ChangeFeed'},
          'restore_policy': {'key': 'properties.restorePolicy', 'type': 'RestorePolicyProperties'},
          'container_delete_retention_policy': {'key': 'properties.containerDeleteRetentionPolicy', 'type': 'DeleteRetentionPolicy'},
          'last_access_time_tracking_policy': {'key': 'properties.lastAccessTimeTrackingPolicy', 'type': 'LastAccessTimeTrackingPolicy'},
      }
  
      def __init__(
          self,
          *,
          cors: Optional["CorsRules"] = None,
          default_service_version: Optional[str] = None,
          delete_retention_policy: Optional["DeleteRetentionPolicy"] = None,
          is_versioning_enabled: Optional[bool] = None,
          automatic_snapshot_policy_enabled: Optional[bool] = None,
          change_feed: Optional["ChangeFeed"] = None,
          restore_policy: Optional["RestorePolicyProperties"] = None,
          container_delete_retention_policy: Optional["DeleteRetentionPolicy"] = None,
          last_access_time_tracking_policy: Optional["LastAccessTimeTrackingPolicy"] = None,
          **kwargs
      ):
          super(BlobServiceProperties, self).__init__(**kwargs)
          self.sku = None
          self.cors = cors
          self.default_service_version = default_service_version
          self.delete_retention_policy = delete_retention_policy
          self.is_versioning_enabled = is_versioning_enabled
          self.automatic_snapshot_policy_enabled = automatic_snapshot_policy_enabled
          self.change_feed = change_feed
          self.restore_policy = restore_policy
          self.container_delete_retention_policy = container_delete_retention_policy
          self.last_access_time_tracking_policy = last_access_time_tracking_policy
  
  
  class ChangeFeed(msrest.serialization.Model):
      """The blob service properties for change feed events.
  
      :param enabled: Indicates whether change feed event logging is enabled for the Blob service.
      :type enabled: bool
      :param retention_in_days: Indicates the duration of changeFeed retention in days. Minimum value
       is 1 day and maximum value is 146000 days (400 years). A null value indicates an infinite
       retention of the change feed.
      :type retention_in_days: int
      """
  
      _validation = {
          'retention_in_days': {'maximum': 146000, 'minimum': 1},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'retention_in_days': {'key': 'retentionInDays', 'type': 'int'},
      }
  
      def __init__(
          self,
          *,
          enabled: Optional[bool] = None,
          retention_in_days: Optional[int] = None,
          **kwargs
      ):
          super(ChangeFeed, self).__init__(**kwargs)
          self.enabled = enabled
          self.retention_in_days = retention_in_days
  
  
  class CheckNameAvailabilityResult(msrest.serialization.Model):
      """The CheckNameAvailability operation response.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar name_available: Gets a boolean value that indicates whether the name is available for you
       to use. If true, the name is available. If false, the name has already been taken or is invalid
       and cannot be used.
      :vartype name_available: bool
      :ivar reason: Gets the reason that a storage account name could not be used. The Reason element
       is only returned if NameAvailable is false. Possible values include: "AccountNameInvalid",
       "AlreadyExists".
      :vartype reason: str or ~azure.mgmt.storage.v2021_01_01.models.Reason
      :ivar message: Gets an error message explaining the Reason value in more detail.
      :vartype message: str
      """
  
      _validation = {
          'name_available': {'readonly': True},
          'reason': {'readonly': True},
          'message': {'readonly': True},
      }
  
      _attribute_map = {
          'name_available': {'key': 'nameAvailable', 'type': 'bool'},
          'reason': {'key': 'reason', 'type': 'str'},
          'message': {'key': 'message', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(CheckNameAvailabilityResult, self).__init__(**kwargs)
          self.name_available = None
          self.reason = None
          self.message = None
  
  
  class CloudErrorBody(msrest.serialization.Model):
      """An error response from the Storage service.
  
      :param code: An identifier for the error. Codes are invariant and are intended to be consumed
       programmatically.
      :type code: str
      :param message: A message describing the error, intended to be suitable for display in a user
       interface.
      :type message: str
      :param target: The target of the particular error. For example, the name of the property in
       error.
      :type target: str
      :param details: A list of additional details about the error.
      :type details: list[~azure.mgmt.storage.v2021_01_01.models.CloudErrorBody]
      """
  
      _attribute_map = {
          'code': {'key': 'code', 'type': 'str'},
          'message': {'key': 'message', 'type': 'str'},
          'target': {'key': 'target', 'type': 'str'},
          'details': {'key': 'details', 'type': '[CloudErrorBody]'},
      }
  
      def __init__(
          self,
          *,
          code: Optional[str] = None,
          message: Optional[str] = None,
          target: Optional[str] = None,
          details: Optional[List["CloudErrorBody"]] = None,
          **kwargs
      ):
          super(CloudErrorBody, self).__init__(**kwargs)
          self.code = code
          self.message = message
          self.target = target
          self.details = details
  
  
  class CorsRule(msrest.serialization.Model):
      """Specifies a CORS rule for the Blob service.
  
      All required parameters must be populated in order to send to Azure.
  
      :param allowed_origins: Required. Required if CorsRule element is present. A list of origin
       domains that will be allowed via CORS, or "*" to allow all domains.
      :type allowed_origins: list[str]
      :param allowed_methods: Required. Required if CorsRule element is present. A list of HTTP
       methods that are allowed to be executed by the origin.
      :type allowed_methods: list[str or
       ~azure.mgmt.storage.v2021_01_01.models.CorsRuleAllowedMethodsItem]
      :param max_age_in_seconds: Required. Required if CorsRule element is present. The number of
       seconds that the client/browser should cache a preflight response.
      :type max_age_in_seconds: int
      :param exposed_headers: Required. Required if CorsRule element is present. A list of response
       headers to expose to CORS clients.
      :type exposed_headers: list[str]
      :param allowed_headers: Required. Required if CorsRule element is present. A list of headers
       allowed to be part of the cross-origin request.
      :type allowed_headers: list[str]
      """
  
      _validation = {
          'allowed_origins': {'required': True},
          'allowed_methods': {'required': True},
          'max_age_in_seconds': {'required': True},
          'exposed_headers': {'required': True},
          'allowed_headers': {'required': True},
      }
  
      _attribute_map = {
          'allowed_origins': {'key': 'allowedOrigins', 'type': '[str]'},
          'allowed_methods': {'key': 'allowedMethods', 'type': '[str]'},
          'max_age_in_seconds': {'key': 'maxAgeInSeconds', 'type': 'int'},
          'exposed_headers': {'key': 'exposedHeaders', 'type': '[str]'},
          'allowed_headers': {'key': 'allowedHeaders', 'type': '[str]'},
      }
  
      def __init__(
          self,
          *,
          allowed_origins: List[str],
          allowed_methods: List[Union[str, "CorsRuleAllowedMethodsItem"]],
          max_age_in_seconds: int,
          exposed_headers: List[str],
          allowed_headers: List[str],
          **kwargs
      ):
          super(CorsRule, self).__init__(**kwargs)
          self.allowed_origins = allowed_origins
          self.allowed_methods = allowed_methods
          self.max_age_in_seconds = max_age_in_seconds
          self.exposed_headers = exposed_headers
          self.allowed_headers = allowed_headers
  
  
  class CorsRules(msrest.serialization.Model):
      """Sets the CORS rules. You can include up to five CorsRule elements in the request.
  
      :param cors_rules: The List of CORS rules. You can include up to five CorsRule elements in the
       request.
      :type cors_rules: list[~azure.mgmt.storage.v2021_01_01.models.CorsRule]
      """
  
      _attribute_map = {
          'cors_rules': {'key': 'corsRules', 'type': '[CorsRule]'},
      }
  
      def __init__(
          self,
          *,
          cors_rules: Optional[List["CorsRule"]] = None,
          **kwargs
      ):
          super(CorsRules, self).__init__(**kwargs)
          self.cors_rules = cors_rules
  
  
  class CustomDomain(msrest.serialization.Model):
      """The custom domain assigned to this storage account. This can be set via Update.
  
      All required parameters must be populated in order to send to Azure.
  
      :param name: Required. Gets or sets the custom domain name assigned to the storage account.
       Name is the CNAME source.
      :type name: str
      :param use_sub_domain_name: Indicates whether indirect CName validation is enabled. Default
       value is false. This should only be set on updates.
      :type use_sub_domain_name: bool
      """
  
      _validation = {
          'name': {'required': True},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'use_sub_domain_name': {'key': 'useSubDomainName', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          name: str,
          use_sub_domain_name: Optional[bool] = None,
          **kwargs
      ):
          super(CustomDomain, self).__init__(**kwargs)
          self.name = name
          self.use_sub_domain_name = use_sub_domain_name
  
  
  class DateAfterCreation(msrest.serialization.Model):
      """Object to define the number of days after creation.
  
      All required parameters must be populated in order to send to Azure.
  
      :param days_after_creation_greater_than: Required. Value indicating the age in days after
       creation.
      :type days_after_creation_greater_than: float
      """
  
      _validation = {
          'days_after_creation_greater_than': {'required': True, 'minimum': 0, 'multiple': 1},
      }
  
      _attribute_map = {
          'days_after_creation_greater_than': {'key': 'daysAfterCreationGreaterThan', 'type': 'float'},
      }
  
      def __init__(
          self,
          *,
          days_after_creation_greater_than: float,
          **kwargs
      ):
          super(DateAfterCreation, self).__init__(**kwargs)
          self.days_after_creation_greater_than = days_after_creation_greater_than
  
  
  class DateAfterModification(msrest.serialization.Model):
      """Object to define the number of days after object last modification Or last access. Properties daysAfterModificationGreaterThan and daysAfterLastAccessTimeGreaterThan are mutually exclusive.
  
      :param days_after_modification_greater_than: Value indicating the age in days after last
       modification.
      :type days_after_modification_greater_than: float
      :param days_after_last_access_time_greater_than: Value indicating the age in days after last
       blob access. This property can only be used in conjunction with last access time tracking
       policy.
      :type days_after_last_access_time_greater_than: float
      """
  
      _validation = {
          'days_after_modification_greater_than': {'minimum': 0, 'multiple': 1},
          'days_after_last_access_time_greater_than': {'minimum': 0, 'multiple': 1},
      }
  
      _attribute_map = {
          'days_after_modification_greater_than': {'key': 'daysAfterModificationGreaterThan', 'type': 'float'},
          'days_after_last_access_time_greater_than': {'key': 'daysAfterLastAccessTimeGreaterThan', 'type': 'float'},
      }
  
      def __init__(
          self,
          *,
          days_after_modification_greater_than: Optional[float] = None,
          days_after_last_access_time_greater_than: Optional[float] = None,
          **kwargs
      ):
          super(DateAfterModification, self).__init__(**kwargs)
          self.days_after_modification_greater_than = days_after_modification_greater_than
          self.days_after_last_access_time_greater_than = days_after_last_access_time_greater_than
  
  
  class ProxyResource(Resource):
      """The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ProxyResource, self).__init__(**kwargs)
  
  
  class DeletedAccount(ProxyResource):
      """Deleted storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar storage_account_resource_id: Full resource id of the original storage account.
      :vartype storage_account_resource_id: str
      :ivar location: Location of the deleted account.
      :vartype location: str
      :ivar restore_reference: Can be used to attempt recovering this deleted account via
       PutStorageAccount API.
      :vartype restore_reference: str
      :ivar creation_time: Creation time of the deleted account.
      :vartype creation_time: str
      :ivar deletion_time: Deletion time of the deleted account.
      :vartype deletion_time: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'storage_account_resource_id': {'readonly': True},
          'location': {'readonly': True},
          'restore_reference': {'readonly': True},
          'creation_time': {'readonly': True},
          'deletion_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'storage_account_resource_id': {'key': 'properties.storageAccountResourceId', 'type': 'str'},
          'location': {'key': 'properties.location', 'type': 'str'},
          'restore_reference': {'key': 'properties.restoreReference', 'type': 'str'},
          'creation_time': {'key': 'properties.creationTime', 'type': 'str'},
          'deletion_time': {'key': 'properties.deletionTime', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(DeletedAccount, self).__init__(**kwargs)
          self.storage_account_resource_id = None
          self.location = None
          self.restore_reference = None
          self.creation_time = None
          self.deletion_time = None
  
  
  class DeletedAccountListResult(msrest.serialization.Model):
      """The response from the List Deleted Accounts operation.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: Gets the list of deleted accounts and their properties.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.DeletedAccount]
      :ivar next_link: Request URL that can be used to query next page of deleted accounts. Returned
       when total number of requested deleted accounts exceed maximum page size.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[DeletedAccount]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(DeletedAccountListResult, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class DeletedShare(msrest.serialization.Model):
      """The deleted share to be restored.
  
      All required parameters must be populated in order to send to Azure.
  
      :param deleted_share_name: Required. Required. Identify the name of the deleted share that will
       be restored.
      :type deleted_share_name: str
      :param deleted_share_version: Required. Required. Identify the version of the deleted share
       that will be restored.
      :type deleted_share_version: str
      """
  
      _validation = {
          'deleted_share_name': {'required': True},
          'deleted_share_version': {'required': True},
      }
  
      _attribute_map = {
          'deleted_share_name': {'key': 'deletedShareName', 'type': 'str'},
          'deleted_share_version': {'key': 'deletedShareVersion', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          deleted_share_name: str,
          deleted_share_version: str,
          **kwargs
      ):
          super(DeletedShare, self).__init__(**kwargs)
          self.deleted_share_name = deleted_share_name
          self.deleted_share_version = deleted_share_version
  
  
  class DeleteRetentionPolicy(msrest.serialization.Model):
      """The service properties for soft delete.
  
      :param enabled: Indicates whether DeleteRetentionPolicy is enabled.
      :type enabled: bool
      :param days: Indicates the number of days that the deleted item should be retained. The minimum
       specified value can be 1 and the maximum value can be 365.
      :type days: int
      """
  
      _validation = {
          'days': {'maximum': 365, 'minimum': 1},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'days': {'key': 'days', 'type': 'int'},
      }
  
      def __init__(
          self,
          *,
          enabled: Optional[bool] = None,
          days: Optional[int] = None,
          **kwargs
      ):
          super(DeleteRetentionPolicy, self).__init__(**kwargs)
          self.enabled = enabled
          self.days = days
  
  
  class Dimension(msrest.serialization.Model):
      """Dimension of blobs, possibly be blob type or access tier.
  
      :param name: Display name of dimension.
      :type name: str
      :param display_name: Display name of dimension.
      :type display_name: str
      """
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'display_name': {'key': 'displayName', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          name: Optional[str] = None,
          display_name: Optional[str] = None,
          **kwargs
      ):
          super(Dimension, self).__init__(**kwargs)
          self.name = name
          self.display_name = display_name
  
  
  class Encryption(msrest.serialization.Model):
      """The encryption settings on the storage account.
  
      All required parameters must be populated in order to send to Azure.
  
      :param services: List of services which support encryption.
      :type services: ~azure.mgmt.storage.v2021_01_01.models.EncryptionServices
      :param key_source: Required. The encryption keySource (provider). Possible values
       (case-insensitive):  Microsoft.Storage, Microsoft.Keyvault. Possible values include:
       "Microsoft.Storage", "Microsoft.Keyvault". Default value: "Microsoft.Storage".
      :type key_source: str or ~azure.mgmt.storage.v2021_01_01.models.KeySource
      :param require_infrastructure_encryption: A boolean indicating whether or not the service
       applies a secondary layer of encryption with platform managed keys for data at rest.
      :type require_infrastructure_encryption: bool
      :param key_vault_properties: Properties provided by key vault.
      :type key_vault_properties: ~azure.mgmt.storage.v2021_01_01.models.KeyVaultProperties
      :param encryption_identity: The identity to be used with service-side encryption at rest.
      :type encryption_identity: ~azure.mgmt.storage.v2021_01_01.models.EncryptionIdentity
      """
  
      _validation = {
          'key_source': {'required': True},
      }
  
      _attribute_map = {
          'services': {'key': 'services', 'type': 'EncryptionServices'},
          'key_source': {'key': 'keySource', 'type': 'str'},
          'require_infrastructure_encryption': {'key': 'requireInfrastructureEncryption', 'type': 'bool'},
          'key_vault_properties': {'key': 'keyvaultproperties', 'type': 'KeyVaultProperties'},
          'encryption_identity': {'key': 'identity', 'type': 'EncryptionIdentity'},
      }
  
      def __init__(
          self,
          *,
          key_source: Union[str, "KeySource"] = "Microsoft.Storage",
          services: Optional["EncryptionServices"] = None,
          require_infrastructure_encryption: Optional[bool] = None,
          key_vault_properties: Optional["KeyVaultProperties"] = None,
          encryption_identity: Optional["EncryptionIdentity"] = None,
          **kwargs
      ):
          super(Encryption, self).__init__(**kwargs)
          self.services = services
          self.key_source = key_source
          self.require_infrastructure_encryption = require_infrastructure_encryption
          self.key_vault_properties = key_vault_properties
          self.encryption_identity = encryption_identity
  
  
  class EncryptionIdentity(msrest.serialization.Model):
      """Encryption identity for the storage account.
  
      :param encryption_user_assigned_identity: Resource identifier of the UserAssigned identity to
       be associated with server-side encryption on the storage account.
      :type encryption_user_assigned_identity: str
      """
  
      _attribute_map = {
          'encryption_user_assigned_identity': {'key': 'userAssignedIdentity', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          encryption_user_assigned_identity: Optional[str] = None,
          **kwargs
      ):
          super(EncryptionIdentity, self).__init__(**kwargs)
          self.encryption_user_assigned_identity = encryption_user_assigned_identity
  
  
  class EncryptionScope(Resource):
      """The Encryption Scope resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param source: The provider for the encryption scope. Possible values (case-insensitive):
       Microsoft.Storage, Microsoft.KeyVault. Possible values include: "Microsoft.Storage",
       "Microsoft.KeyVault".
      :type source: str or ~azure.mgmt.storage.v2021_01_01.models.EncryptionScopeSource
      :param state: The state of the encryption scope. Possible values (case-insensitive):  Enabled,
       Disabled. Possible values include: "Enabled", "Disabled".
      :type state: str or ~azure.mgmt.storage.v2021_01_01.models.EncryptionScopeState
      :ivar creation_time: Gets the creation date and time of the encryption scope in UTC.
      :vartype creation_time: ~datetime.datetime
      :ivar last_modified_time: Gets the last modification date and time of the encryption scope in
       UTC.
      :vartype last_modified_time: ~datetime.datetime
      :param key_vault_properties: The key vault properties for the encryption scope. This is a
       required field if encryption scope 'source' attribute is set to 'Microsoft.KeyVault'.
      :type key_vault_properties:
       ~azure.mgmt.storage.v2021_01_01.models.EncryptionScopeKeyVaultProperties
      :param require_infrastructure_encryption: A boolean indicating whether or not the service
       applies a secondary layer of encryption with platform managed keys for data at rest.
      :type require_infrastructure_encryption: bool
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'creation_time': {'readonly': True},
          'last_modified_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'source': {'key': 'properties.source', 'type': 'str'},
          'state': {'key': 'properties.state', 'type': 'str'},
          'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'key_vault_properties': {'key': 'properties.keyVaultProperties', 'type': 'EncryptionScopeKeyVaultProperties'},
          'require_infrastructure_encryption': {'key': 'properties.requireInfrastructureEncryption', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          source: Optional[Union[str, "EncryptionScopeSource"]] = None,
          state: Optional[Union[str, "EncryptionScopeState"]] = None,
          key_vault_properties: Optional["EncryptionScopeKeyVaultProperties"] = None,
          require_infrastructure_encryption: Optional[bool] = None,
          **kwargs
      ):
          super(EncryptionScope, self).__init__(**kwargs)
          self.source = source
          self.state = state
          self.creation_time = None
          self.last_modified_time = None
          self.key_vault_properties = key_vault_properties
          self.require_infrastructure_encryption = require_infrastructure_encryption
  
  
  class EncryptionScopeKeyVaultProperties(msrest.serialization.Model):
      """The key vault properties for the encryption scope. This is a required field if encryption scope 'source' attribute is set to 'Microsoft.KeyVault'.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :param key_uri: The object identifier for a key vault key object. When applied, the encryption
       scope will use the key referenced by the identifier to enable customer-managed key support on
       this encryption scope.
      :type key_uri: str
      :ivar current_versioned_key_identifier: The object identifier of the current versioned Key
       Vault Key in use.
      :vartype current_versioned_key_identifier: str
      :ivar last_key_rotation_timestamp: Timestamp of last rotation of the Key Vault Key.
      :vartype last_key_rotation_timestamp: ~datetime.datetime
      """
  
      _validation = {
          'current_versioned_key_identifier': {'readonly': True},
          'last_key_rotation_timestamp': {'readonly': True},
      }
  
      _attribute_map = {
          'key_uri': {'key': 'keyUri', 'type': 'str'},
          'current_versioned_key_identifier': {'key': 'currentVersionedKeyIdentifier', 'type': 'str'},
          'last_key_rotation_timestamp': {'key': 'lastKeyRotationTimestamp', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          key_uri: Optional[str] = None,
          **kwargs
      ):
          super(EncryptionScopeKeyVaultProperties, self).__init__(**kwargs)
          self.key_uri = key_uri
          self.current_versioned_key_identifier = None
          self.last_key_rotation_timestamp = None
  
  
  class EncryptionScopeListResult(msrest.serialization.Model):
      """List of encryption scopes requested, and if paging is required, a URL to the next page of encryption scopes.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of encryption scopes requested.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.EncryptionScope]
      :ivar next_link: Request URL that can be used to query next page of encryption scopes. Returned
       when total number of requested encryption scopes exceeds the maximum page size.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[EncryptionScope]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(EncryptionScopeListResult, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class EncryptionService(msrest.serialization.Model):
      """A service that allows server-side encryption to be used.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :param enabled: A boolean indicating whether or not the service encrypts the data as it is
       stored.
      :type enabled: bool
      :ivar last_enabled_time: Gets a rough estimate of the date/time when the encryption was last
       enabled by the user. Only returned when encryption is enabled. There might be some unencrypted
       blobs which were written after this time, as it is just a rough estimate.
      :vartype last_enabled_time: ~datetime.datetime
      :param key_type: Encryption key type to be used for the encryption service. 'Account' key type
       implies that an account-scoped encryption key will be used. 'Service' key type implies that a
       default service key is used. Possible values include: "Service", "Account".
      :type key_type: str or ~azure.mgmt.storage.v2021_01_01.models.KeyType
      """
  
      _validation = {
          'last_enabled_time': {'readonly': True},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'last_enabled_time': {'key': 'lastEnabledTime', 'type': 'iso-8601'},
          'key_type': {'key': 'keyType', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          enabled: Optional[bool] = None,
          key_type: Optional[Union[str, "KeyType"]] = None,
          **kwargs
      ):
          super(EncryptionService, self).__init__(**kwargs)
          self.enabled = enabled
          self.last_enabled_time = None
          self.key_type = key_type
  
  
  class EncryptionServices(msrest.serialization.Model):
      """A list of services that support encryption.
  
      :param blob: The encryption function of the blob storage service.
      :type blob: ~azure.mgmt.storage.v2021_01_01.models.EncryptionService
      :param file: The encryption function of the file storage service.
      :type file: ~azure.mgmt.storage.v2021_01_01.models.EncryptionService
      :param table: The encryption function of the table storage service.
      :type table: ~azure.mgmt.storage.v2021_01_01.models.EncryptionService
      :param queue: The encryption function of the queue storage service.
      :type queue: ~azure.mgmt.storage.v2021_01_01.models.EncryptionService
      """
  
      _attribute_map = {
          'blob': {'key': 'blob', 'type': 'EncryptionService'},
          'file': {'key': 'file', 'type': 'EncryptionService'},
          'table': {'key': 'table', 'type': 'EncryptionService'},
          'queue': {'key': 'queue', 'type': 'EncryptionService'},
      }
  
      def __init__(
          self,
          *,
          blob: Optional["EncryptionService"] = None,
          file: Optional["EncryptionService"] = None,
          table: Optional["EncryptionService"] = None,
          queue: Optional["EncryptionService"] = None,
          **kwargs
      ):
          super(EncryptionServices, self).__init__(**kwargs)
          self.blob = blob
          self.file = file
          self.table = table
          self.queue = queue
  
  
  class Endpoints(msrest.serialization.Model):
      """The URIs that are used to perform a retrieval of a public blob, queue, table, web or dfs object.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar blob: Gets the blob endpoint.
      :vartype blob: str
      :ivar queue: Gets the queue endpoint.
      :vartype queue: str
      :ivar table: Gets the table endpoint.
      :vartype table: str
      :ivar file: Gets the file endpoint.
      :vartype file: str
      :ivar web: Gets the web endpoint.
      :vartype web: str
      :ivar dfs: Gets the dfs endpoint.
      :vartype dfs: str
      :param microsoft_endpoints: Gets the microsoft routing storage endpoints.
      :type microsoft_endpoints:
       ~azure.mgmt.storage.v2021_01_01.models.StorageAccountMicrosoftEndpoints
      :param internet_endpoints: Gets the internet routing storage endpoints.
      :type internet_endpoints:
       ~azure.mgmt.storage.v2021_01_01.models.StorageAccountInternetEndpoints
      """
  
      _validation = {
          'blob': {'readonly': True},
          'queue': {'readonly': True},
          'table': {'readonly': True},
          'file': {'readonly': True},
          'web': {'readonly': True},
          'dfs': {'readonly': True},
      }
  
      _attribute_map = {
          'blob': {'key': 'blob', 'type': 'str'},
          'queue': {'key': 'queue', 'type': 'str'},
          'table': {'key': 'table', 'type': 'str'},
          'file': {'key': 'file', 'type': 'str'},
          'web': {'key': 'web', 'type': 'str'},
          'dfs': {'key': 'dfs', 'type': 'str'},
          'microsoft_endpoints': {'key': 'microsoftEndpoints', 'type': 'StorageAccountMicrosoftEndpoints'},
          'internet_endpoints': {'key': 'internetEndpoints', 'type': 'StorageAccountInternetEndpoints'},
      }
  
      def __init__(
          self,
          *,
          microsoft_endpoints: Optional["StorageAccountMicrosoftEndpoints"] = None,
          internet_endpoints: Optional["StorageAccountInternetEndpoints"] = None,
          **kwargs
      ):
          super(Endpoints, self).__init__(**kwargs)
          self.blob = None
          self.queue = None
          self.table = None
          self.file = None
          self.web = None
          self.dfs = None
          self.microsoft_endpoints = microsoft_endpoints
          self.internet_endpoints = internet_endpoints
  
  
  class ErrorResponse(msrest.serialization.Model):
      """An error response from the storage resource provider.
  
      :param error: Azure Storage Resource Provider error response body.
      :type error: ~azure.mgmt.storage.v2021_01_01.models.ErrorResponseBody
      """
  
      _attribute_map = {
          'error': {'key': 'error', 'type': 'ErrorResponseBody'},
      }
  
      def __init__(
          self,
          *,
          error: Optional["ErrorResponseBody"] = None,
          **kwargs
      ):
          super(ErrorResponse, self).__init__(**kwargs)
          self.error = error
  
  
  class ErrorResponseBody(msrest.serialization.Model):
      """Error response body contract.
  
      :param code: An identifier for the error. Codes are invariant and are intended to be consumed
       programmatically.
      :type code: str
      :param message: A message describing the error, intended to be suitable for display in a user
       interface.
      :type message: str
      """
  
      _attribute_map = {
          'code': {'key': 'code', 'type': 'str'},
          'message': {'key': 'message', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          code: Optional[str] = None,
          message: Optional[str] = None,
          **kwargs
      ):
          super(ErrorResponseBody, self).__init__(**kwargs)
          self.code = code
          self.message = message
  
  
  class ExtendedLocation(msrest.serialization.Model):
      """The complex type of the extended location.
  
      :param name: The name of the extended location.
      :type name: str
      :param type: The type of the extended location. Possible values include: "EdgeZone".
      :type type: str or ~azure.mgmt.storage.v2021_01_01.models.ExtendedLocationTypes
      """
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          name: Optional[str] = None,
          type: Optional[Union[str, "ExtendedLocationTypes"]] = None,
          **kwargs
      ):
          super(ExtendedLocation, self).__init__(**kwargs)
          self.name = name
          self.type = type
  
  
  class FileServiceItems(msrest.serialization.Model):
      """FileServiceItems.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of file services returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.FileServiceProperties]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[FileServiceProperties]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(FileServiceItems, self).__init__(**kwargs)
          self.value = None
  
  
  class FileServiceProperties(Resource):
      """The properties of File services in storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar sku: Sku name and tier.
      :vartype sku: ~azure.mgmt.storage.v2021_01_01.models.Sku
      :param cors: Specifies CORS rules for the File service. You can include up to five CorsRule
       elements in the request. If no CorsRule elements are included in the request body, all CORS
       rules will be deleted, and CORS will be disabled for the File service.
      :type cors: ~azure.mgmt.storage.v2021_01_01.models.CorsRules
      :param share_delete_retention_policy: The file service properties for share soft delete.
      :type share_delete_retention_policy:
       ~azure.mgmt.storage.v2021_01_01.models.DeleteRetentionPolicy
      :param protocol_settings: Protocol settings for file service.
      :type protocol_settings: ~azure.mgmt.storage.v2021_01_01.models.ProtocolSettings
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'sku': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'sku': {'key': 'sku', 'type': 'Sku'},
          'cors': {'key': 'properties.cors', 'type': 'CorsRules'},
          'share_delete_retention_policy': {'key': 'properties.shareDeleteRetentionPolicy', 'type': 'DeleteRetentionPolicy'},
          'protocol_settings': {'key': 'properties.protocolSettings', 'type': 'ProtocolSettings'},
      }
  
      def __init__(
          self,
          *,
          cors: Optional["CorsRules"] = None,
          share_delete_retention_policy: Optional["DeleteRetentionPolicy"] = None,
          protocol_settings: Optional["ProtocolSettings"] = None,
          **kwargs
      ):
          super(FileServiceProperties, self).__init__(**kwargs)
          self.sku = None
          self.cors = cors
          self.share_delete_retention_policy = share_delete_retention_policy
          self.protocol_settings = protocol_settings
  
  
  class FileShare(AzureEntityResource):
      """Properties of the file share, including Id, resource name, resource type, Etag.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      :ivar last_modified_time: Returns the date and time the share was last modified.
      :vartype last_modified_time: ~datetime.datetime
      :param metadata: A name-value pair to associate with the share as metadata.
      :type metadata: dict[str, str]
      :param share_quota: The maximum size of the share, in gigabytes. Must be greater than 0, and
       less than or equal to 5TB (5120). For Large File Shares, the maximum size is 102400.
      :type share_quota: int
      :param enabled_protocols: The authentication protocol that is used for the file share. Can only
       be specified when creating a share. Possible values include: "SMB", "NFS".
      :type enabled_protocols: str or ~azure.mgmt.storage.v2021_01_01.models.EnabledProtocols
      :param root_squash: The property is for NFS share only. The default is NoRootSquash. Possible
       values include: "NoRootSquash", "RootSquash", "AllSquash".
      :type root_squash: str or ~azure.mgmt.storage.v2021_01_01.models.RootSquashType
      :ivar version: The version of the share.
      :vartype version: str
      :ivar deleted: Indicates whether the share was deleted.
      :vartype deleted: bool
      :ivar deleted_time: The deleted time if the share was deleted.
      :vartype deleted_time: ~datetime.datetime
      :ivar remaining_retention_days: Remaining retention days for share that was soft deleted.
      :vartype remaining_retention_days: int
      :param access_tier: Access tier for specific share. GpV2 account can choose between
       TransactionOptimized (default), Hot, and Cool. FileStorage account can choose Premium. Possible
       values include: "TransactionOptimized", "Hot", "Cool", "Premium".
      :type access_tier: str or ~azure.mgmt.storage.v2021_01_01.models.ShareAccessTier
      :ivar access_tier_change_time: Indicates the last modification time for share access tier.
      :vartype access_tier_change_time: ~datetime.datetime
      :ivar access_tier_status: Indicates if there is a pending transition for access tier.
      :vartype access_tier_status: str
      :ivar share_usage_bytes: The approximate size of the data stored on the share. Note that this
       value may not include all recently created or recently resized files.
      :vartype share_usage_bytes: long
      :ivar snapshot_time: Creation time of share snapshot returned in the response of list shares
       with expand param "snapshots".
      :vartype snapshot_time: ~datetime.datetime
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
          'last_modified_time': {'readonly': True},
          'share_quota': {'maximum': 102400, 'minimum': 1},
          'version': {'readonly': True},
          'deleted': {'readonly': True},
          'deleted_time': {'readonly': True},
          'remaining_retention_days': {'readonly': True},
          'access_tier_change_time': {'readonly': True},
          'access_tier_status': {'readonly': True},
          'share_usage_bytes': {'readonly': True},
          'snapshot_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
          'share_quota': {'key': 'properties.shareQuota', 'type': 'int'},
          'enabled_protocols': {'key': 'properties.enabledProtocols', 'type': 'str'},
          'root_squash': {'key': 'properties.rootSquash', 'type': 'str'},
          'version': {'key': 'properties.version', 'type': 'str'},
          'deleted': {'key': 'properties.deleted', 'type': 'bool'},
          'deleted_time': {'key': 'properties.deletedTime', 'type': 'iso-8601'},
          'remaining_retention_days': {'key': 'properties.remainingRetentionDays', 'type': 'int'},
          'access_tier': {'key': 'properties.accessTier', 'type': 'str'},
          'access_tier_change_time': {'key': 'properties.accessTierChangeTime', 'type': 'iso-8601'},
          'access_tier_status': {'key': 'properties.accessTierStatus', 'type': 'str'},
          'share_usage_bytes': {'key': 'properties.shareUsageBytes', 'type': 'long'},
          'snapshot_time': {'key': 'properties.snapshotTime', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          metadata: Optional[Dict[str, str]] = None,
          share_quota: Optional[int] = None,
          enabled_protocols: Optional[Union[str, "EnabledProtocols"]] = None,
          root_squash: Optional[Union[str, "RootSquashType"]] = None,
          access_tier: Optional[Union[str, "ShareAccessTier"]] = None,
          **kwargs
      ):
          super(FileShare, self).__init__(**kwargs)
          self.last_modified_time = None
          self.metadata = metadata
          self.share_quota = share_quota
          self.enabled_protocols = enabled_protocols
          self.root_squash = root_squash
          self.version = None
          self.deleted = None
          self.deleted_time = None
          self.remaining_retention_days = None
          self.access_tier = access_tier
          self.access_tier_change_time = None
          self.access_tier_status = None
          self.share_usage_bytes = None
          self.snapshot_time = None
  
  
  class FileShareItem(AzureEntityResource):
      """The file share properties be listed out.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      :ivar last_modified_time: Returns the date and time the share was last modified.
      :vartype last_modified_time: ~datetime.datetime
      :param metadata: A name-value pair to associate with the share as metadata.
      :type metadata: dict[str, str]
      :param share_quota: The maximum size of the share, in gigabytes. Must be greater than 0, and
       less than or equal to 5TB (5120). For Large File Shares, the maximum size is 102400.
      :type share_quota: int
      :param enabled_protocols: The authentication protocol that is used for the file share. Can only
       be specified when creating a share. Possible values include: "SMB", "NFS".
      :type enabled_protocols: str or ~azure.mgmt.storage.v2021_01_01.models.EnabledProtocols
      :param root_squash: The property is for NFS share only. The default is NoRootSquash. Possible
       values include: "NoRootSquash", "RootSquash", "AllSquash".
      :type root_squash: str or ~azure.mgmt.storage.v2021_01_01.models.RootSquashType
      :ivar version: The version of the share.
      :vartype version: str
      :ivar deleted: Indicates whether the share was deleted.
      :vartype deleted: bool
      :ivar deleted_time: The deleted time if the share was deleted.
      :vartype deleted_time: ~datetime.datetime
      :ivar remaining_retention_days: Remaining retention days for share that was soft deleted.
      :vartype remaining_retention_days: int
      :param access_tier: Access tier for specific share. GpV2 account can choose between
       TransactionOptimized (default), Hot, and Cool. FileStorage account can choose Premium. Possible
       values include: "TransactionOptimized", "Hot", "Cool", "Premium".
      :type access_tier: str or ~azure.mgmt.storage.v2021_01_01.models.ShareAccessTier
      :ivar access_tier_change_time: Indicates the last modification time for share access tier.
      :vartype access_tier_change_time: ~datetime.datetime
      :ivar access_tier_status: Indicates if there is a pending transition for access tier.
      :vartype access_tier_status: str
      :ivar share_usage_bytes: The approximate size of the data stored on the share. Note that this
       value may not include all recently created or recently resized files.
      :vartype share_usage_bytes: long
      :ivar snapshot_time: Creation time of share snapshot returned in the response of list shares
       with expand param "snapshots".
      :vartype snapshot_time: ~datetime.datetime
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
          'last_modified_time': {'readonly': True},
          'share_quota': {'maximum': 102400, 'minimum': 1},
          'version': {'readonly': True},
          'deleted': {'readonly': True},
          'deleted_time': {'readonly': True},
          'remaining_retention_days': {'readonly': True},
          'access_tier_change_time': {'readonly': True},
          'access_tier_status': {'readonly': True},
          'share_usage_bytes': {'readonly': True},
          'snapshot_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
          'share_quota': {'key': 'properties.shareQuota', 'type': 'int'},
          'enabled_protocols': {'key': 'properties.enabledProtocols', 'type': 'str'},
          'root_squash': {'key': 'properties.rootSquash', 'type': 'str'},
          'version': {'key': 'properties.version', 'type': 'str'},
          'deleted': {'key': 'properties.deleted', 'type': 'bool'},
          'deleted_time': {'key': 'properties.deletedTime', 'type': 'iso-8601'},
          'remaining_retention_days': {'key': 'properties.remainingRetentionDays', 'type': 'int'},
          'access_tier': {'key': 'properties.accessTier', 'type': 'str'},
          'access_tier_change_time': {'key': 'properties.accessTierChangeTime', 'type': 'iso-8601'},
          'access_tier_status': {'key': 'properties.accessTierStatus', 'type': 'str'},
          'share_usage_bytes': {'key': 'properties.shareUsageBytes', 'type': 'long'},
          'snapshot_time': {'key': 'properties.snapshotTime', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          metadata: Optional[Dict[str, str]] = None,
          share_quota: Optional[int] = None,
          enabled_protocols: Optional[Union[str, "EnabledProtocols"]] = None,
          root_squash: Optional[Union[str, "RootSquashType"]] = None,
          access_tier: Optional[Union[str, "ShareAccessTier"]] = None,
          **kwargs
      ):
          super(FileShareItem, self).__init__(**kwargs)
          self.last_modified_time = None
          self.metadata = metadata
          self.share_quota = share_quota
          self.enabled_protocols = enabled_protocols
          self.root_squash = root_squash
          self.version = None
          self.deleted = None
          self.deleted_time = None
          self.remaining_retention_days = None
          self.access_tier = access_tier
          self.access_tier_change_time = None
          self.access_tier_status = None
          self.share_usage_bytes = None
          self.snapshot_time = None
  
  
  class FileShareItems(msrest.serialization.Model):
      """Response schema. Contains list of shares returned, and if paging is requested or required, a URL to next page of shares.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of file shares returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.FileShareItem]
      :ivar next_link: Request URL that can be used to query next page of shares. Returned when total
       number of requested shares exceed maximum page size.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[FileShareItem]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(FileShareItems, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class GeoReplicationStats(msrest.serialization.Model):
      """Statistics related to replication for storage account's Blob, Table, Queue and File services. It is only available when geo-redundant replication is enabled for the storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar status: The status of the secondary location. Possible values are: - Live: Indicates that
       the secondary location is active and operational. - Bootstrap: Indicates initial
       synchronization from the primary location to the secondary location is in progress.This
       typically occurs when replication is first enabled. - Unavailable: Indicates that the secondary
       location is temporarily unavailable. Possible values include: "Live", "Bootstrap",
       "Unavailable".
      :vartype status: str or ~azure.mgmt.storage.v2021_01_01.models.GeoReplicationStatus
      :ivar last_sync_time: All primary writes preceding this UTC date/time value are guaranteed to
       be available for read operations. Primary writes following this point in time may or may not be
       available for reads. Element may be default value if value of LastSyncTime is not available,
       this can happen if secondary is offline or we are in bootstrap.
      :vartype last_sync_time: ~datetime.datetime
      :ivar can_failover: A boolean flag which indicates whether or not account failover is supported
       for the account.
      :vartype can_failover: bool
      """
  
      _validation = {
          'status': {'readonly': True},
          'last_sync_time': {'readonly': True},
          'can_failover': {'readonly': True},
      }
  
      _attribute_map = {
          'status': {'key': 'status', 'type': 'str'},
          'last_sync_time': {'key': 'lastSyncTime', 'type': 'iso-8601'},
          'can_failover': {'key': 'canFailover', 'type': 'bool'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(GeoReplicationStats, self).__init__(**kwargs)
          self.status = None
          self.last_sync_time = None
          self.can_failover = None
  
  
  class Identity(msrest.serialization.Model):
      """Identity for the resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :ivar principal_id: The principal ID of resource identity.
      :vartype principal_id: str
      :ivar tenant_id: The tenant ID of resource.
      :vartype tenant_id: str
      :param type: Required. The identity type. Possible values include: "None", "SystemAssigned",
       "UserAssigned", "SystemAssigned,UserAssigned".
      :type type: str or ~azure.mgmt.storage.v2021_01_01.models.IdentityType
      :param user_assigned_identities: Gets or sets a list of key value pairs that describe the set
       of User Assigned identities that will be used with this storage account. The key is the ARM
       resource identifier of the identity. Only 1 User Assigned identity is permitted here.
      :type user_assigned_identities: dict[str,
       ~azure.mgmt.storage.v2021_01_01.models.UserAssignedIdentity]
      """
  
      _validation = {
          'principal_id': {'readonly': True},
          'tenant_id': {'readonly': True},
          'type': {'required': True},
      }
  
      _attribute_map = {
          'principal_id': {'key': 'principalId', 'type': 'str'},
          'tenant_id': {'key': 'tenantId', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'user_assigned_identities': {'key': 'userAssignedIdentities', 'type': '{UserAssignedIdentity}'},
      }
  
      def __init__(
          self,
          *,
          type: Union[str, "IdentityType"],
          user_assigned_identities: Optional[Dict[str, "UserAssignedIdentity"]] = None,
          **kwargs
      ):
          super(Identity, self).__init__(**kwargs)
          self.principal_id = None
          self.tenant_id = None
          self.type = type
          self.user_assigned_identities = user_assigned_identities
  
  
  class ImmutabilityPolicy(AzureEntityResource):
      """The ImmutabilityPolicy property of a blob container, including Id, resource name, resource type, Etag.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      :param immutability_period_since_creation_in_days: The immutability period for the blobs in the
       container since the policy creation, in days.
      :type immutability_period_since_creation_in_days: int
      :ivar state: The ImmutabilityPolicy state of a blob container, possible values include: Locked
       and Unlocked. Possible values include: "Locked", "Unlocked".
      :vartype state: str or ~azure.mgmt.storage.v2021_01_01.models.ImmutabilityPolicyState
      :param allow_protected_append_writes: This property can only be changed for unlocked time-based
       retention policies. When enabled, new blocks can be written to an append blob while maintaining
       immutability protection and compliance. Only new blocks can be added and any existing blocks
       cannot be modified or deleted. This property cannot be changed with ExtendImmutabilityPolicy
       API.
      :type allow_protected_append_writes: bool
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
          'state': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
          'immutability_period_since_creation_in_days': {'key': 'properties.immutabilityPeriodSinceCreationInDays', 'type': 'int'},
          'state': {'key': 'properties.state', 'type': 'str'},
          'allow_protected_append_writes': {'key': 'properties.allowProtectedAppendWrites', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          immutability_period_since_creation_in_days: Optional[int] = None,
          allow_protected_append_writes: Optional[bool] = None,
          **kwargs
      ):
          super(ImmutabilityPolicy, self).__init__(**kwargs)
          self.immutability_period_since_creation_in_days = immutability_period_since_creation_in_days
          self.state = None
          self.allow_protected_append_writes = allow_protected_append_writes
  
  
  class ImmutabilityPolicyProperties(msrest.serialization.Model):
      """The properties of an ImmutabilityPolicy of a blob container.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar etag: ImmutabilityPolicy Etag.
      :vartype etag: str
      :ivar update_history: The ImmutabilityPolicy update history of the blob container.
      :vartype update_history: list[~azure.mgmt.storage.v2021_01_01.models.UpdateHistoryProperty]
      :param immutability_period_since_creation_in_days: The immutability period for the blobs in the
       container since the policy creation, in days.
      :type immutability_period_since_creation_in_days: int
      :ivar state: The ImmutabilityPolicy state of a blob container, possible values include: Locked
       and Unlocked. Possible values include: "Locked", "Unlocked".
      :vartype state: str or ~azure.mgmt.storage.v2021_01_01.models.ImmutabilityPolicyState
      :param allow_protected_append_writes: This property can only be changed for unlocked time-based
       retention policies. When enabled, new blocks can be written to an append blob while maintaining
       immutability protection and compliance. Only new blocks can be added and any existing blocks
       cannot be modified or deleted. This property cannot be changed with ExtendImmutabilityPolicy
       API.
      :type allow_protected_append_writes: bool
      """
  
      _validation = {
          'etag': {'readonly': True},
          'update_history': {'readonly': True},
          'state': {'readonly': True},
      }
  
      _attribute_map = {
          'etag': {'key': 'etag', 'type': 'str'},
          'update_history': {'key': 'updateHistory', 'type': '[UpdateHistoryProperty]'},
          'immutability_period_since_creation_in_days': {'key': 'properties.immutabilityPeriodSinceCreationInDays', 'type': 'int'},
          'state': {'key': 'properties.state', 'type': 'str'},
          'allow_protected_append_writes': {'key': 'properties.allowProtectedAppendWrites', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          immutability_period_since_creation_in_days: Optional[int] = None,
          allow_protected_append_writes: Optional[bool] = None,
          **kwargs
      ):
          super(ImmutabilityPolicyProperties, self).__init__(**kwargs)
          self.etag = None
          self.update_history = None
          self.immutability_period_since_creation_in_days = immutability_period_since_creation_in_days
          self.state = None
          self.allow_protected_append_writes = allow_protected_append_writes
  
  
  class IPRule(msrest.serialization.Model):
      """IP rule with specific IP or IP range in CIDR format.
  
      All required parameters must be populated in order to send to Azure.
  
      :param ip_address_or_range: Required. Specifies the IP or IP range in CIDR format. Only IPV4
       address is allowed.
      :type ip_address_or_range: str
      :param action: The action of IP ACL rule. The only acceptable values to pass in are None and
       "Allow". The default value is None.
      :type action: str
      """
  
      _validation = {
          'ip_address_or_range': {'required': True},
      }
  
      _attribute_map = {
          'ip_address_or_range': {'key': 'value', 'type': 'str'},
          'action': {'key': 'action', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          ip_address_or_range: str,
          action: Optional[str] = None,
          **kwargs
      ):
          super(IPRule, self).__init__(**kwargs)
          self.ip_address_or_range = ip_address_or_range
          self.action = action
  
  
  class KeyVaultProperties(msrest.serialization.Model):
      """Properties of key vault.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :param key_name: The name of KeyVault key.
      :type key_name: str
      :param key_version: The version of KeyVault key.
      :type key_version: str
      :param key_vault_uri: The Uri of KeyVault.
      :type key_vault_uri: str
      :ivar current_versioned_key_identifier: The object identifier of the current versioned Key
       Vault Key in use.
      :vartype current_versioned_key_identifier: str
      :ivar last_key_rotation_timestamp: Timestamp of last rotation of the Key Vault Key.
      :vartype last_key_rotation_timestamp: ~datetime.datetime
      """
  
      _validation = {
          'current_versioned_key_identifier': {'readonly': True},
          'last_key_rotation_timestamp': {'readonly': True},
      }
  
      _attribute_map = {
          'key_name': {'key': 'keyname', 'type': 'str'},
          'key_version': {'key': 'keyversion', 'type': 'str'},
          'key_vault_uri': {'key': 'keyvaulturi', 'type': 'str'},
          'current_versioned_key_identifier': {'key': 'currentVersionedKeyIdentifier', 'type': 'str'},
          'last_key_rotation_timestamp': {'key': 'lastKeyRotationTimestamp', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          key_name: Optional[str] = None,
          key_version: Optional[str] = None,
          key_vault_uri: Optional[str] = None,
          **kwargs
      ):
          super(KeyVaultProperties, self).__init__(**kwargs)
          self.key_name = key_name
          self.key_version = key_version
          self.key_vault_uri = key_vault_uri
          self.current_versioned_key_identifier = None
          self.last_key_rotation_timestamp = None
  
  
  class LastAccessTimeTrackingPolicy(msrest.serialization.Model):
      """The blob service properties for Last access time based tracking policy.
  
      All required parameters must be populated in order to send to Azure.
  
      :param enable: Required. When set to true last access time based tracking is enabled.
      :type enable: bool
      :param name: Name of the policy. The valid value is AccessTimeTracking. This field is currently
       read only. Possible values include: "AccessTimeTracking".
      :type name: str or ~azure.mgmt.storage.v2021_01_01.models.Name
      :param tracking_granularity_in_days: The field specifies blob object tracking granularity in
       days, typically how often the blob object should be tracked.This field is currently read only
       with value as 1.
      :type tracking_granularity_in_days: int
      :param blob_type: An array of predefined supported blob types. Only blockBlob is the supported
       value. This field is currently read only.
      :type blob_type: list[str]
      """
  
      _validation = {
          'enable': {'required': True},
      }
  
      _attribute_map = {
          'enable': {'key': 'enable', 'type': 'bool'},
          'name': {'key': 'name', 'type': 'str'},
          'tracking_granularity_in_days': {'key': 'trackingGranularityInDays', 'type': 'int'},
          'blob_type': {'key': 'blobType', 'type': '[str]'},
      }
  
      def __init__(
          self,
          *,
          enable: bool,
          name: Optional[Union[str, "Name"]] = None,
          tracking_granularity_in_days: Optional[int] = None,
          blob_type: Optional[List[str]] = None,
          **kwargs
      ):
          super(LastAccessTimeTrackingPolicy, self).__init__(**kwargs)
          self.enable = enable
          self.name = name
          self.tracking_granularity_in_days = tracking_granularity_in_days
          self.blob_type = blob_type
  
  
  class LeaseContainerRequest(msrest.serialization.Model):
      """Lease Container request schema.
  
      All required parameters must be populated in order to send to Azure.
  
      :param action: Required. Specifies the lease action. Can be one of the available actions.
       Possible values include: "Acquire", "Renew", "Change", "Release", "Break".
      :type action: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseContainerRequestAction
      :param lease_id: Identifies the lease. Can be specified in any valid GUID string format.
      :type lease_id: str
      :param break_period: Optional. For a break action, proposed duration the lease should continue
       before it is broken, in seconds, between 0 and 60.
      :type break_period: int
      :param lease_duration: Required for acquire. Specifies the duration of the lease, in seconds,
       or negative one (-1) for a lease that never expires.
      :type lease_duration: int
      :param proposed_lease_id: Optional for acquire, required for change. Proposed lease ID, in a
       GUID string format.
      :type proposed_lease_id: str
      """
  
      _validation = {
          'action': {'required': True},
      }
  
      _attribute_map = {
          'action': {'key': 'action', 'type': 'str'},
          'lease_id': {'key': 'leaseId', 'type': 'str'},
          'break_period': {'key': 'breakPeriod', 'type': 'int'},
          'lease_duration': {'key': 'leaseDuration', 'type': 'int'},
          'proposed_lease_id': {'key': 'proposedLeaseId', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          action: Union[str, "LeaseContainerRequestAction"],
          lease_id: Optional[str] = None,
          break_period: Optional[int] = None,
          lease_duration: Optional[int] = None,
          proposed_lease_id: Optional[str] = None,
          **kwargs
      ):
          super(LeaseContainerRequest, self).__init__(**kwargs)
          self.action = action
          self.lease_id = lease_id
          self.break_period = break_period
          self.lease_duration = lease_duration
          self.proposed_lease_id = proposed_lease_id
  
  
  class LeaseContainerResponse(msrest.serialization.Model):
      """Lease Container response schema.
  
      :param lease_id: Returned unique lease ID that must be included with any request to delete the
       container, or to renew, change, or release the lease.
      :type lease_id: str
      :param lease_time_seconds: Approximate time remaining in the lease period, in seconds.
      :type lease_time_seconds: str
      """
  
      _attribute_map = {
          'lease_id': {'key': 'leaseId', 'type': 'str'},
          'lease_time_seconds': {'key': 'leaseTimeSeconds', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          lease_id: Optional[str] = None,
          lease_time_seconds: Optional[str] = None,
          **kwargs
      ):
          super(LeaseContainerResponse, self).__init__(**kwargs)
          self.lease_id = lease_id
          self.lease_time_seconds = lease_time_seconds
  
  
  class LegalHold(msrest.serialization.Model):
      """The LegalHold property of a blob container.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :ivar has_legal_hold: The hasLegalHold public property is set to true by SRP if there are at
       least one existing tag. The hasLegalHold public property is set to false by SRP if all existing
       legal hold tags are cleared out. There can be a maximum of 1000 blob containers with
       hasLegalHold=true for a given account.
      :vartype has_legal_hold: bool
      :param tags: Required. A set of tags. Each tag should be 3 to 23 alphanumeric characters and is
       normalized to lower case at SRP.
      :type tags: list[str]
      """
  
      _validation = {
          'has_legal_hold': {'readonly': True},
          'tags': {'required': True},
      }
  
      _attribute_map = {
          'has_legal_hold': {'key': 'hasLegalHold', 'type': 'bool'},
          'tags': {'key': 'tags', 'type': '[str]'},
      }
  
      def __init__(
          self,
          *,
          tags: List[str],
          **kwargs
      ):
          super(LegalHold, self).__init__(**kwargs)
          self.has_legal_hold = None
          self.tags = tags
  
  
  class LegalHoldProperties(msrest.serialization.Model):
      """The LegalHold property of a blob container.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar has_legal_hold: The hasLegalHold public property is set to true by SRP if there are at
       least one existing tag. The hasLegalHold public property is set to false by SRP if all existing
       legal hold tags are cleared out. There can be a maximum of 1000 blob containers with
       hasLegalHold=true for a given account.
      :vartype has_legal_hold: bool
      :param tags: A set of tags. The list of LegalHold tags of a blob container.
      :type tags: list[~azure.mgmt.storage.v2021_01_01.models.TagProperty]
      """
  
      _validation = {
          'has_legal_hold': {'readonly': True},
      }
  
      _attribute_map = {
          'has_legal_hold': {'key': 'hasLegalHold', 'type': 'bool'},
          'tags': {'key': 'tags', 'type': '[TagProperty]'},
      }
  
      def __init__(
          self,
          *,
          tags: Optional[List["TagProperty"]] = None,
          **kwargs
      ):
          super(LegalHoldProperties, self).__init__(**kwargs)
          self.has_legal_hold = None
          self.tags = tags
  
  
  class ListAccountSasResponse(msrest.serialization.Model):
      """The List SAS credentials operation response.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar account_sas_token: List SAS credentials of storage account.
      :vartype account_sas_token: str
      """
  
      _validation = {
          'account_sas_token': {'readonly': True},
      }
  
      _attribute_map = {
          'account_sas_token': {'key': 'accountSasToken', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListAccountSasResponse, self).__init__(**kwargs)
          self.account_sas_token = None
  
  
  class ListBlobInventoryPolicy(msrest.serialization.Model):
      """List of blob inventory policies returned.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of blob inventory policies.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.BlobInventoryPolicy]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[BlobInventoryPolicy]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListBlobInventoryPolicy, self).__init__(**kwargs)
          self.value = None
  
  
  class ListContainerItem(AzureEntityResource):
      """The blob container properties be listed out.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar etag: Resource Etag.
      :vartype etag: str
      :ivar version: The version of the deleted blob container.
      :vartype version: str
      :ivar deleted: Indicates whether the blob container was deleted.
      :vartype deleted: bool
      :ivar deleted_time: Blob container deletion time.
      :vartype deleted_time: ~datetime.datetime
      :ivar remaining_retention_days: Remaining retention days for soft deleted blob container.
      :vartype remaining_retention_days: int
      :param default_encryption_scope: Default the container to use specified encryption scope for
       all writes.
      :type default_encryption_scope: str
      :param deny_encryption_scope_override: Block override of encryption scope from the container
       default.
      :type deny_encryption_scope_override: bool
      :param public_access: Specifies whether data in the container may be accessed publicly and the
       level of access. Possible values include: "Container", "Blob", "None".
      :type public_access: str or ~azure.mgmt.storage.v2021_01_01.models.PublicAccess
      :ivar last_modified_time: Returns the date and time the container was last modified.
      :vartype last_modified_time: ~datetime.datetime
      :ivar lease_status: The lease status of the container. Possible values include: "Locked",
       "Unlocked".
      :vartype lease_status: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseStatus
      :ivar lease_state: Lease state of the container. Possible values include: "Available",
       "Leased", "Expired", "Breaking", "Broken".
      :vartype lease_state: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseState
      :ivar lease_duration: Specifies whether the lease on a container is of infinite or fixed
       duration, only when the container is leased. Possible values include: "Infinite", "Fixed".
      :vartype lease_duration: str or ~azure.mgmt.storage.v2021_01_01.models.LeaseDuration
      :param metadata: A name-value pair to associate with the container as metadata.
      :type metadata: dict[str, str]
      :ivar immutability_policy: The ImmutabilityPolicy property of the container.
      :vartype immutability_policy:
       ~azure.mgmt.storage.v2021_01_01.models.ImmutabilityPolicyProperties
      :ivar legal_hold: The LegalHold property of the container.
      :vartype legal_hold: ~azure.mgmt.storage.v2021_01_01.models.LegalHoldProperties
      :ivar has_legal_hold: The hasLegalHold public property is set to true by SRP if there are at
       least one existing tag. The hasLegalHold public property is set to false by SRP if all existing
       legal hold tags are cleared out. There can be a maximum of 1000 blob containers with
       hasLegalHold=true for a given account.
      :vartype has_legal_hold: bool
      :ivar has_immutability_policy: The hasImmutabilityPolicy public property is set to true by SRP
       if ImmutabilityPolicy has been created for this container. The hasImmutabilityPolicy public
       property is set to false by SRP if ImmutabilityPolicy has not been created for this container.
      :vartype has_immutability_policy: bool
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'etag': {'readonly': True},
          'version': {'readonly': True},
          'deleted': {'readonly': True},
          'deleted_time': {'readonly': True},
          'remaining_retention_days': {'readonly': True},
          'last_modified_time': {'readonly': True},
          'lease_status': {'readonly': True},
          'lease_state': {'readonly': True},
          'lease_duration': {'readonly': True},
          'immutability_policy': {'readonly': True},
          'legal_hold': {'readonly': True},
          'has_legal_hold': {'readonly': True},
          'has_immutability_policy': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'etag': {'key': 'etag', 'type': 'str'},
          'version': {'key': 'properties.version', 'type': 'str'},
          'deleted': {'key': 'properties.deleted', 'type': 'bool'},
          'deleted_time': {'key': 'properties.deletedTime', 'type': 'iso-8601'},
          'remaining_retention_days': {'key': 'properties.remainingRetentionDays', 'type': 'int'},
          'default_encryption_scope': {'key': 'properties.defaultEncryptionScope', 'type': 'str'},
          'deny_encryption_scope_override': {'key': 'properties.denyEncryptionScopeOverride', 'type': 'bool'},
          'public_access': {'key': 'properties.publicAccess', 'type': 'str'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'lease_status': {'key': 'properties.leaseStatus', 'type': 'str'},
          'lease_state': {'key': 'properties.leaseState', 'type': 'str'},
          'lease_duration': {'key': 'properties.leaseDuration', 'type': 'str'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
          'immutability_policy': {'key': 'properties.immutabilityPolicy', 'type': 'ImmutabilityPolicyProperties'},
          'legal_hold': {'key': 'properties.legalHold', 'type': 'LegalHoldProperties'},
          'has_legal_hold': {'key': 'properties.hasLegalHold', 'type': 'bool'},
          'has_immutability_policy': {'key': 'properties.hasImmutabilityPolicy', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          default_encryption_scope: Optional[str] = None,
          deny_encryption_scope_override: Optional[bool] = None,
          public_access: Optional[Union[str, "PublicAccess"]] = None,
          metadata: Optional[Dict[str, str]] = None,
          **kwargs
      ):
          super(ListContainerItem, self).__init__(**kwargs)
          self.version = None
          self.deleted = None
          self.deleted_time = None
          self.remaining_retention_days = None
          self.default_encryption_scope = default_encryption_scope
          self.deny_encryption_scope_override = deny_encryption_scope_override
          self.public_access = public_access
          self.last_modified_time = None
          self.lease_status = None
          self.lease_state = None
          self.lease_duration = None
          self.metadata = metadata
          self.immutability_policy = None
          self.legal_hold = None
          self.has_legal_hold = None
          self.has_immutability_policy = None
  
  
  class ListContainerItems(msrest.serialization.Model):
      """Response schema. Contains list of blobs returned, and if paging is requested or required, a URL to next page of containers.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of blobs containers returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.ListContainerItem]
      :ivar next_link: Request URL that can be used to query next page of containers. Returned when
       total number of requested containers exceed maximum page size.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[ListContainerItem]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListContainerItems, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class ListQueue(Resource):
      """ListQueue.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param metadata: A name-value pair that represents queue metadata.
      :type metadata: dict[str, str]
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
      }
  
      def __init__(
          self,
          *,
          metadata: Optional[Dict[str, str]] = None,
          **kwargs
      ):
          super(ListQueue, self).__init__(**kwargs)
          self.metadata = metadata
  
  
  class ListQueueResource(msrest.serialization.Model):
      """Response schema. Contains list of queues returned.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of queues returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.ListQueue]
      :ivar next_link: Request URL that can be used to list next page of queues.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[ListQueue]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListQueueResource, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class ListQueueServices(msrest.serialization.Model):
      """ListQueueServices.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of queue services returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.QueueServiceProperties]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[QueueServiceProperties]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListQueueServices, self).__init__(**kwargs)
          self.value = None
  
  
  class ListServiceSasResponse(msrest.serialization.Model):
      """The List service SAS credentials operation response.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar service_sas_token: List service SAS credentials of specific resource.
      :vartype service_sas_token: str
      """
  
      _validation = {
          'service_sas_token': {'readonly': True},
      }
  
      _attribute_map = {
          'service_sas_token': {'key': 'serviceSasToken', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListServiceSasResponse, self).__init__(**kwargs)
          self.service_sas_token = None
  
  
  class ListTableResource(msrest.serialization.Model):
      """Response schema. Contains list of tables returned.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of tables returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.Table]
      :ivar next_link: Request URL that can be used to query next page of tables.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[Table]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListTableResource, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class ListTableServices(msrest.serialization.Model):
      """ListTableServices.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: List of table services returned.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.TableServiceProperties]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[TableServiceProperties]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(ListTableServices, self).__init__(**kwargs)
          self.value = None
  
  
  class ManagementPolicy(Resource):
      """The Get Storage Account ManagementPolicies operation response.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar last_modified_time: Returns the date and time the ManagementPolicies was last modified.
      :vartype last_modified_time: ~datetime.datetime
      :param policy: The Storage Account ManagementPolicy, in JSON format. See more details in:
       https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
      :type policy: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicySchema
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'last_modified_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'last_modified_time': {'key': 'properties.lastModifiedTime', 'type': 'iso-8601'},
          'policy': {'key': 'properties.policy', 'type': 'ManagementPolicySchema'},
      }
  
      def __init__(
          self,
          *,
          policy: Optional["ManagementPolicySchema"] = None,
          **kwargs
      ):
          super(ManagementPolicy, self).__init__(**kwargs)
          self.last_modified_time = None
          self.policy = policy
  
  
  class ManagementPolicyAction(msrest.serialization.Model):
      """Actions are applied to the filtered blobs when the execution condition is met.
  
      :param base_blob: The management policy action for base blob.
      :type base_blob: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyBaseBlob
      :param snapshot: The management policy action for snapshot.
      :type snapshot: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicySnapShot
      :param version: The management policy action for version.
      :type version: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyVersion
      """
  
      _attribute_map = {
          'base_blob': {'key': 'baseBlob', 'type': 'ManagementPolicyBaseBlob'},
          'snapshot': {'key': 'snapshot', 'type': 'ManagementPolicySnapShot'},
          'version': {'key': 'version', 'type': 'ManagementPolicyVersion'},
      }
  
      def __init__(
          self,
          *,
          base_blob: Optional["ManagementPolicyBaseBlob"] = None,
          snapshot: Optional["ManagementPolicySnapShot"] = None,
          version: Optional["ManagementPolicyVersion"] = None,
          **kwargs
      ):
          super(ManagementPolicyAction, self).__init__(**kwargs)
          self.base_blob = base_blob
          self.snapshot = snapshot
          self.version = version
  
  
  class ManagementPolicyBaseBlob(msrest.serialization.Model):
      """Management policy action for base blob.
  
      :param tier_to_cool: The function to tier blobs to cool storage. Support blobs currently at Hot
       tier.
      :type tier_to_cool: ~azure.mgmt.storage.v2021_01_01.models.DateAfterModification
      :param tier_to_archive: The function to tier blobs to archive storage. Support blobs currently
       at Hot or Cool tier.
      :type tier_to_archive: ~azure.mgmt.storage.v2021_01_01.models.DateAfterModification
      :param delete: The function to delete the blob.
      :type delete: ~azure.mgmt.storage.v2021_01_01.models.DateAfterModification
      :param enable_auto_tier_to_hot_from_cool: This property enables auto tiering of a blob from
       cool to hot on a blob access. This property requires
       tierToCool.daysAfterLastAccessTimeGreaterThan.
      :type enable_auto_tier_to_hot_from_cool: bool
      """
  
      _attribute_map = {
          'tier_to_cool': {'key': 'tierToCool', 'type': 'DateAfterModification'},
          'tier_to_archive': {'key': 'tierToArchive', 'type': 'DateAfterModification'},
          'delete': {'key': 'delete', 'type': 'DateAfterModification'},
          'enable_auto_tier_to_hot_from_cool': {'key': 'enableAutoTierToHotFromCool', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          tier_to_cool: Optional["DateAfterModification"] = None,
          tier_to_archive: Optional["DateAfterModification"] = None,
          delete: Optional["DateAfterModification"] = None,
          enable_auto_tier_to_hot_from_cool: Optional[bool] = None,
          **kwargs
      ):
          super(ManagementPolicyBaseBlob, self).__init__(**kwargs)
          self.tier_to_cool = tier_to_cool
          self.tier_to_archive = tier_to_archive
          self.delete = delete
          self.enable_auto_tier_to_hot_from_cool = enable_auto_tier_to_hot_from_cool
  
  
  class ManagementPolicyDefinition(msrest.serialization.Model):
      """An object that defines the Lifecycle rule. Each definition is made up with a filters set and an actions set.
  
      All required parameters must be populated in order to send to Azure.
  
      :param actions: Required. An object that defines the action set.
      :type actions: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyAction
      :param filters: An object that defines the filter set.
      :type filters: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyFilter
      """
  
      _validation = {
          'actions': {'required': True},
      }
  
      _attribute_map = {
          'actions': {'key': 'actions', 'type': 'ManagementPolicyAction'},
          'filters': {'key': 'filters', 'type': 'ManagementPolicyFilter'},
      }
  
      def __init__(
          self,
          *,
          actions: "ManagementPolicyAction",
          filters: Optional["ManagementPolicyFilter"] = None,
          **kwargs
      ):
          super(ManagementPolicyDefinition, self).__init__(**kwargs)
          self.actions = actions
          self.filters = filters
  
  
  class ManagementPolicyFilter(msrest.serialization.Model):
      """Filters limit rule actions to a subset of blobs within the storage account. If multiple filters are defined, a logical AND is performed on all filters.
  
      All required parameters must be populated in order to send to Azure.
  
      :param prefix_match: An array of strings for prefixes to be match.
      :type prefix_match: list[str]
      :param blob_types: Required. An array of predefined enum values. Currently blockBlob supports
       all tiering and delete actions. Only delete actions are supported for appendBlob.
      :type blob_types: list[str]
      :param blob_index_match: An array of blob index tag based filters, there can be at most 10 tag
       filters.
      :type blob_index_match: list[~azure.mgmt.storage.v2021_01_01.models.TagFilter]
      """
  
      _validation = {
          'blob_types': {'required': True},
      }
  
      _attribute_map = {
          'prefix_match': {'key': 'prefixMatch', 'type': '[str]'},
          'blob_types': {'key': 'blobTypes', 'type': '[str]'},
          'blob_index_match': {'key': 'blobIndexMatch', 'type': '[TagFilter]'},
      }
  
      def __init__(
          self,
          *,
          blob_types: List[str],
          prefix_match: Optional[List[str]] = None,
          blob_index_match: Optional[List["TagFilter"]] = None,
          **kwargs
      ):
          super(ManagementPolicyFilter, self).__init__(**kwargs)
          self.prefix_match = prefix_match
          self.blob_types = blob_types
          self.blob_index_match = blob_index_match
  
  
  class ManagementPolicyRule(msrest.serialization.Model):
      """An object that wraps the Lifecycle rule. Each rule is uniquely defined by name.
  
      All required parameters must be populated in order to send to Azure.
  
      :param enabled: Rule is enabled if set to true.
      :type enabled: bool
      :param name: Required. A rule name can contain any combination of alpha numeric characters.
       Rule name is case-sensitive. It must be unique within a policy.
      :type name: str
      :param type: Required. The valid value is Lifecycle. Possible values include: "Lifecycle".
      :type type: str or ~azure.mgmt.storage.v2021_01_01.models.RuleType
      :param definition: Required. An object that defines the Lifecycle rule.
      :type definition: ~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyDefinition
      """
  
      _validation = {
          'name': {'required': True},
          'type': {'required': True},
          'definition': {'required': True},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'definition': {'key': 'definition', 'type': 'ManagementPolicyDefinition'},
      }
  
      def __init__(
          self,
          *,
          name: str,
          type: Union[str, "RuleType"],
          definition: "ManagementPolicyDefinition",
          enabled: Optional[bool] = None,
          **kwargs
      ):
          super(ManagementPolicyRule, self).__init__(**kwargs)
          self.enabled = enabled
          self.name = name
          self.type = type
          self.definition = definition
  
  
  class ManagementPolicySchema(msrest.serialization.Model):
      """The Storage Account ManagementPolicies Rules. See more details in: https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
  
      All required parameters must be populated in order to send to Azure.
  
      :param rules: Required. The Storage Account ManagementPolicies Rules. See more details in:
       https://docs.microsoft.com/en-us/azure/storage/common/storage-lifecycle-managment-concepts.
      :type rules: list[~azure.mgmt.storage.v2021_01_01.models.ManagementPolicyRule]
      """
  
      _validation = {
          'rules': {'required': True},
      }
  
      _attribute_map = {
          'rules': {'key': 'rules', 'type': '[ManagementPolicyRule]'},
      }
  
      def __init__(
          self,
          *,
          rules: List["ManagementPolicyRule"],
          **kwargs
      ):
          super(ManagementPolicySchema, self).__init__(**kwargs)
          self.rules = rules
  
  
  class ManagementPolicySnapShot(msrest.serialization.Model):
      """Management policy action for snapshot.
  
      :param tier_to_cool: The function to tier blob snapshot to cool storage. Support blob snapshot
       currently at Hot tier.
      :type tier_to_cool: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      :param tier_to_archive: The function to tier blob snapshot to archive storage. Support blob
       snapshot currently at Hot or Cool tier.
      :type tier_to_archive: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      :param delete: The function to delete the blob snapshot.
      :type delete: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      """
  
      _attribute_map = {
          'tier_to_cool': {'key': 'tierToCool', 'type': 'DateAfterCreation'},
          'tier_to_archive': {'key': 'tierToArchive', 'type': 'DateAfterCreation'},
          'delete': {'key': 'delete', 'type': 'DateAfterCreation'},
      }
  
      def __init__(
          self,
          *,
          tier_to_cool: Optional["DateAfterCreation"] = None,
          tier_to_archive: Optional["DateAfterCreation"] = None,
          delete: Optional["DateAfterCreation"] = None,
          **kwargs
      ):
          super(ManagementPolicySnapShot, self).__init__(**kwargs)
          self.tier_to_cool = tier_to_cool
          self.tier_to_archive = tier_to_archive
          self.delete = delete
  
  
  class ManagementPolicyVersion(msrest.serialization.Model):
      """Management policy action for blob version.
  
      :param tier_to_cool: The function to tier blob version to cool storage. Support blob version
       currently at Hot tier.
      :type tier_to_cool: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      :param tier_to_archive: The function to tier blob version to archive storage. Support blob
       version currently at Hot or Cool tier.
      :type tier_to_archive: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      :param delete: The function to delete the blob version.
      :type delete: ~azure.mgmt.storage.v2021_01_01.models.DateAfterCreation
      """
  
      _attribute_map = {
          'tier_to_cool': {'key': 'tierToCool', 'type': 'DateAfterCreation'},
          'tier_to_archive': {'key': 'tierToArchive', 'type': 'DateAfterCreation'},
          'delete': {'key': 'delete', 'type': 'DateAfterCreation'},
      }
  
      def __init__(
          self,
          *,
          tier_to_cool: Optional["DateAfterCreation"] = None,
          tier_to_archive: Optional["DateAfterCreation"] = None,
          delete: Optional["DateAfterCreation"] = None,
          **kwargs
      ):
          super(ManagementPolicyVersion, self).__init__(**kwargs)
          self.tier_to_cool = tier_to_cool
          self.tier_to_archive = tier_to_archive
          self.delete = delete
  
  
  class MetricSpecification(msrest.serialization.Model):
      """Metric specification of operation.
  
      :param name: Name of metric specification.
      :type name: str
      :param display_name: Display name of metric specification.
      :type display_name: str
      :param display_description: Display description of metric specification.
      :type display_description: str
      :param unit: Unit could be Bytes or Count.
      :type unit: str
      :param dimensions: Dimensions of blobs, including blob type and access tier.
      :type dimensions: list[~azure.mgmt.storage.v2021_01_01.models.Dimension]
      :param aggregation_type: Aggregation type could be Average.
      :type aggregation_type: str
      :param fill_gap_with_zero: The property to decide fill gap with zero or not.
      :type fill_gap_with_zero: bool
      :param category: The category this metric specification belong to, could be Capacity.
      :type category: str
      :param resource_id_dimension_name_override: Account Resource Id.
      :type resource_id_dimension_name_override: str
      """
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'display_name': {'key': 'displayName', 'type': 'str'},
          'display_description': {'key': 'displayDescription', 'type': 'str'},
          'unit': {'key': 'unit', 'type': 'str'},
          'dimensions': {'key': 'dimensions', 'type': '[Dimension]'},
          'aggregation_type': {'key': 'aggregationType', 'type': 'str'},
          'fill_gap_with_zero': {'key': 'fillGapWithZero', 'type': 'bool'},
          'category': {'key': 'category', 'type': 'str'},
          'resource_id_dimension_name_override': {'key': 'resourceIdDimensionNameOverride', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          name: Optional[str] = None,
          display_name: Optional[str] = None,
          display_description: Optional[str] = None,
          unit: Optional[str] = None,
          dimensions: Optional[List["Dimension"]] = None,
          aggregation_type: Optional[str] = None,
          fill_gap_with_zero: Optional[bool] = None,
          category: Optional[str] = None,
          resource_id_dimension_name_override: Optional[str] = None,
          **kwargs
      ):
          super(MetricSpecification, self).__init__(**kwargs)
          self.name = name
          self.display_name = display_name
          self.display_description = display_description
          self.unit = unit
          self.dimensions = dimensions
          self.aggregation_type = aggregation_type
          self.fill_gap_with_zero = fill_gap_with_zero
          self.category = category
          self.resource_id_dimension_name_override = resource_id_dimension_name_override
  
  
  class Multichannel(msrest.serialization.Model):
      """Multichannel setting. Applies to Premium FileStorage only.
  
      :param enabled: Indicates whether multichannel is enabled.
      :type enabled: bool
      """
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          enabled: Optional[bool] = None,
          **kwargs
      ):
          super(Multichannel, self).__init__(**kwargs)
          self.enabled = enabled
  
  
  class NetworkRuleSet(msrest.serialization.Model):
      """Network rule set.
  
      All required parameters must be populated in order to send to Azure.
  
      :param bypass: Specifies whether traffic is bypassed for Logging/Metrics/AzureServices.
       Possible values are any combination of Logging|Metrics|AzureServices (For example, "Logging,
       Metrics"), or None to bypass none of those traffics. Possible values include: "None",
       "Logging", "Metrics", "AzureServices". Default value: "AzureServices".
      :type bypass: str or ~azure.mgmt.storage.v2021_01_01.models.Bypass
      :param resource_access_rules: Sets the resource access rules.
      :type resource_access_rules: list[~azure.mgmt.storage.v2021_01_01.models.ResourceAccessRule]
      :param virtual_network_rules: Sets the virtual network rules.
      :type virtual_network_rules: list[~azure.mgmt.storage.v2021_01_01.models.VirtualNetworkRule]
      :param ip_rules: Sets the IP ACL rules.
      :type ip_rules: list[~azure.mgmt.storage.v2021_01_01.models.IPRule]
      :param default_action: Required. Specifies the default action of allow or deny when no other
       rules match. Possible values include: "Allow", "Deny". Default value: "Allow".
      :type default_action: str or ~azure.mgmt.storage.v2021_01_01.models.DefaultAction
      """
  
      _validation = {
          'default_action': {'required': True},
      }
  
      _attribute_map = {
          'bypass': {'key': 'bypass', 'type': 'str'},
          'resource_access_rules': {'key': 'resourceAccessRules', 'type': '[ResourceAccessRule]'},
          'virtual_network_rules': {'key': 'virtualNetworkRules', 'type': '[VirtualNetworkRule]'},
          'ip_rules': {'key': 'ipRules', 'type': '[IPRule]'},
          'default_action': {'key': 'defaultAction', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          default_action: Union[str, "DefaultAction"] = "Allow",
          bypass: Optional[Union[str, "Bypass"]] = "AzureServices",
          resource_access_rules: Optional[List["ResourceAccessRule"]] = None,
          virtual_network_rules: Optional[List["VirtualNetworkRule"]] = None,
          ip_rules: Optional[List["IPRule"]] = None,
          **kwargs
      ):
          super(NetworkRuleSet, self).__init__(**kwargs)
          self.bypass = bypass
          self.resource_access_rules = resource_access_rules
          self.virtual_network_rules = virtual_network_rules
          self.ip_rules = ip_rules
          self.default_action = default_action
  
  
  class ObjectReplicationPolicies(msrest.serialization.Model):
      """List storage account object replication policies.
  
      :param value: The replication policy between two storage accounts.
      :type value: list[~azure.mgmt.storage.v2021_01_01.models.ObjectReplicationPolicy]
      """
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[ObjectReplicationPolicy]'},
      }
  
      def __init__(
          self,
          *,
          value: Optional[List["ObjectReplicationPolicy"]] = None,
          **kwargs
      ):
          super(ObjectReplicationPolicies, self).__init__(**kwargs)
          self.value = value
  
  
  class ObjectReplicationPolicy(Resource):
      """The replication policy between two storage accounts. Multiple rules can be defined in one policy.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar policy_id: A unique id for object replication policy.
      :vartype policy_id: str
      :ivar enabled_time: Indicates when the policy is enabled on the source account.
      :vartype enabled_time: ~datetime.datetime
      :param source_account: Required. Source account name.
      :type source_account: str
      :param destination_account: Required. Destination account name.
      :type destination_account: str
      :param rules: The storage account object replication rules.
      :type rules: list[~azure.mgmt.storage.v2021_01_01.models.ObjectReplicationPolicyRule]
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'policy_id': {'readonly': True},
          'enabled_time': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'policy_id': {'key': 'properties.policyId', 'type': 'str'},
          'enabled_time': {'key': 'properties.enabledTime', 'type': 'iso-8601'},
          'source_account': {'key': 'properties.sourceAccount', 'type': 'str'},
          'destination_account': {'key': 'properties.destinationAccount', 'type': 'str'},
          'rules': {'key': 'properties.rules', 'type': '[ObjectReplicationPolicyRule]'},
      }
  
      def __init__(
          self,
          *,
          source_account: Optional[str] = None,
          destination_account: Optional[str] = None,
          rules: Optional[List["ObjectReplicationPolicyRule"]] = None,
          **kwargs
      ):
          super(ObjectReplicationPolicy, self).__init__(**kwargs)
          self.policy_id = None
          self.enabled_time = None
          self.source_account = source_account
          self.destination_account = destination_account
          self.rules = rules
  
  
  class ObjectReplicationPolicyFilter(msrest.serialization.Model):
      """Filters limit replication to a subset of blobs within the storage account. A logical OR is performed on values in the filter. If multiple filters are defined, a logical AND is performed on all filters.
  
      :param prefix_match: Optional. Filters the results to replicate only blobs whose names begin
       with the specified prefix.
      :type prefix_match: list[str]
      :param min_creation_time: Blobs created after the time will be replicated to the destination.
       It must be in datetime format 'yyyy-MM-ddTHH:mm:ssZ'. Example: 2020-02-19T16:05:00Z.
      :type min_creation_time: str
      """
  
      _attribute_map = {
          'prefix_match': {'key': 'prefixMatch', 'type': '[str]'},
          'min_creation_time': {'key': 'minCreationTime', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          prefix_match: Optional[List[str]] = None,
          min_creation_time: Optional[str] = None,
          **kwargs
      ):
          super(ObjectReplicationPolicyFilter, self).__init__(**kwargs)
          self.prefix_match = prefix_match
          self.min_creation_time = min_creation_time
  
  
  class ObjectReplicationPolicyRule(msrest.serialization.Model):
      """The replication policy rule between two containers.
  
      All required parameters must be populated in order to send to Azure.
  
      :param rule_id: Rule Id is auto-generated for each new rule on destination account. It is
       required for put policy on source account.
      :type rule_id: str
      :param source_container: Required. Required. Source container name.
      :type source_container: str
      :param destination_container: Required. Required. Destination container name.
      :type destination_container: str
      :param filters: Optional. An object that defines the filter set.
      :type filters: ~azure.mgmt.storage.v2021_01_01.models.ObjectReplicationPolicyFilter
      """
  
      _validation = {
          'source_container': {'required': True},
          'destination_container': {'required': True},
      }
  
      _attribute_map = {
          'rule_id': {'key': 'ruleId', 'type': 'str'},
          'source_container': {'key': 'sourceContainer', 'type': 'str'},
          'destination_container': {'key': 'destinationContainer', 'type': 'str'},
          'filters': {'key': 'filters', 'type': 'ObjectReplicationPolicyFilter'},
      }
  
      def __init__(
          self,
          *,
          source_container: str,
          destination_container: str,
          rule_id: Optional[str] = None,
          filters: Optional["ObjectReplicationPolicyFilter"] = None,
          **kwargs
      ):
          super(ObjectReplicationPolicyRule, self).__init__(**kwargs)
          self.rule_id = rule_id
          self.source_container = source_container
          self.destination_container = destination_container
          self.filters = filters
  
  
  class Operation(msrest.serialization.Model):
      """Storage REST API operation definition.
  
      :param name: Operation name: {provider}/{resource}/{operation}.
      :type name: str
      :param display: Display metadata associated with the operation.
      :type display: ~azure.mgmt.storage.v2021_01_01.models.OperationDisplay
      :param origin: The origin of operations.
      :type origin: str
      :param service_specification: One property of operation, include metric specifications.
      :type service_specification: ~azure.mgmt.storage.v2021_01_01.models.ServiceSpecification
      """
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'display': {'key': 'display', 'type': 'OperationDisplay'},
          'origin': {'key': 'origin', 'type': 'str'},
          'service_specification': {'key': 'properties.serviceSpecification', 'type': 'ServiceSpecification'},
      }
  
      def __init__(
          self,
          *,
          name: Optional[str] = None,
          display: Optional["OperationDisplay"] = None,
          origin: Optional[str] = None,
          service_specification: Optional["ServiceSpecification"] = None,
          **kwargs
      ):
          super(Operation, self).__init__(**kwargs)
          self.name = name
          self.display = display
          self.origin = origin
          self.service_specification = service_specification
  
  
  class OperationDisplay(msrest.serialization.Model):
      """Display metadata associated with the operation.
  
      :param provider: Service provider: Microsoft Storage.
      :type provider: str
      :param resource: Resource on which the operation is performed etc.
      :type resource: str
      :param operation: Type of operation: get, read, delete, etc.
      :type operation: str
      :param description: Description of the operation.
      :type description: str
      """
  
      _attribute_map = {
          'provider': {'key': 'provider', 'type': 'str'},
          'resource': {'key': 'resource', 'type': 'str'},
          'operation': {'key': 'operation', 'type': 'str'},
          'description': {'key': 'description', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          provider: Optional[str] = None,
          resource: Optional[str] = None,
          operation: Optional[str] = None,
          description: Optional[str] = None,
          **kwargs
      ):
          super(OperationDisplay, self).__init__(**kwargs)
          self.provider = provider
          self.resource = resource
          self.operation = operation
          self.description = description
  
  
  class OperationListResult(msrest.serialization.Model):
      """Result of the request to list Storage operations. It contains a list of operations and a URL link to get the next set of results.
  
      :param value: List of Storage operations supported by the Storage resource provider.
      :type value: list[~azure.mgmt.storage.v2021_01_01.models.Operation]
      """
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[Operation]'},
      }
  
      def __init__(
          self,
          *,
          value: Optional[List["Operation"]] = None,
          **kwargs
      ):
          super(OperationListResult, self).__init__(**kwargs)
          self.value = value
  
  
  class PrivateEndpoint(msrest.serialization.Model):
      """The Private Endpoint resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: The ARM identifier for Private Endpoint.
      :vartype id: str
      """
  
      _validation = {
          'id': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(PrivateEndpoint, self).__init__(**kwargs)
          self.id = None
  
  
  class PrivateEndpointConnection(Resource):
      """The Private Endpoint Connection resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param private_endpoint: The resource of private end point.
      :type private_endpoint: ~azure.mgmt.storage.v2021_01_01.models.PrivateEndpoint
      :param private_link_service_connection_state: A collection of information about the state of
       the connection between service consumer and provider.
      :type private_link_service_connection_state:
       ~azure.mgmt.storage.v2021_01_01.models.PrivateLinkServiceConnectionState
      :ivar provisioning_state: The provisioning state of the private endpoint connection resource.
       Possible values include: "Succeeded", "Creating", "Deleting", "Failed".
      :vartype provisioning_state: str or
       ~azure.mgmt.storage.v2021_01_01.models.PrivateEndpointConnectionProvisioningState
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'provisioning_state': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'private_endpoint': {'key': 'properties.privateEndpoint', 'type': 'PrivateEndpoint'},
          'private_link_service_connection_state': {'key': 'properties.privateLinkServiceConnectionState', 'type': 'PrivateLinkServiceConnectionState'},
          'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          private_endpoint: Optional["PrivateEndpoint"] = None,
          private_link_service_connection_state: Optional["PrivateLinkServiceConnectionState"] = None,
          **kwargs
      ):
          super(PrivateEndpointConnection, self).__init__(**kwargs)
          self.private_endpoint = private_endpoint
          self.private_link_service_connection_state = private_link_service_connection_state
          self.provisioning_state = None
  
  
  class PrivateEndpointConnectionListResult(msrest.serialization.Model):
      """List of private endpoint connection associated with the specified storage account.
  
      :param value: Array of private endpoint connections.
      :type value: list[~azure.mgmt.storage.v2021_01_01.models.PrivateEndpointConnection]
      """
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[PrivateEndpointConnection]'},
      }
  
      def __init__(
          self,
          *,
          value: Optional[List["PrivateEndpointConnection"]] = None,
          **kwargs
      ):
          super(PrivateEndpointConnectionListResult, self).__init__(**kwargs)
          self.value = value
  
  
  class PrivateLinkResource(Resource):
      """A private link resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar group_id: The private link resource group id.
      :vartype group_id: str
      :ivar required_members: The private link resource required member names.
      :vartype required_members: list[str]
      :param required_zone_names: The private link resource Private link DNS zone name.
      :type required_zone_names: list[str]
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'group_id': {'readonly': True},
          'required_members': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'group_id': {'key': 'properties.groupId', 'type': 'str'},
          'required_members': {'key': 'properties.requiredMembers', 'type': '[str]'},
          'required_zone_names': {'key': 'properties.requiredZoneNames', 'type': '[str]'},
      }
  
      def __init__(
          self,
          *,
          required_zone_names: Optional[List[str]] = None,
          **kwargs
      ):
          super(PrivateLinkResource, self).__init__(**kwargs)
          self.group_id = None
          self.required_members = None
          self.required_zone_names = required_zone_names
  
  
  class PrivateLinkResourceListResult(msrest.serialization.Model):
      """A list of private link resources.
  
      :param value: Array of private link resources.
      :type value: list[~azure.mgmt.storage.v2021_01_01.models.PrivateLinkResource]
      """
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[PrivateLinkResource]'},
      }
  
      def __init__(
          self,
          *,
          value: Optional[List["PrivateLinkResource"]] = None,
          **kwargs
      ):
          super(PrivateLinkResourceListResult, self).__init__(**kwargs)
          self.value = value
  
  
  class PrivateLinkServiceConnectionState(msrest.serialization.Model):
      """A collection of information about the state of the connection between service consumer and provider.
  
      :param status: Indicates whether the connection has been Approved/Rejected/Removed by the owner
       of the service. Possible values include: "Pending", "Approved", "Rejected".
      :type status: str or
       ~azure.mgmt.storage.v2021_01_01.models.PrivateEndpointServiceConnectionStatus
      :param description: The reason for approval/rejection of the connection.
      :type description: str
      :param action_required: A message indicating if changes on the service provider require any
       updates on the consumer.
      :type action_required: str
      """
  
      _attribute_map = {
          'status': {'key': 'status', 'type': 'str'},
          'description': {'key': 'description', 'type': 'str'},
          'action_required': {'key': 'actionRequired', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          status: Optional[Union[str, "PrivateEndpointServiceConnectionStatus"]] = None,
          description: Optional[str] = None,
          action_required: Optional[str] = None,
          **kwargs
      ):
          super(PrivateLinkServiceConnectionState, self).__init__(**kwargs)
          self.status = status
          self.description = description
          self.action_required = action_required
  
  
  class ProtocolSettings(msrest.serialization.Model):
      """Protocol settings for file service.
  
      :param smb: Setting for SMB protocol.
      :type smb: ~azure.mgmt.storage.v2021_01_01.models.SmbSetting
      """
  
      _attribute_map = {
          'smb': {'key': 'smb', 'type': 'SmbSetting'},
      }
  
      def __init__(
          self,
          *,
          smb: Optional["SmbSetting"] = None,
          **kwargs
      ):
          super(ProtocolSettings, self).__init__(**kwargs)
          self.smb = smb
  
  
  class QueueServiceProperties(Resource):
      """The properties of a storage account’s Queue service.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param cors: Specifies CORS rules for the Queue service. You can include up to five CorsRule
       elements in the request. If no CorsRule elements are included in the request body, all CORS
       rules will be deleted, and CORS will be disabled for the Queue service.
      :type cors: ~azure.mgmt.storage.v2021_01_01.models.CorsRules
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'cors': {'key': 'properties.cors', 'type': 'CorsRules'},
      }
  
      def __init__(
          self,
          *,
          cors: Optional["CorsRules"] = None,
          **kwargs
      ):
          super(QueueServiceProperties, self).__init__(**kwargs)
          self.cors = cors
  
  
  class ResourceAccessRule(msrest.serialization.Model):
      """Resource Access Rule.
  
      :param tenant_id: Tenant Id.
      :type tenant_id: str
      :param resource_id: Resource Id.
      :type resource_id: str
      """
  
      _attribute_map = {
          'tenant_id': {'key': 'tenantId', 'type': 'str'},
          'resource_id': {'key': 'resourceId', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          tenant_id: Optional[str] = None,
          resource_id: Optional[str] = None,
          **kwargs
      ):
          super(ResourceAccessRule, self).__init__(**kwargs)
          self.tenant_id = tenant_id
          self.resource_id = resource_id
  
  
  class RestorePolicyProperties(msrest.serialization.Model):
      """The blob service properties for blob restore policy.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :param enabled: Required. Blob restore is enabled if set to true.
      :type enabled: bool
      :param days: how long this blob can be restored. It should be great than zero and less than
       DeleteRetentionPolicy.days.
      :type days: int
      :ivar last_enabled_time: Deprecated in favor of minRestoreTime property.
      :vartype last_enabled_time: ~datetime.datetime
      :ivar min_restore_time: Returns the minimum date and time that the restore can be started.
      :vartype min_restore_time: ~datetime.datetime
      """
  
      _validation = {
          'enabled': {'required': True},
          'days': {'maximum': 365, 'minimum': 1},
          'last_enabled_time': {'readonly': True},
          'min_restore_time': {'readonly': True},
      }
  
      _attribute_map = {
          'enabled': {'key': 'enabled', 'type': 'bool'},
          'days': {'key': 'days', 'type': 'int'},
          'last_enabled_time': {'key': 'lastEnabledTime', 'type': 'iso-8601'},
          'min_restore_time': {'key': 'minRestoreTime', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          enabled: bool,
          days: Optional[int] = None,
          **kwargs
      ):
          super(RestorePolicyProperties, self).__init__(**kwargs)
          self.enabled = enabled
          self.days = days
          self.last_enabled_time = None
          self.min_restore_time = None
  
  
  class Restriction(msrest.serialization.Model):
      """The restriction because of which SKU cannot be used.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar type: The type of restrictions. As of now only possible value for this is location.
      :vartype type: str
      :ivar values: The value of restrictions. If the restriction type is set to location. This would
       be different locations where the SKU is restricted.
      :vartype values: list[str]
      :param reason_code: The reason for the restriction. As of now this can be "QuotaId" or
       "NotAvailableForSubscription". Quota Id is set when the SKU has requiredQuotas parameter as the
       subscription does not belong to that quota. The "NotAvailableForSubscription" is related to
       capacity at DC. Possible values include: "QuotaId", "NotAvailableForSubscription".
      :type reason_code: str or ~azure.mgmt.storage.v2021_01_01.models.ReasonCode
      """
  
      _validation = {
          'type': {'readonly': True},
          'values': {'readonly': True},
      }
  
      _attribute_map = {
          'type': {'key': 'type', 'type': 'str'},
          'values': {'key': 'values', 'type': '[str]'},
          'reason_code': {'key': 'reasonCode', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          reason_code: Optional[Union[str, "ReasonCode"]] = None,
          **kwargs
      ):
          super(Restriction, self).__init__(**kwargs)
          self.type = None
          self.values = None
          self.reason_code = reason_code
  
  
  class RoutingPreference(msrest.serialization.Model):
      """Routing preference defines the type of network, either microsoft or internet routing to be used to deliver the user data, the default option is microsoft routing.
  
      :param routing_choice: Routing Choice defines the kind of network routing opted by the user.
       Possible values include: "MicrosoftRouting", "InternetRouting".
      :type routing_choice: str or ~azure.mgmt.storage.v2021_01_01.models.RoutingChoice
      :param publish_microsoft_endpoints: A boolean flag which indicates whether microsoft routing
       storage endpoints are to be published.
      :type publish_microsoft_endpoints: bool
      :param publish_internet_endpoints: A boolean flag which indicates whether internet routing
       storage endpoints are to be published.
      :type publish_internet_endpoints: bool
      """
  
      _attribute_map = {
          'routing_choice': {'key': 'routingChoice', 'type': 'str'},
          'publish_microsoft_endpoints': {'key': 'publishMicrosoftEndpoints', 'type': 'bool'},
          'publish_internet_endpoints': {'key': 'publishInternetEndpoints', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          routing_choice: Optional[Union[str, "RoutingChoice"]] = None,
          publish_microsoft_endpoints: Optional[bool] = None,
          publish_internet_endpoints: Optional[bool] = None,
          **kwargs
      ):
          super(RoutingPreference, self).__init__(**kwargs)
          self.routing_choice = routing_choice
          self.publish_microsoft_endpoints = publish_microsoft_endpoints
          self.publish_internet_endpoints = publish_internet_endpoints
  
  
  class ServiceSasParameters(msrest.serialization.Model):
      """The parameters to list service SAS credentials of a specific resource.
  
      All required parameters must be populated in order to send to Azure.
  
      :param canonicalized_resource: Required. The canonical path to the signed resource.
      :type canonicalized_resource: str
      :param resource: The signed services accessible with the service SAS. Possible values include:
       Blob (b), Container (c), File (f), Share (s). Possible values include: "b", "c", "f", "s".
      :type resource: str or ~azure.mgmt.storage.v2021_01_01.models.SignedResource
      :param permissions: The signed permissions for the service SAS. Possible values include: Read
       (r), Write (w), Delete (d), List (l), Add (a), Create (c), Update (u) and Process (p). Possible
       values include: "r", "d", "w", "l", "a", "c", "u", "p".
      :type permissions: str or ~azure.mgmt.storage.v2021_01_01.models.Permissions
      :param ip_address_or_range: An IP address or a range of IP addresses from which to accept
       requests.
      :type ip_address_or_range: str
      :param protocols: The protocol permitted for a request made with the account SAS. Possible
       values include: "https,http", "https".
      :type protocols: str or ~azure.mgmt.storage.v2021_01_01.models.HttpProtocol
      :param shared_access_start_time: The time at which the SAS becomes valid.
      :type shared_access_start_time: ~datetime.datetime
      :param shared_access_expiry_time: The time at which the shared access signature becomes
       invalid.
      :type shared_access_expiry_time: ~datetime.datetime
      :param identifier: A unique value up to 64 characters in length that correlates to an access
       policy specified for the container, queue, or table.
      :type identifier: str
      :param partition_key_start: The start of partition key.
      :type partition_key_start: str
      :param partition_key_end: The end of partition key.
      :type partition_key_end: str
      :param row_key_start: The start of row key.
      :type row_key_start: str
      :param row_key_end: The end of row key.
      :type row_key_end: str
      :param key_to_sign: The key to sign the account SAS token with.
      :type key_to_sign: str
      :param cache_control: The response header override for cache control.
      :type cache_control: str
      :param content_disposition: The response header override for content disposition.
      :type content_disposition: str
      :param content_encoding: The response header override for content encoding.
      :type content_encoding: str
      :param content_language: The response header override for content language.
      :type content_language: str
      :param content_type: The response header override for content type.
      :type content_type: str
      """
  
      _validation = {
          'canonicalized_resource': {'required': True},
          'identifier': {'max_length': 64, 'min_length': 0},
      }
  
      _attribute_map = {
          'canonicalized_resource': {'key': 'canonicalizedResource', 'type': 'str'},
          'resource': {'key': 'signedResource', 'type': 'str'},
          'permissions': {'key': 'signedPermission', 'type': 'str'},
          'ip_address_or_range': {'key': 'signedIp', 'type': 'str'},
          'protocols': {'key': 'signedProtocol', 'type': 'str'},
          'shared_access_start_time': {'key': 'signedStart', 'type': 'iso-8601'},
          'shared_access_expiry_time': {'key': 'signedExpiry', 'type': 'iso-8601'},
          'identifier': {'key': 'signedIdentifier', 'type': 'str'},
          'partition_key_start': {'key': 'startPk', 'type': 'str'},
          'partition_key_end': {'key': 'endPk', 'type': 'str'},
          'row_key_start': {'key': 'startRk', 'type': 'str'},
          'row_key_end': {'key': 'endRk', 'type': 'str'},
          'key_to_sign': {'key': 'keyToSign', 'type': 'str'},
          'cache_control': {'key': 'rscc', 'type': 'str'},
          'content_disposition': {'key': 'rscd', 'type': 'str'},
          'content_encoding': {'key': 'rsce', 'type': 'str'},
          'content_language': {'key': 'rscl', 'type': 'str'},
          'content_type': {'key': 'rsct', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          canonicalized_resource: str,
          resource: Optional[Union[str, "SignedResource"]] = None,
          permissions: Optional[Union[str, "Permissions"]] = None,
          ip_address_or_range: Optional[str] = None,
          protocols: Optional[Union[str, "HttpProtocol"]] = None,
          shared_access_start_time: Optional[datetime.datetime] = None,
          shared_access_expiry_time: Optional[datetime.datetime] = None,
          identifier: Optional[str] = None,
          partition_key_start: Optional[str] = None,
          partition_key_end: Optional[str] = None,
          row_key_start: Optional[str] = None,
          row_key_end: Optional[str] = None,
          key_to_sign: Optional[str] = None,
          cache_control: Optional[str] = None,
          content_disposition: Optional[str] = None,
          content_encoding: Optional[str] = None,
          content_language: Optional[str] = None,
          content_type: Optional[str] = None,
          **kwargs
      ):
          super(ServiceSasParameters, self).__init__(**kwargs)
          self.canonicalized_resource = canonicalized_resource
          self.resource = resource
          self.permissions = permissions
          self.ip_address_or_range = ip_address_or_range
          self.protocols = protocols
          self.shared_access_start_time = shared_access_start_time
          self.shared_access_expiry_time = shared_access_expiry_time
          self.identifier = identifier
          self.partition_key_start = partition_key_start
          self.partition_key_end = partition_key_end
          self.row_key_start = row_key_start
          self.row_key_end = row_key_end
          self.key_to_sign = key_to_sign
          self.cache_control = cache_control
          self.content_disposition = content_disposition
          self.content_encoding = content_encoding
          self.content_language = content_language
          self.content_type = content_type
  
  
  class ServiceSpecification(msrest.serialization.Model):
      """One property of operation, include metric specifications.
  
      :param metric_specifications: Metric specifications of operation.
      :type metric_specifications: list[~azure.mgmt.storage.v2021_01_01.models.MetricSpecification]
      """
  
      _attribute_map = {
          'metric_specifications': {'key': 'metricSpecifications', 'type': '[MetricSpecification]'},
      }
  
      def __init__(
          self,
          *,
          metric_specifications: Optional[List["MetricSpecification"]] = None,
          **kwargs
      ):
          super(ServiceSpecification, self).__init__(**kwargs)
          self.metric_specifications = metric_specifications
  
  
  class Sku(msrest.serialization.Model):
      """The SKU of the storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :param name: Required. The SKU name. Required for account creation; optional for update. Note
       that in older versions, SKU name was called accountType. Possible values include:
       "Standard_LRS", "Standard_GRS", "Standard_RAGRS", "Standard_ZRS", "Premium_LRS", "Premium_ZRS",
       "Standard_GZRS", "Standard_RAGZRS".
      :type name: str or ~azure.mgmt.storage.v2021_01_01.models.SkuName
      :ivar tier: The SKU tier. This is based on the SKU name. Possible values include: "Standard",
       "Premium".
      :vartype tier: str or ~azure.mgmt.storage.v2021_01_01.models.SkuTier
      """
  
      _validation = {
          'name': {'required': True},
          'tier': {'readonly': True},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'tier': {'key': 'tier', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          name: Union[str, "SkuName"],
          **kwargs
      ):
          super(Sku, self).__init__(**kwargs)
          self.name = name
          self.tier = None
  
  
  class SKUCapability(msrest.serialization.Model):
      """The capability information in the specified SKU, including file encryption, network ACLs, change notification, etc.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar name: The name of capability, The capability information in the specified SKU, including
       file encryption, network ACLs, change notification, etc.
      :vartype name: str
      :ivar value: A string value to indicate states of given capability. Possibly 'true' or 'false'.
      :vartype value: str
      """
  
      _validation = {
          'name': {'readonly': True},
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'value': {'key': 'value', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(SKUCapability, self).__init__(**kwargs)
          self.name = None
          self.value = None
  
  
  class SkuInformation(msrest.serialization.Model):
      """Storage SKU and its properties.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :param name: Required. The SKU name. Required for account creation; optional for update. Note
       that in older versions, SKU name was called accountType. Possible values include:
       "Standard_LRS", "Standard_GRS", "Standard_RAGRS", "Standard_ZRS", "Premium_LRS", "Premium_ZRS",
       "Standard_GZRS", "Standard_RAGZRS".
      :type name: str or ~azure.mgmt.storage.v2021_01_01.models.SkuName
      :ivar tier: The SKU tier. This is based on the SKU name. Possible values include: "Standard",
       "Premium".
      :vartype tier: str or ~azure.mgmt.storage.v2021_01_01.models.SkuTier
      :ivar resource_type: The type of the resource, usually it is 'storageAccounts'.
      :vartype resource_type: str
      :ivar kind: Indicates the type of storage account. Possible values include: "Storage",
       "StorageV2", "BlobStorage", "FileStorage", "BlockBlobStorage".
      :vartype kind: str or ~azure.mgmt.storage.v2021_01_01.models.Kind
      :ivar locations: The set of locations that the SKU is available. This will be supported and
       registered Azure Geo Regions (e.g. West US, East US, Southeast Asia, etc.).
      :vartype locations: list[str]
      :ivar capabilities: The capability information in the specified SKU, including file encryption,
       network ACLs, change notification, etc.
      :vartype capabilities: list[~azure.mgmt.storage.v2021_01_01.models.SKUCapability]
      :param restrictions: The restrictions because of which SKU cannot be used. This is empty if
       there are no restrictions.
      :type restrictions: list[~azure.mgmt.storage.v2021_01_01.models.Restriction]
      """
  
      _validation = {
          'name': {'required': True},
          'tier': {'readonly': True},
          'resource_type': {'readonly': True},
          'kind': {'readonly': True},
          'locations': {'readonly': True},
          'capabilities': {'readonly': True},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'tier': {'key': 'tier', 'type': 'str'},
          'resource_type': {'key': 'resourceType', 'type': 'str'},
          'kind': {'key': 'kind', 'type': 'str'},
          'locations': {'key': 'locations', 'type': '[str]'},
          'capabilities': {'key': 'capabilities', 'type': '[SKUCapability]'},
          'restrictions': {'key': 'restrictions', 'type': '[Restriction]'},
      }
  
      def __init__(
          self,
          *,
          name: Union[str, "SkuName"],
          restrictions: Optional[List["Restriction"]] = None,
          **kwargs
      ):
          super(SkuInformation, self).__init__(**kwargs)
          self.name = name
          self.tier = None
          self.resource_type = None
          self.kind = None
          self.locations = None
          self.capabilities = None
          self.restrictions = restrictions
  
  
  class SmbSetting(msrest.serialization.Model):
      """Setting for SMB protocol.
  
      :param multichannel: Multichannel setting. Applies to Premium FileStorage only.
      :type multichannel: ~azure.mgmt.storage.v2021_01_01.models.Multichannel
      :param versions: SMB protocol versions supported by server. Valid values are SMB2.1, SMB3.0,
       SMB3.1.1. Should be passed as a string with delimiter ';'.
      :type versions: str
      :param authentication_methods: SMB authentication methods supported by server. Valid values are
       NTLMv2, Kerberos. Should be passed as a string with delimiter ';'.
      :type authentication_methods: str
      :param kerberos_ticket_encryption: Kerberos ticket encryption supported by server. Valid values
       are RC4-HMAC, AES-256. Should be passed as a string with delimiter ';'.
      :type kerberos_ticket_encryption: str
      :param channel_encryption: SMB channel encryption supported by server. Valid values are
       AES-128-CCM, AES-128-GCM, AES-256-GCM. Should be passed as a string with delimiter ';'.
      :type channel_encryption: str
      """
  
      _attribute_map = {
          'multichannel': {'key': 'multichannel', 'type': 'Multichannel'},
          'versions': {'key': 'versions', 'type': 'str'},
          'authentication_methods': {'key': 'authenticationMethods', 'type': 'str'},
          'kerberos_ticket_encryption': {'key': 'kerberosTicketEncryption', 'type': 'str'},
          'channel_encryption': {'key': 'channelEncryption', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          multichannel: Optional["Multichannel"] = None,
          versions: Optional[str] = None,
          authentication_methods: Optional[str] = None,
          kerberos_ticket_encryption: Optional[str] = None,
          channel_encryption: Optional[str] = None,
          **kwargs
      ):
          super(SmbSetting, self).__init__(**kwargs)
          self.multichannel = multichannel
          self.versions = versions
          self.authentication_methods = authentication_methods
          self.kerberos_ticket_encryption = kerberos_ticket_encryption
          self.channel_encryption = channel_encryption
  
  
  class TrackedResource(Resource):
      """The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param tags: A set of tags. Resource tags.
      :type tags: dict[str, str]
      :param location: Required. The geo-location where the resource lives.
      :type location: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'location': {'required': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'tags': {'key': 'tags', 'type': '{str}'},
          'location': {'key': 'location', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          location: str,
          tags: Optional[Dict[str, str]] = None,
          **kwargs
      ):
          super(TrackedResource, self).__init__(**kwargs)
          self.tags = tags
          self.location = location
  
  
  class StorageAccount(TrackedResource):
      """The storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param tags: A set of tags. Resource tags.
      :type tags: dict[str, str]
      :param location: Required. The geo-location where the resource lives.
      :type location: str
      :ivar sku: Gets the SKU.
      :vartype sku: ~azure.mgmt.storage.v2021_01_01.models.Sku
      :ivar kind: Gets the Kind. Possible values include: "Storage", "StorageV2", "BlobStorage",
       "FileStorage", "BlockBlobStorage".
      :vartype kind: str or ~azure.mgmt.storage.v2021_01_01.models.Kind
      :param identity: The identity of the resource.
      :type identity: ~azure.mgmt.storage.v2021_01_01.models.Identity
      :param extended_location: The extendedLocation of the resource.
      :type extended_location: ~azure.mgmt.storage.v2021_01_01.models.ExtendedLocation
      :ivar provisioning_state: Gets the status of the storage account at the time the operation was
       called. Possible values include: "Creating", "ResolvingDNS", "Succeeded".
      :vartype provisioning_state: str or ~azure.mgmt.storage.v2021_01_01.models.ProvisioningState
      :ivar primary_endpoints: Gets the URLs that are used to perform a retrieval of a public blob,
       queue, or table object. Note that Standard_ZRS and Premium_LRS accounts only return the blob
       endpoint.
      :vartype primary_endpoints: ~azure.mgmt.storage.v2021_01_01.models.Endpoints
      :ivar primary_location: Gets the location of the primary data center for the storage account.
      :vartype primary_location: str
      :ivar status_of_primary: Gets the status indicating whether the primary location of the storage
       account is available or unavailable. Possible values include: "available", "unavailable".
      :vartype status_of_primary: str or ~azure.mgmt.storage.v2021_01_01.models.AccountStatus
      :ivar last_geo_failover_time: Gets the timestamp of the most recent instance of a failover to
       the secondary location. Only the most recent timestamp is retained. This element is not
       returned if there has never been a failover instance. Only available if the accountType is
       Standard_GRS or Standard_RAGRS.
      :vartype last_geo_failover_time: ~datetime.datetime
      :ivar secondary_location: Gets the location of the geo-replicated secondary for the storage
       account. Only available if the accountType is Standard_GRS or Standard_RAGRS.
      :vartype secondary_location: str
      :ivar status_of_secondary: Gets the status indicating whether the secondary location of the
       storage account is available or unavailable. Only available if the SKU name is Standard_GRS or
       Standard_RAGRS. Possible values include: "available", "unavailable".
      :vartype status_of_secondary: str or ~azure.mgmt.storage.v2021_01_01.models.AccountStatus
      :ivar creation_time: Gets the creation date and time of the storage account in UTC.
      :vartype creation_time: ~datetime.datetime
      :ivar custom_domain: Gets the custom domain the user assigned to this storage account.
      :vartype custom_domain: ~azure.mgmt.storage.v2021_01_01.models.CustomDomain
      :ivar secondary_endpoints: Gets the URLs that are used to perform a retrieval of a public blob,
       queue, or table object from the secondary location of the storage account. Only available if
       the SKU name is Standard_RAGRS.
      :vartype secondary_endpoints: ~azure.mgmt.storage.v2021_01_01.models.Endpoints
      :ivar encryption: Gets the encryption settings on the account. If unspecified, the account is
       unencrypted.
      :vartype encryption: ~azure.mgmt.storage.v2021_01_01.models.Encryption
      :ivar access_tier: Required for storage accounts where kind = BlobStorage. The access tier used
       for billing. Possible values include: "Hot", "Cool".
      :vartype access_tier: str or ~azure.mgmt.storage.v2021_01_01.models.AccessTier
      :param azure_files_identity_based_authentication: Provides the identity based authentication
       settings for Azure Files.
      :type azure_files_identity_based_authentication:
       ~azure.mgmt.storage.v2021_01_01.models.AzureFilesIdentityBasedAuthentication
      :param enable_https_traffic_only: Allows https traffic only to storage service if sets to true.
      :type enable_https_traffic_only: bool
      :ivar network_rule_set: Network rule set.
      :vartype network_rule_set: ~azure.mgmt.storage.v2021_01_01.models.NetworkRuleSet
      :param is_hns_enabled: Account HierarchicalNamespace enabled if sets to true.
      :type is_hns_enabled: bool
      :ivar geo_replication_stats: Geo Replication Stats.
      :vartype geo_replication_stats: ~azure.mgmt.storage.v2021_01_01.models.GeoReplicationStats
      :ivar failover_in_progress: If the failover is in progress, the value will be true, otherwise,
       it will be null.
      :vartype failover_in_progress: bool
      :param large_file_shares_state: Allow large file shares if sets to Enabled. It cannot be
       disabled once it is enabled. Possible values include: "Disabled", "Enabled".
      :type large_file_shares_state: str or
       ~azure.mgmt.storage.v2021_01_01.models.LargeFileSharesState
      :ivar private_endpoint_connections: List of private endpoint connection associated with the
       specified storage account.
      :vartype private_endpoint_connections:
       list[~azure.mgmt.storage.v2021_01_01.models.PrivateEndpointConnection]
      :param routing_preference: Maintains information about the network routing choice opted by the
       user for data transfer.
      :type routing_preference: ~azure.mgmt.storage.v2021_01_01.models.RoutingPreference
      :ivar blob_restore_status: Blob restore status.
      :vartype blob_restore_status: ~azure.mgmt.storage.v2021_01_01.models.BlobRestoreStatus
      :param allow_blob_public_access: Allow or disallow public access to all blobs or containers in
       the storage account. The default interpretation is true for this property.
      :type allow_blob_public_access: bool
      :param minimum_tls_version: Set the minimum TLS version to be permitted on requests to storage.
       The default interpretation is TLS 1.0 for this property. Possible values include: "TLS1_0",
       "TLS1_1", "TLS1_2".
      :type minimum_tls_version: str or ~azure.mgmt.storage.v2021_01_01.models.MinimumTlsVersion
      :param allow_shared_key_access: Indicates whether the storage account permits requests to be
       authorized with the account access key via Shared Key. If false, then all requests, including
       shared access signatures, must be authorized with Azure Active Directory (Azure AD). The
       default value is null, which is equivalent to true.
      :type allow_shared_key_access: bool
      :param enable_nfs_v3: NFS 3.0 protocol support enabled if set to true.
      :type enable_nfs_v3: bool
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'location': {'required': True},
          'sku': {'readonly': True},
          'kind': {'readonly': True},
          'provisioning_state': {'readonly': True},
          'primary_endpoints': {'readonly': True},
          'primary_location': {'readonly': True},
          'status_of_primary': {'readonly': True},
          'last_geo_failover_time': {'readonly': True},
          'secondary_location': {'readonly': True},
          'status_of_secondary': {'readonly': True},
          'creation_time': {'readonly': True},
          'custom_domain': {'readonly': True},
          'secondary_endpoints': {'readonly': True},
          'encryption': {'readonly': True},
          'access_tier': {'readonly': True},
          'network_rule_set': {'readonly': True},
          'geo_replication_stats': {'readonly': True},
          'failover_in_progress': {'readonly': True},
          'private_endpoint_connections': {'readonly': True},
          'blob_restore_status': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'tags': {'key': 'tags', 'type': '{str}'},
          'location': {'key': 'location', 'type': 'str'},
          'sku': {'key': 'sku', 'type': 'Sku'},
          'kind': {'key': 'kind', 'type': 'str'},
          'identity': {'key': 'identity', 'type': 'Identity'},
          'extended_location': {'key': 'extendedLocation', 'type': 'ExtendedLocation'},
          'provisioning_state': {'key': 'properties.provisioningState', 'type': 'str'},
          'primary_endpoints': {'key': 'properties.primaryEndpoints', 'type': 'Endpoints'},
          'primary_location': {'key': 'properties.primaryLocation', 'type': 'str'},
          'status_of_primary': {'key': 'properties.statusOfPrimary', 'type': 'str'},
          'last_geo_failover_time': {'key': 'properties.lastGeoFailoverTime', 'type': 'iso-8601'},
          'secondary_location': {'key': 'properties.secondaryLocation', 'type': 'str'},
          'status_of_secondary': {'key': 'properties.statusOfSecondary', 'type': 'str'},
          'creation_time': {'key': 'properties.creationTime', 'type': 'iso-8601'},
          'custom_domain': {'key': 'properties.customDomain', 'type': 'CustomDomain'},
          'secondary_endpoints': {'key': 'properties.secondaryEndpoints', 'type': 'Endpoints'},
          'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
          'access_tier': {'key': 'properties.accessTier', 'type': 'str'},
          'azure_files_identity_based_authentication': {'key': 'properties.azureFilesIdentityBasedAuthentication', 'type': 'AzureFilesIdentityBasedAuthentication'},
          'enable_https_traffic_only': {'key': 'properties.supportsHttpsTrafficOnly', 'type': 'bool'},
          'network_rule_set': {'key': 'properties.networkAcls', 'type': 'NetworkRuleSet'},
          'is_hns_enabled': {'key': 'properties.isHnsEnabled', 'type': 'bool'},
          'geo_replication_stats': {'key': 'properties.geoReplicationStats', 'type': 'GeoReplicationStats'},
          'failover_in_progress': {'key': 'properties.failoverInProgress', 'type': 'bool'},
          'large_file_shares_state': {'key': 'properties.largeFileSharesState', 'type': 'str'},
          'private_endpoint_connections': {'key': 'properties.privateEndpointConnections', 'type': '[PrivateEndpointConnection]'},
          'routing_preference': {'key': 'properties.routingPreference', 'type': 'RoutingPreference'},
          'blob_restore_status': {'key': 'properties.blobRestoreStatus', 'type': 'BlobRestoreStatus'},
          'allow_blob_public_access': {'key': 'properties.allowBlobPublicAccess', 'type': 'bool'},
          'minimum_tls_version': {'key': 'properties.minimumTlsVersion', 'type': 'str'},
          'allow_shared_key_access': {'key': 'properties.allowSharedKeyAccess', 'type': 'bool'},
          'enable_nfs_v3': {'key': 'properties.isNfsV3Enabled', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          location: str,
          tags: Optional[Dict[str, str]] = None,
          identity: Optional["Identity"] = None,
          extended_location: Optional["ExtendedLocation"] = None,
          azure_files_identity_based_authentication: Optional["AzureFilesIdentityBasedAuthentication"] = None,
          enable_https_traffic_only: Optional[bool] = None,
          is_hns_enabled: Optional[bool] = None,
          large_file_shares_state: Optional[Union[str, "LargeFileSharesState"]] = None,
          routing_preference: Optional["RoutingPreference"] = None,
          allow_blob_public_access: Optional[bool] = None,
          minimum_tls_version: Optional[Union[str, "MinimumTlsVersion"]] = None,
          allow_shared_key_access: Optional[bool] = None,
          enable_nfs_v3: Optional[bool] = None,
          **kwargs
      ):
          super(StorageAccount, self).__init__(tags=tags, location=location, **kwargs)
          self.sku = None
          self.kind = None
          self.identity = identity
          self.extended_location = extended_location
          self.provisioning_state = None
          self.primary_endpoints = None
          self.primary_location = None
          self.status_of_primary = None
          self.last_geo_failover_time = None
          self.secondary_location = None
          self.status_of_secondary = None
          self.creation_time = None
          self.custom_domain = None
          self.secondary_endpoints = None
          self.encryption = None
          self.access_tier = None
          self.azure_files_identity_based_authentication = azure_files_identity_based_authentication
          self.enable_https_traffic_only = enable_https_traffic_only
          self.network_rule_set = None
          self.is_hns_enabled = is_hns_enabled
          self.geo_replication_stats = None
          self.failover_in_progress = None
          self.large_file_shares_state = large_file_shares_state
          self.private_endpoint_connections = None
          self.routing_preference = routing_preference
          self.blob_restore_status = None
          self.allow_blob_public_access = allow_blob_public_access
          self.minimum_tls_version = minimum_tls_version
          self.allow_shared_key_access = allow_shared_key_access
          self.enable_nfs_v3 = enable_nfs_v3
  
  
  class StorageAccountCheckNameAvailabilityParameters(msrest.serialization.Model):
      """The parameters used to check the availability of the storage account name.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      All required parameters must be populated in order to send to Azure.
  
      :param name: Required. The storage account name.
      :type name: str
      :ivar type: The type of resource, Microsoft.Storage/storageAccounts. Has constant value:
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      """
  
      _validation = {
          'name': {'required': True},
          'type': {'required': True, 'constant': True},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
      }
  
      type = "Microsoft.Storage/storageAccounts"
  
      def __init__(
          self,
          *,
          name: str,
          **kwargs
      ):
          super(StorageAccountCheckNameAvailabilityParameters, self).__init__(**kwargs)
          self.name = name
  
  
  class StorageAccountCreateParameters(msrest.serialization.Model):
      """The parameters used when creating a storage account.
  
      All required parameters must be populated in order to send to Azure.
  
      :param sku: Required. Required. Gets or sets the SKU name.
      :type sku: ~azure.mgmt.storage.v2021_01_01.models.Sku
      :param kind: Required. Required. Indicates the type of storage account. Possible values
       include: "Storage", "StorageV2", "BlobStorage", "FileStorage", "BlockBlobStorage".
      :type kind: str or ~azure.mgmt.storage.v2021_01_01.models.Kind
      :param location: Required. Required. Gets or sets the location of the resource. This will be
       one of the supported and registered Azure Geo Regions (e.g. West US, East US, Southeast Asia,
       etc.). The geo region of a resource cannot be changed once it is created, but if an identical
       geo region is specified on update, the request will succeed.
      :type location: str
      :param extended_location: Optional. Set the extended location of the resource. If not set, the
       storage account will be created in Azure main region. Otherwise it will be created in the
       specified extended location.
      :type extended_location: ~azure.mgmt.storage.v2021_01_01.models.ExtendedLocation
      :param tags: A set of tags. Gets or sets a list of key value pairs that describe the resource.
       These tags can be used for viewing and grouping this resource (across resource groups). A
       maximum of 15 tags can be provided for a resource. Each tag must have a key with a length no
       greater than 128 characters and a value with a length no greater than 256 characters.
      :type tags: dict[str, str]
      :param identity: The identity of the resource.
      :type identity: ~azure.mgmt.storage.v2021_01_01.models.Identity
      :param custom_domain: User domain assigned to the storage account. Name is the CNAME source.
       Only one custom domain is supported per storage account at this time. To clear the existing
       custom domain, use an empty string for the custom domain name property.
      :type custom_domain: ~azure.mgmt.storage.v2021_01_01.models.CustomDomain
      :param encryption: Not applicable. Azure Storage encryption is enabled for all storage accounts
       and cannot be disabled.
      :type encryption: ~azure.mgmt.storage.v2021_01_01.models.Encryption
      :param network_rule_set: Network rule set.
      :type network_rule_set: ~azure.mgmt.storage.v2021_01_01.models.NetworkRuleSet
      :param access_tier: Required for storage accounts where kind = BlobStorage. The access tier
       used for billing. Possible values include: "Hot", "Cool".
      :type access_tier: str or ~azure.mgmt.storage.v2021_01_01.models.AccessTier
      :param azure_files_identity_based_authentication: Provides the identity based authentication
       settings for Azure Files.
      :type azure_files_identity_based_authentication:
       ~azure.mgmt.storage.v2021_01_01.models.AzureFilesIdentityBasedAuthentication
      :param enable_https_traffic_only: Allows https traffic only to storage service if sets to true.
       The default value is true since API version 2019-04-01.
      :type enable_https_traffic_only: bool
      :param is_hns_enabled: Account HierarchicalNamespace enabled if sets to true.
      :type is_hns_enabled: bool
      :param large_file_shares_state: Allow large file shares if sets to Enabled. It cannot be
       disabled once it is enabled. Possible values include: "Disabled", "Enabled".
      :type large_file_shares_state: str or
       ~azure.mgmt.storage.v2021_01_01.models.LargeFileSharesState
      :param routing_preference: Maintains information about the network routing choice opted by the
       user for data transfer.
      :type routing_preference: ~azure.mgmt.storage.v2021_01_01.models.RoutingPreference
      :param allow_blob_public_access: Allow or disallow public access to all blobs or containers in
       the storage account. The default interpretation is true for this property.
      :type allow_blob_public_access: bool
      :param minimum_tls_version: Set the minimum TLS version to be permitted on requests to storage.
       The default interpretation is TLS 1.0 for this property. Possible values include: "TLS1_0",
       "TLS1_1", "TLS1_2".
      :type minimum_tls_version: str or ~azure.mgmt.storage.v2021_01_01.models.MinimumTlsVersion
      :param allow_shared_key_access: Indicates whether the storage account permits requests to be
       authorized with the account access key via Shared Key. If false, then all requests, including
       shared access signatures, must be authorized with Azure Active Directory (Azure AD). The
       default value is null, which is equivalent to true.
      :type allow_shared_key_access: bool
      :param enable_nfs_v3: NFS 3.0 protocol support enabled if set to true.
      :type enable_nfs_v3: bool
      """
  
      _validation = {
          'sku': {'required': True},
          'kind': {'required': True},
          'location': {'required': True},
      }
  
      _attribute_map = {
          'sku': {'key': 'sku', 'type': 'Sku'},
          'kind': {'key': 'kind', 'type': 'str'},
          'location': {'key': 'location', 'type': 'str'},
          'extended_location': {'key': 'extendedLocation', 'type': 'ExtendedLocation'},
          'tags': {'key': 'tags', 'type': '{str}'},
          'identity': {'key': 'identity', 'type': 'Identity'},
          'custom_domain': {'key': 'properties.customDomain', 'type': 'CustomDomain'},
          'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
          'network_rule_set': {'key': 'properties.networkAcls', 'type': 'NetworkRuleSet'},
          'access_tier': {'key': 'properties.accessTier', 'type': 'str'},
          'azure_files_identity_based_authentication': {'key': 'properties.azureFilesIdentityBasedAuthentication', 'type': 'AzureFilesIdentityBasedAuthentication'},
          'enable_https_traffic_only': {'key': 'properties.supportsHttpsTrafficOnly', 'type': 'bool'},
          'is_hns_enabled': {'key': 'properties.isHnsEnabled', 'type': 'bool'},
          'large_file_shares_state': {'key': 'properties.largeFileSharesState', 'type': 'str'},
          'routing_preference': {'key': 'properties.routingPreference', 'type': 'RoutingPreference'},
          'allow_blob_public_access': {'key': 'properties.allowBlobPublicAccess', 'type': 'bool'},
          'minimum_tls_version': {'key': 'properties.minimumTlsVersion', 'type': 'str'},
          'allow_shared_key_access': {'key': 'properties.allowSharedKeyAccess', 'type': 'bool'},
          'enable_nfs_v3': {'key': 'properties.isNfsV3Enabled', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          sku: "Sku",
          kind: Union[str, "Kind"],
          location: str,
          extended_location: Optional["ExtendedLocation"] = None,
          tags: Optional[Dict[str, str]] = None,
          identity: Optional["Identity"] = None,
          custom_domain: Optional["CustomDomain"] = None,
          encryption: Optional["Encryption"] = None,
          network_rule_set: Optional["NetworkRuleSet"] = None,
          access_tier: Optional[Union[str, "AccessTier"]] = None,
          azure_files_identity_based_authentication: Optional["AzureFilesIdentityBasedAuthentication"] = None,
          enable_https_traffic_only: Optional[bool] = None,
          is_hns_enabled: Optional[bool] = None,
          large_file_shares_state: Optional[Union[str, "LargeFileSharesState"]] = None,
          routing_preference: Optional["RoutingPreference"] = None,
          allow_blob_public_access: Optional[bool] = None,
          minimum_tls_version: Optional[Union[str, "MinimumTlsVersion"]] = None,
          allow_shared_key_access: Optional[bool] = None,
          enable_nfs_v3: Optional[bool] = None,
          **kwargs
      ):
          super(StorageAccountCreateParameters, self).__init__(**kwargs)
          self.sku = sku
          self.kind = kind
          self.location = location
          self.extended_location = extended_location
          self.tags = tags
          self.identity = identity
          self.custom_domain = custom_domain
          self.encryption = encryption
          self.network_rule_set = network_rule_set
          self.access_tier = access_tier
          self.azure_files_identity_based_authentication = azure_files_identity_based_authentication
          self.enable_https_traffic_only = enable_https_traffic_only
          self.is_hns_enabled = is_hns_enabled
          self.large_file_shares_state = large_file_shares_state
          self.routing_preference = routing_preference
          self.allow_blob_public_access = allow_blob_public_access
          self.minimum_tls_version = minimum_tls_version
          self.allow_shared_key_access = allow_shared_key_access
          self.enable_nfs_v3 = enable_nfs_v3
  
  
  class StorageAccountInternetEndpoints(msrest.serialization.Model):
      """The URIs that are used to perform a retrieval of a public blob, file, web or dfs object via a internet routing endpoint.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar blob: Gets the blob endpoint.
      :vartype blob: str
      :ivar file: Gets the file endpoint.
      :vartype file: str
      :ivar web: Gets the web endpoint.
      :vartype web: str
      :ivar dfs: Gets the dfs endpoint.
      :vartype dfs: str
      """
  
      _validation = {
          'blob': {'readonly': True},
          'file': {'readonly': True},
          'web': {'readonly': True},
          'dfs': {'readonly': True},
      }
  
      _attribute_map = {
          'blob': {'key': 'blob', 'type': 'str'},
          'file': {'key': 'file', 'type': 'str'},
          'web': {'key': 'web', 'type': 'str'},
          'dfs': {'key': 'dfs', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageAccountInternetEndpoints, self).__init__(**kwargs)
          self.blob = None
          self.file = None
          self.web = None
          self.dfs = None
  
  
  class StorageAccountKey(msrest.serialization.Model):
      """An access key for the storage account.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar key_name: Name of the key.
      :vartype key_name: str
      :ivar value: Base 64-encoded value of the key.
      :vartype value: str
      :ivar permissions: Permissions for the key -- read-only or full permissions. Possible values
       include: "Read", "Full".
      :vartype permissions: str or ~azure.mgmt.storage.v2021_01_01.models.KeyPermission
      """
  
      _validation = {
          'key_name': {'readonly': True},
          'value': {'readonly': True},
          'permissions': {'readonly': True},
      }
  
      _attribute_map = {
          'key_name': {'key': 'keyName', 'type': 'str'},
          'value': {'key': 'value', 'type': 'str'},
          'permissions': {'key': 'permissions', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageAccountKey, self).__init__(**kwargs)
          self.key_name = None
          self.value = None
          self.permissions = None
  
  
  class StorageAccountListKeysResult(msrest.serialization.Model):
      """The response from the ListKeys operation.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar keys: Gets the list of storage account keys and their properties for the specified
       storage account.
      :vartype keys: list[~azure.mgmt.storage.v2021_01_01.models.StorageAccountKey]
      """
  
      _validation = {
          'keys': {'readonly': True},
      }
  
      _attribute_map = {
          'keys': {'key': 'keys', 'type': '[StorageAccountKey]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageAccountListKeysResult, self).__init__(**kwargs)
          self.keys = None
  
  
  class StorageAccountListResult(msrest.serialization.Model):
      """The response from the List Storage Accounts operation.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: Gets the list of storage accounts and their properties.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.StorageAccount]
      :ivar next_link: Request URL that can be used to query next page of storage accounts. Returned
       when total number of requested storage accounts exceed maximum page size.
      :vartype next_link: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'next_link': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[StorageAccount]'},
          'next_link': {'key': 'nextLink', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageAccountListResult, self).__init__(**kwargs)
          self.value = None
          self.next_link = None
  
  
  class StorageAccountMicrosoftEndpoints(msrest.serialization.Model):
      """The URIs that are used to perform a retrieval of a public blob, queue, table, web or dfs object via a microsoft routing endpoint.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar blob: Gets the blob endpoint.
      :vartype blob: str
      :ivar queue: Gets the queue endpoint.
      :vartype queue: str
      :ivar table: Gets the table endpoint.
      :vartype table: str
      :ivar file: Gets the file endpoint.
      :vartype file: str
      :ivar web: Gets the web endpoint.
      :vartype web: str
      :ivar dfs: Gets the dfs endpoint.
      :vartype dfs: str
      """
  
      _validation = {
          'blob': {'readonly': True},
          'queue': {'readonly': True},
          'table': {'readonly': True},
          'file': {'readonly': True},
          'web': {'readonly': True},
          'dfs': {'readonly': True},
      }
  
      _attribute_map = {
          'blob': {'key': 'blob', 'type': 'str'},
          'queue': {'key': 'queue', 'type': 'str'},
          'table': {'key': 'table', 'type': 'str'},
          'file': {'key': 'file', 'type': 'str'},
          'web': {'key': 'web', 'type': 'str'},
          'dfs': {'key': 'dfs', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageAccountMicrosoftEndpoints, self).__init__(**kwargs)
          self.blob = None
          self.queue = None
          self.table = None
          self.file = None
          self.web = None
          self.dfs = None
  
  
  class StorageAccountRegenerateKeyParameters(msrest.serialization.Model):
      """The parameters used to regenerate the storage account key.
  
      All required parameters must be populated in order to send to Azure.
  
      :param key_name: Required. The name of storage keys that want to be regenerated, possible
       values are key1, key2, kerb1, kerb2.
      :type key_name: str
      """
  
      _validation = {
          'key_name': {'required': True},
      }
  
      _attribute_map = {
          'key_name': {'key': 'keyName', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          key_name: str,
          **kwargs
      ):
          super(StorageAccountRegenerateKeyParameters, self).__init__(**kwargs)
          self.key_name = key_name
  
  
  class StorageAccountUpdateParameters(msrest.serialization.Model):
      """The parameters that can be provided when updating the storage account properties.
  
      :param sku: Gets or sets the SKU name. Note that the SKU name cannot be updated to
       Standard_ZRS, Premium_LRS or Premium_ZRS, nor can accounts of those SKU names be updated to any
       other value.
      :type sku: ~azure.mgmt.storage.v2021_01_01.models.Sku
      :param tags: A set of tags. Gets or sets a list of key value pairs that describe the resource.
       These tags can be used in viewing and grouping this resource (across resource groups). A
       maximum of 15 tags can be provided for a resource. Each tag must have a key no greater in
       length than 128 characters and a value no greater in length than 256 characters.
      :type tags: dict[str, str]
      :param identity: The identity of the resource.
      :type identity: ~azure.mgmt.storage.v2021_01_01.models.Identity
      :param kind: Optional. Indicates the type of storage account. Currently only StorageV2 value
       supported by server. Possible values include: "Storage", "StorageV2", "BlobStorage",
       "FileStorage", "BlockBlobStorage".
      :type kind: str or ~azure.mgmt.storage.v2021_01_01.models.Kind
      :param custom_domain: Custom domain assigned to the storage account by the user. Name is the
       CNAME source. Only one custom domain is supported per storage account at this time. To clear
       the existing custom domain, use an empty string for the custom domain name property.
      :type custom_domain: ~azure.mgmt.storage.v2021_01_01.models.CustomDomain
      :param encryption: Provides the encryption settings on the account. The default setting is
       unencrypted.
      :type encryption: ~azure.mgmt.storage.v2021_01_01.models.Encryption
      :param access_tier: Required for storage accounts where kind = BlobStorage. The access tier
       used for billing. Possible values include: "Hot", "Cool".
      :type access_tier: str or ~azure.mgmt.storage.v2021_01_01.models.AccessTier
      :param azure_files_identity_based_authentication: Provides the identity based authentication
       settings for Azure Files.
      :type azure_files_identity_based_authentication:
       ~azure.mgmt.storage.v2021_01_01.models.AzureFilesIdentityBasedAuthentication
      :param enable_https_traffic_only: Allows https traffic only to storage service if sets to true.
      :type enable_https_traffic_only: bool
      :param network_rule_set: Network rule set.
      :type network_rule_set: ~azure.mgmt.storage.v2021_01_01.models.NetworkRuleSet
      :param large_file_shares_state: Allow large file shares if sets to Enabled. It cannot be
       disabled once it is enabled. Possible values include: "Disabled", "Enabled".
      :type large_file_shares_state: str or
       ~azure.mgmt.storage.v2021_01_01.models.LargeFileSharesState
      :param routing_preference: Maintains information about the network routing choice opted by the
       user for data transfer.
      :type routing_preference: ~azure.mgmt.storage.v2021_01_01.models.RoutingPreference
      :param allow_blob_public_access: Allow or disallow public access to all blobs or containers in
       the storage account. The default interpretation is true for this property.
      :type allow_blob_public_access: bool
      :param minimum_tls_version: Set the minimum TLS version to be permitted on requests to storage.
       The default interpretation is TLS 1.0 for this property. Possible values include: "TLS1_0",
       "TLS1_1", "TLS1_2".
      :type minimum_tls_version: str or ~azure.mgmt.storage.v2021_01_01.models.MinimumTlsVersion
      :param allow_shared_key_access: Indicates whether the storage account permits requests to be
       authorized with the account access key via Shared Key. If false, then all requests, including
       shared access signatures, must be authorized with Azure Active Directory (Azure AD). The
       default value is null, which is equivalent to true.
      :type allow_shared_key_access: bool
      """
  
      _attribute_map = {
          'sku': {'key': 'sku', 'type': 'Sku'},
          'tags': {'key': 'tags', 'type': '{str}'},
          'identity': {'key': 'identity', 'type': 'Identity'},
          'kind': {'key': 'kind', 'type': 'str'},
          'custom_domain': {'key': 'properties.customDomain', 'type': 'CustomDomain'},
          'encryption': {'key': 'properties.encryption', 'type': 'Encryption'},
          'access_tier': {'key': 'properties.accessTier', 'type': 'str'},
          'azure_files_identity_based_authentication': {'key': 'properties.azureFilesIdentityBasedAuthentication', 'type': 'AzureFilesIdentityBasedAuthentication'},
          'enable_https_traffic_only': {'key': 'properties.supportsHttpsTrafficOnly', 'type': 'bool'},
          'network_rule_set': {'key': 'properties.networkAcls', 'type': 'NetworkRuleSet'},
          'large_file_shares_state': {'key': 'properties.largeFileSharesState', 'type': 'str'},
          'routing_preference': {'key': 'properties.routingPreference', 'type': 'RoutingPreference'},
          'allow_blob_public_access': {'key': 'properties.allowBlobPublicAccess', 'type': 'bool'},
          'minimum_tls_version': {'key': 'properties.minimumTlsVersion', 'type': 'str'},
          'allow_shared_key_access': {'key': 'properties.allowSharedKeyAccess', 'type': 'bool'},
      }
  
      def __init__(
          self,
          *,
          sku: Optional["Sku"] = None,
          tags: Optional[Dict[str, str]] = None,
          identity: Optional["Identity"] = None,
          kind: Optional[Union[str, "Kind"]] = None,
          custom_domain: Optional["CustomDomain"] = None,
          encryption: Optional["Encryption"] = None,
          access_tier: Optional[Union[str, "AccessTier"]] = None,
          azure_files_identity_based_authentication: Optional["AzureFilesIdentityBasedAuthentication"] = None,
          enable_https_traffic_only: Optional[bool] = None,
          network_rule_set: Optional["NetworkRuleSet"] = None,
          large_file_shares_state: Optional[Union[str, "LargeFileSharesState"]] = None,
          routing_preference: Optional["RoutingPreference"] = None,
          allow_blob_public_access: Optional[bool] = None,
          minimum_tls_version: Optional[Union[str, "MinimumTlsVersion"]] = None,
          allow_shared_key_access: Optional[bool] = None,
          **kwargs
      ):
          super(StorageAccountUpdateParameters, self).__init__(**kwargs)
          self.sku = sku
          self.tags = tags
          self.identity = identity
          self.kind = kind
          self.custom_domain = custom_domain
          self.encryption = encryption
          self.access_tier = access_tier
          self.azure_files_identity_based_authentication = azure_files_identity_based_authentication
          self.enable_https_traffic_only = enable_https_traffic_only
          self.network_rule_set = network_rule_set
          self.large_file_shares_state = large_file_shares_state
          self.routing_preference = routing_preference
          self.allow_blob_public_access = allow_blob_public_access
          self.minimum_tls_version = minimum_tls_version
          self.allow_shared_key_access = allow_shared_key_access
  
  
  class StorageQueue(Resource):
      """StorageQueue.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param metadata: A name-value pair that represents queue metadata.
      :type metadata: dict[str, str]
      :ivar approximate_message_count: Integer indicating an approximate number of messages in the
       queue. This number is not lower than the actual number of messages in the queue, but could be
       higher.
      :vartype approximate_message_count: int
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'approximate_message_count': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'metadata': {'key': 'properties.metadata', 'type': '{str}'},
          'approximate_message_count': {'key': 'properties.approximateMessageCount', 'type': 'int'},
      }
  
      def __init__(
          self,
          *,
          metadata: Optional[Dict[str, str]] = None,
          **kwargs
      ):
          super(StorageQueue, self).__init__(**kwargs)
          self.metadata = metadata
          self.approximate_message_count = None
  
  
  class StorageSkuListResult(msrest.serialization.Model):
      """The response from the List Storage SKUs operation.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: Get the list result of storage SKUs and their properties.
      :vartype value: list[~azure.mgmt.storage.v2021_01_01.models.SkuInformation]
      """
  
      _validation = {
          'value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[SkuInformation]'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(StorageSkuListResult, self).__init__(**kwargs)
          self.value = None
  
  
  class SystemData(msrest.serialization.Model):
      """Metadata pertaining to creation and last modification of the resource.
  
      :param created_by: The identity that created the resource.
      :type created_by: str
      :param created_by_type: The type of identity that created the resource. Possible values
       include: "User", "Application", "ManagedIdentity", "Key".
      :type created_by_type: str or ~azure.mgmt.storage.v2021_01_01.models.CreatedByType
      :param created_at: The timestamp of resource creation (UTC).
      :type created_at: ~datetime.datetime
      :param last_modified_by: The identity that last modified the resource.
      :type last_modified_by: str
      :param last_modified_by_type: The type of identity that last modified the resource. Possible
       values include: "User", "Application", "ManagedIdentity", "Key".
      :type last_modified_by_type: str or ~azure.mgmt.storage.v2021_01_01.models.CreatedByType
      :param last_modified_at: The timestamp of resource last modification (UTC).
      :type last_modified_at: ~datetime.datetime
      """
  
      _attribute_map = {
          'created_by': {'key': 'createdBy', 'type': 'str'},
          'created_by_type': {'key': 'createdByType', 'type': 'str'},
          'created_at': {'key': 'createdAt', 'type': 'iso-8601'},
          'last_modified_by': {'key': 'lastModifiedBy', 'type': 'str'},
          'last_modified_by_type': {'key': 'lastModifiedByType', 'type': 'str'},
          'last_modified_at': {'key': 'lastModifiedAt', 'type': 'iso-8601'},
      }
  
      def __init__(
          self,
          *,
          created_by: Optional[str] = None,
          created_by_type: Optional[Union[str, "CreatedByType"]] = None,
          created_at: Optional[datetime.datetime] = None,
          last_modified_by: Optional[str] = None,
          last_modified_by_type: Optional[Union[str, "CreatedByType"]] = None,
          last_modified_at: Optional[datetime.datetime] = None,
          **kwargs
      ):
          super(SystemData, self).__init__(**kwargs)
          self.created_by = created_by
          self.created_by_type = created_by_type
          self.created_at = created_at
          self.last_modified_by = last_modified_by
          self.last_modified_by_type = last_modified_by_type
          self.last_modified_at = last_modified_at
  
  
  class Table(Resource):
      """Properties of the table, including Id, resource name, resource type.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :ivar table_name: Table name under the specified account.
      :vartype table_name: str
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
          'table_name': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'table_name': {'key': 'properties.tableName', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(Table, self).__init__(**kwargs)
          self.table_name = None
  
  
  class TableServiceProperties(Resource):
      """The properties of a storage account’s Table service.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar id: Fully qualified resource ID for the resource. Ex -
       /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}.
      :vartype id: str
      :ivar name: The name of the resource.
      :vartype name: str
      :ivar type: The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or
       "Microsoft.Storage/storageAccounts".
      :vartype type: str
      :param cors: Specifies CORS rules for the Table service. You can include up to five CorsRule
       elements in the request. If no CorsRule elements are included in the request body, all CORS
       rules will be deleted, and CORS will be disabled for the Table service.
      :type cors: ~azure.mgmt.storage.v2021_01_01.models.CorsRules
      """
  
      _validation = {
          'id': {'readonly': True},
          'name': {'readonly': True},
          'type': {'readonly': True},
      }
  
      _attribute_map = {
          'id': {'key': 'id', 'type': 'str'},
          'name': {'key': 'name', 'type': 'str'},
          'type': {'key': 'type', 'type': 'str'},
          'cors': {'key': 'properties.cors', 'type': 'CorsRules'},
      }
  
      def __init__(
          self,
          *,
          cors: Optional["CorsRules"] = None,
          **kwargs
      ):
          super(TableServiceProperties, self).__init__(**kwargs)
          self.cors = cors
  
  
  class TagFilter(msrest.serialization.Model):
      """Blob index tag based filtering for blob objects.
  
      All required parameters must be populated in order to send to Azure.
  
      :param name: Required. This is the filter tag name, it can have 1 - 128 characters.
      :type name: str
      :param op: Required. This is the comparison operator which is used for object comparison and
       filtering. Only == (equality operator) is currently supported.
      :type op: str
      :param value: Required. This is the filter tag value field used for tag based filtering, it can
       have 0 - 256 characters.
      :type value: str
      """
  
      _validation = {
          'name': {'required': True, 'max_length': 128, 'min_length': 1},
          'op': {'required': True},
          'value': {'required': True, 'max_length': 256, 'min_length': 0},
      }
  
      _attribute_map = {
          'name': {'key': 'name', 'type': 'str'},
          'op': {'key': 'op', 'type': 'str'},
          'value': {'key': 'value', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          name: str,
          op: str,
          value: str,
          **kwargs
      ):
          super(TagFilter, self).__init__(**kwargs)
          self.name = name
          self.op = op
          self.value = value
  
  
  class TagProperty(msrest.serialization.Model):
      """A tag of the LegalHold of a blob container.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar tag: The tag value.
      :vartype tag: str
      :ivar timestamp: Returns the date and time the tag was added.
      :vartype timestamp: ~datetime.datetime
      :ivar object_identifier: Returns the Object ID of the user who added the tag.
      :vartype object_identifier: str
      :ivar tenant_id: Returns the Tenant ID that issued the token for the user who added the tag.
      :vartype tenant_id: str
      :ivar upn: Returns the User Principal Name of the user who added the tag.
      :vartype upn: str
      """
  
      _validation = {
          'tag': {'readonly': True},
          'timestamp': {'readonly': True},
          'object_identifier': {'readonly': True},
          'tenant_id': {'readonly': True},
          'upn': {'readonly': True},
      }
  
      _attribute_map = {
          'tag': {'key': 'tag', 'type': 'str'},
          'timestamp': {'key': 'timestamp', 'type': 'iso-8601'},
          'object_identifier': {'key': 'objectIdentifier', 'type': 'str'},
          'tenant_id': {'key': 'tenantId', 'type': 'str'},
          'upn': {'key': 'upn', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(TagProperty, self).__init__(**kwargs)
          self.tag = None
          self.timestamp = None
          self.object_identifier = None
          self.tenant_id = None
          self.upn = None
  
  
  class UpdateHistoryProperty(msrest.serialization.Model):
      """An update history of the ImmutabilityPolicy of a blob container.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar update: The ImmutabilityPolicy update type of a blob container, possible values include:
       put, lock and extend. Possible values include: "put", "lock", "extend".
      :vartype update: str or ~azure.mgmt.storage.v2021_01_01.models.ImmutabilityPolicyUpdateType
      :ivar immutability_period_since_creation_in_days: The immutability period for the blobs in the
       container since the policy creation, in days.
      :vartype immutability_period_since_creation_in_days: int
      :ivar timestamp: Returns the date and time the ImmutabilityPolicy was updated.
      :vartype timestamp: ~datetime.datetime
      :ivar object_identifier: Returns the Object ID of the user who updated the ImmutabilityPolicy.
      :vartype object_identifier: str
      :ivar tenant_id: Returns the Tenant ID that issued the token for the user who updated the
       ImmutabilityPolicy.
      :vartype tenant_id: str
      :ivar upn: Returns the User Principal Name of the user who updated the ImmutabilityPolicy.
      :vartype upn: str
      """
  
      _validation = {
          'update': {'readonly': True},
          'immutability_period_since_creation_in_days': {'readonly': True},
          'timestamp': {'readonly': True},
          'object_identifier': {'readonly': True},
          'tenant_id': {'readonly': True},
          'upn': {'readonly': True},
      }
  
      _attribute_map = {
          'update': {'key': 'update', 'type': 'str'},
          'immutability_period_since_creation_in_days': {'key': 'immutabilityPeriodSinceCreationInDays', 'type': 'int'},
          'timestamp': {'key': 'timestamp', 'type': 'iso-8601'},
          'object_identifier': {'key': 'objectIdentifier', 'type': 'str'},
          'tenant_id': {'key': 'tenantId', 'type': 'str'},
          'upn': {'key': 'upn', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(UpdateHistoryProperty, self).__init__(**kwargs)
          self.update = None
          self.immutability_period_since_creation_in_days = None
          self.timestamp = None
          self.object_identifier = None
          self.tenant_id = None
          self.upn = None
  
  
  class Usage(msrest.serialization.Model):
      """Describes Storage Resource Usage.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar unit: Gets the unit of measurement. Possible values include: "Count", "Bytes", "Seconds",
       "Percent", "CountsPerSecond", "BytesPerSecond".
      :vartype unit: str or ~azure.mgmt.storage.v2021_01_01.models.UsageUnit
      :ivar current_value: Gets the current count of the allocated resources in the subscription.
      :vartype current_value: int
      :ivar limit: Gets the maximum count of the resources that can be allocated in the subscription.
      :vartype limit: int
      :ivar name: Gets the name of the type of usage.
      :vartype name: ~azure.mgmt.storage.v2021_01_01.models.UsageName
      """
  
      _validation = {
          'unit': {'readonly': True},
          'current_value': {'readonly': True},
          'limit': {'readonly': True},
          'name': {'readonly': True},
      }
  
      _attribute_map = {
          'unit': {'key': 'unit', 'type': 'str'},
          'current_value': {'key': 'currentValue', 'type': 'int'},
          'limit': {'key': 'limit', 'type': 'int'},
          'name': {'key': 'name', 'type': 'UsageName'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(Usage, self).__init__(**kwargs)
          self.unit = None
          self.current_value = None
          self.limit = None
          self.name = None
  
  
  class UsageListResult(msrest.serialization.Model):
      """The response from the List Usages operation.
  
      :param value: Gets or sets the list of Storage Resource Usages.
      :type value: list[~azure.mgmt.storage.v2021_01_01.models.Usage]
      """
  
      _attribute_map = {
          'value': {'key': 'value', 'type': '[Usage]'},
      }
  
      def __init__(
          self,
          *,
          value: Optional[List["Usage"]] = None,
          **kwargs
      ):
          super(UsageListResult, self).__init__(**kwargs)
          self.value = value
  
  
  class UsageName(msrest.serialization.Model):
      """The usage names that can be used; currently limited to StorageAccount.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar value: Gets a string describing the resource name.
      :vartype value: str
      :ivar localized_value: Gets a localized string describing the resource name.
      :vartype localized_value: str
      """
  
      _validation = {
          'value': {'readonly': True},
          'localized_value': {'readonly': True},
      }
  
      _attribute_map = {
          'value': {'key': 'value', 'type': 'str'},
          'localized_value': {'key': 'localizedValue', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(UsageName, self).__init__(**kwargs)
          self.value = None
          self.localized_value = None
  
  
  class UserAssignedIdentity(msrest.serialization.Model):
      """UserAssignedIdentity for the resource.
  
      Variables are only populated by the server, and will be ignored when sending a request.
  
      :ivar principal_id: The principal ID of the identity.
      :vartype principal_id: str
      :ivar client_id: The client ID of the identity.
      :vartype client_id: str
      """
  
      _validation = {
          'principal_id': {'readonly': True},
          'client_id': {'readonly': True},
      }
  
      _attribute_map = {
          'principal_id': {'key': 'principalId', 'type': 'str'},
          'client_id': {'key': 'clientId', 'type': 'str'},
      }
  
      def __init__(
          self,
          **kwargs
      ):
          super(UserAssignedIdentity, self).__init__(**kwargs)
          self.principal_id = None
          self.client_id = None
  
  
  class VirtualNetworkRule(msrest.serialization.Model):
      """Virtual Network rule.
  
      All required parameters must be populated in order to send to Azure.
  
      :param virtual_network_resource_id: Required. Resource ID of a subnet, for example:
       /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}.
      :type virtual_network_resource_id: str
      :param action: The action of virtual network rule. The only acceptable values to pass in are
       None and "Allow". The default value is None.
      :type action: str
      :param state: Gets the state of virtual network rule. Possible values include: "provisioning",
       "deprovisioning", "succeeded", "failed", "networkSourceDeleted".
      :type state: str or ~azure.mgmt.storage.v2021_01_01.models.State
      """
  
      _validation = {
          'virtual_network_resource_id': {'required': True},
      }
  
      _attribute_map = {
          'virtual_network_resource_id': {'key': 'id', 'type': 'str'},
          'action': {'key': 'action', 'type': 'str'},
          'state': {'key': 'state', 'type': 'str'},
      }
  
      def __init__(
          self,
          *,
          virtual_network_resource_id: str,
          action: Optional[str] = None,
          state: Optional[Union[str, "State"]] = None,
          **kwargs
      ):
          super(VirtualNetworkRule, self).__init__(**kwargs)
          self.virtual_network_resource_id = virtual_network_resource_id
          self.action = action
          self.state = state
  