# 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 AcceptGrowCapacityPoolForShortTermCloneSplit(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """While auto splitting the short term clone volume, if the parent pool does not have enough space
    to accommodate the volume after split, it will be automatically resized, which will lead to
    increased billing. To accept capacity pool size auto grow and create a short term clone volume,
    set the property as accepted.
    """

    ACCEPTED = "Accepted"
    """Auto grow capacity pool for short term clone split is accepted."""
    DECLINED = "Declined"
    """Auto grow capacity pool for short term clone split is declined. Short term clone volume
    creation will not be allowed, to create short term clone volume accept auto grow capacity pool."""


class ActiveDirectoryStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the Active Directory."""

    CREATED = "Created"
    """Active Directory created but not in use."""
    IN_USE = "InUse"
    """Active Directory in use by SMB Volume."""
    DELETED = "Deleted"
    """Active Directory Deleted."""
    ERROR = "Error"
    """Error with the Active Directory."""
    UPDATING = "Updating"
    """Active Directory Updating."""


class ActualRansomwareProtectionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The actual state of the Advanced Ransomware Protection feature."""

    DISABLED = "Disabled"
    """Advanced Ransomware Protection is disabled."""
    ENABLED = "Enabled"
    """Advanced Ransomware Protection is enabled."""
    LEARNING = "Learning"
    """Advanced Ransomware Protection is in learning mode."""
    PAUSED = "Paused"
    """Advanced Ransomware Protection is in paused state."""


class ApplicationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Application Type."""

    SAP_HANA = "SAP-HANA"
    """SAP_HANA."""
    ORACLE = "ORACLE"
    """ORACLE."""


