# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'BackupPlanAdvancedBackupSettingResourceType',
    'BackupPlanBackupPlanResourceType',
    'BackupPlanBackupRuleResourceType',
    'BackupPlanCopyActionResourceType',
    'BackupPlanLifecycleResourceType',
    'BackupSelectionBackupSelectionResourceType',
    'BackupSelectionConditionResourceType',
    'BackupVaultLockConfigurationType',
    'BackupVaultNotificationObjectType',
]

@pulumi.output_type
class BackupPlanAdvancedBackupSettingResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupOptions":
            suggest = "backup_options"
        elif key == "resourceType":
            suggest = "resource_type"

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

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

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

    def __init__(__self__, *,
                 backup_options: Any,
                 resource_type: str):
        pulumi.set(__self__, "backup_options", backup_options)
        pulumi.set(__self__, "resource_type", resource_type)

    @property
    @pulumi.getter(name="backupOptions")
    def backup_options(self) -> Any:
        return pulumi.get(self, "backup_options")

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


@pulumi.output_type
class BackupPlanBackupPlanResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupPlanName":
            suggest = "backup_plan_name"
        elif key == "backupPlanRule":
            suggest = "backup_plan_rule"
        elif key == "advancedBackupSettings":
            suggest = "advanced_backup_settings"

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

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

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

    def __init__(__self__, *,
                 backup_plan_name: str,
                 backup_plan_rule: Sequence['outputs.BackupPlanBackupRuleResourceType'],
                 advanced_backup_settings: Optional[Sequence['outputs.BackupPlanAdvancedBackupSettingResourceType']] = None):
        pulumi.set(__self__, "backup_plan_name", backup_plan_name)
        pulumi.set(__self__, "backup_plan_rule", backup_plan_rule)
        if advanced_backup_settings is not None:
            pulumi.set(__self__, "advanced_backup_settings", advanced_backup_settings)

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

    @property
    @pulumi.getter(name="backupPlanRule")
    def backup_plan_rule(self) -> Sequence['outputs.BackupPlanBackupRuleResourceType']:
        return pulumi.get(self, "backup_plan_rule")

    @property
    @pulumi.getter(name="advancedBackupSettings")
    def advanced_backup_settings(self) -> Optional[Sequence['outputs.BackupPlanAdvancedBackupSettingResourceType']]:
        return pulumi.get(self, "advanced_backup_settings")


@pulumi.output_type
class BackupPlanBackupRuleResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleName":
            suggest = "rule_name"
        elif key == "targetBackupVault":
            suggest = "target_backup_vault"
        elif key == "completionWindowMinutes":
            suggest = "completion_window_minutes"
        elif key == "copyActions":
            suggest = "copy_actions"
        elif key == "enableContinuousBackup":
            suggest = "enable_continuous_backup"
        elif key == "recoveryPointTags":
            suggest = "recovery_point_tags"
        elif key == "scheduleExpression":
            suggest = "schedule_expression"
        elif key == "startWindowMinutes":
            suggest = "start_window_minutes"

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

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

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

    def __init__(__self__, *,
                 rule_name: str,
                 target_backup_vault: str,
                 completion_window_minutes: Optional[float] = None,
                 copy_actions: Optional[Sequence['outputs.BackupPlanCopyActionResourceType']] = None,
                 enable_continuous_backup: Optional[bool] = None,
                 lifecycle: Optional['outputs.BackupPlanLifecycleResourceType'] = None,
                 recovery_point_tags: Optional[Any] = None,
                 schedule_expression: Optional[str] = None,
                 start_window_minutes: Optional[float] = None):
        pulumi.set(__self__, "rule_name", rule_name)
        pulumi.set(__self__, "target_backup_vault", target_backup_vault)
        if completion_window_minutes is not None:
            pulumi.set(__self__, "completion_window_minutes", completion_window_minutes)
        if copy_actions is not None:
            pulumi.set(__self__, "copy_actions", copy_actions)
        if enable_continuous_backup is not None:
            pulumi.set(__self__, "enable_continuous_backup", enable_continuous_backup)
        if lifecycle is not None:
            pulumi.set(__self__, "lifecycle", lifecycle)
        if recovery_point_tags is not None:
            pulumi.set(__self__, "recovery_point_tags", recovery_point_tags)
        if schedule_expression is not None:
            pulumi.set(__self__, "schedule_expression", schedule_expression)
        if start_window_minutes is not None:
            pulumi.set(__self__, "start_window_minutes", start_window_minutes)

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

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

    @property
    @pulumi.getter(name="completionWindowMinutes")
    def completion_window_minutes(self) -> Optional[float]:
        return pulumi.get(self, "completion_window_minutes")

    @property
    @pulumi.getter(name="copyActions")
    def copy_actions(self) -> Optional[Sequence['outputs.BackupPlanCopyActionResourceType']]:
        return pulumi.get(self, "copy_actions")

    @property
    @pulumi.getter(name="enableContinuousBackup")
    def enable_continuous_backup(self) -> Optional[bool]:
        return pulumi.get(self, "enable_continuous_backup")

    @property
    @pulumi.getter
    def lifecycle(self) -> Optional['outputs.BackupPlanLifecycleResourceType']:
        return pulumi.get(self, "lifecycle")

    @property
    @pulumi.getter(name="recoveryPointTags")
    def recovery_point_tags(self) -> Optional[Any]:
        return pulumi.get(self, "recovery_point_tags")

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

    @property
    @pulumi.getter(name="startWindowMinutes")
    def start_window_minutes(self) -> Optional[float]:
        return pulumi.get(self, "start_window_minutes")


