# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'EnterpriseSnapshotPolicyCrossRegionCopyInfo',
    'EnterpriseSnapshotPolicyCrossRegionCopyInfoRegion',
    'EnterpriseSnapshotPolicyRetainRule',
    'EnterpriseSnapshotPolicySchedule',
    'EnterpriseSnapshotPolicySpecialRetainRules',
    'EnterpriseSnapshotPolicySpecialRetainRulesRule',
    'EnterpriseSnapshotPolicyStorageRule',
    'SolutionInstanceParameter',
    'GetDedicatedBlockStorageClustersClusterResult',
    'GetDiskReplicaGroupsGroupResult',
    'GetDiskReplicaPairsPairResult',
    'GetRegionsRegionResult',
    'GetRegionsRegionZoneResult',
]

@pulumi.output_type
class EnterpriseSnapshotPolicyCrossRegionCopyInfo(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 regions: Optional[Sequence['outputs.EnterpriseSnapshotPolicyCrossRegionCopyInfoRegion']] = None):
        """
        :param bool enabled: Enable Snapshot replication.
        :param Sequence['EnterpriseSnapshotPolicyCrossRegionCopyInfoRegionArgs'] regions: Destination region for Snapshot replication. See `regions` below.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if regions is not None:
            pulumi.set(__self__, "regions", regions)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable Snapshot replication.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def regions(self) -> Optional[Sequence['outputs.EnterpriseSnapshotPolicyCrossRegionCopyInfoRegion']]:
        """
        Destination region for Snapshot replication. See `regions` below.
        """
        return pulumi.get(self, "regions")


@pulumi.output_type
class EnterpriseSnapshotPolicyCrossRegionCopyInfoRegion(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "regionId":
            suggest = "region_id"
        elif key == "retainDays":
            suggest = "retain_days"

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

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

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

    def __init__(__self__, *,
                 region_id: Optional[str] = None,
                 retain_days: Optional[int] = None):
        """
        :param str region_id: Destination region ID.
        :param int retain_days: Number of days of snapshot retention for replication.
        """
        if region_id is not None:
            pulumi.set(__self__, "region_id", region_id)
        if retain_days is not None:
            pulumi.set(__self__, "retain_days", retain_days)

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> Optional[str]:
        """
        Destination region ID.
        """
        return pulumi.get(self, "region_id")

    @property
    @pulumi.getter(name="retainDays")
    def retain_days(self) -> Optional[int]:
        """
        Number of days of snapshot retention for replication.
        """
        return pulumi.get(self, "retain_days")


@pulumi.output_type
class EnterpriseSnapshotPolicyRetainRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeInterval":
            suggest = "time_interval"
        elif key == "timeUnit":
            suggest = "time_unit"

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

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

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

    def __init__(__self__, *,
                 number: Optional[int] = None,
                 time_interval: Optional[int] = None,
                 time_unit: Optional[str] = None):
        """
        :param int number: Retention based on counting method.
        :param int time_interval: Time unit.
        :param str time_unit: Time-based retention.
        """
        if number is not None:
            pulumi.set(__self__, "number", number)
        if time_interval is not None:
            pulumi.set(__self__, "time_interval", time_interval)
        if time_unit is not None:
            pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter
    def number(self) -> Optional[int]:
        """
        Retention based on counting method.
        """
        return pulumi.get(self, "number")

    @property
    @pulumi.getter(name="timeInterval")
    def time_interval(self) -> Optional[int]:
        """
        Time unit.
        """
        return pulumi.get(self, "time_interval")

    @property
    @pulumi.getter(name="timeUnit")
    def time_unit(self) -> Optional[str]:
        """
        Time-based retention.
        """
        return pulumi.get(self, "time_unit")


@pulumi.output_type
class EnterpriseSnapshotPolicySchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronExpression":
            suggest = "cron_expression"

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

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

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

    def __init__(__self__, *,
                 cron_expression: str):
        """
        :param str cron_expression: CronTab expression.
        """
        pulumi.set(__self__, "cron_expression", cron_expression)

    @property
    @pulumi.getter(name="cronExpression")
    def cron_expression(self) -> str:
        """
        CronTab expression.
        """
        return pulumi.get(self, "cron_expression")


@pulumi.output_type
class EnterpriseSnapshotPolicySpecialRetainRules(dict):
    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 rules: Optional[Sequence['outputs.EnterpriseSnapshotPolicySpecialRetainRulesRule']] = None):
        """
        :param bool enabled: Whether special reservations are enabled. Value range:
               - true
               - false.
        :param Sequence['EnterpriseSnapshotPolicySpecialRetainRulesRuleArgs'] rules: List of special retention rules. See `rules` below.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Whether special reservations are enabled. Value range:
        - true
        - false.
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def rules(self) -> Optional[Sequence['outputs.EnterpriseSnapshotPolicySpecialRetainRulesRule']]:
        """
        List of special retention rules. See `rules` below.
        """
        return pulumi.get(self, "rules")


