# 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, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ProtectionContainerMappingAutomaticUpdate',
    'ReplicatedVMManagedDisk',
    'ReplicatedVMManagedDiskTargetDiskEncryption',
    'ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKey',
    'ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKey',
    'ReplicatedVMNetworkInterface',
    'ReplicatedVMUnmanagedDisk',
    'ReplicationRecoveryPlanRecoveryGroup',
    'ReplicationRecoveryPlanRecoveryGroupPostAction',
    'ReplicationRecoveryPlanRecoveryGroupPreAction',
    'GetReplicationRecoveryPlanRecoveryGroupResult',
    'GetReplicationRecoveryPlanRecoveryGroupPostActionResult',
    'GetReplicationRecoveryPlanRecoveryGroupPreActionResult',
]

@pulumi.output_type
class ProtectionContainerMappingAutomaticUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automationAccountId":
            suggest = "automation_account_id"

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

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

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

    def __init__(__self__, *,
                 automation_account_id: Optional[str] = None,
                 enabled: Optional[bool] = None):
        """
        :param str automation_account_id: The automation account ID which holds the automatic update runbook and authenticates to Azure resources.
        :param bool enabled: Should the Mobility service installed on Azure virtual machines be automatically updated. Defaults to `false`.
        """
        if automation_account_id is not None:
            pulumi.set(__self__, "automation_account_id", automation_account_id)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="automationAccountId")
    def automation_account_id(self) -> Optional[str]:
        """
        The automation account ID which holds the automatic update runbook and authenticates to Azure resources.
        """
        return pulumi.get(self, "automation_account_id")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Should the Mobility service installed on Azure virtual machines be automatically updated. Defaults to `false`.
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ReplicatedVMManagedDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskId":
            suggest = "disk_id"
        elif key == "stagingStorageAccountId":
            suggest = "staging_storage_account_id"
        elif key == "targetDiskType":
            suggest = "target_disk_type"
        elif key == "targetReplicaDiskType":
            suggest = "target_replica_disk_type"
        elif key == "targetResourceGroupId":
            suggest = "target_resource_group_id"
        elif key == "targetDiskEncryption":
            suggest = "target_disk_encryption"
        elif key == "targetDiskEncryptionSetId":
            suggest = "target_disk_encryption_set_id"

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

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

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

    def __init__(__self__, *,
                 disk_id: str,
                 staging_storage_account_id: str,
                 target_disk_type: str,
                 target_replica_disk_type: str,
                 target_resource_group_id: str,
                 target_disk_encryption: Optional['outputs.ReplicatedVMManagedDiskTargetDiskEncryption'] = None,
                 target_disk_encryption_set_id: Optional[str] = None):
        """
        :param str disk_id: Id of disk that should be replicated. Changing this forces a new resource to be created.
        :param str staging_storage_account_id: Storage account that should be used for caching. Changing this forces a new resource to be created.
        :param str target_disk_type: What type should the disk be when a failover is done. Possible values are `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS` and `UltraSSD_LRS`. Changing this forces a new resource to be created.
        :param str target_replica_disk_type: What type should the disk be that holds the replication data. Possible values are `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS` and `UltraSSD_LRS`. Changing this forces a new resource to be created.
        :param str target_resource_group_id: Resource group disk should belong to when a failover is done. Changing this forces a new resource to be created.
        :param 'ReplicatedVMManagedDiskTargetDiskEncryptionArgs' target_disk_encryption: A `target_disk_encryption` block as defined below.
        :param str target_disk_encryption_set_id: The Disk Encryption Set that the Managed Disk will be associated with. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "disk_id", disk_id)
        pulumi.set(__self__, "staging_storage_account_id", staging_storage_account_id)
        pulumi.set(__self__, "target_disk_type", target_disk_type)
        pulumi.set(__self__, "target_replica_disk_type", target_replica_disk_type)
        pulumi.set(__self__, "target_resource_group_id", target_resource_group_id)
        if target_disk_encryption is not None:
            pulumi.set(__self__, "target_disk_encryption", target_disk_encryption)
        if target_disk_encryption_set_id is not None:
            pulumi.set(__self__, "target_disk_encryption_set_id", target_disk_encryption_set_id)

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> str:
        """
        Id of disk that should be replicated. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "disk_id")

    @property
    @pulumi.getter(name="stagingStorageAccountId")
    def staging_storage_account_id(self) -> str:
        """
        Storage account that should be used for caching. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "staging_storage_account_id")

    @property
    @pulumi.getter(name="targetDiskType")
    def target_disk_type(self) -> str:
        """
        What type should the disk be when a failover is done. Possible values are `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS` and `UltraSSD_LRS`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "target_disk_type")

    @property
    @pulumi.getter(name="targetReplicaDiskType")
    def target_replica_disk_type(self) -> str:
        """
        What type should the disk be that holds the replication data. Possible values are `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS` and `UltraSSD_LRS`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "target_replica_disk_type")

    @property
    @pulumi.getter(name="targetResourceGroupId")
    def target_resource_group_id(self) -> str:
        """
        Resource group disk should belong to when a failover is done. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "target_resource_group_id")

    @property
    @pulumi.getter(name="targetDiskEncryption")
    def target_disk_encryption(self) -> Optional['outputs.ReplicatedVMManagedDiskTargetDiskEncryption']:
        """
        A `target_disk_encryption` block as defined below.
        """
        return pulumi.get(self, "target_disk_encryption")

    @property
    @pulumi.getter(name="targetDiskEncryptionSetId")
    def target_disk_encryption_set_id(self) -> Optional[str]:
        """
        The Disk Encryption Set that the Managed Disk will be associated with. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "target_disk_encryption_set_id")


@pulumi.output_type
class ReplicatedVMManagedDiskTargetDiskEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskEncryptionKey":
            suggest = "disk_encryption_key"
        elif key == "keyEncryptionKey":
            suggest = "key_encryption_key"

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

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

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

    def __init__(__self__, *,
                 disk_encryption_key: 'outputs.ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKey',
                 key_encryption_key: Optional['outputs.ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKey'] = None):
        """
        :param 'ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs' disk_encryption_key: A `disk_encryption_key` block as defined below.
        :param 'ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKeyArgs' key_encryption_key: A `key_encryption_key` block as defined below.
        """
        pulumi.set(__self__, "disk_encryption_key", disk_encryption_key)
        if key_encryption_key is not None:
            pulumi.set(__self__, "key_encryption_key", key_encryption_key)

    @property
    @pulumi.getter(name="diskEncryptionKey")
    def disk_encryption_key(self) -> 'outputs.ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKey':
        """
        A `disk_encryption_key` block as defined below.
        """
        return pulumi.get(self, "disk_encryption_key")

    @property
    @pulumi.getter(name="keyEncryptionKey")
    def key_encryption_key(self) -> Optional['outputs.ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKey']:
        """
        A `key_encryption_key` block as defined below.
        """
        return pulumi.get(self, "key_encryption_key")


@pulumi.output_type
class ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretUrl":
            suggest = "secret_url"
        elif key == "vaultId":
            suggest = "vault_id"

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

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

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

    def __init__(__self__, *,
                 secret_url: str,
                 vault_id: str):
        """
        :param str secret_url: The URL to the Key Vault Secret used as the Disk Encryption Key that the Managed Disk will be associated with. This can be found as `id` on the `keyvault.Secret` resource. Changing this forces a new resource to be created.
        :param str vault_id: The ID of the Key Vault. This can be found as `id` on the `keyvault.KeyVault` resource. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "secret_url", secret_url)
        pulumi.set(__self__, "vault_id", vault_id)

    @property
    @pulumi.getter(name="secretUrl")
    def secret_url(self) -> str:
        """
        The URL to the Key Vault Secret used as the Disk Encryption Key that the Managed Disk will be associated with. This can be found as `id` on the `keyvault.Secret` resource. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "secret_url")

    @property
    @pulumi.getter(name="vaultId")
    def vault_id(self) -> str:
        """
        The ID of the Key Vault. This can be found as `id` on the `keyvault.KeyVault` resource. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vault_id")