@pulumi.output_type
class BackupPlanCopyActionResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationBackupVaultArn":
            suggest = "destination_backup_vault_arn"

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

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

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

    def __init__(__self__, *,
                 destination_backup_vault_arn: str,
                 lifecycle: Optional['outputs.BackupPlanLifecycleResourceType'] = None):
        pulumi.set(__self__, "destination_backup_vault_arn", destination_backup_vault_arn)
        if lifecycle is not None:
            pulumi.set(__self__, "lifecycle", lifecycle)

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

    @property
    @pulumi.getter
    def lifecycle(self) -> Optional['outputs.BackupPlanLifecycleResourceType']:
        return pulumi.get(self, "lifecycle")


@pulumi.output_type
class BackupPlanLifecycleResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteAfterDays":
            suggest = "delete_after_days"
        elif key == "moveToColdStorageAfterDays":
            suggest = "move_to_cold_storage_after_days"

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

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

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

    def __init__(__self__, *,
                 delete_after_days: Optional[float] = None,
                 move_to_cold_storage_after_days: Optional[float] = None):
        if delete_after_days is not None:
            pulumi.set(__self__, "delete_after_days", delete_after_days)
        if move_to_cold_storage_after_days is not None:
            pulumi.set(__self__, "move_to_cold_storage_after_days", move_to_cold_storage_after_days)

    @property
    @pulumi.getter(name="deleteAfterDays")
    def delete_after_days(self) -> Optional[float]:
        return pulumi.get(self, "delete_after_days")

    @property
    @pulumi.getter(name="moveToColdStorageAfterDays")
    def move_to_cold_storage_after_days(self) -> Optional[float]:
        return pulumi.get(self, "move_to_cold_storage_after_days")


@pulumi.output_type
class BackupSelectionBackupSelectionResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "iamRoleArn":
            suggest = "iam_role_arn"
        elif key == "selectionName":
            suggest = "selection_name"
        elif key == "listOfTags":
            suggest = "list_of_tags"

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

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

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

    def __init__(__self__, *,
                 iam_role_arn: str,
                 selection_name: str,
                 list_of_tags: Optional[Sequence['outputs.BackupSelectionConditionResourceType']] = None,
                 resources: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "iam_role_arn", iam_role_arn)
        pulumi.set(__self__, "selection_name", selection_name)
        if list_of_tags is not None:
            pulumi.set(__self__, "list_of_tags", list_of_tags)
        if resources is not None:
            pulumi.set(__self__, "resources", resources)

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

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

    @property
    @pulumi.getter(name="listOfTags")
    def list_of_tags(self) -> Optional[Sequence['outputs.BackupSelectionConditionResourceType']]:
        return pulumi.get(self, "list_of_tags")

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


@pulumi.output_type
class BackupSelectionConditionResourceType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "conditionKey":
            suggest = "condition_key"
        elif key == "conditionType":
            suggest = "condition_type"
        elif key == "conditionValue":
            suggest = "condition_value"

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

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

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

    def __init__(__self__, *,
                 condition_key: str,
                 condition_type: str,
                 condition_value: str):
        pulumi.set(__self__, "condition_key", condition_key)
        pulumi.set(__self__, "condition_type", condition_type)
        pulumi.set(__self__, "condition_value", condition_value)

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

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

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


@pulumi.output_type
class BackupVaultLockConfigurationType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "changeableForDays":
            suggest = "changeable_for_days"
        elif key == "maxRetentionDays":
            suggest = "max_retention_days"
        elif key == "minRetentionDays":
            suggest = "min_retention_days"

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

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

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

    def __init__(__self__, *,
                 changeable_for_days: Optional[float] = None,
                 max_retention_days: Optional[float] = None,
                 min_retention_days: Optional[float] = None):
        if changeable_for_days is not None:
            pulumi.set(__self__, "changeable_for_days", changeable_for_days)
        if max_retention_days is not None:
            pulumi.set(__self__, "max_retention_days", max_retention_days)
        if min_retention_days is not None:
            pulumi.set(__self__, "min_retention_days", min_retention_days)

    @property
    @pulumi.getter(name="changeableForDays")
    def changeable_for_days(self) -> Optional[float]:
        return pulumi.get(self, "changeable_for_days")

    @property
    @pulumi.getter(name="maxRetentionDays")
    def max_retention_days(self) -> Optional[float]:
        return pulumi.get(self, "max_retention_days")

    @property
    @pulumi.getter(name="minRetentionDays")
    def min_retention_days(self) -> Optional[float]:
        return pulumi.get(self, "min_retention_days")


@pulumi.output_type
class BackupVaultNotificationObjectType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupVaultEvents":
            suggest = "backup_vault_events"
        elif key == "sNSTopicArn":
            suggest = "s_ns_topic_arn"

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

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

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

    def __init__(__self__, *,
                 backup_vault_events: Sequence[str],
                 s_ns_topic_arn: str):
        pulumi.set(__self__, "backup_vault_events", backup_vault_events)
        pulumi.set(__self__, "s_ns_topic_arn", s_ns_topic_arn)

    @property
    @pulumi.getter(name="backupVaultEvents")
    def backup_vault_events(self) -> Sequence[str]:
        return pulumi.get(self, "backup_vault_events")

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


