# 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

__all__ = [
    'BackupPlanAdvancedBackupSettingResourceTypeArgs',
    'BackupPlanBackupPlanResourceTypeArgs',
    'BackupPlanBackupRuleResourceTypeArgs',
    'BackupPlanCopyActionResourceTypeArgs',
    'BackupPlanLifecycleResourceTypeArgs',
    'BackupSelectionBackupSelectionResourceTypeArgs',
    'BackupSelectionConditionResourceTypeArgs',
    'BackupVaultLockConfigurationTypeArgs',
    'BackupVaultNotificationObjectTypeArgs',
]

@pulumi.input_type
class BackupPlanAdvancedBackupSettingResourceTypeArgs:
    def __init__(__self__, *,
                 backup_options: Any,
                 resource_type: pulumi.Input[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")

    @backup_options.setter
    def backup_options(self, value: Any):
        pulumi.set(self, "backup_options", value)

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

    @resource_type.setter
    def resource_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "resource_type", value)


@pulumi.input_type
class BackupPlanBackupPlanResourceTypeArgs:
    def __init__(__self__, *,
                 backup_plan_name: pulumi.Input[str],
                 backup_plan_rule: pulumi.Input[Sequence[pulumi.Input['BackupPlanBackupRuleResourceTypeArgs']]],
                 advanced_backup_settings: Optional[pulumi.Input[Sequence[pulumi.Input['BackupPlanAdvancedBackupSettingResourceTypeArgs']]]] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "backup_plan_name")

    @backup_plan_name.setter
    def backup_plan_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "backup_plan_name", value)

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

    @backup_plan_rule.setter
    def backup_plan_rule(self, value: pulumi.Input[Sequence[pulumi.Input['BackupPlanBackupRuleResourceTypeArgs']]]):
        pulumi.set(self, "backup_plan_rule", value)

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

    @advanced_backup_settings.setter
    def advanced_backup_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackupPlanAdvancedBackupSettingResourceTypeArgs']]]]):
        pulumi.set(self, "advanced_backup_settings", value)


@pulumi.input_type
class BackupPlanBackupRuleResourceTypeArgs:
    def __init__(__self__, *,
                 rule_name: pulumi.Input[str],
                 target_backup_vault: pulumi.Input[str],
                 completion_window_minutes: Optional[pulumi.Input[float]] = None,
                 copy_actions: Optional[pulumi.Input[Sequence[pulumi.Input['BackupPlanCopyActionResourceTypeArgs']]]] = None,
                 enable_continuous_backup: Optional[pulumi.Input[bool]] = None,
                 lifecycle: Optional[pulumi.Input['BackupPlanLifecycleResourceTypeArgs']] = None,
                 recovery_point_tags: Optional[Any] = None,
                 schedule_expression: Optional[pulumi.Input[str]] = None,
                 start_window_minutes: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "rule_name")

    @rule_name.setter
    def rule_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "rule_name", value)

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

    @target_backup_vault.setter
    def target_backup_vault(self, value: pulumi.Input[str]):
        pulumi.set(self, "target_backup_vault", value)

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

    @completion_window_minutes.setter
    def completion_window_minutes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "completion_window_minutes", value)

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

    @copy_actions.setter
    def copy_actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackupPlanCopyActionResourceTypeArgs']]]]):
        pulumi.set(self, "copy_actions", value)

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

    @enable_continuous_backup.setter
    def enable_continuous_backup(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_continuous_backup", value)

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

    @lifecycle.setter
    def lifecycle(self, value: Optional[pulumi.Input['BackupPlanLifecycleResourceTypeArgs']]):
        pulumi.set(self, "lifecycle", value)

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

    @recovery_point_tags.setter
    def recovery_point_tags(self, value: Optional[Any]):
        pulumi.set(self, "recovery_point_tags", value)

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

    @schedule_expression.setter
    def schedule_expression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schedule_expression", value)

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

    @start_window_minutes.setter
    def start_window_minutes(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "start_window_minutes", value)


@pulumi.input_type
class BackupPlanCopyActionResourceTypeArgs:
    def __init__(__self__, *,
                 destination_backup_vault_arn: pulumi.Input[str],
                 lifecycle: Optional[pulumi.Input['BackupPlanLifecycleResourceTypeArgs']] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "destination_backup_vault_arn")

    @destination_backup_vault_arn.setter
    def destination_backup_vault_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "destination_backup_vault_arn", value)

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

    @lifecycle.setter
    def lifecycle(self, value: Optional[pulumi.Input['BackupPlanLifecycleResourceTypeArgs']]):
        pulumi.set(self, "lifecycle", value)


@pulumi.input_type
class BackupPlanLifecycleResourceTypeArgs:
    def __init__(__self__, *,
                 delete_after_days: Optional[pulumi.Input[float]] = None,
                 move_to_cold_storage_after_days: Optional[pulumi.Input[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[pulumi.Input[float]]:
        return pulumi.get(self, "delete_after_days")

    @delete_after_days.setter
    def delete_after_days(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "delete_after_days", value)

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

    @move_to_cold_storage_after_days.setter
    def move_to_cold_storage_after_days(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "move_to_cold_storage_after_days", value)


@pulumi.input_type
class BackupSelectionBackupSelectionResourceTypeArgs:
    def __init__(__self__, *,
                 iam_role_arn: pulumi.Input[str],
                 selection_name: pulumi.Input[str],
                 list_of_tags: Optional[pulumi.Input[Sequence[pulumi.Input['BackupSelectionConditionResourceTypeArgs']]]] = None,
                 resources: Optional[pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "iam_role_arn")

    @iam_role_arn.setter
    def iam_role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "iam_role_arn", value)

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

    @selection_name.setter
    def selection_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "selection_name", value)

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

    @list_of_tags.setter
    def list_of_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackupSelectionConditionResourceTypeArgs']]]]):
        pulumi.set(self, "list_of_tags", value)

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

    @resources.setter
    def resources(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "resources", value)


@pulumi.input_type
class BackupSelectionConditionResourceTypeArgs:
    def __init__(__self__, *,
                 condition_key: pulumi.Input[str],
                 condition_type: pulumi.Input[str],
                 condition_value: pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "condition_key")

    @condition_key.setter
    def condition_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "condition_key", value)

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

    @condition_type.setter
    def condition_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "condition_type", value)

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

    @condition_value.setter
    def condition_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "condition_value", value)


@pulumi.input_type
class BackupVaultLockConfigurationTypeArgs:
    def __init__(__self__, *,
                 changeable_for_days: Optional[pulumi.Input[float]] = None,
                 max_retention_days: Optional[pulumi.Input[float]] = None,
                 min_retention_days: Optional[pulumi.Input[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[pulumi.Input[float]]:
        return pulumi.get(self, "changeable_for_days")

    @changeable_for_days.setter
    def changeable_for_days(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "changeable_for_days", value)

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

    @max_retention_days.setter
    def max_retention_days(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "max_retention_days", value)

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

    @min_retention_days.setter
    def min_retention_days(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "min_retention_days", value)


@pulumi.input_type
class BackupVaultNotificationObjectTypeArgs:
    def __init__(__self__, *,
                 backup_vault_events: pulumi.Input[Sequence[pulumi.Input[str]]],
                 s_ns_topic_arn: pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "backup_vault_events")

    @backup_vault_events.setter
    def backup_vault_events(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "backup_vault_events", value)

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

    @s_ns_topic_arn.setter
    def s_ns_topic_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "s_ns_topic_arn", value)


