# 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

__all__ = [
    'InstanceDataDisk',
    'InstanceSystemDisk',
    'LoadBalancerBackendServer',
    'GetKeyPairsPairResult',
]

@pulumi.output_type
class InstanceDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskId":
            suggest = "disk_id"
        elif key == "encryptKeyId":
            suggest = "encrypt_key_id"

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

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

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

    def __init__(__self__, *,
                 category: Optional[str] = None,
                 disk_id: Optional[str] = None,
                 encrypt_key_id: Optional[str] = None,
                 encrypted: Optional[bool] = None,
                 size: Optional[int] = None):
        """
        :param str category: Data disk type. Optional values:
               - cloud_efficiency: Ultra cloud disk
               - cloud_ssd: Full Flash cloud disk
               - local_hdd: local hdd disk
               - local_ssd: local disk ssd.
        :param str disk_id: Cloud Disk ID.
        :param str encrypt_key_id: The ID of the KMS key used by the cloud disk.
        :param bool encrypted: Whether to encrypt the cloud disk. Value range:  true: Yes  false (default): No.
        :param int size: Data disk size, unit: GB.
        """
        if category is not None:
            pulumi.set(__self__, "category", category)
        if disk_id is not None:
            pulumi.set(__self__, "disk_id", disk_id)
        if encrypt_key_id is not None:
            pulumi.set(__self__, "encrypt_key_id", encrypt_key_id)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        """
        Data disk type. Optional values:
        - cloud_efficiency: Ultra cloud disk
        - cloud_ssd: Full Flash cloud disk
        - local_hdd: local hdd disk
        - local_ssd: local disk ssd.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter(name="diskId")
    def disk_id(self) -> Optional[str]:
        """
        Cloud Disk ID.
        """
        return pulumi.get(self, "disk_id")

    @property
    @pulumi.getter(name="encryptKeyId")
    def encrypt_key_id(self) -> Optional[str]:
        """
        The ID of the KMS key used by the cloud disk.
        """
        return pulumi.get(self, "encrypt_key_id")

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[bool]:
        """
        Whether to encrypt the cloud disk. Value range:  true: Yes  false (default): No.
        """
        return pulumi.get(self, "encrypted")

    @property
    @pulumi.getter
    def size(self) -> Optional[int]:
        """
        Data disk size, unit: GB.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class InstanceSystemDisk(dict):
    def __init__(__self__, *,
                 category: Optional[str] = None,
                 size: Optional[int] = None):
        """
        :param str category: System disk type. Value
               - cloud_efficiency: Ultra cloud disk
               - cloud_ssd: Full Flash cloud disk
               - local_hdd: local hdd disk
               - local_ssd: local disk ssd.
        :param int size: System disk size, unit: GB.
        """
        if category is not None:
            pulumi.set(__self__, "category", category)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        """
        System disk type. Value
        - cloud_efficiency: Ultra cloud disk
        - cloud_ssd: Full Flash cloud disk
        - local_hdd: local hdd disk
        - local_ssd: local disk ssd.
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def size(self) -> Optional[int]:
        """
        System disk size, unit: GB.
        """
        return pulumi.get(self, "size")


@pulumi.output_type
class LoadBalancerBackendServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serverId":
            suggest = "server_id"

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

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

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

    def __init__(__self__, *,
                 server_id: str,
                 ip: Optional[str] = None,
                 port: Optional[int] = None,
                 type: Optional[str] = None,
                 weight: Optional[int] = None):
        """
        :param str server_id: Backend server instance ID  Example value: i-5vb5h5njxiuhn48a * * * *.
        :param str ip: IP address of the backend server  Example value: 192.168.0.5.
        :param int port: Port used by the backend server.
        :param str type: Backend server type  Example value: ens.
        :param int weight: Weight of the backend server  Example value: 100.
        """
        pulumi.set(__self__, "server_id", server_id)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> str:
        """
        Backend server instance ID  Example value: i-5vb5h5njxiuhn48a * * * *.
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter
    def ip(self) -> Optional[str]:
        """
        IP address of the backend server  Example value: 192.168.0.5.
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[int]:
        """
        Port used by the backend server.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Backend server type  Example value: ens.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> Optional[int]:
        """
        Weight of the backend server  Example value: 100.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetKeyPairsPairResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 id: str,
                 key_pair_finger_print: str,
                 key_pair_name: str,
                 version: str):
        """
        :param str create_time: The creation time of the key pair. The date format is in accordance with ISO8601 notation and uses UTC time. The format is yyyy-MM-ddTHH:mm:ssZ.
        :param str id: The ID of the Key Pair.
        :param str key_pair_finger_print: Fingerprint of the key pair.
        :param str key_pair_name: The name of the key pair.
        :param str version: The version number.
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key_pair_finger_print", key_pair_finger_print)
        pulumi.set(__self__, "key_pair_name", key_pair_name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The creation time of the key pair. The date format is in accordance with ISO8601 notation and uses UTC time. The format is yyyy-MM-ddTHH:mm:ssZ.
        """
        return pulumi.get(self, "create_time")

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

    @property
    @pulumi.getter(name="keyPairFingerPrint")
    def key_pair_finger_print(self) -> str:
        """
        Fingerprint of the key pair.
        """
        return pulumi.get(self, "key_pair_finger_print")

    @property
    @pulumi.getter(name="keyPairName")
    def key_pair_name(self) -> str:
        """
        The name of the key pair.
        """
        return pulumi.get(self, "key_pair_name")

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


