# 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__ = [
    'ApplicationBuiltInEnvironmentVariable',
    'ApplicationCustomDomain',
    'ApplicationEnvironmentVariable',
    'ApplicationEnvironmentVariableAlias',
    'ApplicationEnvironmentVariableOverride',
    'ApplicationGitRepository',
    'ApplicationHealthchecks',
    'ApplicationHealthchecksLivenessProbe',
    'ApplicationHealthchecksLivenessProbeType',
    'ApplicationHealthchecksLivenessProbeTypeExec',
    'ApplicationHealthchecksLivenessProbeTypeGrpc',
    'ApplicationHealthchecksLivenessProbeTypeHttp',
    'ApplicationHealthchecksLivenessProbeTypeTcp',
    'ApplicationHealthchecksReadinessProbe',
    'ApplicationHealthchecksReadinessProbeType',
    'ApplicationHealthchecksReadinessProbeTypeExec',
    'ApplicationHealthchecksReadinessProbeTypeGrpc',
    'ApplicationHealthchecksReadinessProbeTypeHttp',
    'ApplicationHealthchecksReadinessProbeTypeTcp',
    'ApplicationPort',
    'ApplicationSecret',
    'ApplicationSecretAlias',
    'ApplicationSecretOverride',
    'ApplicationStorage',
    'ClusterFeatures',
    'ClusterRoutingTable',
    'ContainerBuiltInEnvironmentVariable',
    'ContainerCustomDomain',
    'ContainerEnvironmentVariable',
    'ContainerEnvironmentVariableAlias',
    'ContainerEnvironmentVariableOverride',
    'ContainerHealthchecks',
    'ContainerHealthchecksLivenessProbe',
    'ContainerHealthchecksLivenessProbeType',
    'ContainerHealthchecksLivenessProbeTypeExec',
    'ContainerHealthchecksLivenessProbeTypeGrpc',
    'ContainerHealthchecksLivenessProbeTypeHttp',
    'ContainerHealthchecksLivenessProbeTypeTcp',
    'ContainerHealthchecksReadinessProbe',
    'ContainerHealthchecksReadinessProbeType',
    'ContainerHealthchecksReadinessProbeTypeExec',
    'ContainerHealthchecksReadinessProbeTypeGrpc',
    'ContainerHealthchecksReadinessProbeTypeHttp',
    'ContainerHealthchecksReadinessProbeTypeTcp',
    'ContainerPort',
    'ContainerRegistryConfig',
    'ContainerSecret',
    'ContainerSecretAlias',
    'ContainerSecretOverride',
    'ContainerStorage',
    'EnvironmentBuiltInEnvironmentVariable',
    'EnvironmentEnvironmentVariable',
    'EnvironmentEnvironmentVariableAlias',
    'EnvironmentEnvironmentVariableOverride',
    'EnvironmentSecret',
    'EnvironmentSecretAlias',
    'EnvironmentSecretOverride',
    'JobBuiltInEnvironmentVariable',
    'JobEnvironmentVariable',
    'JobEnvironmentVariableAlias',
    'JobEnvironmentVariableOverride',
    'JobHealthchecks',
    'JobHealthchecksLivenessProbe',
    'JobHealthchecksLivenessProbeType',
    'JobHealthchecksLivenessProbeTypeExec',
    'JobHealthchecksLivenessProbeTypeGrpc',
    'JobHealthchecksLivenessProbeTypeHttp',
    'JobHealthchecksLivenessProbeTypeTcp',
    'JobHealthchecksReadinessProbe',
    'JobHealthchecksReadinessProbeType',
    'JobHealthchecksReadinessProbeTypeExec',
    'JobHealthchecksReadinessProbeTypeGrpc',
    'JobHealthchecksReadinessProbeTypeHttp',
    'JobHealthchecksReadinessProbeTypeTcp',
    'JobSchedule',
    'JobScheduleCronjob',
    'JobScheduleCronjobCommand',
    'JobScheduleOnDelete',
    'JobScheduleOnStart',
    'JobScheduleOnStop',
    'JobSecret',
    'JobSecretAlias',
    'JobSecretOverride',
    'JobSource',
    'JobSourceDocker',
    'JobSourceDockerGitRepository',
    'JobSourceImage',
    'ProjectBuiltInEnvironmentVariable',
    'ProjectEnvironmentVariable',
    'ProjectEnvironmentVariableAlias',
    'ProjectSecret',
    'ProjectSecretAlias',
    'GetApplicationBuiltInEnvironmentVariableResult',
    'GetApplicationCustomDomainResult',
    'GetApplicationEnvironmentVariableResult',
    'GetApplicationEnvironmentVariableAliasResult',
    'GetApplicationEnvironmentVariableOverrideResult',
    'GetApplicationGitRepositoryResult',
    'GetApplicationHealthchecksResult',
    'GetApplicationHealthchecksLivenessProbeResult',
    'GetApplicationHealthchecksLivenessProbeTypeResult',
    'GetApplicationHealthchecksLivenessProbeTypeExecResult',
    'GetApplicationHealthchecksLivenessProbeTypeGrpcResult',
    'GetApplicationHealthchecksLivenessProbeTypeHttpResult',
    'GetApplicationHealthchecksLivenessProbeTypeTcpResult',
    'GetApplicationHealthchecksReadinessProbeResult',
    'GetApplicationHealthchecksReadinessProbeTypeResult',
    'GetApplicationHealthchecksReadinessProbeTypeExecResult',
    'GetApplicationHealthchecksReadinessProbeTypeGrpcResult',
    'GetApplicationHealthchecksReadinessProbeTypeHttpResult',
    'GetApplicationHealthchecksReadinessProbeTypeTcpResult',
    'GetApplicationPortResult',
    'GetApplicationSecretResult',
    'GetApplicationSecretAliasResult',
    'GetApplicationSecretOverrideResult',
    'GetApplicationStorageResult',
    'GetClusterFeatureResult',
    'GetClusterRoutingTableResult',
    'GetContainerBuiltInEnvironmentVariableResult',
    'GetContainerCustomDomainResult',
    'GetContainerEnvironmentVariableResult',
    'GetContainerEnvironmentVariableAliasResult',
    'GetContainerEnvironmentVariableOverrideResult',
    'GetContainerHealthchecksResult',
    'GetContainerHealthchecksLivenessProbeResult',
    'GetContainerHealthchecksLivenessProbeTypeResult',
    'GetContainerHealthchecksLivenessProbeTypeExecResult',
    'GetContainerHealthchecksLivenessProbeTypeGrpcResult',
    'GetContainerHealthchecksLivenessProbeTypeHttpResult',
    'GetContainerHealthchecksLivenessProbeTypeTcpResult',
    'GetContainerHealthchecksReadinessProbeResult',
    'GetContainerHealthchecksReadinessProbeTypeResult',
    'GetContainerHealthchecksReadinessProbeTypeExecResult',
    'GetContainerHealthchecksReadinessProbeTypeGrpcResult',
    'GetContainerHealthchecksReadinessProbeTypeHttpResult',
    'GetContainerHealthchecksReadinessProbeTypeTcpResult',
    'GetContainerPortResult',
    'GetContainerSecretResult',
    'GetContainerSecretAliasResult',
    'GetContainerSecretOverrideResult',
    'GetContainerStorageResult',
    'GetEnvironmentBuiltInEnvironmentVariableResult',
    'GetEnvironmentEnvironmentVariableResult',
    'GetEnvironmentEnvironmentVariableAliasResult',
    'GetEnvironmentEnvironmentVariableOverrideResult',
    'GetEnvironmentSecretResult',
    'GetEnvironmentSecretAliasResult',
    'GetEnvironmentSecretOverrideResult',
    'GetJobBuiltInEnvironmentVariableResult',
    'GetJobEnvironmentVariableResult',
    'GetJobEnvironmentVariableAliasResult',
    'GetJobEnvironmentVariableOverrideResult',
    'GetJobHealthchecksResult',
    'GetJobHealthchecksLivenessProbeResult',
    'GetJobHealthchecksLivenessProbeTypeResult',
    'GetJobHealthchecksLivenessProbeTypeExecResult',
    'GetJobHealthchecksLivenessProbeTypeGrpcResult',
    'GetJobHealthchecksLivenessProbeTypeHttpResult',
    'GetJobHealthchecksLivenessProbeTypeTcpResult',
    'GetJobHealthchecksReadinessProbeResult',
    'GetJobHealthchecksReadinessProbeTypeResult',
    'GetJobHealthchecksReadinessProbeTypeExecResult',
    'GetJobHealthchecksReadinessProbeTypeGrpcResult',
    'GetJobHealthchecksReadinessProbeTypeHttpResult',
    'GetJobHealthchecksReadinessProbeTypeTcpResult',
    'GetJobScheduleResult',
    'GetJobScheduleCronjobResult',
    'GetJobScheduleCronjobCommandResult',
    'GetJobScheduleOnDeleteResult',
    'GetJobScheduleOnStartResult',
    'GetJobScheduleOnStopResult',
    'GetJobSecretResult',
    'GetJobSecretAliasResult',
    'GetJobSecretOverrideResult',
    'GetJobSourceResult',
    'GetJobSourceDockerResult',
    'GetJobSourceDockerGitRepositoryResult',
    'GetJobSourceImageResult',
    'GetProjectBuiltInEnvironmentVariableResult',
    'GetProjectEnvironmentVariableResult',
    'GetProjectEnvironmentVariableAliasResult',
    'GetProjectSecretResult',
    'GetProjectSecretAliasResult',
]

