# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** 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__ = [
    'DataCenter',
    'Endpoint',
    'Gpu',
    'NetworkStorage',
    'Pod',
    'PodEnv',
    'PodRegistry',
    'SavingsPlanInput',
    'Template',
]

@pulumi.output_type
class DataCenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "storageSupport":
            suggest = "storage_support"

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

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

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

    def __init__(__self__, *,
                 id: str,
                 location: str,
                 name: str,
                 storage_support: bool):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "storage_support", storage_support)

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

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

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

    @property
    @pulumi.getter(name="storageSupport")
    def storage_support(self) -> bool:
        return pulumi.get(self, "storage_support")


@pulumi.output_type
class Endpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gpuIds":
            suggest = "gpu_ids"
        elif key == "idleTimeout":
            suggest = "idle_timeout"
        elif key == "networkVolumeId":
            suggest = "network_volume_id"
        elif key == "scalerType":
            suggest = "scaler_type"
        elif key == "scalerValue":
            suggest = "scaler_value"
        elif key == "templateId":
            suggest = "template_id"
        elif key == "workersMax":
            suggest = "workers_max"
        elif key == "workersMin":
            suggest = "workers_min"

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

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

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

    def __init__(__self__, *,
                 gpu_ids: str,
                 id: str,
                 idle_timeout: int,
                 locations: str,
                 name: str,
                 network_volume_id: str,
                 scaler_type: str,
                 scaler_value: int,
                 template_id: str,
                 workers_max: int,
                 workers_min: int):
        pulumi.set(__self__, "gpu_ids", gpu_ids)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "idle_timeout", idle_timeout)
        pulumi.set(__self__, "locations", locations)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_volume_id", network_volume_id)
        pulumi.set(__self__, "scaler_type", scaler_type)
        pulumi.set(__self__, "scaler_value", scaler_value)
        pulumi.set(__self__, "template_id", template_id)
        pulumi.set(__self__, "workers_max", workers_max)
        pulumi.set(__self__, "workers_min", workers_min)

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

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

    @property
    @pulumi.getter(name="idleTimeout")
    def idle_timeout(self) -> int:
        return pulumi.get(self, "idle_timeout")

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

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

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

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

    @property
    @pulumi.getter(name="scalerValue")
    def scaler_value(self) -> int:
        return pulumi.get(self, "scaler_value")

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

    @property
    @pulumi.getter(name="workersMax")
    def workers_max(self) -> int:
        return pulumi.get(self, "workers_max")

    @property
    @pulumi.getter(name="workersMin")
    def workers_min(self) -> int:
        return pulumi.get(self, "workers_min")