class AvsDataStore(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether the volume is enabled for Azure VMware Solution (AVS) datastore purpose."""

    ENABLED = "Enabled"
    """avsDataStore is enabled."""
    DISABLED = "Disabled"
    """avsDataStore is disabled."""


class BackupType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of backup Manual or Scheduled."""

    MANUAL = "Manual"
    """Manual backup."""
    SCHEDULED = "Scheduled"
    """Scheduled backup."""


class BindAuthenticationLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The authentication level to use when binding to the LDAP server."""

    ANONYMOUS = "Anonymous"
    """Anonymous bind i.e. no credentials provided."""
    SIMPLE = "Simple"
    """Simple bind i.e. plain text credentials provided."""


class BreakthroughMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether the volume operates in Breakthrough Mode. When set to 'Enabled', the volume
    runs on the resources configured for this mode, delivering improved performance and higher
    throughput. If set to 'Disabled' or omitted, the volume uses the basic configuration. This
    feature is available only in regions where it’s been configured and first-time users must
    finish onboarding prior to using Breakthrough Mode.
    """

    ENABLED = "Enabled"
    """The volume runs on the resources configured for Breakthrough mode which ensures consistent high
    performance and a higher throughput."""
    DISABLED = "Disabled"
    """The volume uses configuration that provides basic performance and throughput."""


class BucketPatchPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Access permissions for the bucket. Either ReadOnly or ReadWrite."""

    READ_ONLY = "ReadOnly"
    """Read-only access to bucket."""
    READ_WRITE = "ReadWrite"
    """Read-write access to bucket."""


class BucketPermissions(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Access permissions for the bucket. Either ReadOnly or ReadWrite. The default is ReadOnly if no
    value is provided during bucket creation.
    """

    READ_ONLY = "ReadOnly"
    """Read-only access to bucket."""
    READ_WRITE = "ReadWrite"
    """Read-write access to bucket."""


class CacheFileAccessLogs(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether file access logs are enabled for the Cache, based on active diagnostic
    settings present on the Cache.
    """

    ENABLED = "Enabled"
    """fileAccessLogs are enabled."""
    DISABLED = "Disabled"
    """fileAccessLogs are not enabled."""


class CacheLifeCycleState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Azure NetApp Files Cache lifecycle management."""

    CLUSTER_PEERING_OFFER_SENT = "ClusterPeeringOfferSent"
    """Cluster peering offer has been sent."""
    VSERVER_PEERING_OFFER_SENT = "VserverPeeringOfferSent"
    """VServer peering offer has been sent."""
    CREATING = "Creating"
    """Cache creation in progress."""
    SUCCEEDED = "Succeeded"
    """Cache creation succeeded and is available for use."""
    FAILED = "Failed"
    """Cache is in a failed state."""


class CacheProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Azure lifecycle management."""

    CREATING = "Creating"
    """The resource is being created."""
    UPDATING = "Updating"
    """The resource is being updated."""
    DELETING = "Deleting"
    """The resource is being deleted."""
    FAILED = "Failed"
    """The resource is in a failed state."""
    SUCCEEDED = "Succeeded"
    """The resource is succeeded."""
    CANCELED = "Canceled"
    """Resource creation was canceled."""


class CheckElasticResourceAvailabilityReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Availability reason."""

    INVALID = "Invalid"
    """Value indicating the name provided does not match Azure NetApp Files naming requirements."""
    ALREADY_EXISTS = "AlreadyExists"
    """Value indicating the name is already in use and is therefore unavailable."""


class CheckElasticResourceAvailabilityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Availability status."""

    TRUE = "True"
    """Value indicating the name is valid and available."""
    FALSE = "False"
    """Value indicating the the name is invalid, unavailable, or both."""


class CheckNameResourceTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Resource type used for verification."""

    MICROSOFT_NET_APP_NET_APP_ACCOUNTS = "Microsoft.NetApp/netAppAccounts"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS = "Microsoft.NetApp/netAppAccounts/capacityPools"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_SNAPSHOTS = (
        "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
    )
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_SNAPSHOTS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_BACKUP_VAULTS_BACKUPS = "Microsoft.NetApp/netAppAccounts/backupVaults/backups"
    """ANF Backup under a volume , deprecated, use
    ``Microsoft.NetApp/netAppAccounts/backupVaults/backups`` instead."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_BACKUPS = (
        "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/backups"
    )
    """ANF Backup under a Backup Vault."""


class CheckQuotaNameResourceTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Resource type used for verification."""

    MICROSOFT_NET_APP_NET_APP_ACCOUNTS = "Microsoft.NetApp/netAppAccounts"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS = "Microsoft.NetApp/netAppAccounts/capacityPools"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES = "Microsoft.NetApp/netAppAccounts/capacityPools/volumes"
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_SNAPSHOTS = (
        "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/snapshots"
    )
    """MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_SNAPSHOTS."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_BACKUP_VAULTS_BACKUPS = "Microsoft.NetApp/netAppAccounts/backupVaults/backups"
    """ANF Backup under a volume , deprecated, use
    ``Microsoft.NetApp/netAppAccounts/backupVaults/backups`` instead."""
    MICROSOFT_NET_APP_NET_APP_ACCOUNTS_CAPACITY_POOLS_VOLUMES_BACKUPS = (
        "Microsoft.NetApp/netAppAccounts/capacityPools/volumes/backups"
    )
    """ANF Backup under a Backup Vault."""


class ChownMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This parameter specifies who is authorized to change the ownership of a file. restricted - Only
    root user can change the ownership of the file. unrestricted - Non-root users can change
    ownership of files that they own.
    """

    RESTRICTED = "Restricted"
    """RESTRICTED."""
    UNRESTRICTED = "Unrestricted"
    """UNRESTRICTED."""


class CifsChangeNotifyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether a CIFS change notification is enabled for the cache."""

    DISABLED = "Disabled"
    """CIFS change notification is disabled."""
    ENABLED = "Enabled"
    """CIFS change notification is enabled."""


class CoolAccessRetrievalPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """coolAccessRetrievalPolicy determines the data retrieval behavior from the cool tier to standard
    storage based on the read pattern for cool access enabled volumes. The possible values for this
    field are: Default - Data will be pulled from cool tier to standard storage on random reads.
    This policy is the default. OnRead - All client-driven data read is pulled from cool tier to
    standard storage on both sequential and random reads. Never - No client-driven data is pulled
    from cool tier to standard storage.
    """

    DEFAULT = "Default"
    """DEFAULT."""
    ON_READ = "OnRead"
    """ON_READ."""
    NEVER = "Never"
    """NEVER."""


class CoolAccessTieringPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """coolAccessTieringPolicy determines which cold data blocks are moved to cool tier. The possible
    values for this field are: Auto - Moves cold user data blocks in both the Snapshot copies and
    the active file system to the cool tier tier. This policy is the default. SnapshotOnly - Moves
    user data blocks of the Volume Snapshot copies that are not associated with the active file
    system to the cool tier.
    """

    AUTO = "Auto"
    """AUTO."""
    SNAPSHOT_ONLY = "SnapshotOnly"
    """SNAPSHOT_ONLY."""


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 CredentialsStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The bucket credentials status. There states:

    "NoCredentialsSet": Access and Secret key pair have not been generated.
    "CredentialsExpired": Access and Secret key pair have expired.
    "Active": The certificate has been installed and credentials are unexpired.
    """

    NO_CREDENTIALS_SET = "NoCredentialsSet"
    """Access and Secret key pair have not been generated."""
    CREDENTIALS_EXPIRED = "CredentialsExpired"
    """Access and Secret key pair have expired."""
    ACTIVE = "Active"
    """The certificate has been installed on the bucket server and the bucket credentials are
    unexpired."""


class DayOfWeek(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Day of the week."""

    SUNDAY = "Sunday"
    """Take a snapshot each Sunday."""
    MONDAY = "Monday"
    """Take a snapshot each Monday."""
    TUESDAY = "Tuesday"
    """Take a snapshot each Tuesday."""
    WEDNESDAY = "Wednesday"
    """Take a snapshot each Wednesday."""
    THURSDAY = "Thursday"
    """Take a snapshot each Thursday."""
    FRIDAY = "Friday"
    """Take a snapshot each Friday."""
    SATURDAY = "Saturday"
    """Take a snapshot each Saturday."""


class DesiredRansomwareProtectionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The desired state of the Advanced Ransomware Protection feature."""

    DISABLED = "Disabled"
    """Advanced Ransomware Protection is disabled."""
    ENABLED = "Enabled"
    """Advanced Ransomware Protection is enabled."""


class ElasticBackupPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Elastic Backup Policy state."""

    ENABLED = "Enabled"
    """Value indicating the policy is enabled."""
    DISABLED = "Disabled"
    """Value indicating the policy is disabled."""


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

    MANUAL = "Manual"
    """Manual backup type."""
    SCHEDULED = "Scheduled"
    """Scheduled backup type."""


class ElasticKeyVaultStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """KeyVault status."""

    CREATED = "Created"
    """KeyVault connection created but not in use."""
    IN_USE = "InUse"
    """KeyVault connection in use by SMB Volume."""
    DELETED = "Deleted"
    """KeyVault connection Deleted."""
    ERROR = "Error"
    """Error with the KeyVault connection."""
    UPDATING = "Updating"
    """KeyVault connection Updating."""


class ElasticNfsv3Access(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """NFSv3 access."""

    ENABLED = "Enabled"
    """Clients can connect to the volume using the NFSv3 protocol."""
    DISABLED = "Disabled"
    """Clients can't connect to the volume using the NFSv3 protocol."""


class ElasticNfsv4Access(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """NFSv4 access."""

    ENABLED = "Enabled"
    """Clients can connect to the volume using the NFSv4 protocol."""
    DISABLED = "Disabled"
    """Clients can't connect to the volume using the NFSv4 protocol."""


class ElasticPoolEncryptionKeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Pool Encryption Key Source."""

    NET_APP = "NetApp"
    """Represents the encryption key source of Elastic pool is Microsoft.NetApp."""
    KEY_VAULT = "KeyVault"
    """Represents the encryption key source of Elastic pool is Microsoft.KeyVault."""


class ElasticProtocolType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Protocol types for elastic volume."""

    NF_SV3 = "NFSv3"
    """NFSv3 protocol type."""
    NF_SV4 = "NFSv4"
    """NFSv4 protocol type."""
    SMB = "SMB"
    """SMB/CIFS protocol type."""


class ElasticResourceAvailabilityStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Current availability status of the resource."""

    ONLINE = "Online"
    """The resource is currently Online and accessible."""
    OFFLINE = "Offline"
    """The resource is currently Offline and not accessible."""


class ElasticRootAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Root access."""

    ENABLED = "Enabled"
    """Root user access is enabled for clients affected by this rule."""
    DISABLED = "Disabled"
    """Root user access is disabled for clients affected by this rule."""


class ElasticServiceLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Service level for elastic capacity pool."""

    ZONE_REDUNDANT = "ZoneRedundant"
    """Zone redundant storage service level."""


class ElasticSmbEncryption(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """SMB encryption."""

    ENABLED = "Enabled"
    """Value indicating the SMB encryption is enabled."""
    DISABLED = "Disabled"
    """Value indicating the SMB encryption is disabled."""


class ElasticUnixAccessRule(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Unix access rule."""

    READ_ONLY = "ReadOnly"
    """Clients connecting with this rule will only have read access to the volume."""
    READ_WRITE = "ReadWrite"
    """Clients connecting with this rule will have full read and write access to the volume."""
    NO_ACCESS = "NoAccess"
    """Clients connecting with this rule will have no access to the volume."""


class ElasticVolumePolicyEnforcement(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Policy enforcement."""

    ENFORCED = "Enforced"
    """Value indicating the policy is enforced on the volume."""
    NOT_ENFORCED = "NotEnforced"
    """Value indicating the policy is not enforced on the volume."""


class ElasticVolumeRestorationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The current state of the restoration process."""

    RESTORING = "Restoring"
    """Value indicating that the volume is currently restoring."""
    RESTORED = "Restored"
    """Value indicating that the volume is restored."""
    FAILED = "Failed"
    """Value indicating that the volume restore has failed."""


class EnableSubvolumes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether subvolume operations are enabled on the volume."""

    ENABLED = "Enabled"
    """subvolumes are enabled."""
    DISABLED = "Disabled"
    """subvolumes are not enabled."""


class EnableWriteBackState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether writeback is enabled for the cache."""

    DISABLED = "Disabled"
    """Writeback cache is disabled."""
    ENABLED = "Enabled"
    """Writeback cache is enabled."""


class EncryptionKeySource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Source of key used to encrypt data in volume. Applicable if NetApp account has
    encryption.keySource = 'Microsoft.KeyVault'. Possible values (case-insensitive) are:
    'Microsoft.NetApp, Microsoft.KeyVault'.
    """

    MICROSOFT_NET_APP = "Microsoft.NetApp"
    """Microsoft-managed key encryption."""
    MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
    """Customer-managed key encryption."""


class EncryptionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies if the cache is encryption or not."""

    DISABLED = "Disabled"
    """Encryption is disabled."""
    ENABLED = "Enabled"
    """Encryption is enabled."""


class EncryptionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Encryption type of the capacity pool, set encryption type for data at rest for this pool and
    all volumes in it. This value can only be set when creating new pool.
    """

    SINGLE = "Single"
    """EncryptionType Single, volumes will use single encryption at rest."""
    DOUBLE = "Double"
    """EncryptionType Double, volumes will use double encryption at rest."""


class EndpointType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates whether the local volume is the source or destination for the Volume Replication."""

    SRC = "src"
    """SRC."""
    DST = "dst"
    """DST."""


class Exclude(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """An option to filter out replications. 'None' returns all replications, 'Deleted' excludes
    deleted replications. Default is 'None'.
    """

    NONE = "None"
    """'None' returns all replications."""
    DELETED = "Deleted"
    """'Deleted' excludes deleted replications."""


class ExternalReplicationSetupStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Property that only applies to external replications. Provides a machine-readable value for the
    status of the external replication setup.
    """

    CLUSTER_PEER_REQUIRED = "ClusterPeerRequired"
    """Your cluster needs to be peered by using the 'peerExternalCluster' action."""
    CLUSTER_PEER_PENDING = "ClusterPeerPending"
    """The peering needs to be accepted on your cluster before the setup can proceed."""
    V_SERVER_PEER_REQUIRED = "VServerPeerRequired"
    """Need to call 'authorizeExternalReplication' and accept the returned 'vserver peer accept'
    command on your cluster to finish setting up the external replication."""
    REPLICATION_CREATE_REQUIRED = "ReplicationCreateRequired"
    """Need to call 'authorizeExternalReplication' to finish setting up the external replication."""
    NO_ACTION_REQUIRED = "NoActionRequired"
    """External Replication setup is complete, you can now monitor the 'mirrorState' in the
    replication status for the health of the replication."""


class FileAccessLogs(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether file access logs are enabled for the volume, based on active diagnostic
    settings present on the volume.
    """

    ENABLED = "Enabled"
    """fileAccessLogs are enabled."""
    DISABLED = "Disabled"
    """fileAccessLogs are not enabled."""


class GlobalFileLockingState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Flag indicating whether the global file lock is enabled for the cache."""

    DISABLED = "Disabled"
    """Global file locking is disabled."""
    ENABLED = "Enabled"
    """Global file locking is enabled."""


class InAvailabilityReasonType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """<code>Invalid</code> indicates the name provided does not match Azure App Service naming
    requirements. <code>AlreadyExists</code> indicates that the name is already in use and is
    therefore unavailable.
    """

    INVALID = "Invalid"
    """INVALID."""
    ALREADY_EXISTS = "AlreadyExists"
    """ALREADY_EXISTS."""


class KerberosState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Describe if a cache is Kerberos enabled."""

    DISABLED = "Disabled"
    """Kerberos is disabled."""
    ENABLED = "Enabled"
    """Kerberos is enabled."""


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

    MICROSOFT_NET_APP = "Microsoft.NetApp"
    """Microsoft-managed key encryption."""
    MICROSOFT_KEY_VAULT = "Microsoft.KeyVault"
    """Customer-managed key encryption."""


class KeyVaultStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the KeyVault connection."""

    CREATED = "Created"
    """KeyVault connection created but not in use."""
    IN_USE = "InUse"
    """KeyVault connection in use by SMB Volume."""
    DELETED = "Deleted"
    """KeyVault connection Deleted."""
    ERROR = "Error"
    """Error with the KeyVault connection."""
    UPDATING = "Updating"
    """KeyVault connection Updating."""


class LargeVolumeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the type of the Large Volume. When set to 'LargeVolume', the large volume is created
    with standard configuration. If it is set to 'ExtraLargeVolume7Dot2PiB', the extra large volume
    is created with higher capacity limit 7.2PiB with cool access enabled, delivering higher
    capacity limit with lower costs.
    """

    LARGE_VOLUME = "LargeVolume"
    """The large volume is created with standard configuration that provides standard performance and
    throughput."""
    EXTRA_LARGE_VOLUME7_DOT2_PI_B = "PremExtraLargeVolume7Dot2PiB"
    """The extra large volume is created with higher volume capacity limit 7.2PiB with cool access
    enabled, delivering higher capacity limit with lower costs."""


class LdapServerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the LDAP server."""

    ACTIVE_DIRECTORY = "ActiveDirectory"
    """The volume should use Active Directory for LDAP connections."""
    OPEN_LDAP = "OpenLDAP"
    """The volume should use OpenLDAP for LDAP connections."""


class LdapState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies whether LDAP is enabled or not."""

    DISABLED = "Disabled"
    """ldap is disabled."""
    ENABLED = "Enabled"
    """ldap is enabled."""


class ManagedServiceIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of managed service identity (where both SystemAssigned and UserAssigned types are
    allowed).
    """

    NONE = "None"
    """No managed identity."""
    SYSTEM_ASSIGNED = "SystemAssigned"
    """System assigned managed identity."""
    USER_ASSIGNED = "UserAssigned"
    """User assigned managed identity."""
    SYSTEM_ASSIGNED_USER_ASSIGNED = "SystemAssigned,UserAssigned"
    """System and user assigned managed identity."""


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

    AVERAGE = "Average"
    """AVERAGE."""


class MirrorState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The status of the replication."""

    UNINITIALIZED = "Uninitialized"
    """UNINITIALIZED."""
    MIRRORED = "Mirrored"
    """MIRRORED."""
    BROKEN = "Broken"
    """BROKEN."""


class MultiAdStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """MultiAD Status for the account."""

    DISABLED = "Disabled"
    """Account is MultiAD disabled, Means its a SharedAD or SingleAD account."""
    ENABLED = "Enabled"
    """Account is MultiAD enabled."""


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

    ACCEPTED = "Accepted"
    """Resource has been Accepted."""
    CREATING = "Creating"
    """Resource is being Created."""
    PATCHING = "Patching"
    """Resource is being Patched."""
    UPDATING = "Updating"
    """Resource is updating."""
    DELETING = "Deleting"
    """Resource is being Deleted."""
    MOVING = "Moving"
    """Resource is being Moved."""
    FAILED = "Failed"
    """Resource has Failed."""
    SUCCEEDED = "Succeeded"
    """Resource has Succeeded."""


class NetworkFeatures(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Network features available to the volume, or current state of update."""

    BASIC = "Basic"
    """Basic network features."""
    STANDARD = "Standard"
    """Standard network features."""
    BASIC_STANDARD = "Basic_Standard"
    """Updating from Basic to Standard network features."""
    STANDARD_BASIC = "Standard_Basic"
    """Updating from Standard to Basic network features."""


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

    SUCCEEDED = "Succeeded"
    """SUCCEEDED."""
    FAILED = "Failed"
    """FAILED."""
    CANCELED = "Canceled"
    """CANCELED."""
    UPDATING = "Updating"
    """UPDATING."""


class OnCertificateConflictAction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """This action is triggered when a certificate conflict occurs. A conflict arises if you try to
    create a new bucket while one or more already exist on the server, or if you update a bucket
    when multiple buckets are present. This happens because a single certificate is shared among
    all buckets on the same server.

    Note: This applies both to certificates provided directly via the certificateObject property
    and to those retrieved from Azure Key Vault. Details for the latter case are specified in the
    akvDetails.certificateAkvDetails section.
    """

    UPDATE = "Update"
    """Update the existing certificate regardless of whether there is a conflict or not. This means
    all buckets on the server will now use the new certificate."""
    FAIL = "Fail"
    """Fail the operation if a conflict occurs, meaning the bucket operation will fail, and the
    existing certificate will continue to be in use."""


class PolicyStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Policy status."""

    ENABLED = "Enabled"
    """Value indicating the policy is enabled."""
    DISABLED = "Disabled"
    """Value indicating the policy is disabled."""


class ProtocolTypes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Set of supported protocol types, which include NFSv3, NFSv4 and SMB protocol."""

    NF_SV3 = "NFSv3"
    """NFSv3 protocol type."""
    NF_SV4 = "NFSv4"
    """NFSv4 protocol type."""
    SMB = "SMB"
    """SMB protocol type."""


class QosType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The qos type of the pool."""

    AUTO = "Auto"
    """qos type Auto."""
    MANUAL = "Manual"
    """qos type Manual."""


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

    DEFAULT_USER_QUOTA = "DefaultUserQuota"
    """Default user quota."""
    DEFAULT_GROUP_QUOTA = "DefaultGroupQuota"
    """Default group quota."""
    INDIVIDUAL_USER_QUOTA = "IndividualUserQuota"
    """Individual user quota."""
    INDIVIDUAL_GROUP_QUOTA = "IndividualGroupQuota"
    """Individual group quota."""


class RansomwareReportSeverity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Severity of the Advanced Ransomware Protection (ARP) report."""

    NONE = "None"
    """No data is suspected for ransomware activity."""
    LOW = "Low"
    """Low attack probability."""
    MODERATE = "Moderate"
    """Moderate attack probability."""
    HIGH = "High"
    """High amount of data is suspected for ransomware activity."""


class RansomwareReportState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """State of the Advanced Ransomware Protection (ARP) report."""

    ACTIVE = "Active"
    """The ARP report has been created. Take action by running clearsuspects marking suspects as
    FalsePositive or PotentialThreats."""
    RESOLVED = "Resolved"
    """The ARP Report has been resolved."""


class RansomwareSuspectResolution(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """ARP report suspect resolution."""

    POTENTIAL_THREAT = "PotentialThreat"
    """The identified file type is unexpected in your workload and should be treated as a potential
    attack."""
    FALSE_POSITIVE = "FalsePositive"
    """The identified file type is expected in your workload and can be ignored."""


class RegionStorageToNetworkProximity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provides storage to network proximity information in the region."""

    DEFAULT = "Default"
    """Basic network connectivity."""
    T1 = "T1"
    """Standard T1 network connectivity."""
    T2 = "T2"
    """Standard T2 network connectivity."""
    ACROSS_T2 = "AcrossT2"
    """Standard AcrossT2 network connectivity."""
    T1_AND_T2 = "T1AndT2"
    """Standard T1 and T2 network connectivity."""
    T1_AND_ACROSS_T2 = "T1AndAcrossT2"
    """Standard T1 and AcrossT2 network connectivity."""
    T2_AND_ACROSS_T2 = "T2AndAcrossT2"
    """Standard T2 and AcrossT2 network connectivity."""
    T1_AND_T2_AND_ACROSS_T2 = "T1AndT2AndAcrossT2"
    """Standard T1, T2 and AcrossT2 network connectivity."""


class ReplicationMirrorState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The status of the replication."""

    UNINITIALIZED = "Uninitialized"
    """Destination volume has not been initialized."""
    MIRRORED = "Mirrored"
    """Destination volume has been initialized and is ready."""
    BROKEN = "Broken"
    """Destination volume is RW, replication relationship has been broken off."""


class ReplicationSchedule(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Schedule."""

    ENUM_10_MINUTELY = "_10minutely"
    """10_MINUTELY."""
    HOURLY = "hourly"
    """HOURLY."""
    DAILY = "daily"
    """DAILY."""


class ReplicationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Indicates whether the replication is cross zone or cross region."""

    CROSS_REGION_REPLICATION = "CrossRegionReplication"
    """Cross region replication."""
    CROSS_ZONE_REPLICATION = "CrossZoneReplication"
    """Cross zone replication."""


class SecurityStyle(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The security style of volume, default unix, defaults to ntfs for dual protocol or CIFS
    protocol.
    """

    NTFS = "ntfs"
    """NTFS."""
    UNIX = "unix"
    """UNIX."""


class ServiceLevel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The service level of the file system."""

    STANDARD = "Standard"
    """Standard service level."""
    PREMIUM = "Premium"
    """Premium service level."""
    ULTRA = "Ultra"
    """Ultra service level."""
    STANDARD_ZRS = "StandardZRS"
    """Zone redundant storage service level. This will be deprecated soon."""
    FLEXIBLE = "Flexible"
    """Flexible service level."""


class SmbAccessBasedEnumeration(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enables access-based enumeration share property for SMB Shares. Only applicable for
    SMB/DualProtocol volume.
    """

    DISABLED = "Disabled"
    """smbAccessBasedEnumeration share setting is disabled."""
    ENABLED = "Enabled"
    """smbAccessBasedEnumeration share setting is enabled."""


class SmbEncryptionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enables encryption for in-flight smb3 data. Only applicable for SMB/DualProtocol cache."""

    DISABLED = "Disabled"
    """SMB encryption is disabled."""
    ENABLED = "Enabled"
    """SMB encryption is enabled."""


class SmbNonBrowsable(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Enables non-browsable property for SMB Shares. Only applicable for SMB/DualProtocol volume."""

    DISABLED = "Disabled"
    """smbNonBrowsable share setting is disabled."""
    ENABLED = "Enabled"
    """smbNonBrowsable share setting is enabled."""


class SnapshotDirectoryVisibility(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Controls the visibility of the Elastic Volume's read-only snapshot directory, which provides
    access to each of the volume's snapshots.
    """

    HIDDEN = "Hidden"
    """Value indicating the read-only snapshot directory is not visible."""
    VISIBLE = "Visible"
    """Value indicating the read-only snapshot directory is visible."""


class SnapshotUsage(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Snapshot usage for backup."""

    USE_EXISTING_SNAPSHOT = "UseExistingSnapshot"
    """Value indicating an existing snapshot is used."""
    CREATE_NEW_SNAPSHOT = "CreateNewSnapshot"
    """Value indicating a new snapshot is created."""


class VolumeBackupRelationshipStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the volume backup relationship."""

    IDLE = "Idle"
    """IDLE."""
    TRANSFERRING = "Transferring"
    """TRANSFERRING."""
    FAILED = "Failed"
    """FAILED."""
    UNKNOWN = "Unknown"
    """UNKNOWN."""


class VolumeLanguage(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Language supported for volume."""

    C_UTF8 = "c.utf-8"
    """Posix with UTF-8."""
    UTF8_MB4 = "utf8mb4"
    """UTF-8 with 4 byte character support."""
    AR = "ar"
    """Arabic - Deprecated."""
    AR_UTF8 = "ar.utf-8"
    """Arabic with UTF-8."""
    HR = "hr"
    """Croatian - Deprecated."""
    HR_UTF8 = "hr.utf-8"
    """Croatian with UTF-8."""
    CS = "cs"
    """Czech - Deprecated."""
    CS_UTF8 = "cs.utf-8"
    """Czech with UTF-8."""
    DA = "da"
    """Danish - Deprecated."""
    DA_UTF8 = "da.utf-8"
    """Danish with UTF-8."""
    NL = "nl"
    """Dutch - Deprecated."""
    NL_UTF8 = "nl.utf-8"
    """Dutch with UTF-8."""
    EN = "en"
    """English - Deprecated."""
    EN_UTF8 = "en.utf-8"
    """English with UTF-8."""
    FI = "fi"
    """Finnish - Deprecated."""
    FI_UTF8 = "fi.utf-8"
    """Finnish with UTF-8."""
    FR = "fr"
    """French - Deprecated."""
    FR_UTF8 = "fr.utf-8"
    """French with UTF-8."""
    DE = "de"
    """German - Deprecated."""
    DE_UTF8 = "de.utf-8"
    """German with UTF-8."""
    HE = "he"
    """Hebrew - Deprecated."""
    HE_UTF8 = "he.utf-8"
    """Hebrew with UTF-8."""
    HU = "hu"
    """Hungarian - Deprecated."""
    HU_UTF8 = "hu.utf-8"
    """Hungarian with UTF-8."""
    IT = "it"
    """Italian - Deprecated."""
    IT_UTF8 = "it.utf-8"
    """Italian with UTF-8."""
    JA = "ja"
    """Japanese euc-j - Deprecated."""
    JA_UTF8 = "ja.utf-8"
    """Japanese euc-j with UTF-8."""
    JA_V1 = "ja-v1"
    """Japanese euc-j - Deprecated."""
    JA_V1_UTF8 = "ja-v1.utf-8"
    """Japanese euc-j with UTF-8."""
    JA_JP_PCK = "ja-jp.pck"
    """Japanese pck."""
    JA_JP_PCK_UTF8 = "ja-jp.pck.utf-8"
    """Japanese pck with UTF-8 - Deprecated."""
    JA_JP932 = "ja-jp.932"
    """Japanese cp932."""
    JA_JP932_UTF8 = "ja-jp.932.utf-8"
    """Japanese cp932 with UTF-8 - Deprecated."""
    JA_JP_PCK_V2 = "ja-jp.pck-v2"
    """Japanese pck - sjis."""
    JA_JP_PCK_V2_UTF8 = "ja-jp.pck-v2.utf-8"
    """Japanese pck - sjis with UTF-8 - Deprecated."""
    KO = "ko"
    """Korean - Deprecated."""
    KO_UTF8 = "ko.utf-8"
    """Korean with UTF-8."""
    NO = "no"
    """Norwegian - Deprecated."""
    NO_UTF8 = "no.utf-8"
    """Norwegian with UTF-8."""
    PL = "pl"
    """Polish - Deprecated."""
    PL_UTF8 = "pl.utf-8"
    """Polish with UTF-8."""
    PT = "pt"
    """Portuguese - Deprecated."""
    PT_UTF8 = "pt.utf-8"
    """Portuguese with UTF-8."""
    C = "c"
    """Posix - Deprecated."""
    RO = "ro"
    """Romanian - Deprecated."""
    RO_UTF8 = "ro.utf-8"
    """Romanian with UTF-8."""
    RU = "ru"
    """Russian - Deprecated."""
    RU_UTF8 = "ru.utf-8"
    """Russian with UTF-8."""
    ZH = "zh"
    """Simplified Chinese - Deprecated."""
    ZH_UTF8 = "zh.utf-8"
    """Simplified Chinese with UTF-8."""
    ZH_GBK = "zh.gbk"
    """Simplified gbk Chinese."""
    ZH_GBK_UTF8 = "zh.gbk.utf-8"
    """Simplified gbk Chinese with UTF-8 - Deprecated."""
    ZH_TW_BIG5 = "zh-tw.big5"
    """Traditional Chinese BIG 5."""
    ZH_TW_BIG5_UTF8 = "zh-tw.big5.utf-8"
    """Traditional Chinese BIG 5 with UTF-8 - Deprecated."""
    ZH_TW = "zh-tw"
    """Traditional Chinese EUC-TW."""
    ZH_TW_UTF8 = "zh-tw.utf-8"
    """Traditional Chinese EUC-TW with UTF-8 - Deprecated."""
    SK = "sk"
    """Slovak - Deprecated."""
    SK_UTF8 = "sk.utf-8"
    """Slovak with UTF-8."""
    SL = "sl"
    """Slovenian - Deprecated."""
    SL_UTF8 = "sl.utf-8"
    """Slovenian with UTF-8."""
    ES = "es"
    """Spanish - Deprecated."""
    ES_UTF8 = "es.utf-8"
    """Spanish with UTF-8."""
    SV = "sv"
    """Swedish - Deprecated."""
    SV_UTF8 = "sv.utf-8"
    """Swedish with UTF-8."""
    TR = "tr"
    """Turkish - Deprecated."""
    TR_UTF8 = "tr.utf-8"
    """Turkish with UTF-8."""
    EN_US = "en-us"
    """US English - Deprecated."""
    EN_US_UTF8 = "en-us.utf-8"
    """US English with UTF-8."""


class VolumeReplicationRelationshipStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the volume replication relationship."""

    IDLE = "Idle"
    """IDLE."""
    TRANSFERRING = "Transferring"
    """TRANSFERRING."""


class VolumeRestoreRelationshipStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the volume restore relationship."""

    IDLE = "Idle"
    """IDLE."""
    TRANSFERRING = "Transferring"
    """TRANSFERRING."""
    FAILED = "Failed"
    """FAILED."""
    UNKNOWN = "Unknown"
    """UNKNOWN."""


class VolumeSize(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Volume size for backup."""

    LARGE = "Large"
    """Value indicating backup is for a large volume."""
    REGULAR = "Regular"
    """Value indicating backup is not for a large volume."""


class VolumeStorageToNetworkProximity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provides storage to network proximity information for the volume."""

    DEFAULT = "Default"
    """Basic storage to network connectivity."""
    T1 = "T1"
    """Standard T1 storage to network connectivity."""
    T2 = "T2"
    """Standard T2 storage to network connectivity."""
    ACROSS_T2 = "AcrossT2"
    """Standard AcrossT2 storage to network connectivity."""
