# 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',
    'ApplicationDeploymentRestriction',
    'ApplicationEnvironmentVariable',
    'ApplicationEnvironmentVariableAlias',
    'ApplicationEnvironmentVariableOverride',
    'ApplicationGitRepository',
    'ApplicationHealthchecks',
    'ApplicationHealthchecksLivenessProbe',
    'ApplicationHealthchecksLivenessProbeType',
    'ApplicationHealthchecksLivenessProbeTypeExec',
    'ApplicationHealthchecksLivenessProbeTypeGrpc',
    'ApplicationHealthchecksLivenessProbeTypeHttp',
    'ApplicationHealthchecksLivenessProbeTypeTcp',
    'ApplicationHealthchecksReadinessProbe',
    'ApplicationHealthchecksReadinessProbeType',
    'ApplicationHealthchecksReadinessProbeTypeExec',
    'ApplicationHealthchecksReadinessProbeTypeGrpc',
    'ApplicationHealthchecksReadinessProbeTypeHttp',
    'ApplicationHealthchecksReadinessProbeTypeTcp',
    'ApplicationPort',
    'ApplicationSecret',
    'ApplicationSecretAlias',
    'ApplicationSecretOverride',
    'ApplicationStorage',
    'ClusterFeatures',
    'ClusterFeaturesExistingVpc',
    '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',
    'HelmBuiltInEnvironmentVariable',
    'HelmDeploymentRestriction',
    'HelmEnvironmentVariable',
    'HelmEnvironmentVariableAlias',
    'HelmEnvironmentVariableOverride',
    'HelmPorts',
    'HelmRepositoryConfig',
    'HelmSecret',
    'HelmSecretAlias',
    'HelmSecretOverride',
    'HelmSource',
    'HelmSourceGitRepository',
    'HelmSourceHelmRepository',
    'HelmValuesOverride',
    'HelmValuesOverrideFile',
    'HelmValuesOverrideFileGitRepository',
    'HelmValuesOverrideFileRaw',
    'JobBuiltInEnvironmentVariable',
    'JobDeploymentRestriction',
    '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',
    'GetApplicationDeploymentRestrictionResult',
    'GetApplicationEnvironmentVariableResult',
    'GetApplicationEnvironmentVariableAliasResult',
    'GetApplicationEnvironmentVariableOverrideResult',
    'GetApplicationGitRepositoryResult',
    'GetApplicationHealthchecksResult',
    'GetApplicationHealthchecksLivenessProbeResult',
    'GetApplicationHealthchecksLivenessProbeTypeResult',
    'GetApplicationHealthchecksLivenessProbeTypeExecResult',
    'GetApplicationHealthchecksLivenessProbeTypeGrpcResult',
    'GetApplicationHealthchecksLivenessProbeTypeHttpResult',
    'GetApplicationHealthchecksLivenessProbeTypeTcpResult',
    'GetApplicationHealthchecksReadinessProbeResult',
    'GetApplicationHealthchecksReadinessProbeTypeResult',
    'GetApplicationHealthchecksReadinessProbeTypeExecResult',
    'GetApplicationHealthchecksReadinessProbeTypeGrpcResult',
    'GetApplicationHealthchecksReadinessProbeTypeHttpResult',
    'GetApplicationHealthchecksReadinessProbeTypeTcpResult',
    'GetApplicationPortResult',
    'GetApplicationSecretResult',
    'GetApplicationSecretAliasResult',
    'GetApplicationSecretOverrideResult',
    'GetApplicationStorageResult',
    'GetClusterFeaturesResult',
    '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',
    'GetHelmBuiltInEnvironmentVariableResult',
    'GetHelmDeploymentRestrictionResult',
    'GetHelmEnvironmentVariableResult',
    'GetHelmEnvironmentVariableAliasResult',
    'GetHelmEnvironmentVariableOverrideResult',
    'GetHelmSecretResult',
    'GetHelmSecretAliasResult',
    'GetHelmSecretOverrideResult',
    'GetJobBuiltInEnvironmentVariableResult',
    'GetJobDeploymentRestrictionResult',
    '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):
        """
        :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 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):
        """
        :param str domain: Your custom domain.
        :param str id: Id of the custom domain.
        :param str status: Status of the custom domain.
        :param str validation_domain: URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        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:
        """
        Your custom domain.
        """
        return pulumi.get(self, "domain")

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

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

    @property
    @pulumi.getter(name="validationDomain")
    def validation_domain(self) -> Optional[str]:
        """
        URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        return pulumi.get(self, "validation_domain")


@pulumi.output_type
class ApplicationDeploymentRestriction(dict):
    def __init__(__self__, *,
                 mode: str,
                 type: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        :param str id: Id of the deployment restriction
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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

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


@pulumi.output_type
class ApplicationEnvironmentVariable(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 ApplicationEnvironmentVariableAlias(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 ApplicationEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        :param str id: Id of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable override.
        """
        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):
        """
        :param str url: URL of the git repository.
        :param str branch: Branch of the git repository.
               	- Default: `main or master (depending on repository)`.
        :param str git_token_id: The git token ID to be used
        :param str root_path: Root path of the application.
               	- Default: `/`.
        """
        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:
        """
        URL of the git repository.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Branch of the git repository.
        	- Default: `main or master (depending on repository)`.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> Optional[str]:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")

    @property
    @pulumi.getter(name="rootPath")
    def root_path(self) -> Optional[str]:
        """
        Root path of the application.
        	- Default: `/`.
        """
        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):
        """
        :param 'ApplicationHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'ApplicationHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbe']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'ApplicationHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.ApplicationHealthchecksLivenessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'ApplicationHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'ApplicationHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'ApplicationHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'ApplicationHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.ApplicationHealthchecksLivenessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.ApplicationHealthchecksLivenessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.ApplicationHealthchecksLivenessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ApplicationHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'ApplicationHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.ApplicationHealthchecksReadinessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'ApplicationHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'ApplicationHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'ApplicationHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'ApplicationHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.ApplicationHealthchecksReadinessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ApplicationHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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):
        """
        :param int internal_port: Internal port of the application.
               	- Must be: `>= 1` and `<= 65535`.
        :param bool is_default: If this port will be used for the root domain
        :param bool publicly_accessible: Specify if the port is exposed to the world or not for this application.
        :param int external_port: External port of the application.
               	- Required if: `ports.publicly_accessible=true`.
               	- Must be: `>= 1` and `<= 65535`.
        :param str id: Id of the port.
        :param str name: Name of the port.
        :param str protocol: Protocol used for the port of the application.
               	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
               	- Default: `HTTP`.
        """
        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:
        """
        Internal port of the application.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        If this port will be used for the root domain
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="publiclyAccessible")
    def publicly_accessible(self) -> bool:
        """
        Specify if the port is exposed to the world or not for this application.
        """
        return pulumi.get(self, "publicly_accessible")

    @property
    @pulumi.getter(name="externalPort")
    def external_port(self) -> Optional[int]:
        """
        External port of the application.
        	- Required if: `ports.publicly_accessible=true`.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "external_port")

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

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

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        Protocol used for the port of the application.
        	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
        	- Default: `HTTP`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class ApplicationSecret(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 ApplicationSecretAlias(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 ApplicationSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        :param str id: Id of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the secret override.
        """
        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):
        """
        :param str mount_point: Mount point of the storage for the application.
        :param int size: Size of the storage for the application in GB [1024MB = 1GB].
               	- Must be: `>= 1`.
        :param str type: Type of the storage for the application.
               	- Can be: `FAST_SSD`.
        :param str id: Id of the storage.
        """
        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:
        """
        Mount point of the storage for the application.
        """
        return pulumi.get(self, "mount_point")

    @property
    @pulumi.getter
    def size(self) -> int:
        """
        Size of the storage for the application in GB [1024MB = 1GB].
        	- Must be: `>= 1`.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the storage for the application.
        	- Can be: `FAST_SSD`.
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class ClusterFeatures(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "existingVpc":
            suggest = "existing_vpc"
        elif 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__, *,
                 existing_vpc: Optional['outputs.ClusterFeaturesExistingVpc'] = None,
                 static_ip: Optional[bool] = None,
                 vpc_subnet: Optional[str] = None):
        """
        :param 'ClusterFeaturesExistingVpcArgs' existing_vpc: Network configuration if you want to install qovery on an existing VPC
        :param bool static_ip: Static IP (AWS only) [NOTE: can't be updated after creation].
               	- Default: `false`.
        :param str vpc_subnet: Custom VPC subnet (AWS only) [NOTE: can't be updated after creation].
               	- Default: `10.0.0.0/16`.
        """
        if existing_vpc is not None:
            pulumi.set(__self__, "existing_vpc", existing_vpc)
        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="existingVpc")
    def existing_vpc(self) -> Optional['outputs.ClusterFeaturesExistingVpc']:
        """
        Network configuration if you want to install qovery on an existing VPC
        """
        return pulumi.get(self, "existing_vpc")

    @property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> Optional[bool]:
        """
        Static IP (AWS only) [NOTE: can't be updated after creation].
        	- Default: `false`.
        """
        return pulumi.get(self, "static_ip")

    @property
    @pulumi.getter(name="vpcSubnet")
    def vpc_subnet(self) -> Optional[str]:
        """
        Custom VPC subnet (AWS only) [NOTE: can't be updated after creation].
        	- Default: `10.0.0.0/16`.
        """
        return pulumi.get(self, "vpc_subnet")


@pulumi.output_type
class ClusterFeaturesExistingVpc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsVpcEksId":
            suggest = "aws_vpc_eks_id"
        elif key == "eksSubnetsZoneAIds":
            suggest = "eks_subnets_zone_a_ids"
        elif key == "eksSubnetsZoneBIds":
            suggest = "eks_subnets_zone_b_ids"
        elif key == "eksSubnetsZoneCIds":
            suggest = "eks_subnets_zone_c_ids"
        elif key == "documentdbSubnetsZoneAIds":
            suggest = "documentdb_subnets_zone_a_ids"
        elif key == "documentdbSubnetsZoneBIds":
            suggest = "documentdb_subnets_zone_b_ids"
        elif key == "documentdbSubnetsZoneCIds":
            suggest = "documentdb_subnets_zone_c_ids"
        elif key == "elasticacheSubnetsZoneAIds":
            suggest = "elasticache_subnets_zone_a_ids"
        elif key == "elasticacheSubnetsZoneBIds":
            suggest = "elasticache_subnets_zone_b_ids"
        elif key == "elasticacheSubnetsZoneCIds":
            suggest = "elasticache_subnets_zone_c_ids"
        elif key == "rdsSubnetsZoneAIds":
            suggest = "rds_subnets_zone_a_ids"
        elif key == "rdsSubnetsZoneBIds":
            suggest = "rds_subnets_zone_b_ids"
        elif key == "rdsSubnetsZoneCIds":
            suggest = "rds_subnets_zone_c_ids"

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

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

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

    def __init__(__self__, *,
                 aws_vpc_eks_id: str,
                 eks_subnets_zone_a_ids: Sequence[str],
                 eks_subnets_zone_b_ids: Sequence[str],
                 eks_subnets_zone_c_ids: Sequence[str],
                 documentdb_subnets_zone_a_ids: Optional[Sequence[str]] = None,
                 documentdb_subnets_zone_b_ids: Optional[Sequence[str]] = None,
                 documentdb_subnets_zone_c_ids: Optional[Sequence[str]] = None,
                 elasticache_subnets_zone_a_ids: Optional[Sequence[str]] = None,
                 elasticache_subnets_zone_b_ids: Optional[Sequence[str]] = None,
                 elasticache_subnets_zone_c_ids: Optional[Sequence[str]] = None,
                 rds_subnets_zone_a_ids: Optional[Sequence[str]] = None,
                 rds_subnets_zone_b_ids: Optional[Sequence[str]] = None,
                 rds_subnets_zone_c_ids: Optional[Sequence[str]] = None):
        """
        :param str aws_vpc_eks_id: Aws VPC id
        :param Sequence[str] eks_subnets_zone_a_ids: Ids of the subnets for EKS zone a. Must have map_public_ip_on_launch set to true
        :param Sequence[str] eks_subnets_zone_b_ids: Ids of the subnets for EKS zone b. Must have map_public_ip_on_launch set to true
        :param Sequence[str] eks_subnets_zone_c_ids: Ids of the subnets for EKS zone c. Must have map_public_ip_on_launch set to true
        :param Sequence[str] documentdb_subnets_zone_a_ids: Ids of the subnets for document db
        :param Sequence[str] documentdb_subnets_zone_b_ids: Ids of the subnets for document db
        :param Sequence[str] documentdb_subnets_zone_c_ids: Ids of the subnets for document db
        :param Sequence[str] elasticache_subnets_zone_a_ids: Ids of the subnets for elasticache
        :param Sequence[str] elasticache_subnets_zone_b_ids: Ids of the subnets for elasticache
        :param Sequence[str] elasticache_subnets_zone_c_ids: Ids of the subnets for elasticache
        :param Sequence[str] rds_subnets_zone_a_ids: Ids of the subnets for RDS
        :param Sequence[str] rds_subnets_zone_b_ids: Ids of the subnets for RDS
        :param Sequence[str] rds_subnets_zone_c_ids: Ids of the subnets for RDS
        """
        pulumi.set(__self__, "aws_vpc_eks_id", aws_vpc_eks_id)
        pulumi.set(__self__, "eks_subnets_zone_a_ids", eks_subnets_zone_a_ids)
        pulumi.set(__self__, "eks_subnets_zone_b_ids", eks_subnets_zone_b_ids)
        pulumi.set(__self__, "eks_subnets_zone_c_ids", eks_subnets_zone_c_ids)
        if documentdb_subnets_zone_a_ids is not None:
            pulumi.set(__self__, "documentdb_subnets_zone_a_ids", documentdb_subnets_zone_a_ids)
        if documentdb_subnets_zone_b_ids is not None:
            pulumi.set(__self__, "documentdb_subnets_zone_b_ids", documentdb_subnets_zone_b_ids)
        if documentdb_subnets_zone_c_ids is not None:
            pulumi.set(__self__, "documentdb_subnets_zone_c_ids", documentdb_subnets_zone_c_ids)
        if elasticache_subnets_zone_a_ids is not None:
            pulumi.set(__self__, "elasticache_subnets_zone_a_ids", elasticache_subnets_zone_a_ids)
        if elasticache_subnets_zone_b_ids is not None:
            pulumi.set(__self__, "elasticache_subnets_zone_b_ids", elasticache_subnets_zone_b_ids)
        if elasticache_subnets_zone_c_ids is not None:
            pulumi.set(__self__, "elasticache_subnets_zone_c_ids", elasticache_subnets_zone_c_ids)
        if rds_subnets_zone_a_ids is not None:
            pulumi.set(__self__, "rds_subnets_zone_a_ids", rds_subnets_zone_a_ids)
        if rds_subnets_zone_b_ids is not None:
            pulumi.set(__self__, "rds_subnets_zone_b_ids", rds_subnets_zone_b_ids)
        if rds_subnets_zone_c_ids is not None:
            pulumi.set(__self__, "rds_subnets_zone_c_ids", rds_subnets_zone_c_ids)

    @property
    @pulumi.getter(name="awsVpcEksId")
    def aws_vpc_eks_id(self) -> str:
        """
        Aws VPC id
        """
        return pulumi.get(self, "aws_vpc_eks_id")

    @property
    @pulumi.getter(name="eksSubnetsZoneAIds")
    def eks_subnets_zone_a_ids(self) -> Sequence[str]:
        """
        Ids of the subnets for EKS zone a. Must have map_public_ip_on_launch set to true
        """
        return pulumi.get(self, "eks_subnets_zone_a_ids")

    @property
    @pulumi.getter(name="eksSubnetsZoneBIds")
    def eks_subnets_zone_b_ids(self) -> Sequence[str]:
        """
        Ids of the subnets for EKS zone b. Must have map_public_ip_on_launch set to true
        """
        return pulumi.get(self, "eks_subnets_zone_b_ids")

    @property
    @pulumi.getter(name="eksSubnetsZoneCIds")
    def eks_subnets_zone_c_ids(self) -> Sequence[str]:
        """
        Ids of the subnets for EKS zone c. Must have map_public_ip_on_launch set to true
        """
        return pulumi.get(self, "eks_subnets_zone_c_ids")

    @property
    @pulumi.getter(name="documentdbSubnetsZoneAIds")
    def documentdb_subnets_zone_a_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for document db
        """
        return pulumi.get(self, "documentdb_subnets_zone_a_ids")

    @property
    @pulumi.getter(name="documentdbSubnetsZoneBIds")
    def documentdb_subnets_zone_b_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for document db
        """
        return pulumi.get(self, "documentdb_subnets_zone_b_ids")

    @property
    @pulumi.getter(name="documentdbSubnetsZoneCIds")
    def documentdb_subnets_zone_c_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for document db
        """
        return pulumi.get(self, "documentdb_subnets_zone_c_ids")

    @property
    @pulumi.getter(name="elasticacheSubnetsZoneAIds")
    def elasticache_subnets_zone_a_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for elasticache
        """
        return pulumi.get(self, "elasticache_subnets_zone_a_ids")

    @property
    @pulumi.getter(name="elasticacheSubnetsZoneBIds")
    def elasticache_subnets_zone_b_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for elasticache
        """
        return pulumi.get(self, "elasticache_subnets_zone_b_ids")

    @property
    @pulumi.getter(name="elasticacheSubnetsZoneCIds")
    def elasticache_subnets_zone_c_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for elasticache
        """
        return pulumi.get(self, "elasticache_subnets_zone_c_ids")

    @property
    @pulumi.getter(name="rdsSubnetsZoneAIds")
    def rds_subnets_zone_a_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for RDS
        """
        return pulumi.get(self, "rds_subnets_zone_a_ids")

    @property
    @pulumi.getter(name="rdsSubnetsZoneBIds")
    def rds_subnets_zone_b_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for RDS
        """
        return pulumi.get(self, "rds_subnets_zone_b_ids")

    @property
    @pulumi.getter(name="rdsSubnetsZoneCIds")
    def rds_subnets_zone_c_ids(self) -> Optional[Sequence[str]]:
        """
        Ids of the subnets for RDS
        """
        return pulumi.get(self, "rds_subnets_zone_c_ids")


@pulumi.output_type
class ClusterRoutingTable(dict):
    def __init__(__self__, *,
                 description: str,
                 destination: str,
                 target: str):
        """
        :param str description: Description of the route.
        :param str destination: Destination of the route.
        :param str target: Target of the route.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "target", target)

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

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

    @property
    @pulumi.getter
    def target(self) -> str:
        """
        Target of the route.
        """
        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):
        """
        :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 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):
        """
        :param str domain: Your custom domain.
        :param str id: Id of the custom domain.
        :param str status: Status of the custom domain.
        :param str validation_domain: URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        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:
        """
        Your custom domain.
        """
        return pulumi.get(self, "domain")

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

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

    @property
    @pulumi.getter(name="validationDomain")
    def validation_domain(self) -> Optional[str]:
        """
        URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        return pulumi.get(self, "validation_domain")