@pulumi.output_type
class Gpu(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podId":
            suggest = "pod_id"

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

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

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

    def __init__(__self__, *,
                 id: str,
                 pod_id: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "pod_id", pod_id)

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

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


@pulumi.output_type
class NetworkStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataCenter":
            suggest = "data_center"
        elif key == "dataCenterId":
            suggest = "data_center_id"

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

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

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

    def __init__(__self__, *,
                 data_center: 'outputs.DataCenter',
                 data_center_id: str,
                 id: str,
                 name: str,
                 size: int):
        pulumi.set(__self__, "data_center", data_center)
        pulumi.set(__self__, "data_center_id", data_center_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter(name="dataCenter")
    def data_center(self) -> 'outputs.DataCenter':
        return pulumi.get(self, "data_center")

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

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

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

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


@pulumi.output_type
class Pod(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adjustedCostPerHr":
            suggest = "adjusted_cost_per_hr"
        elif key == "aiApiId":
            suggest = "ai_api_id"
        elif key == "apiKey":
            suggest = "api_key"
        elif key == "consumerUserId":
            suggest = "consumer_user_id"
        elif key == "containerDiskInGb":
            suggest = "container_disk_in_gb"
        elif key == "containerRegistryAuthId":
            suggest = "container_registry_auth_id"
        elif key == "costMultiplier":
            suggest = "cost_multiplier"
        elif key == "costPerHr":
            suggest = "cost_per_hr"
        elif key == "createdAt":
            suggest = "created_at"
        elif key == "desiredStatus":
            suggest = "desired_status"
        elif key == "dockerArgs":
            suggest = "docker_args"
        elif key == "dockerId":
            suggest = "docker_id"
        elif key == "gpuCount":
            suggest = "gpu_count"
        elif key == "gpuPowerLimitPercent":
            suggest = "gpu_power_limit_percent"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "lastStartedAt":
            suggest = "last_started_at"
        elif key == "lastStatusChange":
            suggest = "last_status_change"
        elif key == "machineId":
            suggest = "machine_id"
        elif key == "memoryInGb":
            suggest = "memory_in_gb"
        elif key == "podType":
            suggest = "pod_type"
        elif key == "templateId":
            suggest = "template_id"
        elif key == "uptimeSeconds":
            suggest = "uptime_seconds"
        elif key == "vcpuCount":
            suggest = "vcpu_count"
        elif key == "volumeEncrypted":
            suggest = "volume_encrypted"
        elif key == "volumeInGb":
            suggest = "volume_in_gb"
        elif key == "volumeKey":
            suggest = "volume_key"
        elif key == "volumeMountPath":
            suggest = "volume_mount_path"

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

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

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

    def __init__(__self__, *,
                 adjusted_cost_per_hr: float,
                 ai_api_id: str,
                 api_key: str,
                 consumer_user_id: str,
                 container_disk_in_gb: int,
                 container_registry_auth_id: str,
                 cost_multiplier: float,
                 cost_per_hr: float,
                 created_at: str,
                 desired_status: str,
                 docker_args: str,
                 docker_id: str,
                 gpu_count: int,
                 gpu_power_limit_percent: int,
                 id: str,
                 image_name: str,
                 last_started_at: str,
                 last_status_change: str,
                 locked: bool,
                 machine_id: str,
                 memory_in_gb: float,
                 name: str,
                 pod_type: str,
                 port: int,
                 ports: str,
                 registry: 'outputs.PodRegistry',
                 template_id: str,
                 uptime_seconds: int,
                 vcpu_count: float,
                 version: int,
                 volume_encrypted: bool,
                 volume_in_gb: float,
                 volume_key: str,
                 volume_mount_path: str,
                 env: Optional[Sequence[str]] = None,
                 gpus: Optional[Sequence['outputs.Gpu']] = None):
        pulumi.set(__self__, "adjusted_cost_per_hr", adjusted_cost_per_hr)
        pulumi.set(__self__, "ai_api_id", ai_api_id)
        pulumi.set(__self__, "api_key", api_key)
        pulumi.set(__self__, "consumer_user_id", consumer_user_id)
        pulumi.set(__self__, "container_disk_in_gb", container_disk_in_gb)
        pulumi.set(__self__, "container_registry_auth_id", container_registry_auth_id)
        pulumi.set(__self__, "cost_multiplier", cost_multiplier)
        pulumi.set(__self__, "cost_per_hr", cost_per_hr)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "desired_status", desired_status)
        pulumi.set(__self__, "docker_args", docker_args)
        pulumi.set(__self__, "docker_id", docker_id)
        pulumi.set(__self__, "gpu_count", gpu_count)
        pulumi.set(__self__, "gpu_power_limit_percent", gpu_power_limit_percent)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "last_started_at", last_started_at)
        pulumi.set(__self__, "last_status_change", last_status_change)
        pulumi.set(__self__, "locked", locked)
        pulumi.set(__self__, "machine_id", machine_id)
        pulumi.set(__self__, "memory_in_gb", memory_in_gb)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "pod_type", pod_type)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "registry", registry)
        pulumi.set(__self__, "template_id", template_id)
        pulumi.set(__self__, "uptime_seconds", uptime_seconds)
        pulumi.set(__self__, "vcpu_count", vcpu_count)
        pulumi.set(__self__, "version", version)
        pulumi.set(__self__, "volume_encrypted", volume_encrypted)
        pulumi.set(__self__, "volume_in_gb", volume_in_gb)
        pulumi.set(__self__, "volume_key", volume_key)
        pulumi.set(__self__, "volume_mount_path", volume_mount_path)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if gpus is not None:
            pulumi.set(__self__, "gpus", gpus)

    @property
    @pulumi.getter(name="adjustedCostPerHr")
    def adjusted_cost_per_hr(self) -> float:
        return pulumi.get(self, "adjusted_cost_per_hr")

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

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

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

    @property
    @pulumi.getter(name="containerDiskInGb")
    def container_disk_in_gb(self) -> int:
        return pulumi.get(self, "container_disk_in_gb")

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

    @property
    @pulumi.getter(name="costMultiplier")
    def cost_multiplier(self) -> float:
        return pulumi.get(self, "cost_multiplier")

    @property
    @pulumi.getter(name="costPerHr")
    def cost_per_hr(self) -> float:
        return pulumi.get(self, "cost_per_hr")

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

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

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

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

    @property
    @pulumi.getter(name="gpuCount")
    def gpu_count(self) -> int:
        return pulumi.get(self, "gpu_count")

    @property
    @pulumi.getter(name="gpuPowerLimitPercent")
    def gpu_power_limit_percent(self) -> int:
        return pulumi.get(self, "gpu_power_limit_percent")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="memoryInGb")
    def memory_in_gb(self) -> float:
        return pulumi.get(self, "memory_in_gb")

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

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

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

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

    @property
    @pulumi.getter
    def registry(self) -> 'outputs.PodRegistry':
        return pulumi.get(self, "registry")

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

    @property
    @pulumi.getter(name="uptimeSeconds")
    def uptime_seconds(self) -> int:
        return pulumi.get(self, "uptime_seconds")

    @property
    @pulumi.getter(name="vcpuCount")
    def vcpu_count(self) -> float:
        return pulumi.get(self, "vcpu_count")

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

    @property
    @pulumi.getter(name="volumeEncrypted")
    def volume_encrypted(self) -> bool:
        return pulumi.get(self, "volume_encrypted")

    @property
    @pulumi.getter(name="volumeInGb")
    def volume_in_gb(self) -> float:
        return pulumi.get(self, "volume_in_gb")

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

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

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

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


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

    @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 PodRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pass":
            suggest = "pass_"

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

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

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

    def __init__(__self__, *,
                 auth: str,
                 pass_: str,
                 url: str,
                 user: str,
                 username: str):
        pulumi.set(__self__, "auth", auth)
        pulumi.set(__self__, "pass_", pass_)
        pulumi.set(__self__, "url", url)
        pulumi.set(__self__, "user", user)
        pulumi.set(__self__, "username", username)

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

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

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

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

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


