# 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__ = [
    'FirewallEgressRule',
    'FirewallIngressRule',
    'KubernetesClusterInstalledApplication',
    'KubernetesClusterPools',
    'KubernetesClusterPoolsTaint',
    'KubernetesNodePoolTaint',
    'GetDatabaseVersionFilterResult',
    'GetDatabaseVersionSortResult',
    'GetDatabaseVersionVersionResult',
    'GetDiskImageDiskimageResult',
    'GetDiskImageFilterResult',
    'GetDiskImageSortResult',
    'GetInstancesFilterResult',
    'GetInstancesInstanceResult',
    'GetInstancesSortResult',
    'GetKubernetesClusterInstalledApplicationResult',
    'GetKubernetesClusterPoolResult',
    'GetKubernetesClusterPoolTaintResult',
    'GetKubernetesVersionFilterResult',
    'GetKubernetesVersionSortResult',
    'GetKubernetesVersionVersionResult',
    'GetLoadBalancerBackendResult',
    'GetRegionFilterResult',
    'GetRegionRegionResult',
    'GetRegionSortResult',
    'GetSizeFilterResult',
    'GetSizeSizeResult',
    'GetSizeSortResult',
]

@pulumi.output_type
class FirewallEgressRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portRange":
            suggest = "port_range"

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

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

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

    def __init__(__self__, *,
                 action: str,
                 cidrs: Sequence[str],
                 id: Optional[str] = None,
                 label: Optional[str] = None,
                 port_range: Optional[str] = None,
                 protocol: Optional[str] = None):
        """
        :param str action: The action of the rule can be allow or deny. When we set the `action = 'allow'`, this is going to add a rule to allow traffic. Similarly, setting `action = 'deny'` will deny the traffic.
        :param Sequence[str] cidrs: The CIDR notation of the other end to affect, or a valid network CIDR (e.g. 0.0.0.0/0 to open for everyone or 1.2.3.4/32 to open just for a specific IP address)
        :param str id: (String) The ID of this resource.
        :param str label: A string that will be the displayed name/reference for this rule
        :param str port_range: The port or port range to open, can be a single port or a range separated by a dash (`-`), e.g. `80` or `80-443`
        :param str protocol: The protocol choice from `tcp`, `udp` or `icmp` (the default if unspecified is `tcp`)
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "cidrs", cidrs)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if port_range is not None:
            pulumi.set(__self__, "port_range", port_range)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        The action of the rule can be allow or deny. When we set the `action = 'allow'`, this is going to add a rule to allow traffic. Similarly, setting `action = 'deny'` will deny the traffic.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def cidrs(self) -> Sequence[str]:
        """
        The CIDR notation of the other end to affect, or a valid network CIDR (e.g. 0.0.0.0/0 to open for everyone or 1.2.3.4/32 to open just for a specific IP address)
        """
        return pulumi.get(self, "cidrs")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (String) The ID of this resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        A string that will be the displayed name/reference for this rule
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="portRange")
    def port_range(self) -> Optional[str]:
        """
        The port or port range to open, can be a single port or a range separated by a dash (`-`), e.g. `80` or `80-443`
        """
        return pulumi.get(self, "port_range")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The protocol choice from `tcp`, `udp` or `icmp` (the default if unspecified is `tcp`)
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class FirewallIngressRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "portRange":
            suggest = "port_range"

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

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

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

    def __init__(__self__, *,
                 action: str,
                 cidrs: Sequence[str],
                 id: Optional[str] = None,
                 label: Optional[str] = None,
                 port_range: Optional[str] = None,
                 protocol: Optional[str] = None):
        """
        :param str action: The action of the rule can be allow or deny. When we set the `action = 'allow'`, this is going to add a rule to allow traffic. Similarly, setting `action = 'deny'` will deny the traffic.
        :param Sequence[str] cidrs: The CIDR notation of the other end to affect, or a valid network CIDR (e.g. 0.0.0.0/0 to open for everyone or 1.2.3.4/32 to open just for a specific IP address)
        :param str id: (String) The ID of this resource.
        :param str label: A string that will be the displayed name/reference for this rule
        :param str port_range: The port or port range to open, can be a single port or a range separated by a dash (`-`), e.g. `80` or `80-443`
        :param str protocol: The protocol choice from `tcp`, `udp` or `icmp` (the default if unspecified is `tcp`)
        """
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "cidrs", cidrs)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if port_range is not None:
            pulumi.set(__self__, "port_range", port_range)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def action(self) -> str:
        """
        The action of the rule can be allow or deny. When we set the `action = 'allow'`, this is going to add a rule to allow traffic. Similarly, setting `action = 'deny'` will deny the traffic.
        """
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def cidrs(self) -> Sequence[str]:
        """
        The CIDR notation of the other end to affect, or a valid network CIDR (e.g. 0.0.0.0/0 to open for everyone or 1.2.3.4/32 to open just for a specific IP address)
        """
        return pulumi.get(self, "cidrs")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (String) The ID of this resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        A string that will be the displayed name/reference for this rule
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="portRange")
    def port_range(self) -> Optional[str]:
        """
        The port or port range to open, can be a single port or a range separated by a dash (`-`), e.g. `80` or `80-443`
        """
        return pulumi.get(self, "port_range")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The protocol choice from `tcp`, `udp` or `icmp` (the default if unspecified is `tcp`)
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class KubernetesClusterInstalledApplication(dict):
    def __init__(__self__, *,
                 application: Optional[str] = None,
                 category: Optional[str] = None,
                 installed: Optional[bool] = None,
                 version: Optional[str] = None):
        """
        :param str application: (String) name of the application
        :param str category: (String) category of the application
        :param bool installed: (Boolean) whether application is installed or not
        :param str version: (String) version of the application
        """
        if application is not None:
            pulumi.set(__self__, "application", application)
        if category is not None:
            pulumi.set(__self__, "category", category)
        if installed is not None:
            pulumi.set(__self__, "installed", installed)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def application(self) -> Optional[str]:
        """
        (String) name of the application
        """
        return pulumi.get(self, "application")

    @property
    @pulumi.getter
    def category(self) -> Optional[str]:
        """
        (String) category of the application
        """
        return pulumi.get(self, "category")

    @property
    @pulumi.getter
    def installed(self) -> Optional[bool]:
        """
        (Boolean) whether application is installed or not
        """
        return pulumi.get(self, "installed")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        (String) version of the application
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class KubernetesClusterPools(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nodeCount":
            suggest = "node_count"
        elif key == "instanceNames":
            suggest = "instance_names"
        elif key == "publicIpNodePool":
            suggest = "public_ip_node_pool"

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

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

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

    def __init__(__self__, *,
                 node_count: int,
                 size: str,
                 instance_names: Optional[Sequence[str]] = None,
                 label: Optional[str] = None,
                 labels: Optional[Mapping[str, str]] = None,
                 public_ip_node_pool: Optional[bool] = None,
                 taints: Optional[Sequence['outputs.KubernetesClusterPoolsTaint']] = None):
        """
        :param int node_count: Number of nodes in the nodepool
        :param str size: Size of the nodes in the nodepool
        :param Sequence[str] instance_names: Instance names in the nodepool
        :param str label: Node pool label, if you don't provide one, we will generate one for you
        :param bool public_ip_node_pool: Node pool belongs to the public ip node pool
        :param Sequence['KubernetesClusterPoolsTaintArgs'] taints: (see below for nested schema)
               
               Read-Only Output:
        """
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "size", size)
        if instance_names is not None:
            pulumi.set(__self__, "instance_names", instance_names)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if public_ip_node_pool is not None:
            pulumi.set(__self__, "public_ip_node_pool", public_ip_node_pool)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> int:
        """
        Number of nodes in the nodepool
        """
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the nodes in the nodepool
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="instanceNames")
    def instance_names(self) -> Optional[Sequence[str]]:
        """
        Instance names in the nodepool
        """
        return pulumi.get(self, "instance_names")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Node pool label, if you don't provide one, we will generate one for you
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="publicIpNodePool")
    def public_ip_node_pool(self) -> Optional[bool]:
        """
        Node pool belongs to the public ip node pool
        """
        return pulumi.get(self, "public_ip_node_pool")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.KubernetesClusterPoolsTaint']]:
        """
        (see below for nested schema)

        Read-Only Output:
        """
        return pulumi.get(self, "taints")


@pulumi.output_type
class KubernetesClusterPoolsTaint(dict):
    def __init__(__self__, *,
                 effect: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class KubernetesNodePoolTaint(dict):
    def __init__(__self__, *,
                 effect: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class GetDatabaseVersionFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter versions by this key. This may be one of `default`, `engine`, `version`.
        :param Sequence[str] values: Only retrieves `versions` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter versions by this key. This may be one of `default`, `engine`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `versions` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetDatabaseVersionSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort versions by this key. This may be one of `default`, `engine`, `version`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort versions by this key. This may be one of `default`, `engine`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


@pulumi.output_type
class GetDatabaseVersionVersionResult(dict):
    def __init__(__self__, *,
                 default: bool,
                 engine: str,
                 version: str):
        """
        :param bool default: If the version is the default
        :param str engine: The engine of the database
        :param str version: The version of the database
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "engine", engine)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def default(self) -> bool:
        """
        If the version is the default
        """
        return pulumi.get(self, "default")

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

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