@pulumi.output_type
class ContainerEnvironmentVariable(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 ContainerEnvironmentVariableAlias(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 ContainerEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        :param str id: Id of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable override.
        """
        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):
        """
        :param 'ContainerHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'ContainerHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.ContainerHealthchecksReadinessProbe']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'ContainerHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.ContainerHealthchecksLivenessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'ContainerHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'ContainerHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'ContainerHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'ContainerHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.ContainerHealthchecksLivenessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.ContainerHealthchecksLivenessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.ContainerHealthchecksLivenessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ContainerHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'ContainerHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.ContainerHealthchecksReadinessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'ContainerHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'ContainerHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'ContainerHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'ContainerHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.ContainerHealthchecksReadinessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.ContainerHealthchecksReadinessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.ContainerHealthchecksReadinessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ContainerHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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):
        """
        :param int internal_port: Internal port of the container.
               	- Must be: `>= 1` and `<= 65535`.
        :param bool is_default: If this port will be used for the root domain
        :param bool publicly_accessible: Specify if the port is exposed to the world or not for this container.
        :param int external_port: External port of the container.
               	- Required if: `ports.publicly_accessible=true`.
               	- Must be: `>= 1` and `<= 65535`.
        :param str id: Id of the port.
        :param str name: Name of the port.
        :param str protocol: Protocol used for the port of the container.
               	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
               	- Default: `HTTP`.
        """
        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:
        """
        Internal port of the container.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        If this port will be used for the root domain
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="publiclyAccessible")
    def publicly_accessible(self) -> bool:
        """
        Specify if the port is exposed to the world or not for this container.
        """
        return pulumi.get(self, "publicly_accessible")

    @property
    @pulumi.getter(name="externalPort")
    def external_port(self) -> Optional[int]:
        """
        External port of the container.
        	- Required if: `ports.publicly_accessible=true`.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "external_port")

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

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

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        Protocol used for the port of the container.
        	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
        	- Default: `HTTP`.
        """
        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):
        """
        :param str access_key_id: Required if kind is `ECR` or `PUBLIC_ECR`.
        :param str password: Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        :param str region: Required if kind is `ECR` or `SCALEWAY_CR`.
        :param str scaleway_access_key: Required if kind is `SCALEWAY_CR`.
        :param str scaleway_secret_key: Required if kind is `SCALEWAY_CR`.
        :param str secret_access_key: Required if kind is `ECR` or `PUBLIC_ECR`.
        :param str username: Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        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]:
        """
        Required if kind is `ECR` or `PUBLIC_ECR`.
        """
        return pulumi.get(self, "access_key_id")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Required if kind is `ECR` or `SCALEWAY_CR`.
        """
        return pulumi.get(self, "region")

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

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

    @property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[str]:
        """
        Required if kind is `ECR` or `PUBLIC_ECR`.
        """
        return pulumi.get(self, "secret_access_key")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class ContainerSecret(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 ContainerSecretAlias(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 ContainerSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        :param str id: Id of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the secret override.
        """
        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):
        """
        :param str mount_point: Mount point of the storage for the container.
        :param int size: Size of the storage for the container in GB [1024MB = 1GB].
               	- Must be: `>= 1`.
        :param str type: Type of the storage for the container.
               	- Can be: `FAST_SSD`.
        :param str id: Id of the storage.
        """
        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:
        """
        Mount point of the storage for the container.
        """
        return pulumi.get(self, "mount_point")

    @property
    @pulumi.getter
    def size(self) -> int:
        """
        Size of the storage for the container in GB [1024MB = 1GB].
        	- Must be: `>= 1`.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the storage for the container.
        	- Can be: `FAST_SSD`.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the storage.
        """
        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):
        """
        :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 EnvironmentEnvironmentVariable(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 EnvironmentEnvironmentVariableAlias(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 EnvironmentEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        :param str id: Id of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

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


@pulumi.output_type
class EnvironmentSecret(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 EnvironmentSecretAlias(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 EnvironmentSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        :param str id: Id of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

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


@pulumi.output_type
class HelmBuiltInEnvironmentVariable(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 HelmDeploymentRestriction(dict):
    def __init__(__self__, *,
                 mode: str,
                 type: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        :param str id: Id of the deployment restriction
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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

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


@pulumi.output_type
class HelmEnvironmentVariable(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 HelmEnvironmentVariableAlias(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 HelmEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        :param str id: Id of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

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


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

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

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

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

    def __init__(__self__, *,
                 external_port: int,
                 internal_port: int,
                 is_default: bool,
                 service_name: str,
                 namespace: Optional[str] = None,
                 protocol: Optional[str] = None):
        """
        :param int external_port: External port of the container.
               	- Required if: `ports.publicly_accessible=true`.
               	- Must be: `>= 1` and `<= 65535`.
        :param int internal_port: Internal port of the container.
               	- Must be: `>= 1` and `<= 65535`.
        :param bool is_default: If this port will be used for the root domain
        :param str protocol: Protocol used for the port of the container.
               	- Can be: `GRPC`, `HTTP`.
               	- Default: `HTTP`.
        """
        pulumi.set(__self__, "external_port", external_port)
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "service_name", service_name)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter(name="externalPort")
    def external_port(self) -> int:
        """
        External port of the container.
        	- Required if: `ports.publicly_accessible=true`.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "external_port")

    @property
    @pulumi.getter(name="internalPort")
    def internal_port(self) -> int:
        """
        Internal port of the container.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        If this port will be used for the root domain
        """
        return pulumi.get(self, "is_default")

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

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

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        Protocol used for the port of the container.
        	- Can be: `GRPC`, `HTTP`.
        	- Default: `HTTP`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class HelmRepositoryConfig(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 HelmRepositoryConfig. Access the value via the '{suggest}' property getter instead.")

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

    def get(self, key: str, default = None) -> Any:
        HelmRepositoryConfig.__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):
        """
        :param str access_key_id: Required if kind is `ECR` or `PUBLIC_ECR`.
        :param str password: Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        :param str region: Required if kind is `ECR` or `SCALEWAY_CR`.
        :param str scaleway_access_key: Required if kind is `SCALEWAY_CR`.
        :param str scaleway_secret_key: Required if kind is `SCALEWAY_CR`.
        :param str secret_access_key: Required if kind is `ECR` or `PUBLIC_ECR`.
        :param str username: Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        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]:
        """
        Required if kind is `ECR` or `PUBLIC_ECR`.
        """
        return pulumi.get(self, "access_key_id")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Required if kind is `ECR` or `SCALEWAY_CR`.
        """
        return pulumi.get(self, "region")

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

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

    @property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[str]:
        """
        Required if kind is `ECR` or `PUBLIC_ECR`.
        """
        return pulumi.get(self, "secret_access_key")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        Required if kinds are `DOCKER_HUB`, `GITHUB_CR`, `GITLAB`CR`, `GENERIC_CR`.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class HelmSecret(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 HelmSecretAlias(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 HelmSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        :param str id: Id of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

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


@pulumi.output_type
class HelmSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gitRepository":
            suggest = "git_repository"
        elif key == "helmRepository":
            suggest = "helm_repository"

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

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

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

    def __init__(__self__, *,
                 git_repository: Optional['outputs.HelmSourceGitRepository'] = None,
                 helm_repository: Optional['outputs.HelmSourceHelmRepository'] = None):
        """
        :param 'HelmSourceGitRepositoryArgs' git_repository: Git repository
        :param 'HelmSourceHelmRepositoryArgs' helm_repository: Helm repositories can be private or public
        """
        if git_repository is not None:
            pulumi.set(__self__, "git_repository", git_repository)
        if helm_repository is not None:
            pulumi.set(__self__, "helm_repository", helm_repository)

    @property
    @pulumi.getter(name="gitRepository")
    def git_repository(self) -> Optional['outputs.HelmSourceGitRepository']:
        """
        Git repository
        """
        return pulumi.get(self, "git_repository")

    @property
    @pulumi.getter(name="helmRepository")
    def helm_repository(self) -> Optional['outputs.HelmSourceHelmRepository']:
        """
        Helm repositories can be private or public
        """
        return pulumi.get(self, "helm_repository")


@pulumi.output_type
class HelmSourceGitRepository(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 HelmSourceGitRepository. Access the value via the '{suggest}' property getter instead.")

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

    def get(self, key: str, default = None) -> Any:
        HelmSourceGitRepository.__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):
        """
        :param str url: Helm's source git repository URL
        :param str branch: Helm's source git repository branch
        :param str git_token_id: The git token ID to be used
        :param str root_path: Helm's source git repository root path
        """
        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:
        """
        Helm's source git repository URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Helm's source git repository branch
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> Optional[str]:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")

    @property
    @pulumi.getter(name="rootPath")
    def root_path(self) -> Optional[str]:
        """
        Helm's source git repository root path
        """
        return pulumi.get(self, "root_path")


@pulumi.output_type
class HelmSourceHelmRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "chartName":
            suggest = "chart_name"
        elif key == "chartVersion":
            suggest = "chart_version"
        elif key == "helmRepositoryId":
            suggest = "helm_repository_id"

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

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

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

    def __init__(__self__, *,
                 chart_name: str,
                 chart_version: str,
                 helm_repository_id: str):
        """
        :param str chart_name: Chart name
        :param str chart_version: Chart version
        :param str helm_repository_id: helm repository id
        """
        pulumi.set(__self__, "chart_name", chart_name)
        pulumi.set(__self__, "chart_version", chart_version)
        pulumi.set(__self__, "helm_repository_id", helm_repository_id)

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

    @property
    @pulumi.getter(name="chartVersion")
    def chart_version(self) -> str:
        """
        Chart version
        """
        return pulumi.get(self, "chart_version")

    @property
    @pulumi.getter(name="helmRepositoryId")
    def helm_repository_id(self) -> str:
        """
        helm repository id
        """
        return pulumi.get(self, "helm_repository_id")


@pulumi.output_type
class HelmValuesOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "setJson":
            suggest = "set_json"
        elif key == "setString":
            suggest = "set_string"

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

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

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

    def __init__(__self__, *,
                 set: Mapping[str, str],
                 set_json: Mapping[str, str],
                 set_string: Mapping[str, str],
                 file: Optional['outputs.HelmValuesOverrideFile'] = None):
        """
        :param 'HelmValuesOverrideFileArgs' file: Define the overrides by selecting a YAML file from a git repository (preferred) or by passing raw YAML files.
        """
        pulumi.set(__self__, "set", set)
        pulumi.set(__self__, "set_json", set_json)
        pulumi.set(__self__, "set_string", set_string)
        if file is not None:
            pulumi.set(__self__, "file", file)

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

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

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

    @property
    @pulumi.getter
    def file(self) -> Optional['outputs.HelmValuesOverrideFile']:
        """
        Define the overrides by selecting a YAML file from a git repository (preferred) or by passing raw YAML files.
        """
        return pulumi.get(self, "file")


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

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

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

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

    def __init__(__self__, *,
                 git_repository: Optional['outputs.HelmValuesOverrideFileGitRepository'] = None,
                 raw: Optional[Mapping[str, 'outputs.HelmValuesOverrideFileRaw']] = None):
        """
        :param 'HelmValuesOverrideFileGitRepositoryArgs' git_repository: YAML file from a git repository
        :param Mapping[str, 'HelmValuesOverrideFileRawArgs'] raw: Raw YAML files
        """
        if git_repository is not None:
            pulumi.set(__self__, "git_repository", git_repository)
        if raw is not None:
            pulumi.set(__self__, "raw", raw)

    @property
    @pulumi.getter(name="gitRepository")
    def git_repository(self) -> Optional['outputs.HelmValuesOverrideFileGitRepository']:
        """
        YAML file from a git repository
        """
        return pulumi.get(self, "git_repository")

    @property
    @pulumi.getter
    def raw(self) -> Optional[Mapping[str, 'outputs.HelmValuesOverrideFileRaw']]:
        """
        Raw YAML files
        """
        return pulumi.get(self, "raw")


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

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

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

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

    def __init__(__self__, *,
                 branch: str,
                 paths: Sequence[str],
                 url: str,
                 git_token_id: Optional[str] = None):
        """
        :param str branch: YAML file git repository branch
        :param Sequence[str] paths: YAML files git repository paths
        :param str url: YAML file git repository URL
        :param str git_token_id: The git token ID to be used
        """
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "paths", paths)
        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:
        """
        YAML file git repository branch
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter
    def paths(self) -> Sequence[str]:
        """
        YAML files git repository paths
        """
        return pulumi.get(self, "paths")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        YAML file git repository URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> Optional[str]:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")


@pulumi.output_type
class HelmValuesOverrideFileRaw(dict):
    def __init__(__self__, *,
                 content: str):
        """
        :param str content: content of the file
        """
        pulumi.set(__self__, "content", content)

    @property
    @pulumi.getter
    def content(self) -> str:
        """
        content of the file
        """
        return pulumi.get(self, "content")


@pulumi.output_type
class JobBuiltInEnvironmentVariable(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 JobDeploymentRestriction(dict):
    def __init__(__self__, *,
                 mode: str,
                 type: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        :param str id: Id of the deployment restriction
        """
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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

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


@pulumi.output_type
class JobEnvironmentVariable(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 JobEnvironmentVariableAlias(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 JobEnvironmentVariableOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        :param str id: Id of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Id of the environment variable override.
        """
        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):
        """
        :param 'JobHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'JobHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.JobHealthchecksReadinessProbe']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'JobHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.JobHealthchecksLivenessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'JobHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'JobHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'JobHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'JobHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.JobHealthchecksLivenessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.JobHealthchecksLivenessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.JobHealthchecksLivenessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class JobHealthchecksLivenessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'JobHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.JobHealthchecksReadinessProbeType':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'JobHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'JobHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'JobHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'JobHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.JobHealthchecksReadinessProbeTypeGrpc']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.JobHealthchecksReadinessProbeTypeHttp']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.JobHealthchecksReadinessProbeTypeTcp']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeExec(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeGrpc(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeHttp(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class JobHealthchecksReadinessProbeTypeTcp(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        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):
        """
        :param 'JobScheduleCronjobArgs' cronjob: Job's cron.
        :param 'JobScheduleOnDeleteArgs' on_delete: Job's schedule on delete.
        :param 'JobScheduleOnStartArgs' on_start: Job's schedule on start.
        :param 'JobScheduleOnStopArgs' on_stop: Job's schedule on stop.
        """
        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']:
        """
        Job's cron.
        """
        return pulumi.get(self, "cronjob")

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

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

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


@pulumi.output_type
class JobScheduleCronjob(dict):
    def __init__(__self__, *,
                 command: 'outputs.JobScheduleCronjobCommand',
                 schedule: str):
        """
        :param 'JobScheduleCronjobCommandArgs' command: Job's cron command.
        :param str schedule: Job's cron string.
        """
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "schedule", schedule)

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

    @property
    @pulumi.getter
    def schedule(self) -> str:
        """
        Job's cron string.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class JobScheduleCronjobCommand(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        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]]:
        """
        List of arguments of this job.
        """
        return pulumi.get(self, "arguments")

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


@pulumi.output_type
class JobScheduleOnDelete(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        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]]:
        """
        List of arguments of this job.
        """
        return pulumi.get(self, "arguments")

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


@pulumi.output_type
class JobScheduleOnStart(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        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]]:
        """
        List of arguments of this job.
        """
        return pulumi.get(self, "arguments")

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


@pulumi.output_type
class JobScheduleOnStop(dict):
    def __init__(__self__, *,
                 arguments: Optional[Sequence[str]] = None,
                 entrypoint: Optional[str] = None):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        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]]:
        """
        List of arguments of this job.
        """
        return pulumi.get(self, "arguments")

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


@pulumi.output_type
class JobSecret(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 JobSecretAlias(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 JobSecretOverride(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 id: Optional[str] = None):
        """
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        :param str id: Id of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "key")

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

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


@pulumi.output_type
class JobSource(dict):
    def __init__(__self__, *,
                 docker: Optional['outputs.JobSourceDocker'] = None,
                 image: Optional['outputs.JobSourceImage'] = None):
        """
        :param 'JobSourceDockerArgs' docker: Job's docker source.
        :param 'JobSourceImageArgs' image: Job's image source.
        """
        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']:
        """
        Job's docker source.
        """
        return pulumi.get(self, "docker")

    @property
    @pulumi.getter
    def image(self) -> Optional['outputs.JobSourceImage']:
        """
        Job's image source.
        """
        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):
        """
        :param 'JobSourceDockerGitRepositoryArgs' git_repository: Job's docker source git repository.
        :param str dockerfile_path: Job's docker source dockerfile path.
        """
        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':
        """
        Job's docker source git repository.
        """
        return pulumi.get(self, "git_repository")

    @property
    @pulumi.getter(name="dockerfilePath")
    def dockerfile_path(self) -> Optional[str]:
        """
        Job's docker source dockerfile path.
        """
        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):
        """
        :param str branch: Job's docker source git repository branch.
        :param str url: Job's docker source git repository URL.
        :param str git_token_id: The git token ID to be used
        :param str root_path: Job's docker source git repository root path.
        """
        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:
        """
        Job's docker source git repository branch.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Job's docker source git repository URL.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> Optional[str]:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")

    @property
    @pulumi.getter(name="rootPath")
    def root_path(self) -> Optional[str]:
        """
        Job's docker source git repository root path.
        """
        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):
        """
        :param str name: Job's image source name.
        :param str registry_id: Job's image source registry ID.
        :param str tag: Job's image source tag.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "registry_id", registry_id)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Job's image source name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="registryId")
    def registry_id(self) -> str:
        """
        Job's image source registry ID.
        """
        return pulumi.get(self, "registry_id")

    @property
    @pulumi.getter
    def tag(self) -> str:
        """
        Job's image source tag.
        """
        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):
        """
        :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 GetApplicationCustomDomainResult(dict):
    def __init__(__self__, *,
                 domain: str,
                 id: str,
                 status: str,
                 validation_domain: str):
        """
        :param str domain: Your custom domain.
        :param str id: Id of the custom domain.
        :param str status: Status of the custom domain.
        :param str validation_domain: URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        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:
        """
        Your custom domain.
        """
        return pulumi.get(self, "domain")

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

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

    @property
    @pulumi.getter(name="validationDomain")
    def validation_domain(self) -> str:
        """
        URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        return pulumi.get(self, "validation_domain")


@pulumi.output_type
class GetApplicationDeploymentRestrictionResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mode: str,
                 type: str,
                 value: str):
        """
        :param str id: Id of the deployment restriction
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class GetApplicationEnvironmentVariableResult(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 GetApplicationEnvironmentVariableAliasResult(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 GetApplicationEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable override.
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable override.
        """
        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):
        """
        :param str branch: Branch of the git repository.
               	- Default: `main or master (depending on repository)`.
        :param str git_token_id: The git token ID to be used
        :param str root_path: Root path of the application.
               	- Default: `/`.
        :param str url: URL of the git repository.
        """
        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:
        """
        Branch of the git repository.
        	- Default: `main or master (depending on repository)`.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> str:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")

    @property
    @pulumi.getter(name="rootPath")
    def root_path(self) -> str:
        """
        Root path of the application.
        	- Default: `/`.
        """
        return pulumi.get(self, "root_path")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        URL of the git repository.
        """
        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):
        """
        :param 'GetApplicationHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'GetApplicationHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeResult']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetApplicationHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetApplicationHealthchecksLivenessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetApplicationHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetApplicationHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetApplicationHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetApplicationHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetApplicationHealthchecksLivenessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetApplicationHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetApplicationHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetApplicationHealthchecksReadinessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetApplicationHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetApplicationHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetApplicationHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetApplicationHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetApplicationHealthchecksReadinessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetApplicationHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@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):
        """
        :param int external_port: External port of the application.
               	- Required if: `ports.publicly_accessible=true`.
               	- Must be: `>= 1` and `<= 65535`.
        :param str id: Id of the port.
        :param int internal_port: Internal port of the application.
               	- Must be: `>= 1` and `<= 65535`.
        :param bool is_default: If this port will be used for the root domain
        :param str name: Name of the port.
        :param str protocol: Protocol used for the port of the application.
               	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
               	- Default: `HTTP`.
        :param bool publicly_accessible: Specify if the port is exposed to the world or not for this application.
        """
        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:
        """
        External port of the application.
        	- Required if: `ports.publicly_accessible=true`.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "external_port")

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

    @property
    @pulumi.getter(name="internalPort")
    def internal_port(self) -> int:
        """
        Internal port of the application.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        If this port will be used for the root domain
        """
        return pulumi.get(self, "is_default")

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

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        Protocol used for the port of the application.
        	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
        	- Default: `HTTP`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="publiclyAccessible")
    def publicly_accessible(self) -> bool:
        """
        Specify if the port is exposed to the world or not for this application.
        """
        return pulumi.get(self, "publicly_accessible")


@pulumi.output_type
class GetApplicationSecretResult(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 GetApplicationSecretAliasResult(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")


@pulumi.output_type
class GetApplicationSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret override.
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetApplicationStorageResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mount_point: str,
                 size: int,
                 type: str):
        """
        :param str id: Id of the storage.
        :param str mount_point: Mount point of the storage for the application.
        :param int size: Size of the storage for the application in GB [1024MB = 1GB].
               	- Must be: `>= 1`.
        :param str type: Type of the storage for the application.
               	- Can be: `FAST_SSD`.
        """
        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:
        """
        Id of the storage.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="mountPoint")
    def mount_point(self) -> str:
        """
        Mount point of the storage for the application.
        """
        return pulumi.get(self, "mount_point")

    @property
    @pulumi.getter
    def size(self) -> int:
        """
        Size of the storage for the application in GB [1024MB = 1GB].
        	- Must be: `>= 1`.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the storage for the application.
        	- Can be: `FAST_SSD`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClusterFeaturesResult(dict):
    def __init__(__self__, *,
                 static_ip: bool,
                 vpc_subnet: str):
        """
        :param bool static_ip: Static IP (AWS only) [NOTE: can't be updated after creation].
               	- Default: `false`.
        :param str vpc_subnet: Custom VPC subnet (AWS only) [NOTE: can't be updated after creation].
               	- Default: `10.0.0.0/16`.
        """
        pulumi.set(__self__, "static_ip", static_ip)
        pulumi.set(__self__, "vpc_subnet", vpc_subnet)

    @property
    @pulumi.getter(name="staticIp")
    def static_ip(self) -> bool:
        """
        Static IP (AWS only) [NOTE: can't be updated after creation].
        	- Default: `false`.
        """
        return pulumi.get(self, "static_ip")

    @property
    @pulumi.getter(name="vpcSubnet")
    def vpc_subnet(self) -> str:
        """
        Custom VPC subnet (AWS only) [NOTE: can't be updated after creation].
        	- Default: `10.0.0.0/16`.
        """
        return pulumi.get(self, "vpc_subnet")


@pulumi.output_type
class GetClusterRoutingTableResult(dict):
    def __init__(__self__, *,
                 description: str,
                 destination: str,
                 target: str):
        """
        :param str description: Description of the route.
        :param str destination: Destination of the route.
        :param str target: Target of the route.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination", destination)
        pulumi.set(__self__, "target", target)

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

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

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


@pulumi.output_type
class GetContainerBuiltInEnvironmentVariableResult(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 GetContainerCustomDomainResult(dict):
    def __init__(__self__, *,
                 domain: str,
                 id: str,
                 status: str,
                 validation_domain: str):
        """
        :param str domain: Your custom domain.
        :param str id: Id of the custom domain.
        :param str status: Status of the custom domain.
        :param str validation_domain: URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        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:
        """
        Your custom domain.
        """
        return pulumi.get(self, "domain")

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

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

    @property
    @pulumi.getter(name="validationDomain")
    def validation_domain(self) -> str:
        """
        URL provided by Qovery. You must create a CNAME on your DNS provider using that URL.
        """
        return pulumi.get(self, "validation_domain")


@pulumi.output_type
class GetContainerEnvironmentVariableResult(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 GetContainerEnvironmentVariableAliasResult(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 GetContainerEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable override.
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable override.
        """
        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):
        """
        :param 'GetContainerHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'GetContainerHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeResult']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetContainerHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetContainerHealthchecksLivenessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetContainerHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetContainerHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetContainerHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetContainerHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetContainerHealthchecksLivenessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetContainerHealthchecksLivenessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetContainerHealthchecksLivenessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetContainerHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetContainerHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetContainerHealthchecksReadinessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetContainerHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetContainerHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetContainerHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetContainerHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetContainerHealthchecksReadinessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetContainerHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@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):
        """
        :param int external_port: External port of the container.
               	- Required if: `ports.publicly_accessible=true`.
               	- Must be: `>= 1` and `<= 65535`.
        :param str id: Id of the port.
        :param int internal_port: Internal port of the container.
               	- Must be: `>= 1` and `<= 65535`.
        :param bool is_default: If this port will be used for the root domain
        :param str name: Name of the port.
        :param str protocol: Protocol used for the port of the container.
               	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
               	- Default: `HTTP`.
        :param bool publicly_accessible: Specify if the port is exposed to the world or not for this container.
        """
        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:
        """
        External port of the container.
        	- Required if: `ports.publicly_accessible=true`.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "external_port")

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

    @property
    @pulumi.getter(name="internalPort")
    def internal_port(self) -> int:
        """
        Internal port of the container.
        	- Must be: `>= 1` and `<= 65535`.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        If this port will be used for the root domain
        """
        return pulumi.get(self, "is_default")

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

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        Protocol used for the port of the container.
        	- Can be: `GRPC`, `HTTP`, `TCP`, `UDP`.
        	- Default: `HTTP`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="publiclyAccessible")
    def publicly_accessible(self) -> bool:
        """
        Specify if the port is exposed to the world or not for this container.
        """
        return pulumi.get(self, "publicly_accessible")


@pulumi.output_type
class GetContainerSecretResult(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 GetContainerSecretAliasResult(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")


@pulumi.output_type
class GetContainerSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret override.
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetContainerStorageResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mount_point: str,
                 size: int,
                 type: str):
        """
        :param str id: Id of the storage.
        :param str mount_point: Mount point of the storage for the container.
        :param int size: Size of the storage for the container in GB [1024MB = 1GB].
               	- Must be: `>= 1`.
        :param str type: Type of the storage for the container.
               	- Can be: `FAST_SSD`.
        """
        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:
        """
        Id of the storage.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="mountPoint")
    def mount_point(self) -> str:
        """
        Mount point of the storage for the container.
        """
        return pulumi.get(self, "mount_point")

    @property
    @pulumi.getter
    def size(self) -> int:
        """
        Size of the storage for the container in GB [1024MB = 1GB].
        	- Must be: `>= 1`.
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Type of the storage for the container.
        	- Can be: `FAST_SSD`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetEnvironmentBuiltInEnvironmentVariableResult(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 GetEnvironmentEnvironmentVariableResult(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 GetEnvironmentEnvironmentVariableAliasResult(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 GetEnvironmentEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable override.
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetEnvironmentSecretResult(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 GetEnvironmentSecretAliasResult(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")


@pulumi.output_type
class GetEnvironmentSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret override.
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetHelmBuiltInEnvironmentVariableResult(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 GetHelmDeploymentRestrictionResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mode: str,
                 type: str,
                 value: str):
        """
        :param str id: Id of the deployment restriction
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class GetHelmEnvironmentVariableResult(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 GetHelmEnvironmentVariableAliasResult(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 GetHelmEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable override.
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetHelmSecretResult(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 GetHelmSecretAliasResult(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")


@pulumi.output_type
class GetHelmSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret override.
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetJobBuiltInEnvironmentVariableResult(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 GetJobDeploymentRestrictionResult(dict):
    def __init__(__self__, *,
                 id: str,
                 mode: str,
                 type: str,
                 value: str):
        """
        :param str id: Id of the deployment restriction
        :param str mode: Can be EXCLUDE or MATCH
        :param str type: Currently, only PATH is accepted
        :param str value: Value of the deployment restriction
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        Can be EXCLUDE or MATCH
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        Currently, only PATH is accepted
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class GetJobEnvironmentVariableResult(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 GetJobEnvironmentVariableAliasResult(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 GetJobEnvironmentVariableOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the environment variable override.
        :param str key: Name of the environment variable override.
        :param str value: Value of the environment variable override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        Value of the environment variable override.
        """
        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):
        """
        :param 'GetJobHealthchecksLivenessProbeArgs' liveness_probe: Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        :param 'GetJobHealthchecksReadinessProbeArgs' readiness_probe: Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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']:
        """
        Configuration for the liveness probe, in order to know when your service is working correctly. Failing the probe means your service being killed/ask to be restarted.
        """
        return pulumi.get(self, "liveness_probe")

    @property
    @pulumi.getter(name="readinessProbe")
    def readiness_probe(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeResult']:
        """
        Configuration for the readiness probe, in order to know when your service is ready to receive traffic. Failing the probe means your service will stop receiving traffic.
        """
        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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetJobHealthchecksLivenessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetJobHealthchecksLivenessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetJobHealthchecksLivenessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetJobHealthchecksLivenessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetJobHealthchecksLivenessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetJobHealthchecksLivenessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetJobHealthchecksLivenessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetJobHealthchecksLivenessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetJobHealthchecksLivenessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetJobHealthchecksLivenessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@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'):
        """
        :param int failure_threshold: Number of time the an ok probe should fail before declaring it as failed
        :param int initial_delay_seconds: Number of seconds to wait before the first execution of the probe to be trigerred
        :param int period_seconds: Number of seconds before each execution of the probe
        :param int success_threshold: Number of time the probe should success before declaring a failed probe as ok again
        :param int timeout_seconds: Number of seconds within which the check need to respond before declaring it as a failure
        :param 'GetJobHealthchecksReadinessProbeTypeArgs' type: Kind of check to run for this probe. There can only be one configured at a time
        """
        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:
        """
        Number of time the an ok probe should fail before declaring it as failed
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> int:
        """
        Number of seconds to wait before the first execution of the probe to be trigerred
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> int:
        """
        Number of seconds before each execution of the probe
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> int:
        """
        Number of time the probe should success before declaring a failed probe as ok again
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> int:
        """
        Number of seconds within which the check need to respond before declaring it as a failure
        """
        return pulumi.get(self, "timeout_seconds")

    @property
    @pulumi.getter
    def type(self) -> 'outputs.GetJobHealthchecksReadinessProbeTypeResult':
        """
        Kind of check to run for this probe. There can only be one configured at a time
        """
        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):
        """
        :param 'GetJobHealthchecksReadinessProbeTypeExecArgs' exec_: Check that the given command return an exit 0. Binary should be present in the image
        :param 'GetJobHealthchecksReadinessProbeTypeGrpcArgs' grpc: Check that the given port respond to GRPC call
        :param 'GetJobHealthchecksReadinessProbeTypeHttpArgs' http: Check that the given port respond to HTTP call (should return a 2xx response code)
        :param 'GetJobHealthchecksReadinessProbeTypeTcpArgs' tcp: Check that the given port accepting connection
        """
        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']:
        """
        Check that the given command return an exit 0. Binary should be present in the image
        """
        return pulumi.get(self, "exec_")

    @property
    @pulumi.getter
    def grpc(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeTypeGrpcResult']:
        """
        Check that the given port respond to GRPC call
        """
        return pulumi.get(self, "grpc")

    @property
    @pulumi.getter
    def http(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeTypeHttpResult']:
        """
        Check that the given port respond to HTTP call (should return a 2xx response code)
        """
        return pulumi.get(self, "http")

    @property
    @pulumi.getter
    def tcp(self) -> Optional['outputs.GetJobHealthchecksReadinessProbeTypeTcpResult']:
        """
        Check that the given port accepting connection
        """
        return pulumi.get(self, "tcp")


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeExecResult(dict):
    def __init__(__self__, *,
                 commands: Sequence[str]):
        """
        :param Sequence[str] commands: The command and its arguments to exec
        """
        pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def commands(self) -> Sequence[str]:
        """
        The command and its arguments to exec
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeGrpcResult(dict):
    def __init__(__self__, *,
                 port: int,
                 service: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str service: The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        pulumi.set(__self__, "port", port)
        if service is not None:
            pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def service(self) -> Optional[str]:
        """
        The grpc service to connect to. It needs to implement grpc health protocol. https://kubernetes.io/blog/2018/10/01/health-checking-grpc-servers-on-kubernetes/#introducing-grpc-health-probe
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeHttpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 scheme: str,
                 path: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str scheme: if the HTTP GET request should be done in HTTP or HTTPS.
        :param str path: The path that the HTTP GET request. By default it is `/`
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "scheme", scheme)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def scheme(self) -> str:
        """
        if the HTTP GET request should be done in HTTP or HTTPS.
        """
        return pulumi.get(self, "scheme")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        The path that the HTTP GET request. By default it is `/`
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetJobHealthchecksReadinessProbeTypeTcpResult(dict):
    def __init__(__self__, *,
                 port: int,
                 host: Optional[str] = None):
        """
        :param int port: The port number to try to connect to
        :param str host: Optional. If the host need to be different than localhost/pod ip
        """
        pulumi.set(__self__, "port", port)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port number to try to connect to
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def host(self) -> Optional[str]:
        """
        Optional. If the host need to be different than localhost/pod ip
        """
        return pulumi.get(self, "host")


@pulumi.output_type
class GetJobScheduleResult(dict):
    def __init__(__self__, *,
                 cronjob: 'outputs.GetJobScheduleCronjobResult',
                 on_delete: 'outputs.GetJobScheduleOnDeleteResult',
                 on_start: 'outputs.GetJobScheduleOnStartResult',
                 on_stop: 'outputs.GetJobScheduleOnStopResult'):
        """
        :param 'GetJobScheduleCronjobArgs' cronjob: Job's cron.
        :param 'GetJobScheduleOnDeleteArgs' on_delete: Job's schedule on delete.
        :param 'GetJobScheduleOnStartArgs' on_start: Job's schedule on start.
        :param 'GetJobScheduleOnStopArgs' on_stop: Job's schedule on stop.
        """
        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':
        """
        Job's cron.
        """
        return pulumi.get(self, "cronjob")

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

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

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


@pulumi.output_type
class GetJobScheduleCronjobResult(dict):
    def __init__(__self__, *,
                 command: 'outputs.GetJobScheduleCronjobCommandResult',
                 schedule: str):
        """
        :param 'GetJobScheduleCronjobCommandArgs' command: Job's cron command.
        :param str schedule: Job's cron string.
        """
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "schedule", schedule)

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

    @property
    @pulumi.getter
    def schedule(self) -> str:
        """
        Job's cron string.
        """
        return pulumi.get(self, "schedule")


@pulumi.output_type
class GetJobScheduleCronjobCommandResult(dict):
    def __init__(__self__, *,
                 arguments: Sequence[str],
                 entrypoint: str):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        pulumi.set(__self__, "arguments", arguments)
        pulumi.set(__self__, "entrypoint", entrypoint)

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

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


@pulumi.output_type
class GetJobScheduleOnDeleteResult(dict):
    def __init__(__self__, *,
                 arguments: Sequence[str],
                 entrypoint: str):
        """
        :param Sequence[str] arguments: List of arguments of this job.
        :param str entrypoint: Entrypoint of the job.
        """
        pulumi.set(__self__, "arguments", arguments)
        pulumi.set(__self__, "entrypoint", entrypoint)

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

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


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

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

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


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

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

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


@pulumi.output_type
class GetJobSecretResult(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 GetJobSecretAliasResult(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")


@pulumi.output_type
class GetJobSecretOverrideResult(dict):
    def __init__(__self__, *,
                 id: str,
                 key: str,
                 value: str):
        """
        :param str id: Id of the secret override.
        :param str key: Name of the secret override.
        :param str value: Value of the secret override.
        """
        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 override.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetJobSourceResult(dict):
    def __init__(__self__, *,
                 docker: 'outputs.GetJobSourceDockerResult',
                 image: 'outputs.GetJobSourceImageResult'):
        """
        :param 'GetJobSourceDockerArgs' docker: Job's docker source.
        :param 'GetJobSourceImageArgs' image: Job's image source.
        """
        pulumi.set(__self__, "docker", docker)
        pulumi.set(__self__, "image", image)

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

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


@pulumi.output_type
class GetJobSourceDockerResult(dict):
    def __init__(__self__, *,
                 git_repository: 'outputs.GetJobSourceDockerGitRepositoryResult',
                 dockerfile_path: Optional[str] = None):
        """
        :param 'GetJobSourceDockerGitRepositoryArgs' git_repository: Job's docker source git repository.
        :param str dockerfile_path: Job's docker source dockerfile path.
        """
        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':
        """
        Job's docker source git repository.
        """
        return pulumi.get(self, "git_repository")

    @property
    @pulumi.getter(name="dockerfilePath")
    def dockerfile_path(self) -> Optional[str]:
        """
        Job's docker source dockerfile path.
        """
        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):
        """
        :param str branch: Job's docker source git repository branch.
        :param str root_path: Job's docker source git repository root path.
        :param str url: Job's docker source git repository URL.
        :param str git_token_id: The git token ID to be used
        """
        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:
        """
        Job's docker source git repository branch.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="rootPath")
    def root_path(self) -> str:
        """
        Job's docker source git repository root path.
        """
        return pulumi.get(self, "root_path")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Job's docker source git repository URL.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="gitTokenId")
    def git_token_id(self) -> Optional[str]:
        """
        The git token ID to be used
        """
        return pulumi.get(self, "git_token_id")


@pulumi.output_type
class GetJobSourceImageResult(dict):
    def __init__(__self__, *,
                 name: str,
                 registry_id: str,
                 tag: str):
        """
        :param str name: Job's image source name.
        :param str registry_id: Job's image source registry ID.
        :param str tag: Job's image source tag.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "registry_id", registry_id)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Job's image source name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="registryId")
    def registry_id(self) -> str:
        """
        Job's image source registry ID.
        """
        return pulumi.get(self, "registry_id")

    @property
    @pulumi.getter
    def tag(self) -> str:
        """
        Job's image source tag.
        """
        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")


