# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ReplicatedVMManagedDisk',
    'ReplicatedVMNetworkInterface',
]

@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 == "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_set_id: Optional[str] = None):
        """
        :param str disk_id: Id of disk that should be replicated.
        :param str staging_storage_account_id: Storage account that should be used for caching.
        :param str target_disk_type: What type should the disk be when a failover is done.
        :param str target_replica_disk_type: What type should the disk be that holds the replication data.
        :param str target_resource_group_id: Resource group disk should belong to when a failover is done.
        :param 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_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.
        """
        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.
        """
        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.
        """
        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.
        """
        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.
        """
        return pulumi.get(self, "target_resource_group_id")

    @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.
        """
        return pulumi.get(self, "target_disk_encryption_set_id")


@pulumi.output_type
class ReplicatedVMNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if 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__, *,
                 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 recovery_public_ip_address_id: Id of the public IP object to use when a failover is done.
        :param str source_network_interface_id: 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 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="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]:
        """
        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")