@pulumi.output_type
class GetDiskImageDiskimageResult(dict):
    def __init__(__self__, *,
                 id: str,
                 label: str,
                 name: str,
                 version: str):
        """
        :param str id: ID of disk image
        :param str label: Label of disk image
        :param str name: Name of disk image
        :param str version: Version of disk image
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "version", version)

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

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Label of disk image
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of disk image
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        Version of disk image
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetDiskImageFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter diskimages by this key. This may be one of `id`, `label`, `name`, `version`.
        :param Sequence[str] values: Only retrieves `diskimages` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter diskimages by this key. This may be one of `id`, `label`, `name`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `diskimages` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetDiskImageSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort diskimages by this key. This may be one of `id`, `label`, `name`, `version`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort diskimages by this key. This may be one of `id`, `label`, `name`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


@pulumi.output_type
class GetInstancesFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter instances by this key. This may be one of `cpu_cores`, `created_at`, `disk_gb`, `firewall_id`, `hostname`, `id`, `initial_password`, `initial_user`, `network_id`, `notes`, `private_ip`, `pseudo_ip`, `public_ip`, `ram_mb`, `region`, `reverse_dns`, `script`, `size`, `sshkey_id`, `status`, `tags`, `template`.
        :param Sequence[str] values: Only retrieves `instances` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter instances by this key. This may be one of `cpu_cores`, `created_at`, `disk_gb`, `firewall_id`, `hostname`, `id`, `initial_password`, `initial_user`, `network_id`, `notes`, `private_ip`, `pseudo_ip`, `public_ip`, `ram_mb`, `region`, `reverse_dns`, `script`, `size`, `sshkey_id`, `status`, `tags`, `template`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `instances` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetInstancesInstanceResult(dict):
    def __init__(__self__, *,
                 cpu_cores: int,
                 created_at: str,
                 disk_gb: int,
                 firewall_id: str,
                 hostname: str,
                 id: str,
                 initial_password: str,
                 initial_user: str,
                 network_id: str,
                 notes: str,
                 private_ip: str,
                 pseudo_ip: str,
                 public_ip: str,
                 ram_mb: int,
                 region: str,
                 reverse_dns: str,
                 script: str,
                 size: str,
                 sshkey_id: str,
                 status: str,
                 tags: Sequence[str],
                 template: str):
        """
        :param int cpu_cores: CPU of the instance
        :param str created_at: Creation date of the instance
        :param int disk_gb: SSD size of the instance
        :param str firewall_id: Firewall ID of the instance
        :param str hostname: Hostname of the instance
        :param str id: ID of the instance
        :param str initial_password: Initial password of the instance
        :param str initial_user: Initial user of the instance
        :param str network_id: Network id of the instance
        :param str notes: Note of the instance
        :param str private_ip: Private IP of the instance
        :param str pseudo_ip: Pseudo IP of the instance
        :param str public_ip: Public IP of the instance
        :param int ram_mb: RAM of the instance
        :param str region: Region of the instance
        :param str reverse_dns: Reverse DNS of the instance
        :param str script: Script of the instance
        :param str size: Size of the instance
        :param str sshkey_id: SSH key id of the instance
        :param str status: Status of the instance
        :param Sequence[str] tags: Tags of the instance
        :param str template: Disk image/template of the instance
        """
        pulumi.set(__self__, "cpu_cores", cpu_cores)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "disk_gb", disk_gb)
        pulumi.set(__self__, "firewall_id", firewall_id)
        pulumi.set(__self__, "hostname", hostname)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "initial_password", initial_password)
        pulumi.set(__self__, "initial_user", initial_user)
        pulumi.set(__self__, "network_id", network_id)
        pulumi.set(__self__, "notes", notes)
        pulumi.set(__self__, "private_ip", private_ip)
        pulumi.set(__self__, "pseudo_ip", pseudo_ip)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "ram_mb", ram_mb)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "reverse_dns", reverse_dns)
        pulumi.set(__self__, "script", script)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "sshkey_id", sshkey_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "template", template)

    @property
    @pulumi.getter(name="cpuCores")
    def cpu_cores(self) -> int:
        """
        CPU of the instance
        """
        return pulumi.get(self, "cpu_cores")

    @property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> str:
        """
        Creation date of the instance
        """
        return pulumi.get(self, "created_at")

    @property
    @pulumi.getter(name="diskGb")
    def disk_gb(self) -> int:
        """
        SSD size of the instance
        """
        return pulumi.get(self, "disk_gb")

    @property
    @pulumi.getter(name="firewallId")
    def firewall_id(self) -> str:
        """
        Firewall ID of the instance
        """
        return pulumi.get(self, "firewall_id")

    @property
    @pulumi.getter
    def hostname(self) -> str:
        """
        Hostname of the instance
        """
        return pulumi.get(self, "hostname")

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

    @property
    @pulumi.getter(name="initialPassword")
    def initial_password(self) -> str:
        """
        Initial password of the instance
        """
        return pulumi.get(self, "initial_password")

    @property
    @pulumi.getter(name="initialUser")
    def initial_user(self) -> str:
        """
        Initial user of the instance
        """
        return pulumi.get(self, "initial_user")

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> str:
        """
        Network id of the instance
        """
        return pulumi.get(self, "network_id")

    @property
    @pulumi.getter
    def notes(self) -> str:
        """
        Note of the instance
        """
        return pulumi.get(self, "notes")

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> str:
        """
        Private IP of the instance
        """
        return pulumi.get(self, "private_ip")

    @property
    @pulumi.getter(name="pseudoIp")
    def pseudo_ip(self) -> str:
        """
        Pseudo IP of the instance
        """
        return pulumi.get(self, "pseudo_ip")

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> str:
        """
        Public IP of the instance
        """
        return pulumi.get(self, "public_ip")

    @property
    @pulumi.getter(name="ramMb")
    def ram_mb(self) -> int:
        """
        RAM of the instance
        """
        return pulumi.get(self, "ram_mb")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        Region of the instance
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="reverseDns")
    def reverse_dns(self) -> str:
        """
        Reverse DNS of the instance
        """
        return pulumi.get(self, "reverse_dns")

    @property
    @pulumi.getter
    def script(self) -> str:
        """
        Script of the instance
        """
        return pulumi.get(self, "script")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the instance
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshkeyId")
    def sshkey_id(self) -> str:
        """
        SSH key id of the instance
        """
        return pulumi.get(self, "sshkey_id")

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

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        """
        Tags of the instance
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def template(self) -> str:
        """
        Disk image/template of the instance
        """
        return pulumi.get(self, "template")


