# 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 AccessPolicyAssignmentProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of an access policy assignment set."""

    UPDATING = "Updating"
    """The access policy assignments are being updated."""
    SUCCEEDED = "Succeeded"
    """The access policy assignments were successfully updated."""
    DELETING = "Deleting"
    """The access policy assignments are being deleted."""
    DELETED = "Deleted"
    """The access policy assignments are considered deleted, meaning no custom access policies are
    applied."""
    CANCELED = "Canceled"
    """The operation was canceled. Access policy assignments may be in a partially updated state.
    Update them again to have a well-defined state."""
    FAILED = "Failed"
    """The operation failed. Access policy assignments may be in a partially updated state. Update
    them again to have a well-defined state."""


class AccessPolicyProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Provisioning state of access policy."""

    UPDATING = "Updating"
    """An operation is in progress."""
    SUCCEEDED = "Succeeded"
    """The operation succeeded."""
    DELETING = "Deleting"
    """A delete operation is in progress."""
    DELETED = "Deleted"
    """The access policy is considered deleted, if it still exists."""
    CANCELED = "Canceled"
    """The operation was canceled. Access policies may be in a partially updated state. Update them
    again to have a well-defined state."""
    FAILED = "Failed"
    """The operation failed. Access policies may be in a partially updated state. Update them again to
    have a well-defined state."""


class AccessPolicyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Built-In or Custom access policy."""

    CUSTOM = "Custom"
    """User-configurable access policy, using the redis access policy authoring language."""
    BUILT_IN = "BuiltIn"
    """Built-in or well-known access policies, whose policy is not configurable."""


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 DayOfWeek(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Day of the week when a cache can be patched."""

    MONDAY = "Monday"
    """MONDAY."""
    TUESDAY = "Tuesday"
    """TUESDAY."""
    WEDNESDAY = "Wednesday"
    """WEDNESDAY."""
    THURSDAY = "Thursday"
    """THURSDAY."""
    FRIDAY = "Friday"
    """FRIDAY."""
    SATURDAY = "Saturday"
    """SATURDAY."""
    SUNDAY = "Sunday"
    """SUNDAY."""
    EVERYDAY = "Everyday"
    """As a convenience, 'Everyday' is also accepted and means the same as specifying all days of the
    week."""
    WEEKEND = "Weekend"
    """As a convenience, 'Weekend' is also accepted and means the same as specifying Saturday and
    Sunday."""


class DefaultName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The name of the resource that is the target of a particular operation. For singleton resources,
    it must be 'Default'.
    """

    DEFAULT = "default"
    """The name of e.g. the patch schedules resource, which is a singleton, must always be 'Default'."""


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 PrivateEndpointConnectionProvisioningState(  # pylint: disable=name-too-long
    str, Enum, metaclass=CaseInsensitiveEnumMeta
):
    """The current provisioning state."""

    SUCCEEDED = "Succeeded"
    """Connection has been provisioned."""
    CREATING = "Creating"
    """Connection is being created."""
    DELETING = "Deleting"
    """Connection is being deleted."""
    FAILED = "Failed"
    """Connection provisioning has failed."""


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

    PENDING = "Pending"
    """Connection waiting for approval or rejection."""
    APPROVED = "Approved"
    """Connection approved."""
    REJECTED = "Rejected"
    """Connection Rejected."""


class ProvisioningState(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Redis instance provisioning status."""

    CREATING = "Creating"
    """A create operation is in progress."""
    DELETING = "Deleting"
    """A delete operation is in progress."""
    DISABLED = "Disabled"
    """The cache is disabled and cannot be used."""
    FAILED = "Failed"
    """An operation such as create or update failed. If you failed to create the cache it will not be
    in a usable state, so you should delete and recreate it."""
    LINKING = "Linking"
    """Georeplication link is in progress."""
    PROVISIONING = "Provisioning"
    """An operation is in progress."""
    RECOVERING_SCALE_FAILURE = "RecoveringScaleFailure"
    """A scaling operation encountered an error and recovery is in progress."""
    SCALING = "Scaling"
    """A scaling operation is in progress."""
    SUCCEEDED = "Succeeded"
    """The most recent operation successfully completed."""
    UNLINKING = "Unlinking"
    """Georeplication unlink is in progress."""
    UNPROVISIONING = "Unprovisioning"
    """The cache may be being disabled."""
    UPDATING = "Updating"
    """An update operation is in progress."""
    CONFIGURING_AAD = "ConfiguringAAD"
    """An AAD configuration update operation is in progress."""
    MIGRATING = "Migrating"
    """A migration to Azure Managed Redis is in progress."""
    MIGRATION_FAILED = "MigrationFailed"
    """A migration to Azure Managed Redis failed."""
    MIGRATION_SUCCEEDED = "MigrationSucceeded"
    """A migration to Azure Managed Redis succeeded."""
    MIGRATION_CANCELLING = "MigrationCancelling"
    """A cancellation (rollback) of a migration to Azure Managed Redis is in progress."""
    MIGRATION_CANCELLATION_FAILED = "MigrationCancellationFailed"
    """A cancellation (rollback) of a migration to Azure Managed Redis has failed."""


class PublicNetworkAccess(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Whether or not public endpoint access is allowed for this cache.  Value is optional but if
    passed in, must be 'Enabled' or 'Disabled'. If 'Disabled', private endpoints are the exclusive
    access method. Default value is 'Enabled'.
    """

    ENABLED = "Enabled"
    """Public internet access to the cache, via its public IP address, is enabled. Connections may use
    any network path."""
    DISABLED = "Disabled"
    """Public internet access to the cache, via its public IP address, is disabled. Connections must
    use be made via private endpoints."""


class RebootType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Which Redis node(s) to reboot. Depending on this value data loss is possible."""

    PRIMARY_NODE = "PrimaryNode"
    """Reboot the primary nodes used for redis write operations. (This may trigger role changes.)."""
    SECONDARY_NODE = "SecondaryNode"
    """Reboot only the secondary or replica nodes."""
    ALL_NODES = "AllNodes"
    """Reboot all nodes, not guaranteed to happen simultaneously."""


class RedisKeyType(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The Redis access key to regenerate."""

    PRIMARY = "Primary"
    """The primary access key."""
    SECONDARY = "Secondary"
    """The secondary access key."""


class ReplicationRole(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Role of the linked server."""

    PRIMARY = "Primary"
    """The linked server is in the writable primary role."""
    SECONDARY = "Secondary"
    """The linked server is in the read-only replica role."""


class SkuFamily(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The SKU family to use. Valid values: (C, P). (C = Basic/Standard, P = Premium)."""

    C = "C"
    """The SKU family to use - must be 'C' for Basic/Standard SKU redis caches."""
    P = "P"
    """The SKU family to use - must be 'P' for Premium SKU redis caches."""


class SkuName(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """The type of Redis cache to deploy. Valid values: (Basic, Standard, Premium)."""

    BASIC = "Basic"
    """The well known 'Basic' SKU for Azure Cache for Redis. Basic SKU does not have an availability
    SLA."""
    STANDARD = "Standard"
    """The well known 'Standard' SKU for Azure Cache for Redis. Standard SKU has an availability SLA."""
    PREMIUM = "Premium"
    """The well known 'Premium' SKU for Azure Cache for Redis. Premium SKU has an availability SLA,
    and higher performance tiers and more features compared with Standard SKU."""


class TlsVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0',
    '1.1', '1.2').
    """

    ONE0 = "1.0"
    """TLS protocol version 1.0 -- deprecated for security reasons. Do not use this value for new
    caches."""
    ONE1 = "1.1"
    """TLS protocol version 1.1 -- deprecated for security reasons. Do not use this value for new
    caches."""
    ONE2 = "1.2"
    """TLS protocol version 1.2 -- use this value, or higher, for new caches. Or do not specify, so
    that your cache uses the recommended default value."""


class UpdateChannel(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Optional: Specifies the update channel for the monthly Redis updates your Redis Cache will
    receive. Caches using 'Preview' update channel get latest Redis updates at least 4 weeks ahead
    of 'Stable' channel caches. Default value is 'Stable'.
    """

    STABLE = "Stable"
    """Stable channel receives updates, which may include important security and stability updates,
    later than Preview channel."""
    PREVIEW = "Preview"
    """Preview channel normally receives updates before Stable channel, and is the recommended channel
    for non-production workloads."""


class ZonalAllocationPolicy(str, Enum, metaclass=CaseInsensitiveEnumMeta):
    """Optional: Specifies how availability zones are allocated to the Redis cache. 'Automatic'
    enables zone redundancy and Azure will automatically select zones based on regional
    availability and capacity. 'UserDefined' will select availability zones passed in by you using
    the 'zones' parameter. 'NoZones' will produce a non-zonal cache. If 'zonalAllocationPolicy' is
    not passed, it will be set to 'UserDefined' when zones are passed in, otherwise, it will be set
    to 'Automatic' in regions where zones are supported and 'NoZones' in regions where zones are
    not supported.
    """

    AUTOMATIC = "Automatic"
    """The zones for the cache will be selected automatically based on availability and capacity."""
    USER_DEFINED = "UserDefined"
    """UserDefined means the zones for the cache are manually configured using the 'zones' property,
    and can not be automatically selected."""
    NO_ZONES = "NoZones"
    """The cache will not use multiple availability zones."""
