# 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 AdministratorName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of AdministratorName."""

    ACTIVE_DIRECTORY = "ActiveDirectory"
    """ActiveDirectory."""


class AdministratorType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the sever administrator."""

    ACTIVE_DIRECTORY = "ActiveDirectory"
    """ActiveDirectory."""


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

    DEFAULT = "Default"
    """Default."""


class AdvancedThreatProtectionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the Advanced Threat Protection, whether it is enabled or disabled or a
    state has not been applied yet on the specific database or server.
    """

    NEW = "New"
    """New."""
    ENABLED = "Enabled"
    """Enabled."""
    DISABLED = "Disabled"
    """Disabled."""


class AdvisorStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the status of availability of this advisor to customers. Possible values are 'GA',
    'PublicPreview', 'LimitedPublicPreview' and 'PrivatePreview'.
    """

    GA = "GA"
    """GA."""
    PUBLIC_PREVIEW = "PublicPreview"
    """PublicPreview."""
    LIMITED_PUBLIC_PREVIEW = "LimitedPublicPreview"
    """LimitedPublicPreview."""
    PRIVATE_PREVIEW = "PrivatePreview"
    """PrivatePreview."""


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

    AVG = "avg"
    """avg."""
    MIN = "min"
    """min."""
    MAX = "max"
    """max."""
    STDEV = "stdev"
    """stdev."""
    SUM = "sum"
    """sum."""


class AlwaysEncryptedEnclaveType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of enclave requested on the database i.e. Default or VBS enclaves."""

    DEFAULT = "Default"
    """Default."""
    VBS = "VBS"
    """VBS."""


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

    DEFAULT = "Default"
    """Default."""