@pulumi.output_type
class GetInstancesSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort instances by this key. This may be one of `cpu_cores`, `created_at`, `disk_gb`, `firewall_id`, `hostname`, `id`, `initial_password`, `initial_user`, `network_id`, `notes`, `private_ip`, `pseudo_ip`, `public_ip`, `ram_mb`, `region`, `reverse_dns`, `script`, `size`, `sshkey_id`, `status`, `template`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort instances by this key. This may be one of `cpu_cores`, `created_at`, `disk_gb`, `firewall_id`, `hostname`, `id`, `initial_password`, `initial_user`, `network_id`, `notes`, `private_ip`, `pseudo_ip`, `public_ip`, `ram_mb`, `region`, `reverse_dns`, `script`, `size`, `sshkey_id`, `status`, `template`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


@pulumi.output_type
class GetKubernetesClusterInstalledApplicationResult(dict):
    def __init__(__self__, *,
                 application: str,
                 category: str,
                 installed: bool,
                 version: str):
        """
        :param str application: The name of the application
        :param str category: The category of the application
        :param bool installed: If the application is installed, this will return `true`
        :param str version: The version of the application
        """
        pulumi.set(__self__, "application", application)
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "installed", installed)
        pulumi.set(__self__, "version", version)

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

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

    @property
    @pulumi.getter
    def installed(self) -> bool:
        """
        If the application is installed, this will return `true`
        """
        return pulumi.get(self, "installed")

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


