# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'CacheIdentity',
    'CachePatchSchedule',
    'CacheRedisConfiguration',
    'EnterpriseDatabaseModule',
    'GetCachePatchScheduleResult',
    'GetCacheRedisConfigurationResult',
]

@pulumi.output_type
class CacheIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str type: Specifies the type of Managed Service Identity that should be configured on this Redis Cluster. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        :param Sequence[str] identity_ids: A list of User Assigned Managed Identity IDs to be assigned to this Redis Cluster.
               
               > **NOTE:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        """
        CacheIdentity._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            type=type,
            identity_ids=identity_ids,
            principal_id=principal_id,
            tenant_id=tenant_id,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             type: Optional[str] = None,
             identity_ids: Optional[Sequence[str]] = None,
             principal_id: Optional[str] = None,
             tenant_id: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if type is None:
            raise TypeError("Missing 'type' argument")
        if identity_ids is None and 'identityIds' in kwargs:
            identity_ids = kwargs['identityIds']
        if principal_id is None and 'principalId' in kwargs:
            principal_id = kwargs['principalId']
        if tenant_id is None and 'tenantId' in kwargs:
            tenant_id = kwargs['tenantId']

        _setter("type", type)
        if identity_ids is not None:
            _setter("identity_ids", identity_ids)
        if principal_id is not None:
            _setter("principal_id", principal_id)
        if tenant_id is not None:
            _setter("tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Specifies the type of Managed Service Identity that should be configured on this Redis Cluster. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[Sequence[str]]:
        """
        A list of User Assigned Managed Identity IDs to be assigned to this Redis Cluster.

        > **NOTE:** This is required when `type` is set to `UserAssigned` or `SystemAssigned, UserAssigned`.
        """
        return pulumi.get(self, "identity_ids")

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[str]:
        return pulumi.get(self, "principal_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class CachePatchSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dayOfWeek":
            suggest = "day_of_week"
        elif key == "maintenanceWindow":
            suggest = "maintenance_window"
        elif key == "startHourUtc":
            suggest = "start_hour_utc"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CachePatchSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CachePatchSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CachePatchSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 day_of_week: str,
                 maintenance_window: Optional[str] = None,
                 start_hour_utc: Optional[int] = None):
        """
        :param str day_of_week: the Weekday name - possible values include `Monday`, `Tuesday`, `Wednesday` etc.
        :param str maintenance_window: The ISO 8601 timespan which specifies the amount of time the Redis Cache can be updated. Defaults to `PT5H`.
        :param int start_hour_utc: the Start Hour for maintenance in UTC - possible values range from `0 - 23`.
               
               > **Note:** The Patch Window lasts for `5` hours from the `start_hour_utc`.
        """
        CachePatchSchedule._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            day_of_week=day_of_week,
            maintenance_window=maintenance_window,
            start_hour_utc=start_hour_utc,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             day_of_week: Optional[str] = None,
             maintenance_window: Optional[str] = None,
             start_hour_utc: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if day_of_week is None and 'dayOfWeek' in kwargs:
            day_of_week = kwargs['dayOfWeek']
        if day_of_week is None:
            raise TypeError("Missing 'day_of_week' argument")
        if maintenance_window is None and 'maintenanceWindow' in kwargs:
            maintenance_window = kwargs['maintenanceWindow']
        if start_hour_utc is None and 'startHourUtc' in kwargs:
            start_hour_utc = kwargs['startHourUtc']

        _setter("day_of_week", day_of_week)
        if maintenance_window is not None:
            _setter("maintenance_window", maintenance_window)
        if start_hour_utc is not None:
            _setter("start_hour_utc", start_hour_utc)

    @property
    @pulumi.getter(name="dayOfWeek")
    def day_of_week(self) -> str:
        """
        the Weekday name - possible values include `Monday`, `Tuesday`, `Wednesday` etc.
        """
        return pulumi.get(self, "day_of_week")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> Optional[str]:
        """
        The ISO 8601 timespan which specifies the amount of time the Redis Cache can be updated. Defaults to `PT5H`.
        """
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="startHourUtc")
    def start_hour_utc(self) -> Optional[int]:
        """
        the Start Hour for maintenance in UTC - possible values range from `0 - 23`.

        > **Note:** The Patch Window lasts for `5` hours from the `start_hour_utc`.
        """
        return pulumi.get(self, "start_hour_utc")


@pulumi.output_type
class CacheRedisConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aofBackupEnabled":
            suggest = "aof_backup_enabled"
        elif key == "aofStorageConnectionString0":
            suggest = "aof_storage_connection_string0"
        elif key == "aofStorageConnectionString1":
            suggest = "aof_storage_connection_string1"
        elif key == "enableAuthentication":
            suggest = "enable_authentication"
        elif key == "maxfragmentationmemoryReserved":
            suggest = "maxfragmentationmemory_reserved"
        elif key == "maxmemoryDelta":
            suggest = "maxmemory_delta"
        elif key == "maxmemoryPolicy":
            suggest = "maxmemory_policy"
        elif key == "maxmemoryReserved":
            suggest = "maxmemory_reserved"
        elif key == "notifyKeyspaceEvents":
            suggest = "notify_keyspace_events"
        elif key == "rdbBackupEnabled":
            suggest = "rdb_backup_enabled"
        elif key == "rdbBackupFrequency":
            suggest = "rdb_backup_frequency"
        elif key == "rdbBackupMaxSnapshotCount":
            suggest = "rdb_backup_max_snapshot_count"
        elif key == "rdbStorageConnectionString":
            suggest = "rdb_storage_connection_string"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheRedisConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheRedisConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheRedisConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aof_backup_enabled: Optional[bool] = None,
                 aof_storage_connection_string0: Optional[str] = None,
                 aof_storage_connection_string1: Optional[str] = None,
                 enable_authentication: Optional[bool] = None,
                 maxclients: Optional[int] = None,
                 maxfragmentationmemory_reserved: Optional[int] = None,
                 maxmemory_delta: Optional[int] = None,
                 maxmemory_policy: Optional[str] = None,
                 maxmemory_reserved: Optional[int] = None,
                 notify_keyspace_events: Optional[str] = None,
                 rdb_backup_enabled: Optional[bool] = None,
                 rdb_backup_frequency: Optional[int] = None,
                 rdb_backup_max_snapshot_count: Optional[int] = None,
                 rdb_storage_connection_string: Optional[str] = None):
        """
        :param bool aof_backup_enabled: Enable or disable AOF persistence for this Redis Cache. Defaults to `false`.
               
               > **NOTE:** `aof_backup_enabled` can only be set when SKU is `Premium`.
        :param str aof_storage_connection_string0: First Storage Account connection string for AOF persistence.
        :param str aof_storage_connection_string1: Second Storage Account connection string for AOF persistence.
               
               Example usage:
               
               ```python
               import pulumi
               ```
        :param bool enable_authentication: If set to `false`, the Redis instance will be accessible without authentication. Defaults to `true`.
               
               > **NOTE:** `enable_authentication` can only be set to `false` if a `subnet_id` is specified; and only works if there aren't existing instances within the subnet with `enable_authentication` set to `true`.
        :param int maxclients: Returns the max number of connected clients at the same time.
        :param int maxfragmentationmemory_reserved: Value in megabytes reserved to accommodate for memory fragmentation. Defaults are shown below.
        :param int maxmemory_delta: The max-memory delta for this Redis instance. Defaults are shown below.
        :param str maxmemory_policy: How Redis will select what to remove when `maxmemory` is reached. Defaults are shown below. Defaults to `volatile-lru`.
        :param int maxmemory_reserved: Value in megabytes reserved for non-cache usage e.g. failover. Defaults are shown below.
        :param str notify_keyspace_events: Keyspace notifications allows clients to subscribe to Pub/Sub channels in order to receive events affecting the Redis data set in some way. [Reference](https://redis.io/topics/notifications#configuration)
               
               ```python
               import pulumi
               ```
        :param bool rdb_backup_enabled: Is Backup Enabled? Only supported on Premium SKUs. Defaults to `false`.
               
               > **NOTE:** If `rdb_backup_enabled` set to `true`, `rdb_storage_connection_string` must also be set.
        :param int rdb_backup_frequency: The Backup Frequency in Minutes. Only supported on Premium SKUs. Possible values are: `15`, `30`, `60`, `360`, `720` and `1440`.
        :param int rdb_backup_max_snapshot_count: The maximum number of snapshots to create as a backup. Only supported for Premium SKUs.
        :param str rdb_storage_connection_string: The Connection String to the Storage Account. Only supported for Premium SKUs. In the format: `DefaultEndpointsProtocol=https;BlobEndpoint=${azurerm_storage_account.example.primary_blob_endpoint};AccountName=${azurerm_storage_account.example.name};AccountKey=${azurerm_storage_account.example.primary_access_key}`.
               
               > **NOTE:** There's a bug in the Redis API where the original storage connection string isn't being returned, which [is being tracked in this issue](https://github.com/Azure/azure-rest-api-specs/issues/3037). In the interim you can use [the `ignoreChanges` attribute to ignore changes to this field](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) e.g.:
        """
        CacheRedisConfiguration._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            aof_backup_enabled=aof_backup_enabled,
            aof_storage_connection_string0=aof_storage_connection_string0,
            aof_storage_connection_string1=aof_storage_connection_string1,
            enable_authentication=enable_authentication,
            maxclients=maxclients,
            maxfragmentationmemory_reserved=maxfragmentationmemory_reserved,
            maxmemory_delta=maxmemory_delta,
            maxmemory_policy=maxmemory_policy,
            maxmemory_reserved=maxmemory_reserved,
            notify_keyspace_events=notify_keyspace_events,
            rdb_backup_enabled=rdb_backup_enabled,
            rdb_backup_frequency=rdb_backup_frequency,
            rdb_backup_max_snapshot_count=rdb_backup_max_snapshot_count,
            rdb_storage_connection_string=rdb_storage_connection_string,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             aof_backup_enabled: Optional[bool] = None,
             aof_storage_connection_string0: Optional[str] = None,
             aof_storage_connection_string1: Optional[str] = None,
             enable_authentication: Optional[bool] = None,
             maxclients: Optional[int] = None,
             maxfragmentationmemory_reserved: Optional[int] = None,
             maxmemory_delta: Optional[int] = None,
             maxmemory_policy: Optional[str] = None,
             maxmemory_reserved: Optional[int] = None,
             notify_keyspace_events: Optional[str] = None,
             rdb_backup_enabled: Optional[bool] = None,
             rdb_backup_frequency: Optional[int] = None,
             rdb_backup_max_snapshot_count: Optional[int] = None,
             rdb_storage_connection_string: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if aof_backup_enabled is None and 'aofBackupEnabled' in kwargs:
            aof_backup_enabled = kwargs['aofBackupEnabled']
        if aof_storage_connection_string0 is None and 'aofStorageConnectionString0' in kwargs:
            aof_storage_connection_string0 = kwargs['aofStorageConnectionString0']
        if aof_storage_connection_string1 is None and 'aofStorageConnectionString1' in kwargs:
            aof_storage_connection_string1 = kwargs['aofStorageConnectionString1']
        if enable_authentication is None and 'enableAuthentication' in kwargs:
            enable_authentication = kwargs['enableAuthentication']
        if maxfragmentationmemory_reserved is None and 'maxfragmentationmemoryReserved' in kwargs:
            maxfragmentationmemory_reserved = kwargs['maxfragmentationmemoryReserved']
        if maxmemory_delta is None and 'maxmemoryDelta' in kwargs:
            maxmemory_delta = kwargs['maxmemoryDelta']
        if maxmemory_policy is None and 'maxmemoryPolicy' in kwargs:
            maxmemory_policy = kwargs['maxmemoryPolicy']
        if maxmemory_reserved is None and 'maxmemoryReserved' in kwargs:
            maxmemory_reserved = kwargs['maxmemoryReserved']
        if notify_keyspace_events is None and 'notifyKeyspaceEvents' in kwargs:
            notify_keyspace_events = kwargs['notifyKeyspaceEvents']
        if rdb_backup_enabled is None and 'rdbBackupEnabled' in kwargs:
            rdb_backup_enabled = kwargs['rdbBackupEnabled']
        if rdb_backup_frequency is None and 'rdbBackupFrequency' in kwargs:
            rdb_backup_frequency = kwargs['rdbBackupFrequency']
        if rdb_backup_max_snapshot_count is None and 'rdbBackupMaxSnapshotCount' in kwargs:
            rdb_backup_max_snapshot_count = kwargs['rdbBackupMaxSnapshotCount']
        if rdb_storage_connection_string is None and 'rdbStorageConnectionString' in kwargs:
            rdb_storage_connection_string = kwargs['rdbStorageConnectionString']

        if aof_backup_enabled is not None:
            _setter("aof_backup_enabled", aof_backup_enabled)
        if aof_storage_connection_string0 is not None:
            _setter("aof_storage_connection_string0", aof_storage_connection_string0)
        if aof_storage_connection_string1 is not None:
            _setter("aof_storage_connection_string1", aof_storage_connection_string1)
        if enable_authentication is not None:
            _setter("enable_authentication", enable_authentication)
        if maxclients is not None:
            _setter("maxclients", maxclients)
        if maxfragmentationmemory_reserved is not None:
            _setter("maxfragmentationmemory_reserved", maxfragmentationmemory_reserved)
        if maxmemory_delta is not None:
            _setter("maxmemory_delta", maxmemory_delta)
        if maxmemory_policy is not None:
            _setter("maxmemory_policy", maxmemory_policy)
        if maxmemory_reserved is not None:
            _setter("maxmemory_reserved", maxmemory_reserved)
        if notify_keyspace_events is not None:
            _setter("notify_keyspace_events", notify_keyspace_events)
        if rdb_backup_enabled is not None:
            _setter("rdb_backup_enabled", rdb_backup_enabled)
        if rdb_backup_frequency is not None:
            _setter("rdb_backup_frequency", rdb_backup_frequency)
        if rdb_backup_max_snapshot_count is not None:
            _setter("rdb_backup_max_snapshot_count", rdb_backup_max_snapshot_count)
        if rdb_storage_connection_string is not None:
            _setter("rdb_storage_connection_string", rdb_storage_connection_string)

    @property
    @pulumi.getter(name="aofBackupEnabled")
    def aof_backup_enabled(self) -> Optional[bool]:
        """
        Enable or disable AOF persistence for this Redis Cache. Defaults to `false`.

        > **NOTE:** `aof_backup_enabled` can only be set when SKU is `Premium`.
        """
        return pulumi.get(self, "aof_backup_enabled")

    @property
    @pulumi.getter(name="aofStorageConnectionString0")
    def aof_storage_connection_string0(self) -> Optional[str]:
        """
        First Storage Account connection string for AOF persistence.
        """
        return pulumi.get(self, "aof_storage_connection_string0")

    @property
    @pulumi.getter(name="aofStorageConnectionString1")
    def aof_storage_connection_string1(self) -> Optional[str]:
        """
        Second Storage Account connection string for AOF persistence.

        Example usage:

        ```python
        import pulumi
        ```
        """
        return pulumi.get(self, "aof_storage_connection_string1")

    @property
    @pulumi.getter(name="enableAuthentication")
    def enable_authentication(self) -> Optional[bool]:
        """
        If set to `false`, the Redis instance will be accessible without authentication. Defaults to `true`.

        > **NOTE:** `enable_authentication` can only be set to `false` if a `subnet_id` is specified; and only works if there aren't existing instances within the subnet with `enable_authentication` set to `true`.
        """
        return pulumi.get(self, "enable_authentication")

    @property
    @pulumi.getter
    def maxclients(self) -> Optional[int]:
        """
        Returns the max number of connected clients at the same time.
        """
        return pulumi.get(self, "maxclients")

    @property
    @pulumi.getter(name="maxfragmentationmemoryReserved")
    def maxfragmentationmemory_reserved(self) -> Optional[int]:
        """
        Value in megabytes reserved to accommodate for memory fragmentation. Defaults are shown below.
        """
        return pulumi.get(self, "maxfragmentationmemory_reserved")

    @property
    @pulumi.getter(name="maxmemoryDelta")
    def maxmemory_delta(self) -> Optional[int]:
        """
        The max-memory delta for this Redis instance. Defaults are shown below.
        """
        return pulumi.get(self, "maxmemory_delta")

    @property
    @pulumi.getter(name="maxmemoryPolicy")
    def maxmemory_policy(self) -> Optional[str]:
        """
        How Redis will select what to remove when `maxmemory` is reached. Defaults are shown below. Defaults to `volatile-lru`.
        """
        return pulumi.get(self, "maxmemory_policy")

    @property
    @pulumi.getter(name="maxmemoryReserved")
    def maxmemory_reserved(self) -> Optional[int]:
        """
        Value in megabytes reserved for non-cache usage e.g. failover. Defaults are shown below.
        """
        return pulumi.get(self, "maxmemory_reserved")

    @property
    @pulumi.getter(name="notifyKeyspaceEvents")
    def notify_keyspace_events(self) -> Optional[str]:
        """
        Keyspace notifications allows clients to subscribe to Pub/Sub channels in order to receive events affecting the Redis data set in some way. [Reference](https://redis.io/topics/notifications#configuration)

        ```python
        import pulumi
        ```
        """
        return pulumi.get(self, "notify_keyspace_events")

    @property
    @pulumi.getter(name="rdbBackupEnabled")
    def rdb_backup_enabled(self) -> Optional[bool]:
        """
        Is Backup Enabled? Only supported on Premium SKUs. Defaults to `false`.

        > **NOTE:** If `rdb_backup_enabled` set to `true`, `rdb_storage_connection_string` must also be set.
        """
        return pulumi.get(self, "rdb_backup_enabled")

    @property
    @pulumi.getter(name="rdbBackupFrequency")
    def rdb_backup_frequency(self) -> Optional[int]:
        """
        The Backup Frequency in Minutes. Only supported on Premium SKUs. Possible values are: `15`, `30`, `60`, `360`, `720` and `1440`.
        """
        return pulumi.get(self, "rdb_backup_frequency")

    @property
    @pulumi.getter(name="rdbBackupMaxSnapshotCount")
    def rdb_backup_max_snapshot_count(self) -> Optional[int]:
        """
        The maximum number of snapshots to create as a backup. Only supported for Premium SKUs.
        """
        return pulumi.get(self, "rdb_backup_max_snapshot_count")

    @property
    @pulumi.getter(name="rdbStorageConnectionString")
    def rdb_storage_connection_string(self) -> Optional[str]:
        """
        The Connection String to the Storage Account. Only supported for Premium SKUs. In the format: `DefaultEndpointsProtocol=https;BlobEndpoint=${azurerm_storage_account.example.primary_blob_endpoint};AccountName=${azurerm_storage_account.example.name};AccountKey=${azurerm_storage_account.example.primary_access_key}`.

        > **NOTE:** There's a bug in the Redis API where the original storage connection string isn't being returned, which [is being tracked in this issue](https://github.com/Azure/azure-rest-api-specs/issues/3037). In the interim you can use [the `ignoreChanges` attribute to ignore changes to this field](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) e.g.:
        """
        return pulumi.get(self, "rdb_storage_connection_string")


@pulumi.output_type
class EnterpriseDatabaseModule(dict):
    def __init__(__self__, *,
                 name: str,
                 args: Optional[str] = None,
                 version: Optional[str] = None):
        """
        :param str name: The name which should be used for this module. Possible values are `RedisBloom`, `RedisTimeSeries`, `RediSearch` and `RedisJSON`. Changing this forces a new Redis Enterprise Database to be created.
        :param str args: Configuration options for the module (e.g. `ERROR_RATE 0.00 INITIAL_SIZE 400`). Changing this forces a new resource to be created. Defaults to `""`.
        """
        EnterpriseDatabaseModule._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            name=name,
            args=args,
            version=version,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             name: Optional[str] = None,
             args: Optional[str] = None,
             version: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if name is None:
            raise TypeError("Missing 'name' argument")

        _setter("name", name)
        if args is not None:
            _setter("args", args)
        if version is not None:
            _setter("version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name which should be used for this module. Possible values are `RedisBloom`, `RedisTimeSeries`, `RediSearch` and `RedisJSON`. Changing this forces a new Redis Enterprise Database to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def args(self) -> Optional[str]:
        """
        Configuration options for the module (e.g. `ERROR_RATE 0.00 INITIAL_SIZE 400`). Changing this forces a new resource to be created. Defaults to `""`.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        return pulumi.get(self, "version")


@pulumi.output_type
class GetCachePatchScheduleResult(dict):
    def __init__(__self__, *,
                 day_of_week: str,
                 maintenance_window: str,
                 start_hour_utc: int):
        """
        :param str day_of_week: the Weekday name for the patch item
        :param str maintenance_window: The ISO 8601 timespan which specifies the amount of time the Redis Cache can be updated.
        :param int start_hour_utc: The Start Hour for maintenance in UTC
        """
        GetCachePatchScheduleResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            day_of_week=day_of_week,
            maintenance_window=maintenance_window,
            start_hour_utc=start_hour_utc,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             day_of_week: Optional[str] = None,
             maintenance_window: Optional[str] = None,
             start_hour_utc: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if day_of_week is None and 'dayOfWeek' in kwargs:
            day_of_week = kwargs['dayOfWeek']
        if day_of_week is None:
            raise TypeError("Missing 'day_of_week' argument")
        if maintenance_window is None and 'maintenanceWindow' in kwargs:
            maintenance_window = kwargs['maintenanceWindow']
        if maintenance_window is None:
            raise TypeError("Missing 'maintenance_window' argument")
        if start_hour_utc is None and 'startHourUtc' in kwargs:
            start_hour_utc = kwargs['startHourUtc']
        if start_hour_utc is None:
            raise TypeError("Missing 'start_hour_utc' argument")

        _setter("day_of_week", day_of_week)
        _setter("maintenance_window", maintenance_window)
        _setter("start_hour_utc", start_hour_utc)

    @property
    @pulumi.getter(name="dayOfWeek")
    def day_of_week(self) -> str:
        """
        the Weekday name for the patch item
        """
        return pulumi.get(self, "day_of_week")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> str:
        """
        The ISO 8601 timespan which specifies the amount of time the Redis Cache can be updated.
        """
        return pulumi.get(self, "maintenance_window")

    @property
    @pulumi.getter(name="startHourUtc")
    def start_hour_utc(self) -> int:
        """
        The Start Hour for maintenance in UTC
        """
        return pulumi.get(self, "start_hour_utc")


@pulumi.output_type
class GetCacheRedisConfigurationResult(dict):
    def __init__(__self__, *,
                 aof_backup_enabled: bool,
                 aof_storage_connection_string0: str,
                 aof_storage_connection_string1: str,
                 enable_authentication: bool,
                 maxclients: int,
                 maxfragmentationmemory_reserved: int,
                 maxmemory_delta: int,
                 maxmemory_policy: str,
                 maxmemory_reserved: int,
                 notify_keyspace_events: str,
                 rdb_backup_enabled: bool,
                 rdb_backup_frequency: int,
                 rdb_backup_max_snapshot_count: int,
                 rdb_storage_connection_string: str):
        """
        :param bool enable_authentication: Specifies if authentication is enabled
        :param int maxfragmentationmemory_reserved: Value in megabytes reserved to accommodate for memory fragmentation.
        :param int maxmemory_delta: The max-memory delta for this Redis instance.
        :param str maxmemory_policy: How Redis will select what to remove when `maxmemory` is reached.
        :param int maxmemory_reserved: The value in megabytes reserved for non-cache usage e.g. failover
        :param bool rdb_backup_enabled: Is Backup Enabled? Only supported on Premium SKUs.
        :param int rdb_backup_frequency: The Backup Frequency in Minutes. Only supported on Premium SKUs.
        :param int rdb_backup_max_snapshot_count: The maximum number of snapshots that can be created as a backup.
        :param str rdb_storage_connection_string: The Connection String to the Storage Account. Only supported for Premium SKUs.
        """
        GetCacheRedisConfigurationResult._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            aof_backup_enabled=aof_backup_enabled,
            aof_storage_connection_string0=aof_storage_connection_string0,
            aof_storage_connection_string1=aof_storage_connection_string1,
            enable_authentication=enable_authentication,
            maxclients=maxclients,
            maxfragmentationmemory_reserved=maxfragmentationmemory_reserved,
            maxmemory_delta=maxmemory_delta,
            maxmemory_policy=maxmemory_policy,
            maxmemory_reserved=maxmemory_reserved,
            notify_keyspace_events=notify_keyspace_events,
            rdb_backup_enabled=rdb_backup_enabled,
            rdb_backup_frequency=rdb_backup_frequency,
            rdb_backup_max_snapshot_count=rdb_backup_max_snapshot_count,
            rdb_storage_connection_string=rdb_storage_connection_string,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             aof_backup_enabled: Optional[bool] = None,
             aof_storage_connection_string0: Optional[str] = None,
             aof_storage_connection_string1: Optional[str] = None,
             enable_authentication: Optional[bool] = None,
             maxclients: Optional[int] = None,
             maxfragmentationmemory_reserved: Optional[int] = None,
             maxmemory_delta: Optional[int] = None,
             maxmemory_policy: Optional[str] = None,
             maxmemory_reserved: Optional[int] = None,
             notify_keyspace_events: Optional[str] = None,
             rdb_backup_enabled: Optional[bool] = None,
             rdb_backup_frequency: Optional[int] = None,
             rdb_backup_max_snapshot_count: Optional[int] = None,
             rdb_storage_connection_string: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if aof_backup_enabled is None and 'aofBackupEnabled' in kwargs:
            aof_backup_enabled = kwargs['aofBackupEnabled']
        if aof_backup_enabled is None:
            raise TypeError("Missing 'aof_backup_enabled' argument")
        if aof_storage_connection_string0 is None and 'aofStorageConnectionString0' in kwargs:
            aof_storage_connection_string0 = kwargs['aofStorageConnectionString0']
        if aof_storage_connection_string0 is None:
            raise TypeError("Missing 'aof_storage_connection_string0' argument")
        if aof_storage_connection_string1 is None and 'aofStorageConnectionString1' in kwargs:
            aof_storage_connection_string1 = kwargs['aofStorageConnectionString1']
        if aof_storage_connection_string1 is None:
            raise TypeError("Missing 'aof_storage_connection_string1' argument")
        if enable_authentication is None and 'enableAuthentication' in kwargs:
            enable_authentication = kwargs['enableAuthentication']
        if enable_authentication is None:
            raise TypeError("Missing 'enable_authentication' argument")
        if maxclients is None:
            raise TypeError("Missing 'maxclients' argument")
        if maxfragmentationmemory_reserved is None and 'maxfragmentationmemoryReserved' in kwargs:
            maxfragmentationmemory_reserved = kwargs['maxfragmentationmemoryReserved']
        if maxfragmentationmemory_reserved is None:
            raise TypeError("Missing 'maxfragmentationmemory_reserved' argument")
        if maxmemory_delta is None and 'maxmemoryDelta' in kwargs:
            maxmemory_delta = kwargs['maxmemoryDelta']
        if maxmemory_delta is None:
            raise TypeError("Missing 'maxmemory_delta' argument")
        if maxmemory_policy is None and 'maxmemoryPolicy' in kwargs:
            maxmemory_policy = kwargs['maxmemoryPolicy']
        if maxmemory_policy is None:
            raise TypeError("Missing 'maxmemory_policy' argument")
        if maxmemory_reserved is None and 'maxmemoryReserved' in kwargs:
            maxmemory_reserved = kwargs['maxmemoryReserved']
        if maxmemory_reserved is None:
            raise TypeError("Missing 'maxmemory_reserved' argument")
        if notify_keyspace_events is None and 'notifyKeyspaceEvents' in kwargs:
            notify_keyspace_events = kwargs['notifyKeyspaceEvents']
        if notify_keyspace_events is None:
            raise TypeError("Missing 'notify_keyspace_events' argument")
        if rdb_backup_enabled is None and 'rdbBackupEnabled' in kwargs:
            rdb_backup_enabled = kwargs['rdbBackupEnabled']
        if rdb_backup_enabled is None:
            raise TypeError("Missing 'rdb_backup_enabled' argument")
        if rdb_backup_frequency is None and 'rdbBackupFrequency' in kwargs:
            rdb_backup_frequency = kwargs['rdbBackupFrequency']
        if rdb_backup_frequency is None:
            raise TypeError("Missing 'rdb_backup_frequency' argument")
        if rdb_backup_max_snapshot_count is None and 'rdbBackupMaxSnapshotCount' in kwargs:
            rdb_backup_max_snapshot_count = kwargs['rdbBackupMaxSnapshotCount']
        if rdb_backup_max_snapshot_count is None:
            raise TypeError("Missing 'rdb_backup_max_snapshot_count' argument")
        if rdb_storage_connection_string is None and 'rdbStorageConnectionString' in kwargs:
            rdb_storage_connection_string = kwargs['rdbStorageConnectionString']
        if rdb_storage_connection_string is None:
            raise TypeError("Missing 'rdb_storage_connection_string' argument")

        _setter("aof_backup_enabled", aof_backup_enabled)
        _setter("aof_storage_connection_string0", aof_storage_connection_string0)
        _setter("aof_storage_connection_string1", aof_storage_connection_string1)
        _setter("enable_authentication", enable_authentication)
        _setter("maxclients", maxclients)
        _setter("maxfragmentationmemory_reserved", maxfragmentationmemory_reserved)
        _setter("maxmemory_delta", maxmemory_delta)
        _setter("maxmemory_policy", maxmemory_policy)
        _setter("maxmemory_reserved", maxmemory_reserved)
        _setter("notify_keyspace_events", notify_keyspace_events)
        _setter("rdb_backup_enabled", rdb_backup_enabled)
        _setter("rdb_backup_frequency", rdb_backup_frequency)
        _setter("rdb_backup_max_snapshot_count", rdb_backup_max_snapshot_count)
        _setter("rdb_storage_connection_string", rdb_storage_connection_string)

    @property
    @pulumi.getter(name="aofBackupEnabled")
    def aof_backup_enabled(self) -> bool:
        return pulumi.get(self, "aof_backup_enabled")

    @property
    @pulumi.getter(name="aofStorageConnectionString0")
    def aof_storage_connection_string0(self) -> str:
        return pulumi.get(self, "aof_storage_connection_string0")

    @property
    @pulumi.getter(name="aofStorageConnectionString1")
    def aof_storage_connection_string1(self) -> str:
        return pulumi.get(self, "aof_storage_connection_string1")

    @property
    @pulumi.getter(name="enableAuthentication")
    def enable_authentication(self) -> bool:
        """
        Specifies if authentication is enabled
        """
        return pulumi.get(self, "enable_authentication")

    @property
    @pulumi.getter
    def maxclients(self) -> int:
        return pulumi.get(self, "maxclients")

    @property
    @pulumi.getter(name="maxfragmentationmemoryReserved")
    def maxfragmentationmemory_reserved(self) -> int:
        """
        Value in megabytes reserved to accommodate for memory fragmentation.
        """
        return pulumi.get(self, "maxfragmentationmemory_reserved")

    @property
    @pulumi.getter(name="maxmemoryDelta")
    def maxmemory_delta(self) -> int:
        """
        The max-memory delta for this Redis instance.
        """
        return pulumi.get(self, "maxmemory_delta")

    @property
    @pulumi.getter(name="maxmemoryPolicy")
    def maxmemory_policy(self) -> str:
        """
        How Redis will select what to remove when `maxmemory` is reached.
        """
        return pulumi.get(self, "maxmemory_policy")

    @property
    @pulumi.getter(name="maxmemoryReserved")
    def maxmemory_reserved(self) -> int:
        """
        The value in megabytes reserved for non-cache usage e.g. failover
        """
        return pulumi.get(self, "maxmemory_reserved")

    @property
    @pulumi.getter(name="notifyKeyspaceEvents")
    def notify_keyspace_events(self) -> str:
        return pulumi.get(self, "notify_keyspace_events")

    @property
    @pulumi.getter(name="rdbBackupEnabled")
    def rdb_backup_enabled(self) -> bool:
        """
        Is Backup Enabled? Only supported on Premium SKUs.
        """
        return pulumi.get(self, "rdb_backup_enabled")

    @property
    @pulumi.getter(name="rdbBackupFrequency")
    def rdb_backup_frequency(self) -> int:
        """
        The Backup Frequency in Minutes. Only supported on Premium SKUs.
        """
        return pulumi.get(self, "rdb_backup_frequency")

    @property
    @pulumi.getter(name="rdbBackupMaxSnapshotCount")
    def rdb_backup_max_snapshot_count(self) -> int:
        """
        The maximum number of snapshots that can be created as a backup.
        """
        return pulumi.get(self, "rdb_backup_max_snapshot_count")

    @property
    @pulumi.getter(name="rdbStorageConnectionString")
    def rdb_storage_connection_string(self) -> str:
        """
        The Connection String to the Storage Account. Only supported for Premium SKUs.
        """
        return pulumi.get(self, "rdb_storage_connection_string")