@pulumi.output_type
class ApplicationBuiltInEnvironmentVariable(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class ApplicationCustomDomain(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "validationDomain":
            suggest = "validation_domain"

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

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

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

    def __init__(__self__, *,
                 domain: str,
                 id: Optional[str] = None,
                 status: Optional[str] = None,
                 validation_domain: Optional[str] = None):
        pulumi.set(__self__, "domain", domain)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if validation_domain is not None:
            pulumi.set(__self__, "validation_domain", validation_domain)

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

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

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

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


@pulumi.output_type
class ApplicationEnvironmentVariable(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationEnvironmentVariableAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationGitRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gitTokenId":
            suggest = "git_token_id"
        elif key == "rootPath":
            suggest = "root_path"

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

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

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

    def __init__(__self__, *,
                 url: str,
                 branch: Optional[str] = None,
                 git_token_id: Optional[str] = None,
                 root_path: Optional[str] = None):
        pulumi.set(__self__, "url", url)
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if git_token_id is not None:
            pulumi.set(__self__, "git_token_id", git_token_id)
        if root_path is not None:
            pulumi.set(__self__, "root_path", root_path)

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

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

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

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


@pulumi.output_type
class ApplicationHealthchecks(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "livenessProbe":
            suggest = "liveness_probe"
        elif key == "readinessProbe":
            suggest = "readiness_probe"

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

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

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

    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.ApplicationHealthchecksLivenessProbe'] = None,
                 readiness_probe: Optional['outputs.ApplicationHealthchecksReadinessProbe'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.ApplicationHealthchecksLivenessProbe']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbe']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class ApplicationHealthchecksLivenessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.ApplicationHealthchecksLivenessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.ApplicationHealthchecksLivenessProbeTypeExec'] = None,
                 grpc: Optional['outputs.ApplicationHealthchecksLivenessProbeTypeGrpc'] = None,
                 http: Optional['outputs.ApplicationHealthchecksLivenessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.ApplicationHealthchecksLivenessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.ApplicationHealthchecksLivenessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.ApplicationHealthchecksReadinessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.ApplicationHealthchecksReadinessProbeTypeExec'] = None,
                 grpc: Optional['outputs.ApplicationHealthchecksReadinessProbeTypeGrpc'] = None,
                 http: Optional['outputs.ApplicationHealthchecksReadinessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.ApplicationHealthchecksReadinessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class ApplicationPort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "internalPort":
            suggest = "internal_port"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "publiclyAccessible":
            suggest = "publicly_accessible"
        elif key == "externalPort":
            suggest = "external_port"

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

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

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

    def __init__(__self__, *,
                 internal_port: int,
                 is_default: bool,
                 publicly_accessible: bool,
                 external_port: Optional[int] = None,
                 id: Optional[str] = None,
                 name: Optional[str] = None,
                 protocol: Optional[str] = None):
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "publicly_accessible", publicly_accessible)
        if external_port is not None:
            pulumi.set(__self__, "external_port", external_port)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

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

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

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

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

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

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

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


@pulumi.output_type
class ApplicationSecret(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationSecretAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ApplicationStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPoint":
            suggest = "mount_point"

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

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

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

    def __init__(__self__, *,
                 mount_point: str,
                 size: int,
                 type: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "mount_point", mount_point)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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

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


@pulumi.output_type
class ClusterFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "staticIp":
            suggest = "static_ip"
        elif key == "vpcSubnet":
            suggest = "vpc_subnet"

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

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

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

    def __init__(__self__, *,
                 static_ip: Optional[bool] = None,
                 vpc_subnet: Optional[str] = None):
        if static_ip is not None:
            pulumi.set(__self__, "static_ip", static_ip)
        if vpc_subnet is not None:
            pulumi.set(__self__, "vpc_subnet", vpc_subnet)

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

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


@pulumi.output_type
class ClusterRoutingTable(dict):
    def __init__(__self__, *,
                 description: str,
                 destination: str,
                 target: str):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "target", target)

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

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

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


@pulumi.output_type
class ContainerBuiltInEnvironmentVariable(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class ContainerCustomDomain(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "validationDomain":
            suggest = "validation_domain"

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

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

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

    def __init__(__self__, *,
                 domain: str,
                 id: Optional[str] = None,
                 status: Optional[str] = None,
                 validation_domain: Optional[str] = None):
        pulumi.set(__self__, "domain", domain)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if validation_domain is not None:
            pulumi.set(__self__, "validation_domain", validation_domain)

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

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

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

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


@pulumi.output_type
class ContainerEnvironmentVariable(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerEnvironmentVariableAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerHealthchecks(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "livenessProbe":
            suggest = "liveness_probe"
        elif key == "readinessProbe":
            suggest = "readiness_probe"

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

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

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

    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.ContainerHealthchecksLivenessProbe'] = None,
                 readiness_probe: Optional['outputs.ContainerHealthchecksReadinessProbe'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.ContainerHealthchecksLivenessProbe']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.ContainerHealthchecksReadinessProbe']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class ContainerHealthchecksLivenessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.ContainerHealthchecksLivenessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class ContainerHealthchecksLivenessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.ContainerHealthchecksLivenessProbeTypeExec'] = None,
                 grpc: Optional['outputs.ContainerHealthchecksLivenessProbeTypeGrpc'] = None,
                 http: Optional['outputs.ContainerHealthchecksLivenessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.ContainerHealthchecksLivenessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.ContainerHealthchecksLivenessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.ContainerHealthchecksReadinessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.ContainerHealthchecksReadinessProbeTypeExec'] = None,
                 grpc: Optional['outputs.ContainerHealthchecksReadinessProbeTypeGrpc'] = None,
                 http: Optional['outputs.ContainerHealthchecksReadinessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.ContainerHealthchecksReadinessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.ContainerHealthchecksReadinessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class ContainerPort(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "internalPort":
            suggest = "internal_port"
        elif key == "isDefault":
            suggest = "is_default"
        elif key == "publiclyAccessible":
            suggest = "publicly_accessible"
        elif key == "externalPort":
            suggest = "external_port"

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

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

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

    def __init__(__self__, *,
                 internal_port: int,
                 is_default: bool,
                 publicly_accessible: bool,
                 external_port: Optional[int] = None,
                 id: Optional[str] = None,
                 name: Optional[str] = None,
                 protocol: Optional[str] = None):
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "publicly_accessible", publicly_accessible)
        if external_port is not None:
            pulumi.set(__self__, "external_port", external_port)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

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

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

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

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

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

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

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


@pulumi.output_type
class ContainerRegistryConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKeyId":
            suggest = "access_key_id"
        elif key == "scalewayAccessKey":
            suggest = "scaleway_access_key"
        elif key == "scalewaySecretKey":
            suggest = "scaleway_secret_key"
        elif key == "secretAccessKey":
            suggest = "secret_access_key"

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

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

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

    def __init__(__self__, *,
                 access_key_id: Optional[str] = None,
                 password: Optional[str] = None,
                 region: Optional[str] = None,
                 scaleway_access_key: Optional[str] = None,
                 scaleway_secret_key: Optional[str] = None,
                 secret_access_key: Optional[str] = None,
                 username: Optional[str] = None):
        if access_key_id is not None:
            pulumi.set(__self__, "access_key_id", access_key_id)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if scaleway_access_key is not None:
            pulumi.set(__self__, "scaleway_access_key", scaleway_access_key)
        if scaleway_secret_key is not None:
            pulumi.set(__self__, "scaleway_secret_key", scaleway_secret_key)
        if secret_access_key is not None:
            pulumi.set(__self__, "secret_access_key", secret_access_key)
        if username is not None:
            pulumi.set(__self__, "username", username)

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

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

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

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

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

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

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


@pulumi.output_type
class ContainerSecret(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerSecretAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class ContainerStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPoint":
            suggest = "mount_point"

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

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

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

    def __init__(__self__, *,
                 mount_point: str,
                 size: int,
                 type: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "mount_point", mount_point)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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

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


@pulumi.output_type
class EnvironmentBuiltInEnvironmentVariable(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class EnvironmentEnvironmentVariable(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class EnvironmentEnvironmentVariableAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class EnvironmentEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class EnvironmentSecret(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class EnvironmentSecretAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class EnvironmentSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobBuiltInEnvironmentVariable(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class JobEnvironmentVariable(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobEnvironmentVariableAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobHealthchecks(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "livenessProbe":
            suggest = "liveness_probe"
        elif key == "readinessProbe":
            suggest = "readiness_probe"

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

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

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

    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.JobHealthchecksLivenessProbe'] = None,
                 readiness_probe: Optional['outputs.JobHealthchecksReadinessProbe'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.JobHealthchecksLivenessProbe']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.JobHealthchecksReadinessProbe']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class JobHealthchecksLivenessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.JobHealthchecksLivenessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class JobHealthchecksLivenessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.JobHealthchecksLivenessProbeTypeExec'] = None,
                 grpc: Optional['outputs.JobHealthchecksLivenessProbeTypeGrpc'] = None,
                 http: Optional['outputs.JobHealthchecksLivenessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.JobHealthchecksLivenessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.JobHealthchecksLivenessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class JobHealthchecksReadinessProbe(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.JobHealthchecksReadinessProbeType'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class JobHealthchecksReadinessProbeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "exec":
            suggest = "exec_"

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

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

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

    def __init__(__self__, *,
                 exec_: Optional['outputs.JobHealthchecksReadinessProbeTypeExec'] = None,
                 grpc: Optional['outputs.JobHealthchecksReadinessProbeTypeGrpc'] = None,
                 http: Optional['outputs.JobHealthchecksReadinessProbeTypeHttp'] = None,
                 tcp: Optional['outputs.JobHealthchecksReadinessProbeTypeTcp'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.JobHealthchecksReadinessProbeTypeExec']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 path: Optional[str] = None,
                 scheme: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

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

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


@pulumi.output_type
class JobSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onDelete":
            suggest = "on_delete"
        elif key == "onStart":
            suggest = "on_start"
        elif key == "onStop":
            suggest = "on_stop"

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

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

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

    def __init__(__self__, *,
                 cronjob: Optional['outputs.JobScheduleCronjob'] = None,
                 on_delete: Optional['outputs.JobScheduleOnDelete'] = None,
                 on_start: Optional['outputs.JobScheduleOnStart'] = None,
                 on_stop: Optional['outputs.JobScheduleOnStop'] = None):
        if cronjob is not None:
            pulumi.set(__self__, "cronjob", cronjob)
        if on_delete is not None:
            pulumi.set(__self__, "on_delete", on_delete)
        if on_start is not None:
            pulumi.set(__self__, "on_start", on_start)
        if on_stop is not None:
            pulumi.set(__self__, "on_stop", on_stop)

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

    @property
    @pulumi.getter(name="onDelete")
    def on_delete(self) -> Optional['outputs.JobScheduleOnDelete']:
        return pulumi.get(self, "on_delete")

    @property
    @pulumi.getter(name="onStart")
    def on_start(self) -> Optional['outputs.JobScheduleOnStart']:
        return pulumi.get(self, "on_start")

    @property
    @pulumi.getter(name="onStop")
    def on_stop(self) -> Optional['outputs.JobScheduleOnStop']:
        return pulumi.get(self, "on_stop")


@pulumi.output_type
class JobScheduleCronjob(dict):
    def __init__(__self__, *,
                 command: 'outputs.JobScheduleCronjobCommand',
                 schedule: str):
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "schedule", schedule)

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

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


@pulumi.output_type
class JobScheduleCronjobCommand(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)
        if entrypoint is not None:
            pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class JobScheduleOnDelete(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)
        if entrypoint is not None:
            pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class JobScheduleOnStart(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)
        if entrypoint is not None:
            pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class JobScheduleOnStop(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)
        if entrypoint is not None:
            pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class JobSecret(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobSecretAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

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


@pulumi.output_type
class JobSource(dict):
    def __init__(__self__, *,
                 docker: Optional['outputs.JobSourceDocker'] = None,
                 image: Optional['outputs.JobSourceImage'] = None):
        if docker is not None:
            pulumi.set(__self__, "docker", docker)
        if image is not None:
            pulumi.set(__self__, "image", image)

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

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


@pulumi.output_type
class JobSourceDocker(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gitRepository":
            suggest = "git_repository"
        elif key == "dockerfilePath":
            suggest = "dockerfile_path"

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

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

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

    def __init__(__self__, *,
                 git_repository: 'outputs.JobSourceDockerGitRepository',
                 dockerfile_path: Optional[str] = None):
        pulumi.set(__self__, "git_repository", git_repository)
        if dockerfile_path is not None:
            pulumi.set(__self__, "dockerfile_path", dockerfile_path)

    @property
    @pulumi.getter(name="gitRepository")
    def git_repository(self) -> 'outputs.JobSourceDockerGitRepository':
        return pulumi.get(self, "git_repository")

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


@pulumi.output_type
class JobSourceDockerGitRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gitTokenId":
            suggest = "git_token_id"
        elif key == "rootPath":
            suggest = "root_path"

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

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

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

    def __init__(__self__, *,
                 branch: str,
                 url: str,
                 git_token_id: Optional[str] = None,
                 root_path: Optional[str] = None):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "url", url)
        if git_token_id is not None:
            pulumi.set(__self__, "git_token_id", git_token_id)
        if root_path is not None:
            pulumi.set(__self__, "root_path", root_path)

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

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

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

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


@pulumi.output_type
class JobSourceImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "registryId":
            suggest = "registry_id"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 registry_id: str,
                 tag: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "registry_id", registry_id)
        pulumi.set(__self__, "tag", tag)

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

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

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


@pulumi.output_type
class ProjectBuiltInEnvironmentVariable(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None,
                 key: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str id: Id of the environment variable.
        :param str key: Key of the environment variable.
        :param str value: Value of the environment variable.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        Key of the environment variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        """
        Value of the environment variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class ProjectEnvironmentVariable(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Key of the environment variable.
        :param str value: Value of the environment variable.
        :param str id: Id of the environment variable.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Key of the environment variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ProjectEnvironmentVariableAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable alias.
        :param str value: Name of the variable to alias.
        :param str id: Id of the environment variable alias.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Name of the environment variable alias.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Name of the variable to alias.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable alias.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ProjectSecret(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Key of the secret.
        :param str value: Value of the secret.
        :param str id: Id of the secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

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

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the secret.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ProjectSecretAlias(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret alias.
        :param str value: Name of the secret to alias.
        :param str id: Id of the secret alias.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Name of the secret alias.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Name of the secret to alias.
        """
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the secret alias.
        """
        return pulumi.get(self, "id")


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

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

    @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 GetApplicationCustomDomainResult(dict):
    def __init__(__self__, *,
                 domain: str,
                 id: str,
                 status: str,
                 validation_domain: str):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "validation_domain", validation_domain)

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

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

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

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


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

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

    @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 GetApplicationEnvironmentVariableAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetApplicationEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetApplicationGitRepositoryResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 git_token_id: str,
                 root_path: str,
                 url: str):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "git_token_id", git_token_id)
        pulumi.set(__self__, "root_path", root_path)
        pulumi.set(__self__, "url", url)

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

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksResult(dict):
    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.GetApplicationHealthchecksLivenessProbeResult'] = None,
                 readiness_probe: Optional['outputs.GetApplicationHealthchecksReadinessProbeResult'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.GetApplicationHealthchecksLivenessProbeResult']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeResult']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetApplicationHealthchecksLivenessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetApplicationHealthchecksReadinessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetApplicationPortResult(dict):
    def __init__(__self__, *,
                 external_port: int,
                 id: str,
                 internal_port: int,
                 is_default: bool,
                 name: str,
                 protocol: str,
                 publicly_accessible: bool):
        pulumi.set(__self__, "external_port", external_port)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "publicly_accessible", publicly_accessible)

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

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

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

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

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

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

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


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

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

    @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 GetApplicationSecretAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetApplicationSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetApplicationStorageResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mount_point: str,
                 size: int,
                 type: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mount_point", mount_point)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

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

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

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

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


@pulumi.output_type
class GetClusterFeatureResult(dict):
    def __init__(__self__, *,
                 static_ip: bool,
                 vpc_subnet: str):
        pulumi.set(__self__, "static_ip", static_ip)
        pulumi.set(__self__, "vpc_subnet", vpc_subnet)

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

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


@pulumi.output_type
class GetClusterRoutingTableResult(dict):
    def __init__(__self__, *,
                 description: str,
                 destination: str,
                 target: str):
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "target", target)

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

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

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


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

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

    @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 GetContainerCustomDomainResult(dict):
    def __init__(__self__, *,
                 domain: str,
                 id: str,
                 status: str,
                 validation_domain: str):
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "validation_domain", validation_domain)

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

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

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

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


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

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

    @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 GetContainerEnvironmentVariableAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetContainerEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetContainerHealthchecksResult(dict):
    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.GetContainerHealthchecksLivenessProbeResult'] = None,
                 readiness_probe: Optional['outputs.GetContainerHealthchecksReadinessProbeResult'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.GetContainerHealthchecksLivenessProbeResult']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeResult']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetContainerHealthchecksLivenessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetContainerHealthchecksLivenessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetContainerHealthchecksLivenessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetContainerHealthchecksLivenessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetContainerHealthchecksLivenessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetContainerHealthchecksLivenessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetContainerHealthchecksReadinessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetContainerHealthchecksReadinessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetContainerHealthchecksReadinessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetContainerHealthchecksReadinessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetContainerHealthchecksReadinessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetContainerPortResult(dict):
    def __init__(__self__, *,
                 external_port: int,
                 id: str,
                 internal_port: int,
                 is_default: bool,
                 name: str,
                 protocol: str,
                 publicly_accessible: bool):
        pulumi.set(__self__, "external_port", external_port)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "publicly_accessible", publicly_accessible)

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

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

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

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

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

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

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


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

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

    @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 GetContainerSecretAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetContainerSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetContainerStorageResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mount_point: str,
                 size: int,
                 type: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mount_point", mount_point)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

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

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

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

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


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

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

    @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 GetEnvironmentEnvironmentVariableResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetEnvironmentEnvironmentVariableAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetEnvironmentEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetEnvironmentSecretResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetEnvironmentSecretAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetEnvironmentSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobBuiltInEnvironmentVariableResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobEnvironmentVariableResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobEnvironmentVariableAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobHealthchecksResult(dict):
    def __init__(__self__, *,
                 liveness_probe: Optional['outputs.GetJobHealthchecksLivenessProbeResult'] = None,
                 readiness_probe: Optional['outputs.GetJobHealthchecksReadinessProbeResult'] = None):
        if liveness_probe is not None:
            pulumi.set(__self__, "liveness_probe", liveness_probe)
        if readiness_probe is not None:
            pulumi.set(__self__, "readiness_probe", readiness_probe)

    @property
    @pulumi.getter(name="livenessProbe")
    def liveness_probe(self) -> Optional['outputs.GetJobHealthchecksLivenessProbeResult']:
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeResult']:
        return pulumi.get(self, "readiness_probe")


@pulumi.output_type
class GetJobHealthchecksLivenessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetJobHealthchecksLivenessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetJobHealthchecksLivenessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetJobHealthchecksLivenessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetJobHealthchecksLivenessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetJobHealthchecksLivenessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetJobHealthchecksLivenessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeResult(dict):
    def __init__(__self__, *,
                 failure_threshold: int,
                 initial_delay_seconds: int,
                 period_seconds: int,
                 success_threshold: int,
                 timeout_seconds: int,
                 type: 'outputs.GetJobHealthchecksReadinessProbeTypeResult'):
        pulumi.set(__self__, "failure_threshold", failure_threshold)
        pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        pulumi.set(__self__, "period_seconds", period_seconds)
        pulumi.set(__self__, "success_threshold", success_threshold)
        pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        pulumi.set(__self__, "type", type)

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

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

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

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

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

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeResult(dict):
    def __init__(__self__, *,
                 exec_: Optional['outputs.GetJobHealthchecksReadinessProbeTypeExecResult'] = None,
                 grpc: Optional['outputs.GetJobHealthchecksReadinessProbeTypeGrpcResult'] = None,
                 http: Optional['outputs.GetJobHealthchecksReadinessProbeTypeHttpResult'] = None,
                 tcp: Optional['outputs.GetJobHealthchecksReadinessProbeTypeTcpResult'] = None):
        if exec_ is not None:
            pulumi.set(__self__, "exec_", exec_)
        if grpc is not None:
            pulumi.set(__self__, "grpc", grpc)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if tcp is not None:
            pulumi.set(__self__, "tcp", tcp)

    @property
    @pulumi.getter(name="exec")
    def exec_(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeTypeExecResult']:
        return pulumi.get(self, "exec_")

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

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

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        pulumi.set(__self__, "commands", commands)

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

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

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 path: str,
                 port: int,
                 scheme: str):
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)

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

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

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


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 host: str,
                 port: int):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

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

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


@pulumi.output_type
class GetJobScheduleResult(dict):
    def __init__(__self__, *,
                 cronjob: 'outputs.GetJobScheduleCronjobResult',
                 on_delete: 'outputs.GetJobScheduleOnDeleteResult',
                 on_start: 'outputs.GetJobScheduleOnStartResult',
                 on_stop: 'outputs.GetJobScheduleOnStopResult'):
        pulumi.set(__self__, "cronjob", cronjob)
        pulumi.set(__self__, "on_delete", on_delete)
        pulumi.set(__self__, "on_start", on_start)
        pulumi.set(__self__, "on_stop", on_stop)

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

    @property
    @pulumi.getter(name="onDelete")
    def on_delete(self) -> 'outputs.GetJobScheduleOnDeleteResult':
        return pulumi.get(self, "on_delete")

    @property
    @pulumi.getter(name="onStart")
    def on_start(self) -> 'outputs.GetJobScheduleOnStartResult':
        return pulumi.get(self, "on_start")

    @property
    @pulumi.getter(name="onStop")
    def on_stop(self) -> 'outputs.GetJobScheduleOnStopResult':
        return pulumi.get(self, "on_stop")


@pulumi.output_type
class GetJobScheduleCronjobResult(dict):
    def __init__(__self__, *,
                 command: 'outputs.GetJobScheduleCronjobCommandResult',
                 schedule: str):
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "schedule", schedule)

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

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


@pulumi.output_type
class GetJobScheduleCronjobCommandResult(dict):
    def __init__(__self__, *,
                 arguments: Sequence[str],
                 entrypoint: str):
        pulumi.set(__self__, "arguments", arguments)
        pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class GetJobScheduleOnDeleteResult(dict):
    def __init__(__self__, *,
                 arguments: Sequence[str],
                 entrypoint: str):
        pulumi.set(__self__, "arguments", arguments)
        pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class GetJobScheduleOnStartResult(dict):
    def __init__(__self__, *,
                 entrypoint: str,
                 arguments: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "entrypoint", entrypoint)
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)

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

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


@pulumi.output_type
class GetJobScheduleOnStopResult(dict):
    def __init__(__self__, *,
                 entrypoint: str,
                 arguments: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "entrypoint", entrypoint)
        if arguments is not None:
            pulumi.set(__self__, "arguments", arguments)

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

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


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

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

    @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 GetJobSecretAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @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 GetJobSourceResult(dict):
    def __init__(__self__, *,
                 docker: 'outputs.GetJobSourceDockerResult',
                 image: 'outputs.GetJobSourceImageResult'):
        pulumi.set(__self__, "docker", docker)
        pulumi.set(__self__, "image", image)

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

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


@pulumi.output_type
class GetJobSourceDockerResult(dict):
    def __init__(__self__, *,
                 git_repository: 'outputs.GetJobSourceDockerGitRepositoryResult',
                 dockerfile_path: Optional[str] = None):
        pulumi.set(__self__, "git_repository", git_repository)
        if dockerfile_path is not None:
            pulumi.set(__self__, "dockerfile_path", dockerfile_path)

    @property
    @pulumi.getter(name="gitRepository")
    def git_repository(self) -> 'outputs.GetJobSourceDockerGitRepositoryResult':
        return pulumi.get(self, "git_repository")

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


@pulumi.output_type
class GetJobSourceDockerGitRepositoryResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 root_path: str,
                 url: str,
                 git_token_id: Optional[str] = None):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "root_path", root_path)
        pulumi.set(__self__, "url", url)
        if git_token_id is not None:
            pulumi.set(__self__, "git_token_id", git_token_id)

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

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

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

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


@pulumi.output_type
class GetJobSourceImageResult(dict):
    def __init__(__self__, *,
                 name: str,
                 registry_id: str,
                 tag: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "registry_id", registry_id)
        pulumi.set(__self__, "tag", tag)

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

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

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


@pulumi.output_type
class GetProjectBuiltInEnvironmentVariableResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable.
        :param str key: Key of the environment variable.
        :param str value: Value of the environment variable.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Key of the environment variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetProjectEnvironmentVariableResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable.
        :param str key: Key of the environment variable.
        :param str value: Value of the environment variable.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Key of the environment variable.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetProjectEnvironmentVariableAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable alias.
        :param str key: Name of the environment variable alias.
        :param str value: Name of the variable to alias.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        Id of the environment variable alias.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Name of the environment variable alias.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Name of the variable to alias.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetProjectSecretResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret.
        :param str key: Key of the secret.
        :param str value: Value of the secret.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


@pulumi.output_type
class GetProjectSecretAliasResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret alias.
        :param str key: Name of the secret alias.
        :param str value: Name of the secret to alias.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        Name of the secret alias.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Name of the secret to alias.
        """
        return pulumi.get(self, "value")