@pulumi.output_type
class GetKubernetesClusterPoolResult(dict):
    def __init__(__self__, *,
                 instance_names: Sequence[str],
                 label: str,
                 node_count: int,
                 public_ip_node_pool: bool,
                 size: str,
                 labels: Optional[Mapping[str, str]] = None,
                 taints: Optional[Sequence['outputs.GetKubernetesClusterPoolTaintResult']] = None):
        """
        :param Sequence[str] instance_names: Instance names in the nodepool
        :param str label: Node pool label, if you don't provide one, we will generate one for you
        :param int node_count: Number of nodes in the nodepool
        :param bool public_ip_node_pool: Node pool belongs to the public ip node pool
        :param str size: Size of the nodes in the nodepool
        """
        pulumi.set(__self__, "instance_names", instance_names)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "public_ip_node_pool", public_ip_node_pool)
        pulumi.set(__self__, "size", size)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter(name="instanceNames")
    def instance_names(self) -> Sequence[str]:
        """
        Instance names in the nodepool
        """
        return pulumi.get(self, "instance_names")

    @property
    @pulumi.getter
    def label(self) -> str:
        """
        Node pool label, if you don't provide one, we will generate one for you
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> int:
        """
        Number of nodes in the nodepool
        """
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter(name="publicIpNodePool")
    def public_ip_node_pool(self) -> bool:
        """
        Node pool belongs to the public ip node pool
        """
        return pulumi.get(self, "public_ip_node_pool")

    @property
    @pulumi.getter
    def size(self) -> str:
        """
        Size of the nodes in the nodepool
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, str]]:
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def taints(self) -> Optional[Sequence['outputs.GetKubernetesClusterPoolTaintResult']]:
        return pulumi.get(self, "taints")


