# pylint: disable=too-many-lines
# 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) Python Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

from enum import Enum
from azure.core import CaseInsensitiveEnumMeta


class AccessTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The default access tier for block blobs in the storage account. Required for storage accounts
    where kind = BlobStorage. See more details in:
    `https://learn.microsoft.com/azure/storage/blobs/access-tiers-overview
    <https://learn.microsoft.com/azure/storage/blobs/access-tiers-overview>`_.
    """

    HOT = "Hot"
    """HOT."""
    COOL = "Cool"
    """COOL."""
    PREMIUM = "Premium"
    """PREMIUM."""
    COLD = "Cold"
    """COLD."""
    SMART = "Smart"
    """SMART."""


class AccountImmutabilityPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The ImmutabilityPolicy state defines the mode of the policy. Disabled state disables the
    policy, Unlocked state allows increase and decrease of immutability retention time and also
    allows toggling allowProtectedAppendWrites property, Locked state only allows the increase of
    the immutability retention time. A policy can only be created in a Disabled or Unlocked state
    and can be toggled between the two states. Only a policy in an Unlocked state can transition to
    a Locked state which cannot be reverted.
    """

    UNLOCKED = "Unlocked"
    """UNLOCKED."""
    LOCKED = "Locked"
    """LOCKED."""
    DISABLED = "Disabled"
    """DISABLED."""


class AccountStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status indicating whether the primary location of the storage account is available or
    unavailable.
    """

    AVAILABLE = "available"
    """AVAILABLE."""
    UNAVAILABLE = "unavailable"
    """UNAVAILABLE."""


class AccountType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the Active Directory account type for Azure Storage. If directoryServiceOptions is
    set to AD (AD DS authentication), this property is optional. If provided, samAccountName should
    also be provided. For directoryServiceOptions AADDS (Entra DS authentication) or AADKERB (Entra
    authentication), this property can be omitted.
    """

    USER = "User"
    """USER."""
    COMPUTER = "Computer"
    """COMPUTER."""


class AdvancedPlatformMetricsFilterType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of filter applied to the advanced platform metrics rule."""

    ALL_CONTAINERS_FILTER = "AllContainersFilter"
    """Filter applies to all containers."""
    CONTAINER_PREFIX_FILTER = "ContainerPrefixFilter"
    """Filter applies to containers matching a prefix."""
    CONTAINER_LIST_FILTER = "ContainerListFilter"
    """Filter applies to a specific list of containers."""


class AdvancedPlatformMetricsRuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the advanced platform metrics rule."""

    CONTAINER_LEVEL_CAPACITY_METRICS = "ContainerLevelCapacityMetrics"
    """Container level capacity metrics rule type."""


