# 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
from ._inputs import *

__all__ = ['PodArgs', 'Pod']

@pulumi.input_type
class PodArgs:
    def __init__(__self__, *,
                 gpu_count: pulumi.Input[int],
                 gpu_type_id: pulumi.Input[str],
                 image_name: pulumi.Input[str],
                 ai_api_id: Optional[pulumi.Input[str]] = None,
                 cloud_type: Optional[pulumi.Input[str]] = None,
                 container_disk_in_gb: Optional[pulumi.Input[int]] = None,
                 country_code: Optional[pulumi.Input[str]] = None,
                 cuda_version: Optional[pulumi.Input[str]] = None,
                 data_center_id: Optional[pulumi.Input[str]] = None,
                 deploy_cost: Optional[pulumi.Input[float]] = None,
                 docker_args: Optional[pulumi.Input[str]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input['PodEnvArgs']]]] = None,
                 gpu_type_id_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 min_disk: Optional[pulumi.Input[int]] = None,
                 min_download: Optional[pulumi.Input[int]] = None,
                 min_memory_in_gb: Optional[pulumi.Input[int]] = None,
                 min_upload: Optional[pulumi.Input[int]] = None,
                 min_vcpu_count: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_volume_id: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 ports: Optional[pulumi.Input[str]] = None,
                 savings_plan: Optional[pulumi.Input['SavingsPlanInputArgs']] = None,
                 start_jupyter: Optional[pulumi.Input[bool]] = None,
                 start_ssh: Optional[pulumi.Input[bool]] = None,
                 stop_after: Optional[pulumi.Input[str]] = None,
                 support_public_ip: Optional[pulumi.Input[bool]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 terminate_after: Optional[pulumi.Input[str]] = None,
                 volume_in_gb: Optional[pulumi.Input[int]] = None,
                 volume_key: Optional[pulumi.Input[str]] = None,
                 volume_mount_path: Optional[pulumi.Input[str]] = None):
        """
        The set of arguments for constructing a Pod resource.
        """
        pulumi.set(__self__, "gpu_count", gpu_count)
        pulumi.set(__self__, "gpu_type_id", gpu_type_id)
        pulumi.set(__self__, "image_name", image_name)
        if ai_api_id is not None:
            pulumi.set(__self__, "ai_api_id", ai_api_id)
        if cloud_type is not None:
            pulumi.set(__self__, "cloud_type", cloud_type)
        if container_disk_in_gb is not None:
            pulumi.set(__self__, "container_disk_in_gb", container_disk_in_gb)
        if country_code is not None:
            pulumi.set(__self__, "country_code", country_code)
        if cuda_version is not None:
            pulumi.set(__self__, "cuda_version", cuda_version)
        if data_center_id is not None:
            pulumi.set(__self__, "data_center_id", data_center_id)
        if deploy_cost is not None:
            pulumi.set(__self__, "deploy_cost", deploy_cost)
        if docker_args is not None:
            pulumi.set(__self__, "docker_args", docker_args)
        if env is not None:
            pulumi.set(__self__, "env", env)
        if gpu_type_id_list is not None:
            pulumi.set(__self__, "gpu_type_id_list", gpu_type_id_list)
        if min_disk is not None:
            pulumi.set(__self__, "min_disk", min_disk)
        if min_download is not None:
            pulumi.set(__self__, "min_download", min_download)
        if min_memory_in_gb is not None:
            pulumi.set(__self__, "min_memory_in_gb", min_memory_in_gb)
        if min_upload is not None:
            pulumi.set(__self__, "min_upload", min_upload)
        if min_vcpu_count is not None:
            pulumi.set(__self__, "min_vcpu_count", min_vcpu_count)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if network_volume_id is not None:
            pulumi.set(__self__, "network_volume_id", network_volume_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if savings_plan is not None:
            pulumi.set(__self__, "savings_plan", savings_plan)
        if start_jupyter is not None:
            pulumi.set(__self__, "start_jupyter", start_jupyter)
        if start_ssh is not None:
            pulumi.set(__self__, "start_ssh", start_ssh)
        if stop_after is not None:
            pulumi.set(__self__, "stop_after", stop_after)
        if support_public_ip is not None:
            pulumi.set(__self__, "support_public_ip", support_public_ip)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)
        if terminate_after is not None:
            pulumi.set(__self__, "terminate_after", terminate_after)
        if volume_in_gb is not None:
            pulumi.set(__self__, "volume_in_gb", volume_in_gb)
        if volume_key is not None:
            pulumi.set(__self__, "volume_key", volume_key)
        if volume_mount_path is not None:
            pulumi.set(__self__, "volume_mount_path", volume_mount_path)

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

    @gpu_count.setter
    def gpu_count(self, value: pulumi.Input[int]):
        pulumi.set(self, "gpu_count", value)

    @property
    @pulumi.getter(name="gpuTypeId")
    def gpu_type_id(self) -> pulumi.Input[str]:
        return pulumi.get(self, "gpu_type_id")

    @gpu_type_id.setter
    def gpu_type_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "gpu_type_id", value)

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

    @image_name.setter
    def image_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "image_name", value)

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

    @ai_api_id.setter
    def ai_api_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ai_api_id", value)

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

    @cloud_type.setter
    def cloud_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cloud_type", value)

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

    @container_disk_in_gb.setter
    def container_disk_in_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "container_disk_in_gb", value)

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

    @country_code.setter
    def country_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "country_code", value)

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

    @cuda_version.setter
    def cuda_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cuda_version", value)

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

    @data_center_id.setter
    def data_center_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "data_center_id", value)

    @property
    @pulumi.getter(name="deployCost")
    def deploy_cost(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "deploy_cost")

    @deploy_cost.setter
    def deploy_cost(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "deploy_cost", value)

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

    @docker_args.setter
    def docker_args(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "docker_args", value)

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

    @env.setter
    def env(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PodEnvArgs']]]]):
        pulumi.set(self, "env", value)

    @property
    @pulumi.getter(name="gpuTypeIdList")
    def gpu_type_id_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "gpu_type_id_list")

    @gpu_type_id_list.setter
    def gpu_type_id_list(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "gpu_type_id_list", value)

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

    @min_disk.setter
    def min_disk(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_disk", value)

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

    @min_download.setter
    def min_download(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_download", value)

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

    @min_memory_in_gb.setter
    def min_memory_in_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_memory_in_gb", value)

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

    @min_upload.setter
    def min_upload(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_upload", value)

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

    @min_vcpu_count.setter
    def min_vcpu_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_vcpu_count", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

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

    @network_volume_id.setter
    def network_volume_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_volume_id", value)

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

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

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

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ports", value)

    @property
    @pulumi.getter(name="savingsPlan")
    def savings_plan(self) -> Optional[pulumi.Input['SavingsPlanInputArgs']]:
        return pulumi.get(self, "savings_plan")

    @savings_plan.setter
    def savings_plan(self, value: Optional[pulumi.Input['SavingsPlanInputArgs']]):
        pulumi.set(self, "savings_plan", value)

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

    @start_jupyter.setter
    def start_jupyter(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "start_jupyter", value)

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

    @start_ssh.setter
    def start_ssh(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "start_ssh", value)

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

    @stop_after.setter
    def stop_after(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stop_after", value)

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

    @support_public_ip.setter
    def support_public_ip(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "support_public_ip", value)

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

    @template_id.setter
    def template_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "template_id", value)

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

    @terminate_after.setter
    def terminate_after(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "terminate_after", value)

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

    @volume_in_gb.setter
    def volume_in_gb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "volume_in_gb", value)

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

    @volume_key.setter
    def volume_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_key", value)

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

    @volume_mount_path.setter
    def volume_mount_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "volume_mount_path", value)


class Pod(pulumi.CustomResource):
    @overload
    def __init__(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 ai_api_id: Optional[pulumi.Input[str]] = None,
                 cloud_type: Optional[pulumi.Input[str]] = None,
                 container_disk_in_gb: Optional[pulumi.Input[int]] = None,
                 country_code: Optional[pulumi.Input[str]] = None,
                 cuda_version: Optional[pulumi.Input[str]] = None,
                 data_center_id: Optional[pulumi.Input[str]] = None,
                 deploy_cost: Optional[pulumi.Input[float]] = None,
                 docker_args: Optional[pulumi.Input[str]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PodEnvArgs']]]]] = None,
                 gpu_count: Optional[pulumi.Input[int]] = None,
                 gpu_type_id: Optional[pulumi.Input[str]] = None,
                 gpu_type_id_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 min_disk: Optional[pulumi.Input[int]] = None,
                 min_download: Optional[pulumi.Input[int]] = None,
                 min_memory_in_gb: Optional[pulumi.Input[int]] = None,
                 min_upload: Optional[pulumi.Input[int]] = None,
                 min_vcpu_count: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_volume_id: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 ports: Optional[pulumi.Input[str]] = None,
                 savings_plan: Optional[pulumi.Input[pulumi.InputType['SavingsPlanInputArgs']]] = None,
                 start_jupyter: Optional[pulumi.Input[bool]] = None,
                 start_ssh: Optional[pulumi.Input[bool]] = None,
                 stop_after: Optional[pulumi.Input[str]] = None,
                 support_public_ip: Optional[pulumi.Input[bool]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 terminate_after: Optional[pulumi.Input[str]] = None,
                 volume_in_gb: Optional[pulumi.Input[int]] = None,
                 volume_key: Optional[pulumi.Input[str]] = None,
                 volume_mount_path: Optional[pulumi.Input[str]] = None,
                 __props__=None):
        """
        Create a Pod resource with the given unique name, props, and options.
        :param str resource_name: The name of the resource.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    @overload
    def __init__(__self__,
                 resource_name: str,
                 args: PodArgs,
                 opts: Optional[pulumi.ResourceOptions] = None):
        """
        Create a Pod resource with the given unique name, props, and options.
        :param str resource_name: The name of the resource.
        :param PodArgs args: The arguments to use to populate this resource's properties.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(PodArgs, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

    def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 ai_api_id: Optional[pulumi.Input[str]] = None,
                 cloud_type: Optional[pulumi.Input[str]] = None,
                 container_disk_in_gb: Optional[pulumi.Input[int]] = None,
                 country_code: Optional[pulumi.Input[str]] = None,
                 cuda_version: Optional[pulumi.Input[str]] = None,
                 data_center_id: Optional[pulumi.Input[str]] = None,
                 deploy_cost: Optional[pulumi.Input[float]] = None,
                 docker_args: Optional[pulumi.Input[str]] = None,
                 env: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PodEnvArgs']]]]] = None,
                 gpu_count: Optional[pulumi.Input[int]] = None,
                 gpu_type_id: Optional[pulumi.Input[str]] = None,
                 gpu_type_id_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 image_name: Optional[pulumi.Input[str]] = None,
                 min_disk: Optional[pulumi.Input[int]] = None,
                 min_download: Optional[pulumi.Input[int]] = None,
                 min_memory_in_gb: Optional[pulumi.Input[int]] = None,
                 min_upload: Optional[pulumi.Input[int]] = None,
                 min_vcpu_count: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 network_volume_id: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 ports: Optional[pulumi.Input[str]] = None,
                 savings_plan: Optional[pulumi.Input[pulumi.InputType['SavingsPlanInputArgs']]] = None,
                 start_jupyter: Optional[pulumi.Input[bool]] = None,
                 start_ssh: Optional[pulumi.Input[bool]] = None,
                 stop_after: Optional[pulumi.Input[str]] = None,
                 support_public_ip: Optional[pulumi.Input[bool]] = None,
                 template_id: Optional[pulumi.Input[str]] = None,
                 terminate_after: Optional[pulumi.Input[str]] = None,
                 volume_in_gb: Optional[pulumi.Input[int]] = None,
                 volume_key: Optional[pulumi.Input[str]] = None,
                 volume_mount_path: Optional[pulumi.Input[str]] = None,
                 __props__=None):
        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = PodArgs.__new__(PodArgs)

            __props__.__dict__["ai_api_id"] = ai_api_id
            __props__.__dict__["cloud_type"] = cloud_type
            __props__.__dict__["container_disk_in_gb"] = container_disk_in_gb
            __props__.__dict__["country_code"] = country_code
            __props__.__dict__["cuda_version"] = cuda_version
            __props__.__dict__["data_center_id"] = data_center_id
            __props__.__dict__["deploy_cost"] = deploy_cost
            __props__.__dict__["docker_args"] = docker_args
            __props__.__dict__["env"] = env
            if gpu_count is None and not opts.urn:
                raise TypeError("Missing required property 'gpu_count'")
            __props__.__dict__["gpu_count"] = gpu_count
            if gpu_type_id is None and not opts.urn:
                raise TypeError("Missing required property 'gpu_type_id'")
            __props__.__dict__["gpu_type_id"] = gpu_type_id
            __props__.__dict__["gpu_type_id_list"] = gpu_type_id_list
            if image_name is None and not opts.urn:
                raise TypeError("Missing required property 'image_name'")
            __props__.__dict__["image_name"] = image_name
            __props__.__dict__["min_disk"] = min_disk
            __props__.__dict__["min_download"] = min_download
            __props__.__dict__["min_memory_in_gb"] = min_memory_in_gb
            __props__.__dict__["min_upload"] = min_upload
            __props__.__dict__["min_vcpu_count"] = min_vcpu_count
            __props__.__dict__["name"] = name
            __props__.__dict__["network_volume_id"] = network_volume_id
            __props__.__dict__["port"] = port
            __props__.__dict__["ports"] = ports
            __props__.__dict__["savings_plan"] = savings_plan
            __props__.__dict__["start_jupyter"] = start_jupyter
            __props__.__dict__["start_ssh"] = start_ssh
            __props__.__dict__["stop_after"] = stop_after
            __props__.__dict__["support_public_ip"] = support_public_ip
            __props__.__dict__["template_id"] = template_id
            __props__.__dict__["terminate_after"] = terminate_after
            __props__.__dict__["volume_in_gb"] = volume_in_gb
            __props__.__dict__["volume_key"] = volume_key
            __props__.__dict__["volume_mount_path"] = volume_mount_path
            __props__.__dict__["pod"] = None
        super(Pod, __self__).__init__(
            'runpod:index:Pod',
            resource_name,
            __props__,
            opts)

    @staticmethod
    def get(resource_name: str,
            id: pulumi.Input[str],
            opts: Optional[pulumi.ResourceOptions] = None) -> 'Pod':
        """
        Get an existing Pod resource's state with the given name, id, and optional extra
        properties used to qualify the lookup.

        :param str resource_name: The unique name of the resulting resource.
        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = PodArgs.__new__(PodArgs)

        __props__.__dict__["ai_api_id"] = None
        __props__.__dict__["cloud_type"] = None
        __props__.__dict__["container_disk_in_gb"] = None
        __props__.__dict__["country_code"] = None
        __props__.__dict__["cuda_version"] = None
        __props__.__dict__["data_center_id"] = None
        __props__.__dict__["deploy_cost"] = None
        __props__.__dict__["docker_args"] = None
        __props__.__dict__["env"] = None
        __props__.__dict__["gpu_count"] = None
        __props__.__dict__["gpu_type_id"] = None
        __props__.__dict__["gpu_type_id_list"] = None
        __props__.__dict__["image_name"] = None
        __props__.__dict__["min_disk"] = None
        __props__.__dict__["min_download"] = None
        __props__.__dict__["min_memory_in_gb"] = None
        __props__.__dict__["min_upload"] = None
        __props__.__dict__["min_vcpu_count"] = None
        __props__.__dict__["name"] = None
        __props__.__dict__["network_volume_id"] = None
        __props__.__dict__["pod"] = None
        __props__.__dict__["port"] = None
        __props__.__dict__["ports"] = None
        __props__.__dict__["savings_plan"] = None
        __props__.__dict__["start_jupyter"] = None
        __props__.__dict__["start_ssh"] = None
        __props__.__dict__["stop_after"] = None
        __props__.__dict__["support_public_ip"] = None
        __props__.__dict__["template_id"] = None
        __props__.__dict__["terminate_after"] = None
        __props__.__dict__["volume_in_gb"] = None
        __props__.__dict__["volume_key"] = None
        __props__.__dict__["volume_mount_path"] = None
        return Pod(resource_name, opts=opts, __props__=__props__)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="deployCost")
    def deploy_cost(self) -> pulumi.Output[Optional[float]]:
        return pulumi.get(self, "deploy_cost")

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

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

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

    @property
    @pulumi.getter(name="gpuTypeId")
    def gpu_type_id(self) -> pulumi.Output[str]:
        return pulumi.get(self, "gpu_type_id")

    @property
    @pulumi.getter(name="gpuTypeIdList")
    def gpu_type_id_list(self) -> pulumi.Output[Optional[Sequence[str]]]:
        return pulumi.get(self, "gpu_type_id_list")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def pod(self) -> pulumi.Output['outputs.Pod']:
        return pulumi.get(self, "pod")

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

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

    @property
    @pulumi.getter(name="savingsPlan")
    def savings_plan(self) -> pulumi.Output[Optional['outputs.SavingsPlanInput']]:
        return pulumi.get(self, "savings_plan")

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

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

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

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

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

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

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

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

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