@pulumi.output_type
class ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyUrl":
            suggest = "key_url"
        elif key == "vaultId":
            suggest = "vault_id"

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

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

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

    def __init__(__self__, *,
                 key_url: str,
                 vault_id: str):
        """
        :param str key_url: The URL to the Key Vault Key used as the Key Encryption Key that the Managed Disk will be associated with. This can be found as `id` on the `keyvault.Key` resource. Changing this forces a new resource to be created.
        :param str vault_id: The ID of the Key Vault. This can be found as `id` on the `keyvault.KeyVault` resource. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "key_url", key_url)
        pulumi.set(__self__, "vault_id", vault_id)

    @property
    @pulumi.getter(name="keyUrl")
    def key_url(self) -> str:
        """
        The URL to the Key Vault Key used as the Key Encryption Key that the Managed Disk will be associated with. This can be found as `id` on the `keyvault.Key` resource. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "key_url")

    @property
    @pulumi.getter(name="vaultId")
    def vault_id(self) -> str:
        """
        The ID of the Key Vault. This can be found as `id` on the `keyvault.KeyVault` resource. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "vault_id")


@pulumi.output_type
class ReplicatedVMNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failoverTestPublicIpAddressId":
            suggest = "failover_test_public_ip_address_id"
        elif key == "failoverTestStaticIp":
            suggest = "failover_test_static_ip"
        elif key == "failoverTestSubnetName":
            suggest = "failover_test_subnet_name"
        elif key == "isPrimary":
            suggest = "is_primary"
        elif key == "recoveryPublicIpAddressId":
            suggest = "recovery_public_ip_address_id"
        elif key == "sourceNetworkInterfaceId":
            suggest = "source_network_interface_id"
        elif key == "targetStaticIp":
            suggest = "target_static_ip"
        elif key == "targetSubnetName":
            suggest = "target_subnet_name"

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

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

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

    def __init__(__self__, *,
                 failover_test_public_ip_address_id: Optional[str] = None,
                 failover_test_static_ip: Optional[str] = None,
                 failover_test_subnet_name: Optional[str] = None,
                 is_primary: Optional[bool] = None,
                 recovery_public_ip_address_id: Optional[str] = None,
                 source_network_interface_id: Optional[str] = None,
                 target_static_ip: Optional[str] = None,
                 target_subnet_name: Optional[str] = None):
        """
        :param str failover_test_public_ip_address_id: Id of the public IP object to use when a test failover is done.
        :param str failover_test_static_ip: Static IP to assign when a test failover is done.
        :param str failover_test_subnet_name: Name of the subnet to to use when a test failover is done.
        :param str recovery_public_ip_address_id: Id of the public IP object to use when a failover is done.
        :param str source_network_interface_id: (Required if the network_interface block is specified) Id source network interface.
        :param str target_static_ip: Static IP to assign when a failover is done.
        :param str target_subnet_name: Name of the subnet to to use when a failover is done.
        """
        if failover_test_public_ip_address_id is not None:
            pulumi.set(__self__, "failover_test_public_ip_address_id", failover_test_public_ip_address_id)
        if failover_test_static_ip is not None:
            pulumi.set(__self__, "failover_test_static_ip", failover_test_static_ip)
        if failover_test_subnet_name is not None:
            pulumi.set(__self__, "failover_test_subnet_name", failover_test_subnet_name)
        if is_primary is not None:
            pulumi.set(__self__, "is_primary", is_primary)
        if recovery_public_ip_address_id is not None:
            pulumi.set(__self__, "recovery_public_ip_address_id", recovery_public_ip_address_id)
        if source_network_interface_id is not None:
            pulumi.set(__self__, "source_network_interface_id", source_network_interface_id)
        if target_static_ip is not None:
            pulumi.set(__self__, "target_static_ip", target_static_ip)
        if target_subnet_name is not None:
            pulumi.set(__self__, "target_subnet_name", target_subnet_name)

    @property
    @pulumi.getter(name="failoverTestPublicIpAddressId")
    def failover_test_public_ip_address_id(self) -> Optional[str]:
        """
        Id of the public IP object to use when a test failover is done.
        """
        return pulumi.get(self, "failover_test_public_ip_address_id")

    @property
    @pulumi.getter(name="failoverTestStaticIp")
    def failover_test_static_ip(self) -> Optional[str]:
        """
        Static IP to assign when a test failover is done.
        """
        return pulumi.get(self, "failover_test_static_ip")

    @property
    @pulumi.getter(name="failoverTestSubnetName")
    def failover_test_subnet_name(self) -> Optional[str]:
        """
        Name of the subnet to to use when a test failover is done.
        """
        return pulumi.get(self, "failover_test_subnet_name")

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

    @property
    @pulumi.getter(name="recoveryPublicIpAddressId")
    def recovery_public_ip_address_id(self) -> Optional[str]:
        """
        Id of the public IP object to use when a failover is done.
        """
        return pulumi.get(self, "recovery_public_ip_address_id")

    @property
    @pulumi.getter(name="sourceNetworkInterfaceId")
    def source_network_interface_id(self) -> Optional[str]:
        """
        (Required if the network_interface block is specified) Id source network interface.
        """
        return pulumi.get(self, "source_network_interface_id")

    @property
    @pulumi.getter(name="targetStaticIp")
    def target_static_ip(self) -> Optional[str]:
        """
        Static IP to assign when a failover is done.
        """
        return pulumi.get(self, "target_static_ip")

    @property
    @pulumi.getter(name="targetSubnetName")
    def target_subnet_name(self) -> Optional[str]:
        """
        Name of the subnet to to use when a failover is done.
        """
        return pulumi.get(self, "target_subnet_name")


@pulumi.output_type
class ReplicatedVMUnmanagedDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskUri":
            suggest = "disk_uri"
        elif key == "stagingStorageAccountId":
            suggest = "staging_storage_account_id"
        elif key == "targetStorageAccountId":
            suggest = "target_storage_account_id"

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

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

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

    def __init__(__self__, *,
                 disk_uri: str,
                 staging_storage_account_id: str,
                 target_storage_account_id: str):
        """
        :param str disk_uri: Id of disk that should be replicated.
        :param str staging_storage_account_id: Storage account that should be used for caching.
        :param str target_storage_account_id: Storage account disk should belong to when a failover is done.
        """
        pulumi.set(__self__, "disk_uri", disk_uri)
        pulumi.set(__self__, "staging_storage_account_id", staging_storage_account_id)
        pulumi.set(__self__, "target_storage_account_id", target_storage_account_id)

    @property
    @pulumi.getter(name="diskUri")
    def disk_uri(self) -> str:
        """
        Id of disk that should be replicated.
        """
        return pulumi.get(self, "disk_uri")

    @property
    @pulumi.getter(name="stagingStorageAccountId")
    def staging_storage_account_id(self) -> str:
        """
        Storage account that should be used for caching.
        """
        return pulumi.get(self, "staging_storage_account_id")

    @property
    @pulumi.getter(name="targetStorageAccountId")
    def target_storage_account_id(self) -> str:
        """
        Storage account disk should belong to when a failover is done.
        """
        return pulumi.get(self, "target_storage_account_id")


@pulumi.output_type
class ReplicationRecoveryPlanRecoveryGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "postActions":
            suggest = "post_actions"
        elif key == "preActions":
            suggest = "pre_actions"
        elif key == "replicatedProtectedItems":
            suggest = "replicated_protected_items"

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

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

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

    def __init__(__self__, *,
                 type: str,
                 post_actions: Optional[Sequence['outputs.ReplicationRecoveryPlanRecoveryGroupPostAction']] = None,
                 pre_actions: Optional[Sequence['outputs.ReplicationRecoveryPlanRecoveryGroupPreAction']] = None,
                 replicated_protected_items: Optional[Sequence[str]] = None):
        """
        :param str type: The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        :param Sequence['ReplicationRecoveryPlanRecoveryGroupPostActionArgs'] post_actions: one or more `action` block as defined below. which will be executed after the group recovery.
        :param Sequence['ReplicationRecoveryPlanRecoveryGroupPreActionArgs'] pre_actions: one or more `action` block as defined below. which will be executed before the group recovery.
        :param Sequence[str] replicated_protected_items: (required) one or more id of protected VM.
        """
        pulumi.set(__self__, "type", type)
        if post_actions is not None:
            pulumi.set(__self__, "post_actions", post_actions)
        if pre_actions is not None:
            pulumi.set(__self__, "pre_actions", pre_actions)
        if replicated_protected_items is not None:
            pulumi.set(__self__, "replicated_protected_items", replicated_protected_items)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="postActions")
    def post_actions(self) -> Optional[Sequence['outputs.ReplicationRecoveryPlanRecoveryGroupPostAction']]:
        """
        one or more `action` block as defined below. which will be executed after the group recovery.
        """
        return pulumi.get(self, "post_actions")

    @property
    @pulumi.getter(name="preActions")
    def pre_actions(self) -> Optional[Sequence['outputs.ReplicationRecoveryPlanRecoveryGroupPreAction']]:
        """
        one or more `action` block as defined below. which will be executed before the group recovery.
        """
        return pulumi.get(self, "pre_actions")

    @property
    @pulumi.getter(name="replicatedProtectedItems")
    def replicated_protected_items(self) -> Optional[Sequence[str]]:
        """
        (required) one or more id of protected VM.
        """
        return pulumi.get(self, "replicated_protected_items")


@pulumi.output_type
class ReplicationRecoveryPlanRecoveryGroupPostAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failOverDirections":
            suggest = "fail_over_directions"
        elif key == "failOverTypes":
            suggest = "fail_over_types"
        elif key == "fabricLocation":
            suggest = "fabric_location"
        elif key == "manualActionInstruction":
            suggest = "manual_action_instruction"
        elif key == "runbookId":
            suggest = "runbook_id"
        elif key == "scriptPath":
            suggest = "script_path"

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

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

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

    def __init__(__self__, *,
                 fail_over_directions: Sequence[str],
                 fail_over_types: Sequence[str],
                 name: str,
                 type: str,
                 fabric_location: Optional[str] = None,
                 manual_action_instruction: Optional[str] = None,
                 runbook_id: Optional[str] = None,
                 script_path: Optional[str] = None):
        """
        :param Sequence[str] fail_over_directions: Directions of fail over. Possible values are `PrimaryToRecovery` and `RecoveryToPrimary`
        :param Sequence[str] fail_over_types: Types of fail over. Possible values are `TestFailover`, `PlannedFailover` and `UnplannedFailover`
        :param str name: The name of the Replication Plan. The name can contain only letters, numbers, and hyphens. It should start with a letter and end with a letter or a number. Can be a maximum of 63 characters. Changing this forces a new resource to be created.
        :param str type: The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        :param str fabric_location: The fabric location of runbook or script. Possible values are `Primary` and `Recovery`.
        :param str manual_action_instruction: Instructions of manual action.
        :param str runbook_id: Id of runbook.
        :param str script_path: Path of action script.
        """
        pulumi.set(__self__, "fail_over_directions", fail_over_directions)
        pulumi.set(__self__, "fail_over_types", fail_over_types)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if fabric_location is not None:
            pulumi.set(__self__, "fabric_location", fabric_location)
        if manual_action_instruction is not None:
            pulumi.set(__self__, "manual_action_instruction", manual_action_instruction)
        if runbook_id is not None:
            pulumi.set(__self__, "runbook_id", runbook_id)
        if script_path is not None:
            pulumi.set(__self__, "script_path", script_path)

    @property
    @pulumi.getter(name="failOverDirections")
    def fail_over_directions(self) -> Sequence[str]:
        """
        Directions of fail over. Possible values are `PrimaryToRecovery` and `RecoveryToPrimary`
        """
        return pulumi.get(self, "fail_over_directions")

    @property
    @pulumi.getter(name="failOverTypes")
    def fail_over_types(self) -> Sequence[str]:
        """
        Types of fail over. Possible values are `TestFailover`, `PlannedFailover` and `UnplannedFailover`
        """
        return pulumi.get(self, "fail_over_types")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Replication Plan. The name can contain only letters, numbers, and hyphens. It should start with a letter and end with a letter or a number. Can be a maximum of 63 characters. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="fabricLocation")
    def fabric_location(self) -> Optional[str]:
        """
        The fabric location of runbook or script. Possible values are `Primary` and `Recovery`.
        """
        return pulumi.get(self, "fabric_location")

    @property
    @pulumi.getter(name="manualActionInstruction")
    def manual_action_instruction(self) -> Optional[str]:
        """
        Instructions of manual action.
        """
        return pulumi.get(self, "manual_action_instruction")

    @property
    @pulumi.getter(name="runbookId")
    def runbook_id(self) -> Optional[str]:
        """
        Id of runbook.
        """
        return pulumi.get(self, "runbook_id")

    @property
    @pulumi.getter(name="scriptPath")
    def script_path(self) -> Optional[str]:
        """
        Path of action script.
        """
        return pulumi.get(self, "script_path")


@pulumi.output_type
class ReplicationRecoveryPlanRecoveryGroupPreAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failOverDirections":
            suggest = "fail_over_directions"
        elif key == "failOverTypes":
            suggest = "fail_over_types"
        elif key == "fabricLocation":
            suggest = "fabric_location"
        elif key == "manualActionInstruction":
            suggest = "manual_action_instruction"
        elif key == "runbookId":
            suggest = "runbook_id"
        elif key == "scriptPath":
            suggest = "script_path"

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

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

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

    def __init__(__self__, *,
                 fail_over_directions: Sequence[str],
                 fail_over_types: Sequence[str],
                 name: str,
                 type: str,
                 fabric_location: Optional[str] = None,
                 manual_action_instruction: Optional[str] = None,
                 runbook_id: Optional[str] = None,
                 script_path: Optional[str] = None):
        """
        :param Sequence[str] fail_over_directions: Directions of fail over. Possible values are `PrimaryToRecovery` and `RecoveryToPrimary`
        :param Sequence[str] fail_over_types: Types of fail over. Possible values are `TestFailover`, `PlannedFailover` and `UnplannedFailover`
        :param str name: The name of the Replication Plan. The name can contain only letters, numbers, and hyphens. It should start with a letter and end with a letter or a number. Can be a maximum of 63 characters. Changing this forces a new resource to be created.
        :param str type: The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        :param str fabric_location: The fabric location of runbook or script. Possible values are `Primary` and `Recovery`.
        :param str manual_action_instruction: Instructions of manual action.
        :param str runbook_id: Id of runbook.
        :param str script_path: Path of action script.
        """
        pulumi.set(__self__, "fail_over_directions", fail_over_directions)
        pulumi.set(__self__, "fail_over_types", fail_over_types)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if fabric_location is not None:
            pulumi.set(__self__, "fabric_location", fabric_location)
        if manual_action_instruction is not None:
            pulumi.set(__self__, "manual_action_instruction", manual_action_instruction)
        if runbook_id is not None:
            pulumi.set(__self__, "runbook_id", runbook_id)
        if script_path is not None:
            pulumi.set(__self__, "script_path", script_path)

    @property
    @pulumi.getter(name="failOverDirections")
    def fail_over_directions(self) -> Sequence[str]:
        """
        Directions of fail over. Possible values are `PrimaryToRecovery` and `RecoveryToPrimary`
        """
        return pulumi.get(self, "fail_over_directions")

    @property
    @pulumi.getter(name="failOverTypes")
    def fail_over_types(self) -> Sequence[str]:
        """
        Types of fail over. Possible values are `TestFailover`, `PlannedFailover` and `UnplannedFailover`
        """
        return pulumi.get(self, "fail_over_types")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Replication Plan. The name can contain only letters, numbers, and hyphens. It should start with a letter and end with a letter or a number. Can be a maximum of 63 characters. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The Recovery Plan Group Type. Possible values are `Boot`, `Failover` and `Shutdown`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="fabricLocation")
    def fabric_location(self) -> Optional[str]:
        """
        The fabric location of runbook or script. Possible values are `Primary` and `Recovery`.
        """
        return pulumi.get(self, "fabric_location")

    @property
    @pulumi.getter(name="manualActionInstruction")
    def manual_action_instruction(self) -> Optional[str]:
        """
        Instructions of manual action.
        """
        return pulumi.get(self, "manual_action_instruction")

    @property
    @pulumi.getter(name="runbookId")
    def runbook_id(self) -> Optional[str]:
        """
        Id of runbook.
        """
        return pulumi.get(self, "runbook_id")

    @property
    @pulumi.getter(name="scriptPath")
    def script_path(self) -> Optional[str]:
        """
        Path of action script.
        """
        return pulumi.get(self, "script_path")


@pulumi.output_type
class GetReplicationRecoveryPlanRecoveryGroupResult(dict):
    def __init__(__self__, *,
                 post_actions: Sequence[Sequence['outputs.GetReplicationRecoveryPlanRecoveryGroupPostActionResult']],
                 pre_actions: Sequence[Sequence['outputs.GetReplicationRecoveryPlanRecoveryGroupPreActionResult']],
                 replicated_protected_items: Sequence[str],
                 type: str):
        """
        :param Sequence[Sequence['GetReplicationRecoveryPlanRecoveryGroupPostActionArgs']] post_actions: one or more `action` block. which will be executed after the group recovery.
        :param Sequence[Sequence['GetReplicationRecoveryPlanRecoveryGroupPreActionArgs']] pre_actions: one or more `action` block. which will be executed before the group recovery.
        :param Sequence[str] replicated_protected_items: one or more id of protected VM.
        :param str type: Type of the action detail.
        """
        pulumi.set(__self__, "post_actions", post_actions)
        pulumi.set(__self__, "pre_actions", pre_actions)
        pulumi.set(__self__, "replicated_protected_items", replicated_protected_items)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="postActions")
    def post_actions(self) -> Sequence[Sequence['outputs.GetReplicationRecoveryPlanRecoveryGroupPostActionResult']]:
        """
        one or more `action` block. which will be executed after the group recovery.
        """
        return pulumi.get(self, "post_actions")

    @property
    @pulumi.getter(name="preActions")
    def pre_actions(self) -> Sequence[Sequence['outputs.GetReplicationRecoveryPlanRecoveryGroupPreActionResult']]:
        """
        one or more `action` block. which will be executed before the group recovery.
        """
        return pulumi.get(self, "pre_actions")

    @property
    @pulumi.getter(name="replicatedProtectedItems")
    def replicated_protected_items(self) -> Sequence[str]:
        """
        one or more id of protected VM.
        """
        return pulumi.get(self, "replicated_protected_items")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the action detail.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetReplicationRecoveryPlanRecoveryGroupPostActionResult(dict):
    def __init__(__self__, *,
                 fabric_location: str,
                 fail_over_directions: Sequence[str],
                 fail_over_types: Sequence[str],
                 manual_action_instruction: str,
                 name: str,
                 runbook_id: str,
                 script_path: str,
                 type: str):
        """
        :param str fabric_location: The fabric location of runbook or script.
        :param Sequence[str] fail_over_directions: Directions of fail over.
        :param Sequence[str] fail_over_types: Types of fail over.
        :param str manual_action_instruction: Instructions of manual action.
        :param str name: The name of the Replication Plan.
        :param str runbook_id: Id of runbook.
        :param str script_path: Path of action script.
        :param str type: Type of the action detail.
        """
        pulumi.set(__self__, "fabric_location", fabric_location)
        pulumi.set(__self__, "fail_over_directions", fail_over_directions)
        pulumi.set(__self__, "fail_over_types", fail_over_types)
        pulumi.set(__self__, "manual_action_instruction", manual_action_instruction)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "runbook_id", runbook_id)
        pulumi.set(__self__, "script_path", script_path)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="fabricLocation")
    def fabric_location(self) -> str:
        """
        The fabric location of runbook or script.
        """
        return pulumi.get(self, "fabric_location")

    @property
    @pulumi.getter(name="failOverDirections")
    def fail_over_directions(self) -> Sequence[str]:
        """
        Directions of fail over.
        """
        return pulumi.get(self, "fail_over_directions")

    @property
    @pulumi.getter(name="failOverTypes")
    def fail_over_types(self) -> Sequence[str]:
        """
        Types of fail over.
        """
        return pulumi.get(self, "fail_over_types")

    @property
    @pulumi.getter(name="manualActionInstruction")
    def manual_action_instruction(self) -> str:
        """
        Instructions of manual action.
        """
        return pulumi.get(self, "manual_action_instruction")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Replication Plan.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="runbookId")
    def runbook_id(self) -> str:
        """
        Id of runbook.
        """
        return pulumi.get(self, "runbook_id")

    @property
    @pulumi.getter(name="scriptPath")
    def script_path(self) -> str:
        """
        Path of action script.
        """
        return pulumi.get(self, "script_path")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the action detail.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetReplicationRecoveryPlanRecoveryGroupPreActionResult(dict):
    def __init__(__self__, *,
                 fabric_location: str,
                 fail_over_directions: Sequence[str],
                 fail_over_types: Sequence[str],
                 manual_action_instruction: str,
                 name: str,
                 runbook_id: str,
                 script_path: str,
                 type: str):
        """
        :param str fabric_location: The fabric location of runbook or script.
        :param Sequence[str] fail_over_directions: Directions of fail over.
        :param Sequence[str] fail_over_types: Types of fail over.
        :param str manual_action_instruction: Instructions of manual action.
        :param str name: The name of the Replication Plan.
        :param str runbook_id: Id of runbook.
        :param str script_path: Path of action script.
        :param str type: Type of the action detail.
        """
        pulumi.set(__self__, "fabric_location", fabric_location)
        pulumi.set(__self__, "fail_over_directions", fail_over_directions)
        pulumi.set(__self__, "fail_over_types", fail_over_types)
        pulumi.set(__self__, "manual_action_instruction", manual_action_instruction)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "runbook_id", runbook_id)
        pulumi.set(__self__, "script_path", script_path)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="fabricLocation")
    def fabric_location(self) -> str:
        """
        The fabric location of runbook or script.
        """
        return pulumi.get(self, "fabric_location")

    @property
    @pulumi.getter(name="failOverDirections")
    def fail_over_directions(self) -> Sequence[str]:
        """
        Directions of fail over.
        """
        return pulumi.get(self, "fail_over_directions")

    @property
    @pulumi.getter(name="failOverTypes")
    def fail_over_types(self) -> Sequence[str]:
        """
        Types of fail over.
        """
        return pulumi.get(self, "fail_over_types")

    @property
    @pulumi.getter(name="manualActionInstruction")
    def manual_action_instruction(self) -> str:
        """
        Instructions of manual action.
        """
        return pulumi.get(self, "manual_action_instruction")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Replication Plan.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="runbookId")
    def runbook_id(self) -> str:
        """
        Id of runbook.
        """
        return pulumi.get(self, "runbook_id")

    @property
    @pulumi.getter(name="scriptPath")
    def script_path(self) -> str:
        """
        Path of action script.
        """
        return pulumi.get(self, "script_path")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the action detail.
        """
        return pulumi.get(self, "type")