class AuthMetadataLookupModes(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The managed instance's authentication metadata lookup mode."""

    AZURE_AD = "AzureAD"
    """AzureAD."""
    PAIRED = "Paired"
    """Paired."""
    WINDOWS = "Windows"
    """Windows."""


class AutoExecuteStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the auto-execute status (whether to let the system execute the recommendations) of this
    advisor. Possible values are 'Enabled' and 'Disabled'.
    """

    ENABLED = "Enabled"
    """Enabled."""
    DISABLED = "Disabled"
    """Disabled."""
    DEFAULT = "Default"
    """Default."""


class AutoExecuteStatusInheritedFrom(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the resource from which current value of auto-execute status is inherited. Auto-execute
    status can be set on (and inherited from) different levels in the resource hierarchy. Possible
    values are 'Subscription', 'Server', 'ElasticPool', 'Database' and 'Default' (when status is
    not explicitly set on any level).
    """

    DEFAULT = "Default"
    """Default."""
    SUBSCRIPTION = "Subscription"
    """Subscription."""
    SERVER = "Server"
    """Server."""
    ELASTIC_POOL = "ElasticPool"
    """ElasticPool."""
    DATABASE = "Database"
    """Database."""


class AutomaticTuningDisabledReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Reason description if desired and actual state are different."""

    DEFAULT = "Default"
    """Default."""
    DISABLED = "Disabled"
    """Disabled."""
    AUTO_CONFIGURED = "AutoConfigured"
    """AutoConfigured."""
    INHERITED_FROM_SERVER = "InheritedFromServer"
    """InheritedFromServer."""
    QUERY_STORE_OFF = "QueryStoreOff"
    """QueryStoreOff."""
    QUERY_STORE_READ_ONLY = "QueryStoreReadOnly"
    """QueryStoreReadOnly."""
    NOT_SUPPORTED = "NotSupported"
    """NotSupported."""


class AutomaticTuningMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Automatic tuning desired state."""

    INHERIT = "Inherit"
    """Inherit."""
    CUSTOM = "Custom"
    """Custom."""
    AUTO = "Auto"
    """Auto."""
    UNSPECIFIED = "Unspecified"
    """Unspecified."""


class AutomaticTuningOptionModeActual(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Automatic tuning option actual state."""

    OFF = "Off"
    """Off."""
    ON = "On"
    """On."""


class AutomaticTuningOptionModeDesired(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Automatic tuning option desired state."""

    OFF = "Off"
    """Off."""
    ON = "On"
    """On."""
    DEFAULT = "Default"
    """Default."""


class AutomaticTuningServerMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Automatic tuning desired state."""

    CUSTOM = "Custom"
    """Custom."""
    AUTO = "Auto"
    """Auto."""
    UNSPECIFIED = "Unspecified"
    """Unspecified."""


class AutomaticTuningServerReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Reason description if desired and actual state are different."""

    DEFAULT = "Default"
    """Default."""
    DISABLED = "Disabled"
    """Disabled."""
    AUTO_CONFIGURED = "AutoConfigured"
    """AutoConfigured."""


class AvailabilityZoneType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the availability zone the database is pinned to."""

    NO_PREFERENCE = "NoPreference"
    """NoPreference."""
    ONE = "1"
    """1."""
    TWO = "2"
    """2."""
    THREE = "3"
    """3."""


class BackupStorageAccessTier(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The BackupStorageAccessTier for the LTR backup."""

    HOT = "Hot"
    """Hot."""
    ARCHIVE = "Archive"
    """Archive."""


class BackupStorageRedundancy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The storage account type used to store backups for this database."""

    GEO = "Geo"
    """Geo."""
    LOCAL = "Local"
    """Local."""
    ZONE = "Zone"
    """Zone."""
    GEO_ZONE = "GeoZone"
    """GeoZone."""


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

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


class BlobAuditingPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the audit. If state is Enabled, storageEndpoint or
    isAzureMonitorTargetEnabled are required.
    """

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


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

    SUPPORTED_EDITIONS = "supportedEditions"
    """supportedEditions."""
    SUPPORTED_ELASTIC_POOL_EDITIONS = "supportedElasticPoolEditions"
    """supportedElasticPoolEditions."""
    SUPPORTED_MANAGED_INSTANCE_VERSIONS = "supportedManagedInstanceVersions"
    """supportedManagedInstanceVersions."""
    SUPPORTED_INSTANCE_POOL_EDITIONS = "supportedInstancePoolEditions"
    """supportedInstancePoolEditions."""
    SUPPORTED_MANAGED_INSTANCE_EDITIONS = "supportedManagedInstanceEditions"
    """supportedManagedInstanceEditions."""
    SUPPORTED_JOB_AGENT_VERSIONS = "supportedJobAgentVersions"
    """supportedJobAgentVersions."""


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

    VISIBLE = "Visible"
    """Visible."""
    AVAILABLE = "Available"
    """Available."""
    DEFAULT = "Default"
    """Default."""
    DISABLED = "Disabled"
    """Disabled."""


class CatalogCollationType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Collation of the metadata catalog."""

    DATABASE_DEFAULT = "DATABASE_DEFAULT"
    """DATABASE_DEFAULT."""
    SQL_LATIN1_GENERAL_CP1_CI_AS = "SQL_Latin1_General_CP1_CI_AS"
    """SQL_Latin1_General_CP1_CI_AS."""


class CheckNameAvailabilityReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The reason code explaining why the name is unavailable. Will be undefined if the name is
    available.
    """

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


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

    MICROSOFT_SQL_SERVERS = "Microsoft.Sql/servers"
    """Microsoft.Sql/servers."""


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

    NONE = "None"
    """None."""
    NATIVE = "Native"
    """Native."""
    RECOMMENDED = "Recommended"
    """Recommended."""
    MIP = "MIP"
    """MIP."""


class ColumnDataType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The column data type."""

    IMAGE = "image"
    """image."""
    TEXT = "text"
    """text."""
    UNIQUEIDENTIFIER = "uniqueidentifier"
    """uniqueidentifier."""
    DATE = "date"
    """date."""
    TIME = "time"
    """time."""
    DATETIME2 = "datetime2"
    """datetime2."""
    DATETIMEOFFSET = "datetimeoffset"
    """datetimeoffset."""
    TINYINT = "tinyint"
    """tinyint."""
    SMALLINT = "smallint"
    """smallint."""
    INT = "int"
    """int."""
    SMALLDATETIME = "smalldatetime"
    """smalldatetime."""
    REAL = "real"
    """real."""
    MONEY = "money"
    """money."""
    DATETIME = "datetime"
    """datetime."""
    FLOAT = "float"
    """float."""
    SQL_VARIANT = "sql_variant"
    """sql_variant."""
    NTEXT = "ntext"
    """ntext."""
    BIT = "bit"
    """bit."""
    DECIMAL = "decimal"
    """decimal."""
    NUMERIC = "numeric"
    """numeric."""
    SMALLMONEY = "smallmoney"
    """smallmoney."""
    BIGINT = "bigint"
    """bigint."""
    HIERARCHYID = "hierarchyid"
    """hierarchyid."""
    GEOMETRY = "geometry"
    """geometry."""
    GEOGRAPHY = "geography"
    """geography."""
    VARBINARY = "varbinary"
    """varbinary."""
    VARCHAR = "varchar"
    """varchar."""
    BINARY = "binary"
    """binary."""
    CHAR = "char"
    """char."""
    TIMESTAMP = "timestamp"
    """timestamp."""
    NVARCHAR = "nvarchar"
    """nvarchar."""
    NCHAR = "nchar"
    """nchar."""
    XML = "xml"
    """xml."""
    SYSNAME = "sysname"
    """sysname."""


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

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


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 CreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the mode of database creation.

    Default: regular database creation.

    Copy: creates a database as a copy of an existing database. sourceDatabaseId must be specified
    as the resource ID of the source database.

    Secondary: creates a database as a secondary replica of an existing database. sourceDatabaseId
    must be specified as the resource ID of the existing primary database.

    PointInTimeRestore: Creates a database by restoring a point in time backup of an existing
    database. sourceDatabaseId must be specified as the resource ID of the existing database, and
    restorePointInTime must be specified.

    Recovery: Creates a database by restoring a geo-replicated backup. sourceDatabaseId must be
    specified as the recoverable database resource ID to restore.

    Restore: Creates a database by restoring a backup of a deleted database. sourceDatabaseId must
    be specified. If sourceDatabaseId is the database's original resource ID, then
    sourceDatabaseDeletionDate must be specified. Otherwise sourceDatabaseId must be the restorable
    dropped database resource ID and sourceDatabaseDeletionDate is ignored. restorePointInTime may
    also be specified to restore from an earlier point in time.

    RestoreLongTermRetentionBackup: Creates a database by restoring from a long term retention
    vault. recoveryServicesRecoveryPointResourceId must be specified as the recovery point resource
    ID.

    Copy, Secondary, and RestoreLongTermRetentionBackup are not supported for DataWarehouse
    edition.
    """

    DEFAULT = "Default"
    """Default."""
    COPY = "Copy"
    """Copy."""
    SECONDARY = "Secondary"
    """Secondary."""
    POINT_IN_TIME_RESTORE = "PointInTimeRestore"
    """PointInTimeRestore."""
    RESTORE = "Restore"
    """Restore."""
    RECOVERY = "Recovery"
    """Recovery."""
    RESTORE_EXTERNAL_BACKUP = "RestoreExternalBackup"
    """RestoreExternalBackup."""
    RESTORE_EXTERNAL_BACKUP_SECONDARY = "RestoreExternalBackupSecondary"
    """RestoreExternalBackupSecondary."""
    RESTORE_LONG_TERM_RETENTION_BACKUP = "RestoreLongTermRetentionBackup"
    """RestoreLongTermRetentionBackup."""
    ONLINE_SECONDARY = "OnlineSecondary"
    """OnlineSecondary."""


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

    NONE = "None"
    """None."""
    USER_ASSIGNED = "UserAssigned"
    """UserAssigned."""


class DatabaseKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The database key type. Only supported value is 'AzureKeyVault'."""

    AZURE_KEY_VAULT = "AzureKeyVault"
    """AzureKeyVault."""


class DatabaseLicenseType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The license type to apply for this database. ``LicenseIncluded`` if you need a license, or
    ``BasePrice`` if you have a license and are eligible for the Azure Hybrid Benefit.
    """

    LICENSE_INCLUDED = "LicenseIncluded"
    """LicenseIncluded."""
    BASE_PRICE = "BasePrice"
    """BasePrice."""


class DatabaseReadScale(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of read-only routing. If enabled, connections that have application intent set to
    readonly in their connection string may be routed to a readonly secondary replica in the same
    region. Not applicable to a Hyperscale database within an elastic pool.
    """

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


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

    ALL = "All"
    """All."""
    LIVE = "Live"
    """Live."""
    DELETED = "Deleted"
    """Deleted."""


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

    ONLINE = "Online"
    """Online."""
    RESTORING = "Restoring"
    """Restoring."""
    RECOVERY_PENDING = "RecoveryPending"
    """RecoveryPending."""
    RECOVERING = "Recovering"
    """Recovering."""
    SUSPECT = "Suspect"
    """Suspect."""
    OFFLINE = "Offline"
    """Offline."""
    STANDBY = "Standby"
    """Standby."""
    SHUTDOWN = "Shutdown"
    """Shutdown."""
    EMERGENCY_MODE = "EmergencyMode"
    """EmergencyMode."""
    AUTO_CLOSED = "AutoClosed"
    """AutoClosed."""
    COPYING = "Copying"
    """Copying."""
    CREATING = "Creating"
    """Creating."""
    INACCESSIBLE = "Inaccessible"
    """Inaccessible."""
    OFFLINE_SECONDARY = "OfflineSecondary"
    """OfflineSecondary."""
    PAUSING = "Pausing"
    """Pausing."""
    PAUSED = "Paused"
    """Paused."""
    RESUMING = "Resuming"
    """Resuming."""
    SCALING = "Scaling"
    """Scaling."""
    OFFLINE_CHANGING_DW_PERFORMANCE_TIERS = "OfflineChangingDwPerformanceTiers"
    """OfflineChangingDwPerformanceTiers."""
    ONLINE_CHANGING_DW_PERFORMANCE_TIERS = "OnlineChangingDwPerformanceTiers"
    """OnlineChangingDwPerformanceTiers."""
    DISABLED = "Disabled"
    """Disabled."""
    STOPPING = "Stopping"
    """Stopping."""
    STOPPED = "Stopped"
    """Stopped."""
    STARTING = "Starting"
    """Starting."""


class DataMaskingFunction(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The masking function that is used for the data masking rule."""

    DEFAULT = "Default"
    """Default."""
    CCN = "CCN"
    """CCN."""
    EMAIL = "Email"
    """Email."""
    NUMBER = "Number"
    """Number."""
    SSN = "SSN"
    """SSN."""
    TEXT = "Text"
    """Text."""


class DataMaskingRuleState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The rule state. Used to delete a rule. To delete an existing rule, specify the schemaName,
    tableName, columnName, maskingFunction, and specify ruleState as disabled. However, if the rule
    doesn't already exist, the rule will be created with ruleState set to enabled, regardless of
    the provided value of ruleState.
    """

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


class DataMaskingState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the data masking policy."""

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


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

    CURRENT = "current"
    """current."""


class DayOfWeek(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Day of maintenance window."""

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


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

    DEFAULT = "Default"
    """Default."""


class DiffBackupIntervalInHours(int, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The differential backup interval in hours. This is how many interval hours between each
    differential backup will be supported. This is only applicable to live databases but not
    dropped databases.
    """

    TWELVE = 12
    """12."""
    TWENTY_FOUR = 24
    """24."""


class DNSRefreshOperationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The status of the DNS refresh operation."""

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


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

    CURRENT = "current"
    """current."""


class ElasticPoolLicenseType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The license type to apply for this elastic pool."""

    LICENSE_INCLUDED = "LicenseIncluded"
    """LicenseIncluded."""
    BASE_PRICE = "BasePrice"
    """BasePrice."""


class ElasticPoolState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the elastic pool."""

    CREATING = "Creating"
    """Creating."""
    READY = "Ready"
    """Ready."""
    DISABLED = "Disabled"
    """Disabled."""


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

    CURRENT = "current"
    """current."""


class ErrorType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Error type (e.g. None, User)."""

    NONE = "None"
    """None."""
    USER = "User"
    """User."""


class ExternalGovernanceStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of external governance."""

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


class FailoverGroupDatabasesSecondaryType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Databases secondary type on partner server."""

    GEO = "Geo"
    """Geo."""
    STANDBY = "Standby"
    """Standby."""


class FailoverGroupReplicationRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Local replication role of the failover group instance."""

    PRIMARY = "Primary"
    """Primary."""
    SECONDARY = "Secondary"
    """Secondary."""


class FailoverModeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The link failover mode - can be Manual if intended to be used for two-way failover with a
    supported SQL Server, or None for one-way failover to Azure.
    """

    NONE = "None"
    """None."""
    MANUAL = "Manual"
    """Manual."""


class FailoverType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The failover type, can be ForcedAllowDataLoss or Planned."""

    FORCED_ALLOW_DATA_LOSS = "ForcedAllowDataLoss"
    """ForcedAllowDataLoss."""
    PLANNED = "Planned"
    """Planned."""


class FreeLimitExhaustionBehavior(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the behavior when monthly free limits are exhausted for the free database.

    AutoPause: The database will be auto paused upon exhaustion of free limits for remainder of the
    month.

    BillForUsage: The database will continue to be online upon exhaustion of free limits and any
    overage will be billed.
    """

    AUTO_PAUSE = "AutoPause"
    """AutoPause."""
    BILL_OVER_USAGE = "BillOverUsage"
    """BillOverUsage."""


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

    DEFAULT = "Default"
    """Default."""


class GeoBackupPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the geo backup policy."""

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


class HybridSecondaryUsage(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Hybrid secondary usage. Possible values are 'Active' (default value) and 'Passive' (customer
    uses the secondary as Passive DR).
    """

    ACTIVE = "Active"
    """Active."""
    PASSIVE = "Passive"
    """Passive."""


class HybridSecondaryUsageDetected(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Hybrid secondary usage detected. Possible values are 'Active' (customer does not meet the
    requirements to use the secondary as Passive DR) and 'Passive' (customer meets the requirements
    to use the secondary as Passive DR).
    """

    ACTIVE = "Active"
    """Active."""
    PASSIVE = "Passive"
    """Passive."""


class IdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an
    Azure Active Directory principal for the resource.
    """

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


class ImplementationMethod(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets the method in which this recommended action can be manually implemented. e.g., TSql,
    AzurePowerShell.
    """

    T_SQL = "TSql"
    """TSql."""
    AZURE_POWER_SHELL = "AzurePowerShell"
    """AzurePowerShell."""


class InaccessibilityReason(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Root cause kind. Allowed values are “TransparentDataEncryption”, “DatabaseReplication”, and
    “Unknown”.
    """

    UNKNOWN = "Unknown"
    """Unknown."""
    TRANSPARENT_DATA_ENCRYPTION = "TransparentDataEncryption"
    """TransparentDataEncryption."""
    DATABASE_REPLICATION = "DatabaseReplication"
    """DatabaseReplication."""


class InstanceFailoverGroupReplicationRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Local replication role of the failover group instance."""

    PRIMARY = "Primary"
    """Primary."""
    SECONDARY = "Secondary"
    """Secondary."""


class InstancePoolLicenseType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The license type. Possible values are 'LicenseIncluded' (price for SQL license is included) and
    'BasePrice' (without SQL license price).
    """

    LICENSE_INCLUDED = "LicenseIncluded"
    """LicenseIncluded."""
    BASE_PRICE = "BasePrice"
    """BasePrice."""


class InstanceRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """New role of managed instance in a distributed availability group, can be Primary or Secondary."""

    PRIMARY = "Primary"
    """Primary."""
    SECONDARY = "Secondary"
    """Secondary."""


class IsRetryable(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets whether the error could be ignored and recommended action could be retried. Possible
    values are: Yes/No.
    """

    YES = "Yes"
    """Yes."""
    NO = "No"
    """No."""


class JobAgentIdentityType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The job agent identity type."""

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


class JobAgentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of the job agent."""

    CREATING = "Creating"
    """Creating."""
    READY = "Ready"
    """Ready."""
    UPDATING = "Updating"
    """Updating."""
    DELETING = "Deleting"
    """Deleting."""
    DISABLED = "Disabled"
    """Disabled."""


class JobExecutionLifecycle(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The detailed state of the job execution."""

    CREATED = "Created"
    """Created."""
    IN_PROGRESS = "InProgress"
    """InProgress."""
    WAITING_FOR_CHILD_JOB_EXECUTIONS = "WaitingForChildJobExecutions"
    """WaitingForChildJobExecutions."""
    WAITING_FOR_RETRY = "WaitingForRetry"
    """WaitingForRetry."""
    SUCCEEDED = "Succeeded"
    """Succeeded."""
    SUCCEEDED_WITH_SKIPPED = "SucceededWithSkipped"
    """SucceededWithSkipped."""
    FAILED = "Failed"
    """Failed."""
    TIMED_OUT = "TimedOut"
    """TimedOut."""
    CANCELED = "Canceled"
    """Canceled."""
    SKIPPED = "Skipped"
    """Skipped."""


class JobScheduleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Schedule interval type."""

    ONCE = "Once"
    """Once."""
    RECURRING = "Recurring"
    """Recurring."""


class JobStepActionSource(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The source of the action to execute."""

    INLINE = "Inline"
    """Inline."""


class JobStepActionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of action being executed by the job step."""

    T_SQL = "TSql"
    """TSql."""


class JobStepOutputType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The output destination type."""

    SQL_DATABASE = "SqlDatabase"
    """SqlDatabase."""


class JobTargetGroupMembershipType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether the target is included or excluded from the group."""

    INCLUDE = "Include"
    """Include."""
    EXCLUDE = "Exclude"
    """Exclude."""


class JobTargetType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the target."""

    TARGET_GROUP = "TargetGroup"
    """TargetGroup."""
    SQL_DATABASE = "SqlDatabase"
    """SqlDatabase."""
    SQL_ELASTIC_POOL = "SqlElasticPool"
    """SqlElasticPool."""
    SQL_SHARD_MAP = "SqlShardMap"
    """SqlShardMap."""
    SQL_SERVER = "SqlServer"
    """SqlServer."""


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

    CURRENT = "current"
    """current."""


class LedgerDigestUploadsState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of ledger digest upload."""

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


class LinkRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """SQL server side link role."""

    PRIMARY = "Primary"
    """Primary."""
    SECONDARY = "Secondary"
    """Secondary."""


class LogSizeUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The units that the limit is expressed in."""

    MEGABYTES = "Megabytes"
    """Megabytes."""
    GIGABYTES = "Gigabytes"
    """Gigabytes."""
    TERABYTES = "Terabytes"
    """Terabytes."""
    PETABYTES = "Petabytes"
    """Petabytes."""
    PERCENT = "Percent"
    """Percent."""


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

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


class ManagedDatabaseCreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Managed database create mode. PointInTimeRestore: Create a database by restoring a point in
    time backup of an existing database. SourceDatabaseName, SourceManagedInstanceName and
    PointInTime must be specified. RestoreExternalBackup: Create a database by restoring from
    external backup files. Collation, StorageContainerUri and StorageContainerSasToken must be
    specified. Recovery: Creates a database by restoring a geo-replicated backup.
    RecoverableDatabaseId must be specified as the recoverable database resource ID to restore.
    RestoreLongTermRetentionBackup: Create a database by restoring from a long term retention
    backup (longTermRetentionBackupResourceId required).
    """

    DEFAULT = "Default"
    """Default."""
    RESTORE_EXTERNAL_BACKUP = "RestoreExternalBackup"
    """RestoreExternalBackup."""
    POINT_IN_TIME_RESTORE = "PointInTimeRestore"
    """PointInTimeRestore."""
    RECOVERY = "Recovery"
    """Recovery."""
    RESTORE_LONG_TERM_RETENTION_BACKUP = "RestoreLongTermRetentionBackup"
    """RestoreLongTermRetentionBackup."""


class ManagedDatabaseStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Status of the database."""

    ONLINE = "Online"
    """Online."""
    OFFLINE = "Offline"
    """Offline."""
    SHUTDOWN = "Shutdown"
    """Shutdown."""
    CREATING = "Creating"
    """Creating."""
    INACCESSIBLE = "Inaccessible"
    """Inaccessible."""
    RESTORING = "Restoring"
    """Restoring."""
    UPDATING = "Updating"
    """Updating."""
    STOPPING = "Stopping"
    """Stopping."""
    STOPPED = "Stopped"
    """Stopped."""
    STARTING = "Starting"
    """Starting."""
    DB_MOVING = "DbMoving"
    """DbMoving."""
    DB_COPYING = "DbCopying"
    """DbCopying."""


class ManagedInstanceAdministratorType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the managed instance administrator."""

    ACTIVE_DIRECTORY = "ActiveDirectory"
    """ActiveDirectory."""


class ManagedInstanceDatabaseFormat(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the internal format of instance databases specific to the SQL engine version."""

    ALWAYS_UP_TO_DATE = "AlwaysUpToDate"
    """AlwaysUpToDate."""
    SQL_SERVER2022 = "SQLServer2022"
    """SQLServer2022."""
    SQL_SERVER2025 = "SQLServer2025"
    """SQLServer2025."""


class ManagedInstanceLicenseType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The license type. Possible values are 'LicenseIncluded' (regular price inclusive of a new SQL
    license) and 'BasePrice' (discounted AHB price for bringing your own SQL licenses).
    """

    LICENSE_INCLUDED = "LicenseIncluded"
    """LicenseIncluded."""
    BASE_PRICE = "BasePrice"
    """BasePrice."""


class ManagedInstanceLongTermRetentionPolicyName(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Type of ManagedInstanceLongTermRetentionPolicyName."""

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


class ManagedInstanceProxyOverride(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Connection type used for connecting to the instance."""

    PROXY = "Proxy"
    """Proxy."""
    REDIRECT = "Redirect"
    """Redirect."""
    DEFAULT = "Default"
    """Default."""


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

    CURRENT = "current"
    """current."""


class ManagedLedgerDigestUploadsState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of ledger digest upload."""

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


class ManagedServerCreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the mode of database creation.

    Default: Regular instance creation.

    Restore: Creates an instance by restoring a set of backups to specific point in time.
    RestorePointInTime and SourceManagedInstanceId must be specified.
    """

    DEFAULT = "Default"
    """Default."""
    POINT_IN_TIME_RESTORE = "PointInTimeRestore"
    """PointInTimeRestore."""


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

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


class ManagementOperationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The operation state."""

    PENDING = "Pending"
    """Pending."""
    IN_PROGRESS = "InProgress"
    """InProgress."""
    SUCCEEDED = "Succeeded"
    """Succeeded."""
    FAILED = "Failed"
    """Failed."""
    CANCEL_IN_PROGRESS = "CancelInProgress"
    """CancelInProgress."""
    CANCELLED = "Cancelled"
    """Cancelled."""


class MaxSizeUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The units that the limit is expressed in."""

    MEGABYTES = "Megabytes"
    """Megabytes."""
    GIGABYTES = "Gigabytes"
    """Gigabytes."""
    TERABYTES = "Terabytes"
    """Terabytes."""
    PETABYTES = "Petabytes"
    """Petabytes."""


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

    CPU = "cpu"
    """cpu."""
    IO = "io"
    """io."""
    LOG_IO = "logIo"
    """logIo."""
    DURATION = "duration"
    """duration."""
    DTU = "dtu"
    """dtu."""


class MinimalTlsVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Minimal TLS version. Allowed values: 'None', 1.0', '1.1', '1.2', '1.3'."""

    NONE = "None"
    """None."""
    ONE0 = "1.0"
    """1.0."""
    ONE1 = "1.1"
    """1.1."""
    ONE2 = "1.2"
    """1.2."""
    ONE3 = "1.3"
    """1.3."""


class MoveOperationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Operation mode."""

    MOVE = "Move"
    """Move."""
    COPY = "Copy"
    """Copy."""


class OperationMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Operation mode of the operation: Import, Export, or PolybaseImport."""

    POLYBASE_IMPORT = "PolybaseImport"
    """PolybaseImport."""
    IMPORT = "Import"
    """Import."""
    EXPORT = "Export"
    """Export."""


class OperationOrigin(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The intended executor of the operation."""

    USER = "user"
    """user."""
    SYSTEM = "system"
    """system."""


class PauseDelayTimeUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Unit of time that delay is expressed in."""

    MINUTES = "Minutes"
    """Minutes."""


class PerformanceLevelUnit(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Unit type used to measure performance level."""

    DTU = "DTU"
    """DTU."""
    V_CORES = "VCores"
    """VCores."""


class Phase(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The operation phase."""

    LOG_TRANSITION_IN_PROGRESS = "LogTransitionInProgress"
    """LogTransitionInProgress."""
    COPYING = "Copying"
    """Copying."""
    BUILDING_HYPERSCALE_COMPONENTS = "BuildingHyperscaleComponents"
    """BuildingHyperscaleComponents."""
    CATCHUP = "Catchup"
    """Catchup."""
    WAITING_FOR_CUTOVER = "WaitingForCutover"
    """WaitingForCutover."""
    CUTOVER_IN_PROGRESS = "CutoverInProgress"
    """CutoverInProgress."""


class PricingModel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Pricing model of Managed Instance."""

    REGULAR = "Regular"
    """Regular."""
    FREEMIUM = "Freemium"
    """Freemium."""


class PrincipalType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Principal Type of the sever administrator."""

    USER = "User"
    """User."""
    GROUP = "Group"
    """Group."""
    APPLICATION = "Application"
    """Application."""


class PrivateEndpointProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """State of the private endpoint connection."""

    APPROVING = "Approving"
    """Approving."""
    READY = "Ready"
    """Ready."""
    DROPPING = "Dropping"
    """Dropping."""
    FAILED = "Failed"
    """Failed."""
    REJECTING = "Rejecting"
    """Rejecting."""


class PrivateLinkServiceConnectionStateActionsRequire(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """The actions required for private link service connection."""

    NONE = "None"
    """None."""


class PrivateLinkServiceConnectionStateStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The private link service connection status."""

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


class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The ARM provisioning state of the job execution."""

    CREATED = "Created"
    """Created."""
    IN_PROGRESS = "InProgress"
    """InProgress."""
    SUCCEEDED = "Succeeded"
    """Succeeded."""
    FAILED = "Failed"
    """Failed."""
    CANCELED = "Canceled"
    """Canceled."""


class QueryMetricUnitType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The unit of the metric."""

    PERCENTAGE = "percentage"
    """percentage."""
    KB = "KB"
    """KB."""
    MICROSECONDS = "microseconds"
    """microseconds."""
    COUNT = "count"
    """count."""


class QueryTimeGrainType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Interval type (length)."""

    PT1_H = "PT1H"
    """PT1H."""
    P1_D = "P1D"
    """P1D."""


class ReadOnlyEndpointFailoverPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Failover policy of the read-only endpoint for the failover group."""

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


class ReadWriteEndpointFailoverPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Failover policy of the read-write endpoint for the failover group. If failoverPolicy is
    Automatic then failoverWithDataLossGracePeriodMinutes is required.
    """

    MANUAL = "Manual"
    """Manual."""
    AUTOMATIC = "Automatic"
    """Automatic."""


class RecommendedActionCurrentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Current state the recommended action is in. Some commonly used states are: Active      ->
    recommended action is active and no action has been taken yet. Pending     -> recommended
    action is approved for and is awaiting execution. Executing   -> recommended action is being
    applied on the user database. Verifying   -> recommended action was applied and is being
    verified of its usefulness by the system. Success     -> recommended action was applied and
    improvement found during verification. Pending Revert  -> verification found little or no
    improvement so recommended action is queued for revert or user has manually reverted. Reverting
    -> changes made while applying recommended action are being reverted on the user database.
    Reverted    -> successfully reverted the changes made by recommended action on user database.
    Ignored     -> user explicitly ignored/discarded the recommended action.
    """

    ACTIVE = "Active"
    """Active."""
    PENDING = "Pending"
    """Pending."""
    EXECUTING = "Executing"
    """Executing."""
    VERIFYING = "Verifying"
    """Verifying."""
    PENDING_REVERT = "PendingRevert"
    """PendingRevert."""
    REVERT_CANCELLED = "RevertCancelled"
    """RevertCancelled."""
    REVERTING = "Reverting"
    """Reverting."""
    REVERTED = "Reverted"
    """Reverted."""
    IGNORED = "Ignored"
    """Ignored."""
    EXPIRED = "Expired"
    """Expired."""
    MONITORING = "Monitoring"
    """Monitoring."""
    RESOLVED = "Resolved"
    """Resolved."""
    SUCCESS = "Success"
    """Success."""
    ERROR = "Error"
    """Error."""


class RecommendedActionInitiatedBy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Gets if approval for applying this recommended action was given by user/system."""

    USER = "User"
    """User."""
    SYSTEM = "System"
    """System."""


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

    ENABLE = "enable"
    """enable."""
    DISABLE = "disable"
    """disable."""


class ReplicaConnectedState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Link connected state."""

    DISCONNECTED = "DISCONNECTED"
    """DISCONNECTED."""
    CONNECTED = "CONNECTED"
    """CONNECTED."""


class ReplicaSynchronizationHealth(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Link health state."""

    NOT_HEALTHY = "NOT_HEALTHY"
    """NOT_HEALTHY."""
    PARTIALLY_HEALTHY = "PARTIALLY_HEALTHY"
    """PARTIALLY_HEALTHY."""
    HEALTHY = "HEALTHY"
    """HEALTHY."""


class ReplicationLinkType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Link type (GEO, NAMED, STANDBY). Update operation does not support NAMED."""

    GEO = "GEO"
    """GEO."""
    NAMED = "NAMED"
    """NAMED."""
    STANDBY = "STANDBY"
    """STANDBY."""


class ReplicationModeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Replication mode of the link."""

    ASYNC = "Async"
    """Async."""
    SYNC = "Sync"
    """Sync."""


class ReplicationRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Local replication role."""

    PRIMARY = "Primary"
    """Primary."""
    SECONDARY = "Secondary"
    """Secondary."""
    NON_READABLE_SECONDARY = "NonReadableSecondary"
    """NonReadableSecondary."""
    SOURCE = "Source"
    """Source."""
    COPY = "Copy"
    """Copy."""


class ReplicationState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Replication state (PENDING, SEEDING, CATCHUP, SUSPENDED)."""

    PENDING = "PENDING"
    """PENDING."""
    SEEDING = "SEEDING"
    """SEEDING."""
    CATCH_UP = "CATCH_UP"
    """CATCH_UP."""
    SUSPENDED = "SUSPENDED"
    """SUSPENDED."""


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

    PRIMARY = "Primary"
    """Primary."""
    READABLE_SECONDARY = "ReadableSecondary"
    """ReadableSecondary."""


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

    DEFAULT = "Default"
    """Default."""


class RestorePointType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of restore point."""

    CONTINUOUS = "CONTINUOUS"
    """CONTINUOUS."""
    DISCRETE = "DISCRETE"
    """DISCRETE."""


class RoleChangeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the role change, can be Planned or Forced."""

    FORCED = "Forced"
    """Forced."""
    PLANNED = "Planned"
    """Planned."""


class RuleSeverity(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """SQL Vulnerability Assessment rule severity."""

    HIGH = "High"
    """High."""
    MEDIUM = "Medium"
    """Medium."""
    LOW = "Low"
    """Low."""
    INFORMATIONAL = "Informational"
    """Informational."""
    OBSOLETE = "Obsolete"
    """Obsolete."""


class RuleStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """SQL Vulnerability Assessment baseline status."""

    NON_FINDING = "NonFinding"
    """NonFinding."""
    FINDING = "Finding"
    """Finding."""
    INTERNAL_ERROR = "InternalError"
    """InternalError."""


class RuleType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """SQL Vulnerability Assessment rule type."""

    BINARY = "Binary"
    """Binary."""
    BASELINE_EXPECTED = "BaselineExpected"
    """BaselineExpected."""
    POSITIVE_LIST = "PositiveList"
    """PositiveList."""
    NEGATIVE_LIST = "NegativeList"
    """NegativeList."""


class SampleName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The name of the sample schema to apply when creating this database."""

    ADVENTURE_WORKS_LT = "AdventureWorksLT"
    """AdventureWorksLT."""
    WIDE_WORLD_IMPORTERS_STD = "WideWorldImportersStd"
    """WideWorldImportersStd."""
    WIDE_WORLD_IMPORTERS_FULL = "WideWorldImportersFull"
    """WideWorldImportersFull."""


class SecondaryInstanceType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the geo-secondary instance. Set 'Standby' if the instance is used as a DR option only."""

    GEO = "Geo"
    """Geo."""
    STANDBY = "Standby"
    """Standby."""


class SecondaryType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The secondary type of the database if it is a secondary.  Valid values are Geo, Named and
    Standby.
    """

    GEO = "Geo"
    """Geo."""
    NAMED = "Named"
    """Named."""
    STANDBY = "Standby"
    """Standby."""


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

    DEFAULT = "Default"
    """Default."""


class SecurityAlertPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the policy, whether it is enabled or disabled or a policy has not been
    applied yet on the specific database.
    """

    NEW = "New"
    """New."""
    ENABLED = "Enabled"
    """Enabled."""
    DISABLED = "Disabled"
    """Disabled."""


class SecurityAlertsPolicyState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the policy, whether it is enabled or disabled or a policy has not been
    applied yet on the specific database.
    """

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


class SecurityEventType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of the security event."""

    UNDEFINED = "Undefined"
    """Undefined."""
    SQL_INJECTION_VULNERABILITY = "SqlInjectionVulnerability"
    """SqlInjectionVulnerability."""
    SQL_INJECTION_EXPLOIT = "SqlInjectionExploit"
    """SqlInjectionExploit."""


class SeedingModeType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Database seeding mode – can be Automatic (default), or Manual for supported scenarios."""

    AUTOMATIC = "Automatic"
    """Automatic."""
    MANUAL = "Manual"
    """Manual."""


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

    NONE = "None"
    """None."""
    LOW = "Low"
    """Low."""
    MEDIUM = "Medium"
    """Medium."""
    HIGH = "High"
    """High."""
    CRITICAL = "Critical"
    """Critical."""


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

    CURRENT = "current"
    """current."""
    RECOMMENDED = "recommended"
    """recommended."""


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

    SET = "set"
    """set."""
    REMOVE = "remove"
    """remove."""


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

    ALLOW_POLYBASE_EXPORT = "allowPolybaseExport"
    """allowPolybaseExport."""


class ServerConnectionType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The server connection type."""

    DEFAULT = "Default"
    """Default."""
    REDIRECT = "Redirect"
    """Redirect."""
    PROXY = "Proxy"
    """Proxy."""


class ServerCreateMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Create mode for server, only valid values for this are Normal and Restore."""

    NORMAL = "Normal"
    """Normal."""
    RESTORE = "Restore"
    """Restore."""


class ServerKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The encryption protector type like 'ServiceManaged', 'AzureKeyVault'."""

    SERVICE_MANAGED = "ServiceManaged"
    """ServiceManaged."""
    AZURE_KEY_VAULT = "AzureKeyVault"
    """AzureKeyVault."""


class ServerNetworkAccessFlag(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not to restrict outbound network access for this server.  Value is optional but if
    passed in, must be 'Enabled' or 'Disabled'.
    """

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


class ServerPublicNetworkAccessFlag(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not public endpoint access is allowed for this server.  Value is optional but if
    passed in, must be 'Enabled' or 'Disabled' or 'SecuredByPerimeter'.
    """

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


class ServerTrustGroupPropertiesTrustScopesItem(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Type of ServerTrustGroupPropertiesTrustScopesItem."""

    GLOBAL_TRANSACTIONS = "GlobalTransactions"
    """GlobalTransactions."""
    SERVICE_BROKER = "ServiceBroker"
    """ServiceBroker."""


class ServerWorkspaceFeature(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not existing server has a workspace created and if it allows connection from
    workspace.
    """

    CONNECTED = "Connected"
    """Connected."""
    DISCONNECTED = "Disconnected"
    """Disconnected."""


class ServicePrincipalType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Service principal type."""

    NONE = "None"
    """None."""
    SYSTEM_ASSIGNED = "SystemAssigned"
    """SystemAssigned."""


class SetLegalHoldImmutability(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The setting for whether LegalHold is enabled or disabled on the LTR backup. When LegalHold is
    enabled, the backup cannot be deleted until the LegalHold is removed.
    """

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


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

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


class SqlAgentConfigurationPropertiesState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The state of Sql Agent."""

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


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

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


class SqlVulnerabilityAssessmentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the SQL Vulnerability Assessment, whether it is enabled or disabled or a
    state has not been applied yet on the specific database or server.
    """

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


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

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


class StorageCapabilityStorageAccountType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The storage account type for the database's backups."""

    GRS = "GRS"
    """GRS."""
    LRS = "LRS"
    """LRS."""
    ZRS = "ZRS"
    """ZRS."""
    GZRS = "GZRS"
    """GZRS."""


class StorageKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Storage key type: StorageAccessKey, SharedAccessKey or ManagedIdentity."""

    SHARED_ACCESS_KEY = "SharedAccessKey"
    """SharedAccessKey."""
    STORAGE_ACCESS_KEY = "StorageAccessKey"
    """StorageAccessKey."""
    MANAGED_IDENTITY = "ManagedIdentity"
    """ManagedIdentity."""


class SyncAgentState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """State of the sync agent."""

    ONLINE = "Online"
    """Online."""
    OFFLINE = "Offline"
    """Offline."""
    NEVER_CONNECTED = "NeverConnected"
    """NeverConnected."""


class SyncConflictResolutionPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Conflict resolution policy of the sync group."""

    HUB_WIN = "HubWin"
    """HubWin."""
    MEMBER_WIN = "MemberWin"
    """MemberWin."""


class SyncDirection(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Sync direction of the sync member."""

    BIDIRECTIONAL = "Bidirectional"
    """Bidirectional."""
    ONE_WAY_MEMBER_TO_HUB = "OneWayMemberToHub"
    """OneWayMemberToHub."""
    ONE_WAY_HUB_TO_MEMBER = "OneWayHubToMember"
    """OneWayHubToMember."""


class SyncGroupLogType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the sync group log."""

    ALL = "All"
    """All."""
    ERROR = "Error"
    """Error."""
    WARNING = "Warning"
    """Warning."""
    SUCCESS = "Success"
    """Success."""


class SyncGroupState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Sync state of the sync group."""

    NOT_READY = "NotReady"
    """NotReady."""
    ERROR = "Error"
    """Error."""
    WARNING = "Warning"
    """Warning."""
    PROGRESSING = "Progressing"
    """Progressing."""
    GOOD = "Good"
    """Good."""


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

    ALL = "All"
    """All."""
    ERROR = "Error"
    """Error."""
    WARNING = "Warning"
    """Warning."""
    SUCCESS = "Success"
    """Success."""


class SyncMemberDbType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Type of the sync agent linked database."""

    AZURE_SQL_DATABASE = "AzureSqlDatabase"
    """AzureSqlDatabase."""
    SQL_SERVER_DATABASE = "SqlServerDatabase"
    """SqlServerDatabase."""


class SyncMemberState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Sync state of the sync member."""

    SYNC_IN_PROGRESS = "SyncInProgress"
    """SyncInProgress."""
    SYNC_SUCCEEDED = "SyncSucceeded"
    """SyncSucceeded."""
    SYNC_FAILED = "SyncFailed"
    """SyncFailed."""
    DISABLED_TOMBSTONE_CLEANUP = "DisabledTombstoneCleanup"
    """DisabledTombstoneCleanup."""
    DISABLED_BACKUP_RESTORE = "DisabledBackupRestore"
    """DisabledBackupRestore."""
    SYNC_SUCCEEDED_WITH_WARNINGS = "SyncSucceededWithWarnings"
    """SyncSucceededWithWarnings."""
    SYNC_CANCELLING = "SyncCancelling"
    """SyncCancelling."""
    SYNC_CANCELLED = "SyncCancelled"
    """SyncCancelled."""
    UN_PROVISIONED = "UnProvisioned"
    """UnProvisioned."""
    PROVISIONING = "Provisioning"
    """Provisioning."""
    PROVISIONED = "Provisioned"
    """Provisioned."""
    PROVISION_FAILED = "ProvisionFailed"
    """ProvisionFailed."""
    DE_PROVISIONING = "DeProvisioning"
    """DeProvisioning."""
    DE_PROVISIONED = "DeProvisioned"
    """DeProvisioned."""
    DE_PROVISION_FAILED = "DeProvisionFailed"
    """DeProvisionFailed."""
    REPROVISIONING = "Reprovisioning"
    """Reprovisioning."""
    REPROVISION_FAILED = "ReprovisionFailed"
    """ReprovisionFailed."""
    UN_REPROVISIONED = "UnReprovisioned"
    """UnReprovisioned."""


class TableTemporalType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The table temporal type."""

    NON_TEMPORAL_TABLE = "NonTemporalTable"
    """NonTemporalTable."""
    HISTORY_TABLE = "HistoryTable"
    """HistoryTable."""
    SYSTEM_VERSIONED_TEMPORAL_TABLE = "SystemVersionedTemporalTable"
    """SystemVersionedTemporalTable."""


class TimeBasedImmutability(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The setting for whether or not time-based immutability is enabled for the LTR backup. When
    time-based immutability is enabled and locked, the backup cannot be deleted until
    BackupExpirationTime.
    """

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


class TimeBasedImmutabilityMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The time-based immutability mode. Only applicable if time-based immutability is enabled."""

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


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

    CURRENT = "current"
    """current."""


class TransparentDataEncryptionScanState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the encryption scan state of the transparent data encryption."""

    NONE = "None"
    """None."""
    RESUME = "Resume"
    """Resume."""
    RUNNING = "Running"
    """Running."""
    SUSPEND = "Suspend"
    """Suspend."""
    ABORTED = "Aborted"
    """Aborted."""
    COMPLETED = "Completed"
    """Completed."""


class TransparentDataEncryptionState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Specifies the state of the transparent data encryption."""

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


class UpsertManagedServerOperationStepWithEstimatesAndDurationStatus(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Type of UpsertManagedServerOperationStepWithEstimatesAndDurationStatus."""

    NOT_STARTED = "NotStarted"
    """NotStarted."""
    IN_PROGRESS = "InProgress"
    """InProgress."""
    SLOWED_DOWN = "SlowedDown"
    """SlowedDown."""
    COMPLETED = "Completed"
    """Completed."""
    FAILED = "Failed"
    """Failed."""
    CANCELED = "Canceled"
    """Canceled."""


class VirtualNetworkRuleState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Virtual Network Rule State."""

    INITIALIZING = "Initializing"
    """Initializing."""
    IN_PROGRESS = "InProgress"
    """InProgress."""
    READY = "Ready"
    """Ready."""
    FAILED = "Failed"
    """Failed."""
    DELETING = "Deleting"
    """Deleting."""
    UNKNOWN = "Unknown"
    """Unknown."""


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

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


class VulnerabilityAssessmentPolicyBaselineName(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """Type of VulnerabilityAssessmentPolicyBaselineName."""

    MASTER = "master"
    """master."""
    DEFAULT = "default"
    """default."""


class VulnerabilityAssessmentScanState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The scan status."""

    PASSED = "Passed"
    """Passed."""
    FAILED = "Failed"
    """Failed."""
    FAILED_TO_RUN = "FailedToRun"
    """FailedToRun."""
    IN_PROGRESS = "InProgress"
    """InProgress."""


class VulnerabilityAssessmentScanTriggerType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The scan trigger type."""

    ON_DEMAND = "OnDemand"
    """OnDemand."""
    RECURRING = "Recurring"
    """Recurring."""