@pulumi.output_type
class GetKubernetesClusterPoolTaintResult(dict):
    def __init__(__self__, *,
                 effect: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class GetKubernetesVersionFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter versions by this key. This may be one of `default`, `label`, `type`, `version`.
        :param Sequence[str] values: Only retrieves `versions` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter versions by this key. This may be one of `default`, `label`, `type`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `versions` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetKubernetesVersionSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort versions by this key. This may be one of `default`, `label`, `type`, `version`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort versions by this key. This may be one of `default`, `label`, `type`, `version`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


@pulumi.output_type
class GetKubernetesVersionVersionResult(dict):
    def __init__(__self__, *,
                 default: bool,
                 label: str,
                 type: str,
                 version: str):
        """
        :param bool default: If is the default version used in all cluster, this will return `true`
        :param str label: The label of this version
        :param str type: The type of the cluster, can be `talos` or `k3s`
        :param str version: A version of the Kubernetes
        """
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "label", label)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def default(self) -> bool:
        """
        If is the default version used in all cluster, this will return `true`
        """
        return pulumi.get(self, "default")

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

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the cluster, can be `talos` or `k3s`
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        A version of the Kubernetes
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetLoadBalancerBackendResult(dict):
    def __init__(__self__, *,
                 health_check_port: int,
                 ip: str,
                 protocol: str,
                 source_port: int,
                 target_port: int):
        """
        :param int health_check_port: The health check port of the backend
        :param str ip: The ip of the backend
        :param str protocol: The protocol of the backend
        :param int source_port: The source port of the backend
        :param int target_port: The target port of the backend
        """
        pulumi.set(__self__, "health_check_port", health_check_port)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "source_port", source_port)
        pulumi.set(__self__, "target_port", target_port)

    @property
    @pulumi.getter(name="healthCheckPort")
    def health_check_port(self) -> int:
        """
        The health check port of the backend
        """
        return pulumi.get(self, "health_check_port")

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

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

    @property
    @pulumi.getter(name="sourcePort")
    def source_port(self) -> int:
        """
        The source port of the backend
        """
        return pulumi.get(self, "source_port")

    @property
    @pulumi.getter(name="targetPort")
    def target_port(self) -> int:
        """
        The target port of the backend
        """
        return pulumi.get(self, "target_port")