@pulumi.output_type
class SavingsPlanInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "planLength":
            suggest = "plan_length"
        elif key == "upfrontCost":
            suggest = "upfront_cost"

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

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

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

    def __init__(__self__, *,
                 plan_length: str,
                 upfront_cost: float):
        pulumi.set(__self__, "plan_length", plan_length)
        pulumi.set(__self__, "upfront_cost", upfront_cost)

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

    @property
    @pulumi.getter(name="upfrontCost")
    def upfront_cost(self) -> float:
        return pulumi.get(self, "upfront_cost")


@pulumi.output_type
class Template(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "advancedStart":
            suggest = "advanced_start"
        elif key == "boundEndpointId":
            suggest = "bound_endpoint_id"
        elif key == "containerDiskInGb":
            suggest = "container_disk_in_gb"
        elif key == "containerRegistryAuthId":
            suggest = "container_registry_auth_id"
        elif key == "dockerArgs":
            suggest = "docker_args"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "isPublic":
            suggest = "is_public"
        elif key == "isRunpod":
            suggest = "is_runpod"
        elif key == "isServerless":
            suggest = "is_serverless"
        elif key == "runtimeInMin":
            suggest = "runtime_in_min"
        elif key == "startJupyter":
            suggest = "start_jupyter"
        elif key == "startScript":
            suggest = "start_script"
        elif key == "startSsh":
            suggest = "start_ssh"
        elif key == "volumeInGb":
            suggest = "volume_in_gb"
        elif key == "volumeMountPath":
            suggest = "volume_mount_path"

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

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

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

    def __init__(__self__, *,
                 advanced_start: bool,
                 bound_endpoint_id: str,
                 category: str,
                 container_disk_in_gb: int,
                 container_registry_auth_id: str,
                 docker_args: str,
                 earned: float,
                 id: str,
                 image_name: str,
                 is_public: bool,
                 is_runpod: bool,
                 is_serverless: bool,
                 name: str,
                 ports: str,
                 readme: str,
                 runtime_in_min: int,
                 start_jupyter: bool,
                 start_script: str,
                 start_ssh: bool,
                 volume_in_gb: int,
                 volume_mount_path: str,
                 env: Optional[Sequence['outputs.PodEnv']] = None):
        pulumi.set(__self__, "advanced_start", advanced_start)
        pulumi.set(__self__, "bound_endpoint_id", bound_endpoint_id)
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "container_disk_in_gb", container_disk_in_gb)
        pulumi.set(__self__, "container_registry_auth_id", container_registry_auth_id)
        pulumi.set(__self__, "docker_args", docker_args)
        pulumi.set(__self__, "earned", earned)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "is_public", is_public)
        pulumi.set(__self__, "is_runpod", is_runpod)
        pulumi.set(__self__, "is_serverless", is_serverless)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ports", ports)
        pulumi.set(__self__, "readme", readme)
        pulumi.set(__self__, "runtime_in_min", runtime_in_min)
        pulumi.set(__self__, "start_jupyter", start_jupyter)
        pulumi.set(__self__, "start_script", start_script)
        pulumi.set(__self__, "start_ssh", start_ssh)
        pulumi.set(__self__, "volume_in_gb", volume_in_gb)
        pulumi.set(__self__, "volume_mount_path", volume_mount_path)
        if env is not None:
            pulumi.set(__self__, "env", env)

    @property
    @pulumi.getter(name="advancedStart")
    def advanced_start(self) -> bool:
        return pulumi.get(self, "advanced_start")

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

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

    @property
    @pulumi.getter(name="containerDiskInGb")
    def container_disk_in_gb(self) -> int:
        return pulumi.get(self, "container_disk_in_gb")

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

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

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

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

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

    @property
    @pulumi.getter(name="isPublic")
    def is_public(self) -> bool:
        return pulumi.get(self, "is_public")

    @property
    @pulumi.getter(name="isRunpod")
    def is_runpod(self) -> bool:
        return pulumi.get(self, "is_runpod")

    @property
    @pulumi.getter(name="isServerless")
    def is_serverless(self) -> bool:
        return pulumi.get(self, "is_serverless")

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

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

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

    @property
    @pulumi.getter(name="runtimeInMin")
    def runtime_in_min(self) -> int:
        return pulumi.get(self, "runtime_in_min")

    @property
    @pulumi.getter(name="startJupyter")
    def start_jupyter(self) -> bool:
        return pulumi.get(self, "start_jupyter")

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

    @property
    @pulumi.getter(name="startSsh")
    def start_ssh(self) -> bool:
        return pulumi.get(self, "start_ssh")

    @property
    @pulumi.getter(name="volumeInGb")
    def volume_in_gb(self) -> int:
        return pulumi.get(self, "volume_in_gb")

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

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