@pulumi.output_type
class EnterpriseSnapshotPolicySpecialRetainRulesRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "specialPeriodUnit":
            suggest = "special_period_unit"
        elif key == "timeInterval":
            suggest = "time_interval"
        elif key == "timeUnit":
            suggest = "time_unit"

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

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

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

    def __init__(__self__, *,
                 special_period_unit: Optional[str] = None,
                 time_interval: Optional[int] = None,
                 time_unit: Optional[str] = None):
        """
        :param str special_period_unit: The cycle unit of the special reserved snapshot. If the value is set to WEEKS, the first snapshot of each week is reserved. The retention time is determined by TimeUnit and TimeInterval. The value range is:
               - WEEKS
               - MONTHS
               - YEARS.
        """
        if special_period_unit is not None:
            pulumi.set(__self__, "special_period_unit", special_period_unit)
        if time_interval is not None:
            pulumi.set(__self__, "time_interval", time_interval)
        if time_unit is not None:
            pulumi.set(__self__, "time_unit", time_unit)

    @property
    @pulumi.getter(name="specialPeriodUnit")
    def special_period_unit(self) -> Optional[str]:
        """
        The cycle unit of the special reserved snapshot. If the value is set to WEEKS, the first snapshot of each week is reserved. The retention time is determined by TimeUnit and TimeInterval. The value range is:
        - WEEKS
        - MONTHS
        - YEARS.
        """
        return pulumi.get(self, "special_period_unit")

    @property
    @pulumi.getter(name="timeInterval")
    def time_interval(self) -> Optional[int]:
        return pulumi.get(self, "time_interval")

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


@pulumi.output_type
class EnterpriseSnapshotPolicyStorageRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableImmediateAccess":
            suggest = "enable_immediate_access"

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

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

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

    def __init__(__self__, *,
                 enable_immediate_access: Optional[bool] = None):
        """
        :param bool enable_immediate_access: Snapshot speed available.
        """
        if enable_immediate_access is not None:
            pulumi.set(__self__, "enable_immediate_access", enable_immediate_access)

    @property
    @pulumi.getter(name="enableImmediateAccess")
    def enable_immediate_access(self) -> Optional[bool]:
        """
        Snapshot speed available.
        """
        return pulumi.get(self, "enable_immediate_access")


@pulumi.output_type
class SolutionInstanceParameter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "parameterKey":
            suggest = "parameter_key"
        elif key == "parameterValue":
            suggest = "parameter_value"

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

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

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

    def __init__(__self__, *,
                 parameter_key: str,
                 parameter_value: str):
        """
        :param str parameter_key: Create parameter Key.
        :param str parameter_value: Create parameter Value.
        """
        pulumi.set(__self__, "parameter_key", parameter_key)
        pulumi.set(__self__, "parameter_value", parameter_value)

    @property
    @pulumi.getter(name="parameterKey")
    def parameter_key(self) -> str:
        """
        Create parameter Key.
        """
        return pulumi.get(self, "parameter_key")

    @property
    @pulumi.getter(name="parameterValue")
    def parameter_value(self) -> str:
        """
        Create parameter Value.
        """
        return pulumi.get(self, "parameter_value")


