# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'GetNodeTypeResult',
    'AwaitableGetNodeTypeResult',
    'get_node_type',
]

@pulumi.output_type
class GetNodeTypeResult:
    """
    A collection of values returned by getNodeType.
    """
    def __init__(__self__, category=None, gb_per_core=None, id=None, is_io_cache_enabled=None, local_disk=None, min_cores=None, min_gpus=None, min_memory_gb=None, photon_driver_capable=None, photon_worker_capable=None, support_port_forwarding=None):
        if category and not isinstance(category, str):
            raise TypeError("Expected argument 'category' to be a str")
        pulumi.set(__self__, "category", category)
        if gb_per_core and not isinstance(gb_per_core, int):
            raise TypeError("Expected argument 'gb_per_core' to be a int")
        pulumi.set(__self__, "gb_per_core", gb_per_core)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if is_io_cache_enabled and not isinstance(is_io_cache_enabled, bool):
            raise TypeError("Expected argument 'is_io_cache_enabled' to be a bool")
        pulumi.set(__self__, "is_io_cache_enabled", is_io_cache_enabled)
        if local_disk and not isinstance(local_disk, bool):
            raise TypeError("Expected argument 'local_disk' to be a bool")
        pulumi.set(__self__, "local_disk", local_disk)
        if min_cores and not isinstance(min_cores, int):
            raise TypeError("Expected argument 'min_cores' to be a int")
        pulumi.set(__self__, "min_cores", min_cores)
        if min_gpus and not isinstance(min_gpus, int):
            raise TypeError("Expected argument 'min_gpus' to be a int")
        pulumi.set(__self__, "min_gpus", min_gpus)
        if min_memory_gb and not isinstance(min_memory_gb, int):
            raise TypeError("Expected argument 'min_memory_gb' to be a int")
        pulumi.set(__self__, "min_memory_gb", min_memory_gb)
        if photon_driver_capable and not isinstance(photon_driver_capable, bool):
            raise TypeError("Expected argument 'photon_driver_capable' to be a bool")
        pulumi.set(__self__, "photon_driver_capable", photon_driver_capable)
        if photon_worker_capable and not isinstance(photon_worker_capable, bool):
            raise TypeError("Expected argument 'photon_worker_capable' to be a bool")
        pulumi.set(__self__, "photon_worker_capable", photon_worker_capable)
        if support_port_forwarding and not isinstance(support_port_forwarding, bool):
            raise TypeError("Expected argument 'support_port_forwarding' to be a bool")
        pulumi.set(__self__, "support_port_forwarding", support_port_forwarding)

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

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The provider-assigned unique ID for this managed resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isIoCacheEnabled")
    def is_io_cache_enabled(self) -> Optional[bool]:
        return pulumi.get(self, "is_io_cache_enabled")

    @property
    @pulumi.getter(name="localDisk")
    def local_disk(self) -> Optional[bool]:
        return pulumi.get(self, "local_disk")

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

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

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

    @property
    @pulumi.getter(name="photonDriverCapable")
    def photon_driver_capable(self) -> Optional[bool]:
        return pulumi.get(self, "photon_driver_capable")

    @property
    @pulumi.getter(name="photonWorkerCapable")
    def photon_worker_capable(self) -> Optional[bool]:
        return pulumi.get(self, "photon_worker_capable")

    @property
    @pulumi.getter(name="supportPortForwarding")
    def support_port_forwarding(self) -> Optional[bool]:
        return pulumi.get(self, "support_port_forwarding")


class AwaitableGetNodeTypeResult(GetNodeTypeResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetNodeTypeResult(
            category=self.category,
            gb_per_core=self.gb_per_core,
            id=self.id,
            is_io_cache_enabled=self.is_io_cache_enabled,
            local_disk=self.local_disk,
            min_cores=self.min_cores,
            min_gpus=self.min_gpus,
            min_memory_gb=self.min_memory_gb,
            photon_driver_capable=self.photon_driver_capable,
            photon_worker_capable=self.photon_worker_capable,
            support_port_forwarding=self.support_port_forwarding)


def get_node_type(category: Optional[str] = None,
                  gb_per_core: Optional[int] = None,
                  is_io_cache_enabled: Optional[bool] = None,
                  local_disk: Optional[bool] = None,
                  min_cores: Optional[int] = None,
                  min_gpus: Optional[int] = None,
                  min_memory_gb: Optional[int] = None,
                  photon_driver_capable: Optional[bool] = None,
                  photon_worker_capable: Optional[bool] = None,
                  support_port_forwarding: Optional[bool] = None,
                  opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNodeTypeResult:
    """
    Use this data source to access information about an existing resource.
    """
    __args__ = dict()
    __args__['category'] = category
    __args__['gbPerCore'] = gb_per_core
    __args__['isIoCacheEnabled'] = is_io_cache_enabled
    __args__['localDisk'] = local_disk
    __args__['minCores'] = min_cores
    __args__['minGpus'] = min_gpus
    __args__['minMemoryGb'] = min_memory_gb
    __args__['photonDriverCapable'] = photon_driver_capable
    __args__['photonWorkerCapable'] = photon_worker_capable
    __args__['supportPortForwarding'] = support_port_forwarding
    if opts is None:
        opts = pulumi.InvokeOptions()
    if opts.version is None:
        opts.version = _utilities.get_version()
    __ret__ = pulumi.runtime.invoke('databricks:databricks/getNodeType:getNodeType', __args__, opts=opts, typ=GetNodeTypeResult).value

    return AwaitableGetNodeTypeResult(
        category=__ret__.category,
        gb_per_core=__ret__.gb_per_core,
        id=__ret__.id,
        is_io_cache_enabled=__ret__.is_io_cache_enabled,
        local_disk=__ret__.local_disk,
        min_cores=__ret__.min_cores,
        min_gpus=__ret__.min_gpus,
        min_memory_gb=__ret__.min_memory_gb,
        photon_driver_capable=__ret__.photon_driver_capable,
        photon_worker_capable=__ret__.photon_worker_capable,
        support_port_forwarding=__ret__.support_port_forwarding)