class AllowedCopyScope(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Restrict copy to and from Storage Accounts within an AAD tenant or with Private Links to the
    same VNet.
    """

    PRIVATE_LINK = "PrivateLink"
    """PRIVATE_LINK."""
    AAD = "AAD"
    """AAD."""
    ALL = "All"
    """ALL."""


class AllowedMethods(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of AllowedMethods."""

    DELETE = "DELETE"
    """DELETE."""
    GET = "GET"
    """GET."""
    HEAD = "HEAD"
    """HEAD."""
    MERGE = "MERGE"
    """MERGE."""
    POST = "POST"
    """POST."""
    OPTIONS = "OPTIONS"
    """OPTIONS."""
    PUT = "PUT"
    """PUT."""
    PATCH = "PATCH"
    """PATCH."""
    CONNECT = "CONNECT"
    """CONNECT."""
    TRACE = "TRACE"
    """TRACE."""


class BlobInventoryPolicyName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of BlobInventoryPolicyName."""

    DEFAULT = "default"
    """DEFAULT."""


class BlobRestoreProgressStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    IN_PROGRESS = "InProgress"
    """IN_PROGRESS."""
    COMPLETE = "Complete"
    """COMPLETE."""
    FAILED = "Failed"
    """FAILED."""


class Bypass(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    NONE = "None"
    """NONE."""
    LOGGING = "Logging"
    """LOGGING."""
    METRICS = "Metrics"
    """METRICS."""
    AZURE_SERVICES = "AzureServices"
    """AZURE_SERVICES."""


class CreatedByType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The kind of entity that created the resource."""

    USER = "User"
    """The entity was created by a user."""
    APPLICATION = "Application"
    """The entity was created by an application."""
    MANAGED_IDENTITY = "ManagedIdentity"
    """The entity was created by a managed identity."""
    KEY = "Key"
    """The entity was created by a key."""


class DefaultAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the default action of allow or deny when no other rules match."""

    ALLOW = "Allow"
    """ALLOW."""
    DENY = "Deny"
    """DENY."""


class DefaultSharePermission(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Default share permission for users using Kerberos authentication if RBAC role is not assigned."""

    NONE = "None"
    """NONE."""
    STORAGE_FILE_DATA_SMB_SHARE_READER = "StorageFileDataSmbShareReader"
    """STORAGE_FILE_DATA_SMB_SHARE_READER."""
    STORAGE_FILE_DATA_SMB_SHARE_CONTRIBUTOR = "StorageFileDataSmbShareContributor"
    """STORAGE_FILE_DATA_SMB_SHARE_CONTRIBUTOR."""
    STORAGE_FILE_DATA_SMB_SHARE_ELEVATED_CONTRIBUTOR = "StorageFileDataSmbShareElevatedContributor"
    """STORAGE_FILE_DATA_SMB_SHARE_ELEVATED_CONTRIBUTOR."""


class DirectoryServiceOptions(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates the directory service used. Note that this enum may be extended in the future."""

    NONE = "None"
    """NONE."""
    AADDS = "AADDS"
    """AADDS."""
    AD = "AD"
    """AD."""
    AADKERB = "AADKERB"
    """AADKERB."""


class DnsEndpointType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Allows you to specify the type of endpoint. Set this to AzureDNSZone to create a large number
    of accounts in a single subscription, which creates accounts in an Azure DNS Zone and the
    endpoint URL will have an alphanumeric DNS Zone identifier.
    """

    STANDARD = "Standard"
    """STANDARD."""
    AZURE_DNS_ZONE = "AzureDnsZone"
    """AZURE_DNS_ZONE."""


class EnabledProtocols(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication protocol that is used for the file share. Can only be specified when
    creating a share.
    """

    SMB = "SMB"
    """SMB."""
    NFS = "NFS"
    """NFS."""


class EncryptionScopeSource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The provider for the encryption scope. Possible values (case-insensitive):  Microsoft.Storage,
    Microsoft.KeyVault.
    """

    MICROSOFT_STORAGE = "Microsoft.Storage"
    """MICROSOFT_STORAGE."""
    MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
    """MICROSOFT_KEY_VAULT."""


class EncryptionScopeState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the encryption scope. Possible values (case-insensitive):  Enabled, Disabled."""

    ENABLED = "Enabled"
    """ENABLED."""
    DISABLED = "Disabled"
    """DISABLED."""


class ExpirationAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The SAS Expiration Action defines the action to be performed when sasPolicy.sasExpirationPeriod
    is violated. The 'Log' action can be used for audit purposes and the 'Block' action can be used
    to block and deny the usage of SAS tokens that do not adhere to the sas policy expiration
    period.
    """

    LOG = "Log"
    """LOG."""
    BLOCK = "Block"
    """BLOCK."""


class ExtendedLocationTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of extendedLocation."""

    EDGE_ZONE = "EdgeZone"
    """EDGE_ZONE."""


class Format(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This is a required field, it specifies the format for the inventory files."""

    CSV = "Csv"
    """CSV."""
    PARQUET = "Parquet"
    """PARQUET."""


class GeoReplicationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    LIVE = "Live"
    """LIVE."""
    BOOTSTRAP = "Bootstrap"
    """BOOTSTRAP."""
    UNAVAILABLE = "Unavailable"
    """UNAVAILABLE."""


class HttpProtocol(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The protocol permitted for a request made with the account SAS."""

    HTTPS_HTTP = "https,http"
    """HTTPS_HTTP."""
    HTTPS = "https"
    """HTTPS."""


class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The identity type."""

    NONE = "None"
    """NONE."""
    SYSTEM_ASSIGNED = "SystemAssigned"
    """SYSTEM_ASSIGNED."""
    USER_ASSIGNED = "UserAssigned"
    """USER_ASSIGNED."""
    SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned,UserAssigned"
    """SYSTEM_ASSIGNED_USER_ASSIGNED."""


class ImmutabilityPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The ImmutabilityPolicy state of a blob container, possible values include: Locked and Unlocked."""

    LOCKED = "Locked"
    """LOCKED."""
    UNLOCKED = "Unlocked"
    """UNLOCKED."""


class ImmutabilityPolicyUpdateType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The ImmutabilityPolicy update type of a blob container, possible values include: put, lock and
    extend.
    """

    PUT = "put"
    """PUT."""
    LOCK = "lock"
    """LOCK."""
    EXTEND = "extend"
    """EXTEND."""


class IntervalUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Run interval unit of task execution. This is a required field when
    ExecutionTrigger.properties.type is 'OnSchedule'; this property should not be present when
    ExecutionTrigger.properties.type is 'RunOnce'.
    """

    DAYS = "Days"
    """DAYS."""


class InventoryRuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The valid value is Inventory."""

    INVENTORY = "Inventory"
    """INVENTORY."""


class IssueType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of issue."""

    UNKNOWN = "Unknown"
    """UNKNOWN."""
    CONFIGURATION_PROPAGATION_FAILURE = "ConfigurationPropagationFailure"
    """CONFIGURATION_PROPAGATION_FAILURE."""


class KeyPermission(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Permissions for the key -- read-only or full permissions."""

    READ = "Read"
    """READ."""
    FULL = "Full"
    """FULL."""


class KeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The encryption keySource (provider). Possible values (case-insensitive):  Microsoft.Storage,
    Microsoft.Keyvault.
    """

    MICROSOFT_STORAGE = "Microsoft.Storage"
    """MICROSOFT_STORAGE."""
    MICROSOFT_KEYVAULT = "Microsoft.Keyvault"
    """MICROSOFT_KEYVAULT."""


class KeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    SERVICE = "Service"
    """SERVICE."""
    ACCOUNT = "Account"
    """ACCOUNT."""


class Kind(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates the type of storage account."""

    STORAGE = "Storage"
    """STORAGE."""
    STORAGE_V2 = "StorageV2"
    """STORAGE_V2."""
    BLOB_STORAGE = "BlobStorage"
    """BLOB_STORAGE."""
    FILE_STORAGE = "FileStorage"
    """FILE_STORAGE."""
    BLOCK_BLOB_STORAGE = "BlockBlobStorage"
    """BLOCK_BLOB_STORAGE."""


class LargeFileSharesState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Allow large file shares if sets to Enabled. It cannot be disabled once it is enabled."""

    DISABLED = "Disabled"
    """DISABLED."""
    ENABLED = "Enabled"
    """ENABLED."""


class LeaseContainerRequestAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the lease action. Can be one of the available actions."""

    ACQUIRE = "Acquire"
    """ACQUIRE."""
    RENEW = "Renew"
    """RENEW."""
    CHANGE = "Change"
    """CHANGE."""
    RELEASE = "Release"
    """RELEASE."""
    BREAK = "Break"
    """BREAK."""


class LeaseDuration(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether the lease on a container is of infinite or fixed duration, only when the
    container is leased.
    """

    INFINITE = "Infinite"
    """INFINITE."""
    FIXED = "Fixed"
    """FIXED."""


class LeaseShareAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the lease action. Can be one of the available actions."""

    ACQUIRE = "Acquire"
    """ACQUIRE."""
    RENEW = "Renew"
    """RENEW."""
    CHANGE = "Change"
    """CHANGE."""
    RELEASE = "Release"
    """RELEASE."""
    BREAK = "Break"
    """BREAK."""


class LeaseState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Lease state of the container."""

    AVAILABLE = "Available"
    """AVAILABLE."""
    LEASED = "Leased"
    """LEASED."""
    EXPIRED = "Expired"
    """EXPIRED."""
    BREAKING = "Breaking"
    """BREAKING."""
    BROKEN = "Broken"
    """BROKEN."""


class LeaseStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The lease status of the container."""

    LOCKED = "Locked"
    """LOCKED."""
    UNLOCKED = "Unlocked"
    """UNLOCKED."""


class ListContainersInclude(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of ListContainersInclude."""

    DELETED = "deleted"
    """DELETED."""


class ListEncryptionScopesInclude(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of ListEncryptionScopesInclude."""

    ALL = "All"
    """ALL."""
    ENABLED = "Enabled"
    """ENABLED."""
    DISABLED = "Disabled"
    """DISABLED."""


class ListLocalUserIncludeParam(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of ListLocalUserIncludeParam."""

    NFSV3 = "nfsv3"
    """NFSV3."""


class ManagementPolicyName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of ManagementPolicyName."""

    DEFAULT = "default"
    """DEFAULT."""


class MetricsEmitted(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The metrics emitted by the advanced platform metrics rule."""

    CONTAINER_BLOB_COUNT = "ContainerBlobCount"
    """Container blob count metric."""
    CONTAINER_USED_SIZE = "ContainerUsedSize"
    """Container used size metric."""


class MigrationName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of MigrationName."""

    DEFAULT = "default"
    """DEFAULT."""


class MigrationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This property denotes the container level immutability to object level immutability migration
    state.
    """

    IN_PROGRESS = "InProgress"
    """IN_PROGRESS."""
    COMPLETED = "Completed"
    """COMPLETED."""


class MigrationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Current status of migration."""

    INVALID = "Invalid"
    """INVALID."""
    SUBMITTED_FOR_CONVERSION = "SubmittedForConversion"
    """SUBMITTED_FOR_CONVERSION."""
    IN_PROGRESS = "InProgress"
    """IN_PROGRESS."""
    COMPLETE = "Complete"
    """COMPLETE."""
    FAILED = "Failed"
    """FAILED."""


class MinimumTlsVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Set the minimum TLS version to be permitted on requests to storage. The default interpretation
    is TLS 1.0 for this property. Minimum TLS version 1.3 version is not supported.
    """

    TLS1_0 = "TLS1_0"
    """TLS1_0."""
    TLS1_1 = "TLS1_1"
    """TLS1_1."""
    TLS1_2 = "TLS1_2"
    """TLS1_2."""
    TLS1_3 = "TLS1_3"
    """TLS1_3."""


class Name(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Name of the policy. The valid value is AccessTimeTracking. This field is currently read only."""

    ACCESS_TIME_TRACKING = "AccessTimeTracking"
    """ACCESS_TIME_TRACKING."""


class NativeDataSharingProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of the resource at the time the operation was called."""

    ACCEPTED = "Accepted"
    """The request has been accepted for processing."""
    CREATING = "Creating"
    """The resource is being created."""
    SUCCEEDED = "Succeeded"
    """The resource has been successfully created."""
    DELETING = "Deleting"
    """The resource is being deleted."""
    CANCELED = "Canceled"
    """The request has been canceled."""
    FAILED = "Failed"
    """The resource creation or deletion has failed."""


class NetworkSecurityPerimeterConfigurationProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Provisioning state of Network Security Perimeter configuration propagation."""

    ACCEPTED = "Accepted"
    """ACCEPTED."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""
    DELETING = "Deleting"
    """DELETING."""
    CANCELED = "Canceled"
    """CANCELED."""


class NspAccessRuleDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Direction of Access Rule."""

    INBOUND = "Inbound"
    """INBOUND."""
    OUTBOUND = "Outbound"
    """OUTBOUND."""


class ObjectType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This is a required field. This field specifies the scope of the inventory created either at the
    blob or container level.
    """

    BLOB = "Blob"
    """BLOB."""
    CONTAINER = "Container"
    """CONTAINER."""


class Permissions(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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).
    """

    R = "r"
    """R."""
    D = "d"
    """D."""
    W = "w"
    """W."""
    L = "l"
    """L."""
    A = "a"
    """A."""
    C = "c"
    """C."""
    U = "u"
    """U."""
    P = "p"
    """P."""


class PostFailoverRedundancy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The redundancy type of the account after an account failover is performed."""

    STANDARD_LRS = "Standard_LRS"
    """STANDARD_LRS."""
    STANDARD_ZRS = "Standard_ZRS"
    """STANDARD_ZRS."""


class PostPlannedFailoverRedundancy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The redundancy type of the account after a planned account failover is performed."""

    STANDARD_GRS = "Standard_GRS"
    """STANDARD_GRS."""
    STANDARD_GZRS = "Standard_GZRS"
    """STANDARD_GZRS."""
    STANDARD_RAGRS = "Standard_RAGRS"
    """STANDARD_RAGRS."""
    STANDARD_RAGZRS = "Standard_RAGZRS"
    """STANDARD_RAGZRS."""


class PrivateEndpointConnectionProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """The current provisioning state."""

    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    CREATING = "Creating"
    """CREATING."""
    DELETING = "Deleting"
    """DELETING."""
    FAILED = "Failed"
    """FAILED."""


class PrivateEndpointServiceConnectionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The private endpoint connection status."""

    PENDING = "Pending"
    """PENDING."""
    APPROVED = "Approved"
    """APPROVED."""
    REJECTED = "Rejected"
    """REJECTED."""


class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the storage account at the time the operation was called."""

    CREATING = "Creating"
    """CREATING."""
    RESOLVING_DNS = "ResolvingDNS"
    """RESOLVING_DNS."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""


class PublicAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether data in the container may be accessed publicly and the level of access."""

    CONTAINER = "Container"
    """CONTAINER."""
    BLOB = "Blob"
    """BLOB."""
    NONE = "None"
    """NONE."""


class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Allow, disallow, or let Network Security Perimeter configuration to evaluate public network
    access to Storage Account. Value is optional but if passed in, must be 'Enabled', 'Disabled' or
    'SecuredByPerimeter'.
    """

    ENABLED = "Enabled"
    """ENABLED."""
    DISABLED = "Disabled"
    """DISABLED."""
    SECURED_BY_PERIMETER = "SecuredByPerimeter"
    """SECURED_BY_PERIMETER."""


class Reason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the reason that a storage account name could not be used. The Reason element is only
    returned if NameAvailable is false.
    """

    ACCOUNT_NAME_INVALID = "AccountNameInvalid"
    """ACCOUNT_NAME_INVALID."""
    ALREADY_EXISTS = "AlreadyExists"
    """ALREADY_EXISTS."""


class ReasonCode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    QUOTA_ID = "QuotaId"
    """QUOTA_ID."""
    NOT_AVAILABLE_FOR_SUBSCRIPTION = "NotAvailableForSubscription"
    """NOT_AVAILABLE_FOR_SUBSCRIPTION."""


class ResourceAssociationAccessMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Access Mode of the resource association."""

    ENFORCED = "Enforced"
    """ENFORCED."""
    LEARNING = "Learning"
    """LEARNING."""
    AUDIT = "Audit"
    """AUDIT."""


class RootSquashType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The property is for NFS share only. The default is NoRootSquash."""

    NO_ROOT_SQUASH = "NoRootSquash"
    """NO_ROOT_SQUASH."""
    ROOT_SQUASH = "RootSquash"
    """ROOT_SQUASH."""
    ALL_SQUASH = "AllSquash"
    """ALL_SQUASH."""


class RoutingChoice(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Routing Choice defines the kind of network routing opted by the user."""

    MICROSOFT_ROUTING = "MicrosoftRouting"
    """MICROSOFT_ROUTING."""
    INTERNET_ROUTING = "InternetRouting"
    """INTERNET_ROUTING."""


class RuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The valid value is Lifecycle."""

    LIFECYCLE = "Lifecycle"
    """LIFECYCLE."""


class RunResult(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Represents the overall result of the execution for the run instance."""

    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""


class RunStatusEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Represents the status of the execution."""

    IN_PROGRESS = "InProgress"
    """IN_PROGRESS."""
    FINISHED = "Finished"
    """FINISHED."""


class Schedule(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This is a required field. This field is used to schedule an inventory formation."""

    DAILY = "Daily"
    """DAILY."""
    WEEKLY = "Weekly"
    """WEEKLY."""


class Services(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The signed services accessible with the account SAS. Possible values include: Blob (b), Queue
    (q), Table (t), File (f).
    """

    B = "b"
    """B."""
    Q = "q"
    """Q."""
    T = "t"
    """T."""
    F = "f"
    """F."""


class Severity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Severity of the issue."""

    WARNING = "Warning"
    """WARNING."""
    ERROR = "Error"
    """ERROR."""


class ShareAccessTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Access tier for specific share. GpV2 account can choose between TransactionOptimized (default),
    Hot, and Cool. FileStorage account can choose Premium.
    """

    TRANSACTION_OPTIMIZED = "TransactionOptimized"
    """TRANSACTION_OPTIMIZED."""
    HOT = "Hot"
    """HOT."""
    COOL = "Cool"
    """COOL."""
    PREMIUM = "Premium"
    """PREMIUM."""


class SignedResource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The signed services accessible with the service SAS. Possible values include: Blob (b),
    Container (c), File (f), Share (s).
    """

    B = "b"
    """B."""
    C = "c"
    """C."""
    F = "f"
    """F."""
    S = "s"
    """S."""


class SignedResourceTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """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.
    """

    S = "s"
    """S."""
    C = "c"
    """C."""
    O = "o"
    """O."""


class SkuConversionStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This property indicates the current sku conversion status."""

    IN_PROGRESS = "InProgress"
    """IN_PROGRESS."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""


class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The SKU name. Required for account creation; optional for update. Note that in older versions,
    SKU name was called accountType.
    """

    STANDARD_LRS = "Standard_LRS"
    """STANDARD_LRS."""
    STANDARD_GRS = "Standard_GRS"
    """STANDARD_GRS."""
    STANDARD_RAGRS = "Standard_RAGRS"
    """STANDARD_RAGRS."""
    STANDARD_ZRS = "Standard_ZRS"
    """STANDARD_ZRS."""
    PREMIUM_LRS = "Premium_LRS"
    """PREMIUM_LRS."""
    PREMIUM_ZRS = "Premium_ZRS"
    """PREMIUM_ZRS."""
    STANDARD_GZRS = "Standard_GZRS"
    """STANDARD_GZRS."""
    STANDARD_RAGZRS = "Standard_RAGZRS"
    """STANDARD_RAGZRS."""
    STANDARD_V2_LRS = "StandardV2_LRS"
    """STANDARD_V2_LRS."""
    STANDARD_V2_GRS = "StandardV2_GRS"
    """STANDARD_V2_GRS."""
    STANDARD_V2_ZRS = "StandardV2_ZRS"
    """STANDARD_V2_ZRS."""
    STANDARD_V2_GZRS = "StandardV2_GZRS"
    """STANDARD_V2_GZRS."""
    PREMIUM_V2_LRS = "PremiumV2_LRS"
    """PREMIUM_V2_LRS."""
    PREMIUM_V2_ZRS = "PremiumV2_ZRS"
    """PREMIUM_V2_ZRS."""


class SkuTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The SKU tier. This is based on the SKU name."""

    STANDARD = "Standard"
    """STANDARD."""
    PREMIUM = "Premium"
    """PREMIUM."""


class State(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the state of virtual network rule."""

    PROVISIONING = "Provisioning"
    """PROVISIONING."""
    DEPROVISIONING = "Deprovisioning"
    """DEPROVISIONING."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""
    NETWORK_SOURCE_DELETED = "NetworkSourceDeleted"
    """NETWORK_SOURCE_DELETED."""


class StorageAccountExpand(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of StorageAccountExpand."""

    GEO_REPLICATION_STATS = "geoReplicationStats"
    """GEO_REPLICATION_STATS."""
    BLOB_RESTORE_STATUS = "blobRestoreStatus"
    """BLOB_RESTORE_STATUS."""


class StorageConnectorAuthType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The auth type supported for bucket connection in storage connector."""

    MANAGED_IDENTITY = "ManagedIdentity"
    """Managed Identity auth type."""


class StorageConnectorConnectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The connection type for bucket connection in storage connector."""

    DATA_SHARE = "DataShare"
    """DataShare connection type."""


class StorageConnectorDataSourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the backing data source for storage connector."""

    AZURE_DATA_SHARE = "Azure_DataShare"
    """Azure DataShare data source type."""


class StorageConnectorSourceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the backing data source for storage connector."""

    DATA_SHARE = "DataShare"
    """Source type - DataShare."""


class StorageConnectorState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the storage connector."""

    ACTIVE = "Active"
    """Whether the connector is active."""
    INACTIVE = "Inactive"
    """Whether the connector is inactive."""


class StorageDataShareAccessPolicyPermission(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The permissions supported in access policies for storage data share."""

    NONE = "None"
    """No permission."""
    READ = "Read"
    """Read permission."""


class StorageTaskAssignmentProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of the storage account at the time the operation was called."""

    VALIDATE_SUBSCRIPTION_QUOTA_BEGIN = "ValidateSubscriptionQuotaBegin"
    """VALIDATE_SUBSCRIPTION_QUOTA_BEGIN."""
    VALIDATE_SUBSCRIPTION_QUOTA_END = "ValidateSubscriptionQuotaEnd"
    """VALIDATE_SUBSCRIPTION_QUOTA_END."""
    ACCEPTED = "Accepted"
    """ACCEPTED."""
    CREATING = "Creating"
    """CREATING."""
    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    DELETING = "Deleting"
    """DELETING."""
    CANCELED = "Canceled"
    """CANCELED."""
    FAILED = "Failed"
    """FAILED."""


class TriggerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The trigger type of the storage task assignment execution."""

    RUN_ONCE = "RunOnce"
    """RUN_ONCE."""
    ON_SCHEDULE = "OnSchedule"
    """ON_SCHEDULE."""
    MOCK_RUN = "MockRun"
    """Run the task as a mock for testing."""


class UsageUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the unit of measurement."""

    COUNT = "Count"
    """COUNT."""
    BYTES = "Bytes"
    """BYTES."""
    SECONDS = "Seconds"
    """SECONDS."""
    PERCENT = "Percent"
    """PERCENT."""
    COUNTS_PER_SECOND = "CountsPerSecond"
    """COUNTS_PER_SECOND."""
    BYTES_PER_SECOND = "BytesPerSecond"
    """BYTES_PER_SECOND."""


class ZonePlacementPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The availability zone pinning policy for the storage account."""

    ANY = "Any"
    """ANY."""
    NONE = "None"
    """NONE."""