@pulumi.output_type
class GetRegionFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter regions by this key. This may be one of `code`, `country`, `default`, `name`.
        :param Sequence[str] values: Only retrieves `regions` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter regions by this key. This may be one of `code`, `country`, `default`, `name`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `regions` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetRegionRegionResult(dict):
    def __init__(__self__, *,
                 code: str,
                 country: str,
                 default: bool,
                 name: str):
        """
        :param str code: The code of the region
        :param str country: The country of the region
        :param bool default: If the region is the default region, this will return `true`
        :param str name: A human name of the region
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "country", country)
        pulumi.set(__self__, "default", default)
        pulumi.set(__self__, "name", name)

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

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

    @property
    @pulumi.getter
    def default(self) -> bool:
        """
        If the region is the default region, this will return `true`
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A human name of the region
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetRegionSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort regions by this key. This may be one of `code`, `country`, `default`, `name`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort regions by this key. This may be one of `code`, `country`, `default`, `name`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


@pulumi.output_type
class GetSizeFilterResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str],
                 all: Optional[bool] = None,
                 match_by: Optional[str] = None):
        """
        :param str key: Filter sizes by this key. This may be one of `cpu`, `description`, `disk`, `gpu_type`, `gpu`, `name`, `ram`, `selectable`, `type`.
        :param Sequence[str] values: Only retrieves `sizes` which keys has value that matches one of the values provided here
        :param bool all: Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        :param str match_by: One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)
        if all is not None:
            pulumi.set(__self__, "all", all)
        if match_by is not None:
            pulumi.set(__self__, "match_by", match_by)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Filter sizes by this key. This may be one of `cpu`, `description`, `disk`, `gpu_type`, `gpu`, `name`, `ram`, `selectable`, `type`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        Only retrieves `sizes` which keys has value that matches one of the values provided here
        """
        return pulumi.get(self, "values")

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Set to `true` to require that a field match all of the `values` instead of just one or more of them. This is useful when matching against multi-valued fields such as lists or sets where you want to ensure that all of the `values` are present in the list or set.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter(name="matchBy")
    def match_by(self) -> Optional[str]:
        """
        One of `exact` (default), `re`, or `substring`. For string-typed fields, specify `re` to match by using the `values` as regular expressions, or specify `substring` to match by treating the `values` as substrings to find within the string field.
        """
        return pulumi.get(self, "match_by")


@pulumi.output_type
class GetSizeSizeResult(dict):
    def __init__(__self__, *,
                 cpu: int,
                 description: str,
                 disk: int,
                 gpu: int,
                 gpu_type: str,
                 name: str,
                 ram: int,
                 selectable: bool,
                 type: str):
        """
        :param int cpu: Total of CPU
        :param str description: A description of the instance size
        :param int disk: The size of SSD
        :param int gpu: Total of GPU
        :param str gpu_type: GPU type
        :param str name: The name of the size
        :param int ram: Total of RAM
        :param bool selectable: If can use the instance size
        :param str type: A human name of the size
        """
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "gpu", gpu)
        pulumi.set(__self__, "gpu_type", gpu_type)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ram", ram)
        pulumi.set(__self__, "selectable", selectable)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def cpu(self) -> int:
        """
        Total of CPU
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        A description of the instance size
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def disk(self) -> int:
        """
        The size of SSD
        """
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter
    def gpu(self) -> int:
        """
        Total of GPU
        """
        return pulumi.get(self, "gpu")

    @property
    @pulumi.getter(name="gpuType")
    def gpu_type(self) -> str:
        """
        GPU type
        """
        return pulumi.get(self, "gpu_type")

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

    @property
    @pulumi.getter
    def ram(self) -> int:
        """
        Total of RAM
        """
        return pulumi.get(self, "ram")

    @property
    @pulumi.getter
    def selectable(self) -> bool:
        """
        If can use the instance size
        """
        return pulumi.get(self, "selectable")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        A human name of the size
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetSizeSortResult(dict):
    def __init__(__self__, *,
                 key: str,
                 direction: Optional[str] = None):
        """
        :param str key: Sort sizes by this key. This may be one of `cpu`, `description`, `disk`, `gpu_type`, `gpu`, `name`, `ram`, `selectable`, `type`.
        :param str direction: The sort direction. This may be either `asc` or `desc`.
        """
        pulumi.set(__self__, "key", key)
        if direction is not None:
            pulumi.set(__self__, "direction", direction)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Sort sizes by this key. This may be one of `cpu`, `description`, `disk`, `gpu_type`, `gpu`, `name`, `ram`, `selectable`, `type`.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def direction(self) -> Optional[str]:
        """
        The sort direction. This may be either `asc` or `desc`.
        """
        return pulumi.get(self, "direction")


