# 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

__all__ = [
    'ReplicatedVMManagedDiskArgs',
    'ReplicatedVMManagedDiskTargetDiskEncryptionArgs',
    'ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs',
    'ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKeyArgs',
    'ReplicatedVMNetworkInterfaceArgs',
]

@pulumi.input_type
class ReplicatedVMManagedDiskArgs:
    def __init__(__self__, *,
                 disk_id: pulumi.Input[str],
                 staging_storage_account_id: pulumi.Input[str],
                 target_disk_type: pulumi.Input[str],
                 target_replica_disk_type: pulumi.Input[str],
                 target_resource_group_id: pulumi.Input[str],
                 target_disk_encryption: Optional[pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionArgs']] = None,
                 target_disk_encryption_set_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] disk_id: Id of disk that should be replicated.
        :param pulumi.Input[str] staging_storage_account_id: Storage account that should be used for caching.
        :param pulumi.Input[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`.
        :param pulumi.Input[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`.
        :param pulumi.Input[str] target_resource_group_id: Resource group disk should belong to when a failover is done.
        :param pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionArgs'] target_disk_encryption: A `target_disk_encryption` block as defined below.
        :param pulumi.Input[str] target_disk_encryption_set_id: The Disk Encryption Set that the Managed Disk will be associated with.
        """
        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) -> pulumi.Input[str]:
        """
        Id of disk that should be replicated.
        """
        return pulumi.get(self, "disk_id")

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

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

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

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

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

    @property
    @pulumi.getter(name="targetReplicaDiskType")
    def target_replica_disk_type(self) -> pulumi.Input[str]:
        """
        What type should the disk be that holds the replication data. Possible values are `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS` and `UltraSSD_LRS`.
        """
        return pulumi.get(self, "target_replica_disk_type")

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

    @property
    @pulumi.getter(name="targetResourceGroupId")
    def target_resource_group_id(self) -> pulumi.Input[str]:
        """
        Resource group disk should belong to when a failover is done.
        """
        return pulumi.get(self, "target_resource_group_id")

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

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

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

    @property
    @pulumi.getter(name="targetDiskEncryptionSetId")
    def target_disk_encryption_set_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Disk Encryption Set that the Managed Disk will be associated with.
        """
        return pulumi.get(self, "target_disk_encryption_set_id")

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


@pulumi.input_type
class ReplicatedVMManagedDiskTargetDiskEncryptionArgs:
    def __init__(__self__, *,
                 disk_encryption_key: pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs'],
                 key_encryption_key: Optional[pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKeyArgs']] = None):
        """
        :param pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs'] disk_encryption_key: A `disk_encryption_key` block as defined below.
        :param pulumi.Input['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) -> pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs']:
        """
        A `disk_encryption_key` block as defined below.
        """
        return pulumi.get(self, "disk_encryption_key")

    @disk_encryption_key.setter
    def disk_encryption_key(self, value: pulumi.Input['ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs']):
        pulumi.set(self, "disk_encryption_key", value)

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

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


@pulumi.input_type
class ReplicatedVMManagedDiskTargetDiskEncryptionDiskEncryptionKeyArgs:
    def __init__(__self__, *,
                 secret_url: pulumi.Input[str],
                 vault_id: pulumi.Input[str]):
        """
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

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

    @property
    @pulumi.getter(name="vaultId")
    def vault_id(self) -> pulumi.Input[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")

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


@pulumi.input_type
class ReplicatedVMManagedDiskTargetDiskEncryptionKeyEncryptionKeyArgs:
    def __init__(__self__, *,
                 key_url: pulumi.Input[str],
                 vault_id: pulumi.Input[str]):
        """
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

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

    @property
    @pulumi.getter(name="vaultId")
    def vault_id(self) -> pulumi.Input[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")

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


@pulumi.input_type
class ReplicatedVMNetworkInterfaceArgs:
    def __init__(__self__, *,
                 is_primary: Optional[pulumi.Input[bool]] = None,
                 recovery_public_ip_address_id: Optional[pulumi.Input[str]] = None,
                 source_network_interface_id: Optional[pulumi.Input[str]] = None,
                 target_static_ip: Optional[pulumi.Input[str]] = None,
                 target_subnet_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] is_primary: If this is the primary network interface used for failover. If there is only one `network_interface` block, this is automatically set to `true`.
        :param pulumi.Input[str] recovery_public_ip_address_id: Id of the public IP object to use when a failover is done.
        :param pulumi.Input[str] source_network_interface_id: (Required if the network_interface block is specified) Id source network interface.
        :param pulumi.Input[str] target_static_ip: Static IP to assign when a failover is done.
        :param pulumi.Input[str] target_subnet_name: Name of the subnet to to use when a failover is done.
        """
        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="isPrimary")
    def is_primary(self) -> Optional[pulumi.Input[bool]]:
        """
        If this is the primary network interface used for failover. If there is only one `network_interface` block, this is automatically set to `true`.
        """
        return pulumi.get(self, "is_primary")

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

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

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

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

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

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

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

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

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