@pulumi.output_type
class GetDedicatedBlockStorageClustersClusterResult(dict):
    def __init__(__self__, *,
                 available_capacity: str,
                 category: str,
                 create_time: str,
                 dedicated_block_storage_cluster_id: str,
                 dedicated_block_storage_cluster_name: str,
                 delivery_capacity: str,
                 description: str,
                 expired_time: str,
                 id: str,
                 performance_level: str,
                 resource_group_id: str,
                 status: str,
                 supported_category: str,
                 total_capacity: str,
                 type: str,
                 used_capacity: str,
                 zone_id: str):
        """
        :param str available_capacity: The available capacity of the dedicated block storage cluster. Unit: GiB.
        :param str category: The type of cloud disk that can be created by a dedicated block storage cluster.
        :param str create_time: The creation time of the resource
        :param str dedicated_block_storage_cluster_id: The first ID of the resource
        :param str dedicated_block_storage_cluster_name: The name of the resource
        :param str delivery_capacity: Capacity to be delivered in GB.
        :param str description: The description of the dedicated block storage cluster.
        :param str expired_time: The expiration time of the dedicated block storage cluster, in the Unix timestamp format, in seconds.
        :param str performance_level: Cloud disk performance level, possible values:-PL0.-PL1.-PL2.-PL3.> Only valid in SupportedCategory = cloud_essd.
        :param str resource_group_id: The ID of the resource group
        :param str status: The status of the resource
        :param str supported_category: This parameter is not supported.
        :param str total_capacity: The total capacity of the dedicated block storage cluster. Unit: GiB.
        :param str type: The dedicated block storage cluster performance type. Possible values:-Standard: Basic type. This type of dedicated block storage cluster can create an ESSD PL0 cloud disk.-Premium: performance type. This type of dedicated block storage cluster can create an ESSD PL1 cloud disk.
        :param str used_capacity: The used (created disk) capacity of the current cluster, in GB
        :param str zone_id: The zone ID  of the resource
        """
        pulumi.set(__self__, "available_capacity", available_capacity)
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "dedicated_block_storage_cluster_id", dedicated_block_storage_cluster_id)
        pulumi.set(__self__, "dedicated_block_storage_cluster_name", dedicated_block_storage_cluster_name)
        pulumi.set(__self__, "delivery_capacity", delivery_capacity)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "performance_level", performance_level)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "supported_category", supported_category)
        pulumi.set(__self__, "total_capacity", total_capacity)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "used_capacity", used_capacity)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="availableCapacity")
    def available_capacity(self) -> str:
        """
        The available capacity of the dedicated block storage cluster. Unit: GiB.
        """
        return pulumi.get(self, "available_capacity")

    @property
    @pulumi.getter
    def category(self) -> str:
        """
        The type of cloud disk that can be created by a dedicated block storage cluster.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The creation time of the resource
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter(name="dedicatedBlockStorageClusterId")
    def dedicated_block_storage_cluster_id(self) -> str:
        """
        The first ID of the resource
        """
        return pulumi.get(self, "dedicated_block_storage_cluster_id")

    @property
    @pulumi.getter(name="dedicatedBlockStorageClusterName")
    def dedicated_block_storage_cluster_name(self) -> str:
        """
        The name of the resource
        """
        return pulumi.get(self, "dedicated_block_storage_cluster_name")

    @property
    @pulumi.getter(name="deliveryCapacity")
    def delivery_capacity(self) -> str:
        """
        Capacity to be delivered in GB.
        """
        return pulumi.get(self, "delivery_capacity")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the dedicated block storage cluster.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        The expiration time of the dedicated block storage cluster, in the Unix timestamp format, in seconds.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="performanceLevel")
    def performance_level(self) -> str:
        """
        Cloud disk performance level, possible values:-PL0.-PL1.-PL2.-PL3.> Only valid in SupportedCategory = cloud_essd.
        """
        return pulumi.get(self, "performance_level")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The ID of the resource group
        """
        return pulumi.get(self, "resource_group_id")

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

    @property
    @pulumi.getter(name="supportedCategory")
    def supported_category(self) -> str:
        """
        This parameter is not supported.
        """
        return pulumi.get(self, "supported_category")

    @property
    @pulumi.getter(name="totalCapacity")
    def total_capacity(self) -> str:
        """
        The total capacity of the dedicated block storage cluster. Unit: GiB.
        """
        return pulumi.get(self, "total_capacity")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The dedicated block storage cluster performance type. Possible values:-Standard: Basic type. This type of dedicated block storage cluster can create an ESSD PL0 cloud disk.-Premium: performance type. This type of dedicated block storage cluster can create an ESSD PL1 cloud disk.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="usedCapacity")
    def used_capacity(self) -> str:
        """
        The used (created disk) capacity of the current cluster, in GB
        """
        return pulumi.get(self, "used_capacity")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        The zone ID  of the resource
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetDiskReplicaGroupsGroupResult(dict):
    def __init__(__self__, *,
                 description: str,
                 destination_region_id: str,
                 destination_zone_id: str,
                 group_name: str,
                 id: str,
                 last_recover_point: str,
                 primary_region: str,
                 primary_zone: str,
                 replica_group_id: str,
                 rpo: int,
                 site: str,
                 source_region_id: str,
                 source_zone_id: str,
                 standby_region: str,
                 standby_zone: str,
                 status: str):
        """
        :param str description: The description of the consistent replication group.
        :param str destination_region_id: The ID of the region to which the disaster recovery site belongs.
        :param str destination_zone_id: The ID of the zone to which the disaster recovery site belongs.
        :param str group_name: Consistent replication group name.
        :param str id: The ID of the Disk Replica Group.
        :param str primary_region: The initial source region of the replication group.
        :param str primary_zone: The initial source available area of the replication group.
        :param str replica_group_id: The ID of the consistent replication group.
        :param int rpo: The recovery point objective (RPO) of the replication pair-consistent group.
        :param str site: Site information sources for replication pairs and consistent replication groups.
        :param str source_region_id: The ID of the region to which the production site belongs.
        :param str source_zone_id: The ID of the zone to which the production site belongs.
        :param str standby_region: The initial destination region of the replication group.
        :param str standby_zone: The initial destination zone of the replication group.
        :param str status: The status of the consistent replication group. Possible values:
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination_region_id", destination_region_id)
        pulumi.set(__self__, "destination_zone_id", destination_zone_id)
        pulumi.set(__self__, "group_name", group_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "last_recover_point", last_recover_point)
        pulumi.set(__self__, "primary_region", primary_region)
        pulumi.set(__self__, "primary_zone", primary_zone)
        pulumi.set(__self__, "replica_group_id", replica_group_id)
        pulumi.set(__self__, "rpo", rpo)
        pulumi.set(__self__, "site", site)
        pulumi.set(__self__, "source_region_id", source_region_id)
        pulumi.set(__self__, "source_zone_id", source_zone_id)
        pulumi.set(__self__, "standby_region", standby_region)
        pulumi.set(__self__, "standby_zone", standby_zone)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the consistent replication group.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationRegionId")
    def destination_region_id(self) -> str:
        """
        The ID of the region to which the disaster recovery site belongs.
        """
        return pulumi.get(self, "destination_region_id")

    @property
    @pulumi.getter(name="destinationZoneId")
    def destination_zone_id(self) -> str:
        """
        The ID of the zone to which the disaster recovery site belongs.
        """
        return pulumi.get(self, "destination_zone_id")

    @property
    @pulumi.getter(name="groupName")
    def group_name(self) -> str:
        """
        Consistent replication group name.
        """
        return pulumi.get(self, "group_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Disk Replica Group.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="primaryRegion")
    def primary_region(self) -> str:
        """
        The initial source region of the replication group.
        """
        return pulumi.get(self, "primary_region")

    @property
    @pulumi.getter(name="primaryZone")
    def primary_zone(self) -> str:
        """
        The initial source available area of the replication group.
        """
        return pulumi.get(self, "primary_zone")

    @property
    @pulumi.getter(name="replicaGroupId")
    def replica_group_id(self) -> str:
        """
        The ID of the consistent replication group.
        """
        return pulumi.get(self, "replica_group_id")

    @property
    @pulumi.getter
    def rpo(self) -> int:
        """
        The recovery point objective (RPO) of the replication pair-consistent group.
        """
        return pulumi.get(self, "rpo")

    @property
    @pulumi.getter
    def site(self) -> str:
        """
        Site information sources for replication pairs and consistent replication groups.
        """
        return pulumi.get(self, "site")

    @property
    @pulumi.getter(name="sourceRegionId")
    def source_region_id(self) -> str:
        """
        The ID of the region to which the production site belongs.
        """
        return pulumi.get(self, "source_region_id")

    @property
    @pulumi.getter(name="sourceZoneId")
    def source_zone_id(self) -> str:
        """
        The ID of the zone to which the production site belongs.
        """
        return pulumi.get(self, "source_zone_id")

    @property
    @pulumi.getter(name="standbyRegion")
    def standby_region(self) -> str:
        """
        The initial destination region of the replication group.
        """
        return pulumi.get(self, "standby_region")

    @property
    @pulumi.getter(name="standbyZone")
    def standby_zone(self) -> str:
        """
        The initial destination zone of the replication group.
        """
        return pulumi.get(self, "standby_zone")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the consistent replication group. Possible values:
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetDiskReplicaPairsPairResult(dict):
    def __init__(__self__, *,
                 bandwidth: str,
                 description: str,
                 destination_disk_id: str,
                 destination_region_id: str,
                 destination_zone_id: str,
                 disk_id: str,
                 id: str,
                 pair_name: str,
                 payment_type: str,
                 replica_pair_id: str,
                 resource_group_id: str,
                 rpo: str,
                 source_zone_id: str,
                 status: str):
        """
        :param str bandwidth: The bandwidth for asynchronous data replication between cloud disks. The unit is Kbps. Value range:-10240 Kbps: equal to 10 Mbps.-20480 Kbps: equal to 20 Mbps.-51200 Kbps: equal to 50 Mbps.-102400 Kbps: equal to 100 Mbps.Default value: 10240.This parameter cannot be specified when the ChargeType value is POSTPAY. The system value is 0, which indicates that the disk is dynamically allocated according to data write changes during asynchronous replication.
        :param str description: The description of the asynchronous replication relationship. 2 to 256 English or Chinese characters in length and cannot start with' http:// 'or' https.
        :param str destination_disk_id: The ID of the standby disk.
        :param str destination_region_id: The ID of the region to which the disaster recovery site belongs.
        :param str destination_zone_id: The ID of the zone to which the disaster recovery site belongs.
        :param str disk_id: The ID of the primary disk.
        :param str pair_name: The name of the asynchronous replication relationship. The length must be 2 to 128 characters in length and must start with a letter or Chinese name. It cannot start with http:// or https. It can contain Chinese, English, numbers, half-width colons (:), underscores (_), half-width periods (.), or dashes (-).
        :param str payment_type: The payment type of the resource.
        :param str replica_pair_id: The first ID of the resource
        :param str resource_group_id: The ID of the resource group
        :param str rpo: The RPO value set by the consistency group in seconds. Currently only 900 seconds are supported.
        :param str source_zone_id: The ID of the zone to which the production site belongs.
        :param str status: The status of the resource.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination_disk_id", destination_disk_id)
        pulumi.set(__self__, "destination_region_id", destination_region_id)
        pulumi.set(__self__, "destination_zone_id", destination_zone_id)
        pulumi.set(__self__, "disk_id", disk_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "pair_name", pair_name)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "replica_pair_id", replica_pair_id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "rpo", rpo)
        pulumi.set(__self__, "source_zone_id", source_zone_id)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def bandwidth(self) -> str:
        """
        The bandwidth for asynchronous data replication between cloud disks. The unit is Kbps. Value range:-10240 Kbps: equal to 10 Mbps.-20480 Kbps: equal to 20 Mbps.-51200 Kbps: equal to 50 Mbps.-102400 Kbps: equal to 100 Mbps.Default value: 10240.This parameter cannot be specified when the ChargeType value is POSTPAY. The system value is 0, which indicates that the disk is dynamically allocated according to data write changes during asynchronous replication.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the asynchronous replication relationship. 2 to 256 English or Chinese characters in length and cannot start with' http:// 'or' https.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationDiskId")
    def destination_disk_id(self) -> str:
        """
        The ID of the standby disk.
        """
        return pulumi.get(self, "destination_disk_id")

    @property
    @pulumi.getter(name="destinationRegionId")
    def destination_region_id(self) -> str:
        """
        The ID of the region to which the disaster recovery site belongs.
        """
        return pulumi.get(self, "destination_region_id")

    @property
    @pulumi.getter(name="destinationZoneId")
    def destination_zone_id(self) -> str:
        """
        The ID of the zone to which the disaster recovery site belongs.
        """
        return pulumi.get(self, "destination_zone_id")

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> str:
        """
        The ID of the primary disk.
        """
        return pulumi.get(self, "disk_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="pairName")
    def pair_name(self) -> str:
        """
        The name of the asynchronous replication relationship. The length must be 2 to 128 characters in length and must start with a letter or Chinese name. It cannot start with http:// or https. It can contain Chinese, English, numbers, half-width colons (:), underscores (_), half-width periods (.), or dashes (-).
        """
        return pulumi.get(self, "pair_name")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The payment type of the resource.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter(name="replicaPairId")
    def replica_pair_id(self) -> str:
        """
        The first ID of the resource
        """
        return pulumi.get(self, "replica_pair_id")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The ID of the resource group
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter
    def rpo(self) -> str:
        """
        The RPO value set by the consistency group in seconds. Currently only 900 seconds are supported.
        """
        return pulumi.get(self, "rpo")

    @property
    @pulumi.getter(name="sourceZoneId")
    def source_zone_id(self) -> str:
        """
        The ID of the zone to which the production site belongs.
        """
        return pulumi.get(self, "source_zone_id")

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


@pulumi.output_type
class GetRegionsRegionResult(dict):
    def __init__(__self__, *,
                 region_id: str,
                 zones: Sequence['outputs.GetRegionsRegionZoneResult']):
        """
        :param str region_id: The ID of the region.
        :param Sequence['GetRegionsRegionZoneArgs'] zones: A list of Ebs Zones.
        """
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> str:
        """
        The ID of the region.
        """
        return pulumi.get(self, "region_id")

    @property
    @pulumi.getter
    def zones(self) -> Sequence['outputs.GetRegionsRegionZoneResult']:
        """
        A list of Ebs Zones.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class GetRegionsRegionZoneResult(dict):
    def __init__(__self__, *,
                 zone_id: str):
        """
        :param str zone_id: The ID of the zone.
        """
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        The ID of the zone.
        """
        return pulumi.get(self, "zone_id")


