# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'ContainerGroupAcrRegistryInfoArgs',
    'ContainerGroupAcrRegistryInfoArgsDict',
    'ContainerGroupContainerArgs',
    'ContainerGroupContainerArgsDict',
    'ContainerGroupContainerEnvironmentVarArgs',
    'ContainerGroupContainerEnvironmentVarArgsDict',
    'ContainerGroupContainerEnvironmentVarFieldRefArgs',
    'ContainerGroupContainerEnvironmentVarFieldRefArgsDict',
    'ContainerGroupContainerLivenessProbeArgs',
    'ContainerGroupContainerLivenessProbeArgsDict',
    'ContainerGroupContainerLivenessProbeExecArgs',
    'ContainerGroupContainerLivenessProbeExecArgsDict',
    'ContainerGroupContainerLivenessProbeHttpGetArgs',
    'ContainerGroupContainerLivenessProbeHttpGetArgsDict',
    'ContainerGroupContainerLivenessProbeTcpSocketArgs',
    'ContainerGroupContainerLivenessProbeTcpSocketArgsDict',
    'ContainerGroupContainerPortArgs',
    'ContainerGroupContainerPortArgsDict',
    'ContainerGroupContainerReadinessProbeArgs',
    'ContainerGroupContainerReadinessProbeArgsDict',
    'ContainerGroupContainerReadinessProbeExecArgs',
    'ContainerGroupContainerReadinessProbeExecArgsDict',
    'ContainerGroupContainerReadinessProbeHttpGetArgs',
    'ContainerGroupContainerReadinessProbeHttpGetArgsDict',
    'ContainerGroupContainerReadinessProbeTcpSocketArgs',
    'ContainerGroupContainerReadinessProbeTcpSocketArgsDict',
    'ContainerGroupContainerSecurityContextArgs',
    'ContainerGroupContainerSecurityContextArgsDict',
    'ContainerGroupContainerSecurityContextCapabilityArgs',
    'ContainerGroupContainerSecurityContextCapabilityArgsDict',
    'ContainerGroupContainerVolumeMountArgs',
    'ContainerGroupContainerVolumeMountArgsDict',
    'ContainerGroupDnsConfigArgs',
    'ContainerGroupDnsConfigArgsDict',
    'ContainerGroupDnsConfigOptionArgs',
    'ContainerGroupDnsConfigOptionArgsDict',
    'ContainerGroupHostAliasArgs',
    'ContainerGroupHostAliasArgsDict',
    'ContainerGroupImageRegistryCredentialArgs',
    'ContainerGroupImageRegistryCredentialArgsDict',
    'ContainerGroupInitContainerArgs',
    'ContainerGroupInitContainerArgsDict',
    'ContainerGroupInitContainerEnvironmentVarArgs',
    'ContainerGroupInitContainerEnvironmentVarArgsDict',
    'ContainerGroupInitContainerEnvironmentVarFieldRefArgs',
    'ContainerGroupInitContainerEnvironmentVarFieldRefArgsDict',
    'ContainerGroupInitContainerPortArgs',
    'ContainerGroupInitContainerPortArgsDict',
    'ContainerGroupInitContainerSecurityContextArgs',
    'ContainerGroupInitContainerSecurityContextArgsDict',
    'ContainerGroupInitContainerSecurityContextCapabilityArgs',
    'ContainerGroupInitContainerSecurityContextCapabilityArgsDict',
    'ContainerGroupInitContainerVolumeMountArgs',
    'ContainerGroupInitContainerVolumeMountArgsDict',
    'ContainerGroupSecurityContextArgs',
    'ContainerGroupSecurityContextArgsDict',
    'ContainerGroupSecurityContextSysctlArgs',
    'ContainerGroupSecurityContextSysctlArgsDict',
    'ContainerGroupVolumeArgs',
    'ContainerGroupVolumeArgsDict',
    'ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgs',
    'ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgsDict',
    'ImageCacheImageRegistryCredentialArgs',
    'ImageCacheImageRegistryCredentialArgsDict',
    'OpenApiImageCacheImageRegistryCredentialArgs',
    'OpenApiImageCacheImageRegistryCredentialArgsDict',
    'VirtualNodeTaintArgs',
    'VirtualNodeTaintArgsDict',
]

MYPY = False

if not MYPY:
    class ContainerGroupAcrRegistryInfoArgsDict(TypedDict):
        domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The domain name of the ACR Enterprise Edition instance. Defaults to all domain names of the corresponding instance. Support specifying individual domain names, multiple separated by half comma.
        """
        instance_id: NotRequired[pulumi.Input[str]]
        """
        The ACR enterprise edition example ID.
        """
        instance_name: NotRequired[pulumi.Input[str]]
        """
        The name of the ACR enterprise edition instance.
        """
        region_id: NotRequired[pulumi.Input[str]]
        """
        The ACR enterprise edition instance belongs to the region.
        """
elif False:
    ContainerGroupAcrRegistryInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupAcrRegistryInfoArgs:
    def __init__(__self__, *,
                 domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 instance_id: Optional[pulumi.Input[str]] = None,
                 instance_name: Optional[pulumi.Input[str]] = None,
                 region_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] domains: The domain name of the ACR Enterprise Edition instance. Defaults to all domain names of the corresponding instance. Support specifying individual domain names, multiple separated by half comma.
        :param pulumi.Input[str] instance_id: The ACR enterprise edition example ID.
        :param pulumi.Input[str] instance_name: The name of the ACR enterprise edition instance.
        :param pulumi.Input[str] region_id: The ACR enterprise edition instance belongs to the region.
        """
        if domains is not None:
            pulumi.set(__self__, "domains", domains)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if instance_name is not None:
            pulumi.set(__self__, "instance_name", instance_name)
        if region_id is not None:
            pulumi.set(__self__, "region_id", region_id)

    @property
    @pulumi.getter
    def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The domain name of the ACR Enterprise Edition instance. Defaults to all domain names of the corresponding instance. Support specifying individual domain names, multiple separated by half comma.
        """
        return pulumi.get(self, "domains")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ACR enterprise edition example ID.
        """
        return pulumi.get(self, "instance_id")

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

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the ACR enterprise edition instance.
        """
        return pulumi.get(self, "instance_name")

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

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ACR enterprise edition instance belongs to the region.
        """
        return pulumi.get(self, "region_id")

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


if not MYPY:
    class ContainerGroupContainerArgsDict(TypedDict):
        image: pulumi.Input[str]
        """
        The image of the container.
        """
        name: pulumi.Input[str]
        """
        The name of the mounted volume.
        """
        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The arguments passed to the commands.
        """
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        Commands to be executed inside the container when performing health checks using the command line method.
        """
        cpu: NotRequired[pulumi.Input[float]]
        """
        The amount of CPU resources allocated to the container. Default value: `0`.
        """
        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarArgsDict']]]]
        """
        The structure of environmentVars. See `environment_vars` below.
        """
        gpu: NotRequired[pulumi.Input[int]]
        """
        The number GPUs. Default value: `0`.
        """
        image_pull_policy: NotRequired[pulumi.Input[str]]
        """
        The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        """
        lifecycle_pre_stop_handler_execs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The commands to be executed in containers when you use the CLI to specify the preStop callback function.
        """
        liveness_probes: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeArgsDict']]]]
        """
        The health check of the container. See `liveness_probe` below.
        """
        memory: NotRequired[pulumi.Input[float]]
        """
        The amount of memory resources allocated to the container. Default value: `0`.
        """
        ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerPortArgsDict']]]]
        """
        The structure of port. See `ports` below.
        """
        readiness_probes: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeArgsDict']]]]
        """
        The health check of the container. See `readiness_probe` below.
        """
        ready: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether the container passed the readiness probe.
        """
        restart_count: NotRequired[pulumi.Input[int]]
        """
        The number of times that the container restarted.
        """
        security_contexts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextArgsDict']]]]
        """
        The security context of the container. See `security_context` below.
        """
        volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerVolumeMountArgsDict']]]]
        """
        The structure of volumeMounts. See `volume_mounts` below.
        """
        working_dir: NotRequired[pulumi.Input[str]]
        """
        The working directory of the container.
        """
elif False:
    ContainerGroupContainerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerArgs:
    def __init__(__self__, *,
                 image: pulumi.Input[str],
                 name: pulumi.Input[str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 cpu: Optional[pulumi.Input[float]] = None,
                 environment_vars: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarArgs']]]] = None,
                 gpu: Optional[pulumi.Input[int]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 lifecycle_pre_stop_handler_execs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 liveness_probes: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeArgs']]]] = None,
                 memory: Optional[pulumi.Input[float]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerPortArgs']]]] = None,
                 readiness_probes: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeArgs']]]] = None,
                 ready: Optional[pulumi.Input[bool]] = None,
                 restart_count: Optional[pulumi.Input[int]] = None,
                 security_contexts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextArgs']]]] = None,
                 volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerVolumeMountArgs']]]] = None,
                 working_dir: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] image: The image of the container.
        :param pulumi.Input[str] name: The name of the mounted volume.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] args: The arguments passed to the commands.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] commands: Commands to be executed inside the container when performing health checks using the command line method.
        :param pulumi.Input[float] cpu: The amount of CPU resources allocated to the container. Default value: `0`.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarArgs']]] environment_vars: The structure of environmentVars. See `environment_vars` below.
        :param pulumi.Input[int] gpu: The number GPUs. Default value: `0`.
        :param pulumi.Input[str] image_pull_policy: The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] lifecycle_pre_stop_handler_execs: The commands to be executed in containers when you use the CLI to specify the preStop callback function.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeArgs']]] liveness_probes: The health check of the container. See `liveness_probe` below.
        :param pulumi.Input[float] memory: The amount of memory resources allocated to the container. Default value: `0`.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerPortArgs']]] ports: The structure of port. See `ports` below.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeArgs']]] readiness_probes: The health check of the container. See `readiness_probe` below.
        :param pulumi.Input[bool] ready: Indicates whether the container passed the readiness probe.
        :param pulumi.Input[int] restart_count: The number of times that the container restarted.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextArgs']]] security_contexts: The security context of the container. See `security_context` below.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerVolumeMountArgs']]] volume_mounts: The structure of volumeMounts. See `volume_mounts` below.
        :param pulumi.Input[str] working_dir: The working directory of the container.
        """
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "name", name)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if environment_vars is not None:
            pulumi.set(__self__, "environment_vars", environment_vars)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if lifecycle_pre_stop_handler_execs is not None:
            pulumi.set(__self__, "lifecycle_pre_stop_handler_execs", lifecycle_pre_stop_handler_execs)
        if liveness_probes is not None:
            pulumi.set(__self__, "liveness_probes", liveness_probes)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if readiness_probes is not None:
            pulumi.set(__self__, "readiness_probes", readiness_probes)
        if ready is not None:
            pulumi.set(__self__, "ready", ready)
        if restart_count is not None:
            pulumi.set(__self__, "restart_count", restart_count)
        if security_contexts is not None:
            pulumi.set(__self__, "security_contexts", security_contexts)
        if volume_mounts is not None:
            pulumi.set(__self__, "volume_mounts", volume_mounts)
        if working_dir is not None:
            pulumi.set(__self__, "working_dir", working_dir)

    @property
    @pulumi.getter
    def image(self) -> pulumi.Input[str]:
        """
        The image of the container.
        """
        return pulumi.get(self, "image")

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the mounted volume.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The arguments passed to the commands.
        """
        return pulumi.get(self, "args")

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

    @property
    @pulumi.getter
    def commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Commands to be executed inside the container when performing health checks using the command line method.
        """
        return pulumi.get(self, "commands")

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

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[float]]:
        """
        The amount of CPU resources allocated to the container. Default value: `0`.
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter(name="environmentVars")
    def environment_vars(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarArgs']]]]:
        """
        The structure of environmentVars. See `environment_vars` below.
        """
        return pulumi.get(self, "environment_vars")

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

    @property
    @pulumi.getter
    def gpu(self) -> Optional[pulumi.Input[int]]:
        """
        The number GPUs. Default value: `0`.
        """
        return pulumi.get(self, "gpu")

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

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        """
        return pulumi.get(self, "image_pull_policy")

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

    @property
    @pulumi.getter(name="lifecyclePreStopHandlerExecs")
    def lifecycle_pre_stop_handler_execs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The commands to be executed in containers when you use the CLI to specify the preStop callback function.
        """
        return pulumi.get(self, "lifecycle_pre_stop_handler_execs")

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

    @property
    @pulumi.getter(name="livenessProbes")
    def liveness_probes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeArgs']]]]:
        """
        The health check of the container. See `liveness_probe` below.
        """
        return pulumi.get(self, "liveness_probes")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[float]]:
        """
        The amount of memory resources allocated to the container. Default value: `0`.
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerPortArgs']]]]:
        """
        The structure of port. See `ports` below.
        """
        return pulumi.get(self, "ports")

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

    @property
    @pulumi.getter(name="readinessProbes")
    def readiness_probes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeArgs']]]]:
        """
        The health check of the container. See `readiness_probe` below.
        """
        return pulumi.get(self, "readiness_probes")

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

    @property
    @pulumi.getter
    def ready(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the container passed the readiness probe.
        """
        return pulumi.get(self, "ready")

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

    @property
    @pulumi.getter(name="restartCount")
    def restart_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of times that the container restarted.
        """
        return pulumi.get(self, "restart_count")

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

    @property
    @pulumi.getter(name="securityContexts")
    def security_contexts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextArgs']]]]:
        """
        The security context of the container. See `security_context` below.
        """
        return pulumi.get(self, "security_contexts")

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

    @property
    @pulumi.getter(name="volumeMounts")
    def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerVolumeMountArgs']]]]:
        """
        The structure of volumeMounts. See `volume_mounts` below.
        """
        return pulumi.get(self, "volume_mounts")

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

    @property
    @pulumi.getter(name="workingDir")
    def working_dir(self) -> Optional[pulumi.Input[str]]:
        """
        The working directory of the container.
        """
        return pulumi.get(self, "working_dir")

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


if not MYPY:
    class ContainerGroupContainerEnvironmentVarArgsDict(TypedDict):
        field_reves: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarFieldRefArgsDict']]]]
        key: NotRequired[pulumi.Input[str]]
        value: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerEnvironmentVarArgs:
    def __init__(__self__, *,
                 field_reves: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarFieldRefArgs']]]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if field_reves is not None:
            pulumi.set(__self__, "field_reves", field_reves)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="fieldReves")
    def field_reves(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerEnvironmentVarFieldRefArgs']]]]:
        return pulumi.get(self, "field_reves")

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

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

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

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

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


if not MYPY:
    class ContainerGroupContainerEnvironmentVarFieldRefArgsDict(TypedDict):
        field_path: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupContainerEnvironmentVarFieldRefArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerEnvironmentVarFieldRefArgs:
    def __init__(__self__, *,
                 field_path: Optional[pulumi.Input[str]] = None):
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

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


if not MYPY:
    class ContainerGroupContainerLivenessProbeArgsDict(TypedDict):
        execs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeExecArgsDict']]]]
        """
        Health check using command line method. See `exec` below.
        """
        failure_threshold: NotRequired[pulumi.Input[int]]
        """
        Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        """
        http_gets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeHttpGetArgsDict']]]]
        """
        Health check using HTTP request method. See `http_get` below.

        > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        """
        initial_delay_seconds: NotRequired[pulumi.Input[int]]
        """
        Check the time to start execution, calculated from the completion of container startup.
        """
        period_seconds: NotRequired[pulumi.Input[int]]
        """
        Buffer time for the program to handle operations before closing.
        """
        success_threshold: NotRequired[pulumi.Input[int]]
        """
        The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        """
        tcp_sockets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeTcpSocketArgsDict']]]]
        """
        Health check using TCP socket method. See `tcp_socket` below.
        """
        timeout_seconds: NotRequired[pulumi.Input[int]]
        """
        Check the timeout, the default is 1 second, the minimum is 1 second.
        """
elif False:
    ContainerGroupContainerLivenessProbeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerLivenessProbeArgs:
    def __init__(__self__, *,
                 execs: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeExecArgs']]]] = None,
                 failure_threshold: Optional[pulumi.Input[int]] = None,
                 http_gets: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeHttpGetArgs']]]] = None,
                 initial_delay_seconds: Optional[pulumi.Input[int]] = None,
                 period_seconds: Optional[pulumi.Input[int]] = None,
                 success_threshold: Optional[pulumi.Input[int]] = None,
                 tcp_sockets: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeTcpSocketArgs']]]] = None,
                 timeout_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeExecArgs']]] execs: Health check using command line method. See `exec` below.
        :param pulumi.Input[int] failure_threshold: Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeHttpGetArgs']]] http_gets: Health check using HTTP request method. See `http_get` below.
               
               > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        :param pulumi.Input[int] initial_delay_seconds: Check the time to start execution, calculated from the completion of container startup.
        :param pulumi.Input[int] period_seconds: Buffer time for the program to handle operations before closing.
        :param pulumi.Input[int] success_threshold: The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeTcpSocketArgs']]] tcp_sockets: Health check using TCP socket method. See `tcp_socket` below.
        :param pulumi.Input[int] timeout_seconds: Check the timeout, the default is 1 second, the minimum is 1 second.
        """
        if execs is not None:
            pulumi.set(__self__, "execs", execs)
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_gets is not None:
            pulumi.set(__self__, "http_gets", http_gets)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if tcp_sockets is not None:
            pulumi.set(__self__, "tcp_sockets", tcp_sockets)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter
    def execs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeExecArgs']]]]:
        """
        Health check using command line method. See `exec` below.
        """
        return pulumi.get(self, "execs")

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

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        """
        return pulumi.get(self, "failure_threshold")

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

    @property
    @pulumi.getter(name="httpGets")
    def http_gets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeHttpGetArgs']]]]:
        """
        Health check using HTTP request method. See `http_get` below.

        > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        """
        return pulumi.get(self, "http_gets")

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

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Check the time to start execution, calculated from the completion of container startup.
        """
        return pulumi.get(self, "initial_delay_seconds")

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

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Buffer time for the program to handle operations before closing.
        """
        return pulumi.get(self, "period_seconds")

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

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        """
        return pulumi.get(self, "success_threshold")

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

    @property
    @pulumi.getter(name="tcpSockets")
    def tcp_sockets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerLivenessProbeTcpSocketArgs']]]]:
        """
        Health check using TCP socket method. See `tcp_socket` below.
        """
        return pulumi.get(self, "tcp_sockets")

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

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Check the timeout, the default is 1 second, the minimum is 1 second.
        """
        return pulumi.get(self, "timeout_seconds")

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


if not MYPY:
    class ContainerGroupContainerLivenessProbeExecArgsDict(TypedDict):
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    ContainerGroupContainerLivenessProbeExecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerLivenessProbeExecArgs:
    def __init__(__self__, *,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if commands is not None:
            pulumi.set(__self__, "commands", commands)

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

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


if not MYPY:
    class ContainerGroupContainerLivenessProbeHttpGetArgsDict(TypedDict):
        path: NotRequired[pulumi.Input[str]]
        port: NotRequired[pulumi.Input[int]]
        scheme: NotRequired[pulumi.Input[str]]
        """
        The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
elif False:
    ContainerGroupContainerLivenessProbeHttpGetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerLivenessProbeHttpGetArgs:
    def __init__(__self__, *,
                 path: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 scheme: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] scheme: The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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

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

    @property
    @pulumi.getter
    def scheme(self) -> Optional[pulumi.Input[str]]:
        """
        The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
        return pulumi.get(self, "scheme")

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


if not MYPY:
    class ContainerGroupContainerLivenessProbeTcpSocketArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[int]]
elif False:
    ContainerGroupContainerLivenessProbeTcpSocketArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerLivenessProbeTcpSocketArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None):
        if port is not None:
            pulumi.set(__self__, "port", port)

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

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


if not MYPY:
    class ContainerGroupContainerPortArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[int]]
        protocol: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupContainerPortArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerPortArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 protocol: Optional[pulumi.Input[str]] = None):
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

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

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

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

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


if not MYPY:
    class ContainerGroupContainerReadinessProbeArgsDict(TypedDict):
        execs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeExecArgsDict']]]]
        """
        Health check using command line method. See `exec` below.
        """
        failure_threshold: NotRequired[pulumi.Input[int]]
        """
        Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        """
        http_gets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeHttpGetArgsDict']]]]
        """
        Health check using HTTP request method. See `http_get` below.

        > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        """
        initial_delay_seconds: NotRequired[pulumi.Input[int]]
        """
        Check the time to start execution, calculated from the completion of container startup.
        """
        period_seconds: NotRequired[pulumi.Input[int]]
        """
        Buffer time for the program to handle operations before closing.
        """
        success_threshold: NotRequired[pulumi.Input[int]]
        """
        The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        """
        tcp_sockets: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeTcpSocketArgsDict']]]]
        """
        Health check using TCP socket method. See `tcp_socket` below.
        """
        timeout_seconds: NotRequired[pulumi.Input[int]]
        """
        Check the timeout, the default is 1 second, the minimum is 1 second.
        """
elif False:
    ContainerGroupContainerReadinessProbeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerReadinessProbeArgs:
    def __init__(__self__, *,
                 execs: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeExecArgs']]]] = None,
                 failure_threshold: Optional[pulumi.Input[int]] = None,
                 http_gets: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeHttpGetArgs']]]] = None,
                 initial_delay_seconds: Optional[pulumi.Input[int]] = None,
                 period_seconds: Optional[pulumi.Input[int]] = None,
                 success_threshold: Optional[pulumi.Input[int]] = None,
                 tcp_sockets: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeTcpSocketArgs']]]] = None,
                 timeout_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeExecArgs']]] execs: Health check using command line method. See `exec` below.
        :param pulumi.Input[int] failure_threshold: Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeHttpGetArgs']]] http_gets: Health check using HTTP request method. See `http_get` below.
               
               > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        :param pulumi.Input[int] initial_delay_seconds: Check the time to start execution, calculated from the completion of container startup.
        :param pulumi.Input[int] period_seconds: Buffer time for the program to handle operations before closing.
        :param pulumi.Input[int] success_threshold: The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeTcpSocketArgs']]] tcp_sockets: Health check using TCP socket method. See `tcp_socket` below.
        :param pulumi.Input[int] timeout_seconds: Check the timeout, the default is 1 second, the minimum is 1 second.
        """
        if execs is not None:
            pulumi.set(__self__, "execs", execs)
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_gets is not None:
            pulumi.set(__self__, "http_gets", http_gets)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if tcp_sockets is not None:
            pulumi.set(__self__, "tcp_sockets", tcp_sockets)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter
    def execs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeExecArgs']]]]:
        """
        Health check using command line method. See `exec` below.
        """
        return pulumi.get(self, "execs")

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

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        Threshold for the number of checks that are determined to have failed since the last successful check (must be consecutive failures), default is 3.
        """
        return pulumi.get(self, "failure_threshold")

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

    @property
    @pulumi.getter(name="httpGets")
    def http_gets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeHttpGetArgs']]]]:
        """
        Health check using HTTP request method. See `http_get` below.

        > **NOTE:** When you configure `readiness_probe`, you can select only one of the `exec`, `tcp_socket`, `http_get`.
        """
        return pulumi.get(self, "http_gets")

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

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Check the time to start execution, calculated from the completion of container startup.
        """
        return pulumi.get(self, "initial_delay_seconds")

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

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Buffer time for the program to handle operations before closing.
        """
        return pulumi.get(self, "period_seconds")

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

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        The check count threshold for re-identifying successful checks since the last failed check (must be consecutive successes), default is 1. Current must be 1.
        """
        return pulumi.get(self, "success_threshold")

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

    @property
    @pulumi.getter(name="tcpSockets")
    def tcp_sockets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerReadinessProbeTcpSocketArgs']]]]:
        """
        Health check using TCP socket method. See `tcp_socket` below.
        """
        return pulumi.get(self, "tcp_sockets")

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

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Check the timeout, the default is 1 second, the minimum is 1 second.
        """
        return pulumi.get(self, "timeout_seconds")

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


if not MYPY:
    class ContainerGroupContainerReadinessProbeExecArgsDict(TypedDict):
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    ContainerGroupContainerReadinessProbeExecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerReadinessProbeExecArgs:
    def __init__(__self__, *,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if commands is not None:
            pulumi.set(__self__, "commands", commands)

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

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


if not MYPY:
    class ContainerGroupContainerReadinessProbeHttpGetArgsDict(TypedDict):
        path: NotRequired[pulumi.Input[str]]
        port: NotRequired[pulumi.Input[int]]
        scheme: NotRequired[pulumi.Input[str]]
        """
        The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
elif False:
    ContainerGroupContainerReadinessProbeHttpGetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerReadinessProbeHttpGetArgs:
    def __init__(__self__, *,
                 path: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 scheme: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] scheme: The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if scheme is not None:
            pulumi.set(__self__, "scheme", scheme)

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

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

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

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

    @property
    @pulumi.getter
    def scheme(self) -> Optional[pulumi.Input[str]]:
        """
        The protocol type corresponding to the HTTP Get request when using the HTTP request method for health checks. Valid values: `HTTP`, `HTTPS`.
        """
        return pulumi.get(self, "scheme")

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


if not MYPY:
    class ContainerGroupContainerReadinessProbeTcpSocketArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[int]]
elif False:
    ContainerGroupContainerReadinessProbeTcpSocketArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerReadinessProbeTcpSocketArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None):
        if port is not None:
            pulumi.set(__self__, "port", port)

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

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


if not MYPY:
    class ContainerGroupContainerSecurityContextArgsDict(TypedDict):
        capabilities: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextCapabilityArgsDict']]]]
        privileged: NotRequired[pulumi.Input[bool]]
        """
        Specifies whether to give extended privileges to this container. Default value: `false`. Valid values: `true` and `false`.
        """
        run_as_user: NotRequired[pulumi.Input[int]]
elif False:
    ContainerGroupContainerSecurityContextArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerSecurityContextArgs:
    def __init__(__self__, *,
                 capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupContainerSecurityContextCapabilityArgs']]]] = None,
                 privileged: Optional[pulumi.Input[bool]] = None,
                 run_as_user: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[bool] privileged: Specifies whether to give extended privileges to this container. Default value: `false`. Valid values: `true` and `false`.
        """
        if capabilities is not None:
            pulumi.set(__self__, "capabilities", capabilities)
        if privileged is not None:
            pulumi.set(__self__, "privileged", privileged)
        if run_as_user is not None:
            pulumi.set(__self__, "run_as_user", run_as_user)

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

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

    @property
    @pulumi.getter
    def privileged(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether to give extended privileges to this container. Default value: `false`. Valid values: `true` and `false`.
        """
        return pulumi.get(self, "privileged")

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

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

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


if not MYPY:
    class ContainerGroupContainerSecurityContextCapabilityArgsDict(TypedDict):
        adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    ContainerGroupContainerSecurityContextCapabilityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerSecurityContextCapabilityArgs:
    def __init__(__self__, *,
                 adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if adds is not None:
            pulumi.set(__self__, "adds", adds)

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

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


if not MYPY:
    class ContainerGroupContainerVolumeMountArgsDict(TypedDict):
        mount_path: NotRequired[pulumi.Input[str]]
        name: NotRequired[pulumi.Input[str]]
        read_only: NotRequired[pulumi.Input[bool]]
elif False:
    ContainerGroupContainerVolumeMountArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupContainerVolumeMountArgs:
    def __init__(__self__, *,
                 mount_path: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 read_only: Optional[pulumi.Input[bool]] = None):
        if mount_path is not None:
            pulumi.set(__self__, "mount_path", mount_path)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

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

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

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

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

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

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


if not MYPY:
    class ContainerGroupDnsConfigArgsDict(TypedDict):
        name_servers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The list of DNS server IP addresses.
        """
        options: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupDnsConfigOptionArgsDict']]]]
        """
        The structure of options. See `options` below.
        """
        searches: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The list of DNS lookup domains.
        """
elif False:
    ContainerGroupDnsConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupDnsConfigArgs:
    def __init__(__self__, *,
                 name_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 options: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupDnsConfigOptionArgs']]]] = None,
                 searches: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] name_servers: The list of DNS server IP addresses.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupDnsConfigOptionArgs']]] options: The structure of options. See `options` below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] searches: The list of DNS lookup domains.
        """
        if name_servers is not None:
            pulumi.set(__self__, "name_servers", name_servers)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if searches is not None:
            pulumi.set(__self__, "searches", searches)

    @property
    @pulumi.getter(name="nameServers")
    def name_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of DNS server IP addresses.
        """
        return pulumi.get(self, "name_servers")

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

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupDnsConfigOptionArgs']]]]:
        """
        The structure of options. See `options` below.
        """
        return pulumi.get(self, "options")

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

    @property
    @pulumi.getter
    def searches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of DNS lookup domains.
        """
        return pulumi.get(self, "searches")

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


if not MYPY:
    class ContainerGroupDnsConfigOptionArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[str]]
        value: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupDnsConfigOptionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupDnsConfigOptionArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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


if not MYPY:
    class ContainerGroupHostAliasArgsDict(TypedDict):
        hostnames: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The information about the host.
        """
        ip: NotRequired[pulumi.Input[str]]
        """
        The IP address of the host.
        """
elif False:
    ContainerGroupHostAliasArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupHostAliasArgs:
    def __init__(__self__, *,
                 hostnames: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] hostnames: The information about the host.
        :param pulumi.Input[str] ip: The IP address of the host.
        """
        if hostnames is not None:
            pulumi.set(__self__, "hostnames", hostnames)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)

    @property
    @pulumi.getter
    def hostnames(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The information about the host.
        """
        return pulumi.get(self, "hostnames")

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

    @property
    @pulumi.getter
    def ip(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address of the host.
        """
        return pulumi.get(self, "ip")

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


if not MYPY:
    class ContainerGroupImageRegistryCredentialArgsDict(TypedDict):
        password: pulumi.Input[str]
        """
        The password used to log on to the image repository. It is required when `image_registry_credential` is configured.
        """
        server: pulumi.Input[str]
        """
        The address of the image repository. It is required when `image_registry_credential` is configured.
        """
        user_name: pulumi.Input[str]
        """
        The username used to log on to the image repository. It is required when `image_registry_credential` is configured.
        """
elif False:
    ContainerGroupImageRegistryCredentialArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupImageRegistryCredentialArgs:
    def __init__(__self__, *,
                 password: pulumi.Input[str],
                 server: pulumi.Input[str],
                 user_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] password: The password used to log on to the image repository. It is required when `image_registry_credential` is configured.
        :param pulumi.Input[str] server: The address of the image repository. It is required when `image_registry_credential` is configured.
        :param pulumi.Input[str] user_name: The username used to log on to the image repository. It is required when `image_registry_credential` is configured.
        """
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter
    def password(self) -> pulumi.Input[str]:
        """
        The password used to log on to the image repository. It is required when `image_registry_credential` is configured.
        """
        return pulumi.get(self, "password")

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

    @property
    @pulumi.getter
    def server(self) -> pulumi.Input[str]:
        """
        The address of the image repository. It is required when `image_registry_credential` is configured.
        """
        return pulumi.get(self, "server")

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

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> pulumi.Input[str]:
        """
        The username used to log on to the image repository. It is required when `image_registry_credential` is configured.
        """
        return pulumi.get(self, "user_name")

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


if not MYPY:
    class ContainerGroupInitContainerArgsDict(TypedDict):
        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The arguments passed to the commands.
        """
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The commands run by the init container.
        """
        cpu: NotRequired[pulumi.Input[float]]
        """
        The amount of CPU resources allocated to the container. Default value: `0`.
        """
        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarArgsDict']]]]
        """
        The structure of environmentVars. See `environment_vars` below.
        """
        gpu: NotRequired[pulumi.Input[int]]
        """
        The number GPUs. Default value: `0`.
        """
        image: NotRequired[pulumi.Input[str]]
        """
        The image of the container.
        """
        image_pull_policy: NotRequired[pulumi.Input[str]]
        """
        The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        """
        memory: NotRequired[pulumi.Input[float]]
        """
        The amount of memory resources allocated to the container. Default value: `0`.
        """
        name: NotRequired[pulumi.Input[str]]
        """
        The name of the mounted volume.
        """
        ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerPortArgsDict']]]]
        """
        The structure of port. See `ports` below.
        """
        ready: NotRequired[pulumi.Input[bool]]
        """
        Indicates whether the container passed the readiness probe.
        """
        restart_count: NotRequired[pulumi.Input[int]]
        """
        The number of times that the container restarted.
        """
        security_contexts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextArgsDict']]]]
        """
        The security context of the container. See `security_context` below.
        """
        volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerVolumeMountArgsDict']]]]
        """
        The structure of volumeMounts. See `volume_mounts` below.
        """
        working_dir: NotRequired[pulumi.Input[str]]
        """
        The working directory of the container.
        """
elif False:
    ContainerGroupInitContainerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 cpu: Optional[pulumi.Input[float]] = None,
                 environment_vars: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarArgs']]]] = None,
                 gpu: Optional[pulumi.Input[int]] = None,
                 image: Optional[pulumi.Input[str]] = None,
                 image_pull_policy: Optional[pulumi.Input[str]] = None,
                 memory: Optional[pulumi.Input[float]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerPortArgs']]]] = None,
                 ready: Optional[pulumi.Input[bool]] = None,
                 restart_count: Optional[pulumi.Input[int]] = None,
                 security_contexts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextArgs']]]] = None,
                 volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerVolumeMountArgs']]]] = None,
                 working_dir: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] args: The arguments passed to the commands.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] commands: The commands run by the init container.
        :param pulumi.Input[float] cpu: The amount of CPU resources allocated to the container. Default value: `0`.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarArgs']]] environment_vars: The structure of environmentVars. See `environment_vars` below.
        :param pulumi.Input[int] gpu: The number GPUs. Default value: `0`.
        :param pulumi.Input[str] image: The image of the container.
        :param pulumi.Input[str] image_pull_policy: The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        :param pulumi.Input[float] memory: The amount of memory resources allocated to the container. Default value: `0`.
        :param pulumi.Input[str] name: The name of the mounted volume.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerPortArgs']]] ports: The structure of port. See `ports` below.
        :param pulumi.Input[bool] ready: Indicates whether the container passed the readiness probe.
        :param pulumi.Input[int] restart_count: The number of times that the container restarted.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextArgs']]] security_contexts: The security context of the container. See `security_context` below.
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerVolumeMountArgs']]] volume_mounts: The structure of volumeMounts. See `volume_mounts` below.
        :param pulumi.Input[str] working_dir: The working directory of the container.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if environment_vars is not None:
            pulumi.set(__self__, "environment_vars", environment_vars)
        if gpu is not None:
            pulumi.set(__self__, "gpu", gpu)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if image_pull_policy is not None:
            pulumi.set(__self__, "image_pull_policy", image_pull_policy)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if ready is not None:
            pulumi.set(__self__, "ready", ready)
        if restart_count is not None:
            pulumi.set(__self__, "restart_count", restart_count)
        if security_contexts is not None:
            pulumi.set(__self__, "security_contexts", security_contexts)
        if volume_mounts is not None:
            pulumi.set(__self__, "volume_mounts", volume_mounts)
        if working_dir is not None:
            pulumi.set(__self__, "working_dir", working_dir)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The arguments passed to the commands.
        """
        return pulumi.get(self, "args")

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

    @property
    @pulumi.getter
    def commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The commands run by the init container.
        """
        return pulumi.get(self, "commands")

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

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[float]]:
        """
        The amount of CPU resources allocated to the container. Default value: `0`.
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter(name="environmentVars")
    def environment_vars(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarArgs']]]]:
        """
        The structure of environmentVars. See `environment_vars` below.
        """
        return pulumi.get(self, "environment_vars")

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

    @property
    @pulumi.getter
    def gpu(self) -> Optional[pulumi.Input[int]]:
        """
        The number GPUs. Default value: `0`.
        """
        return pulumi.get(self, "gpu")

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

    @property
    @pulumi.getter
    def image(self) -> Optional[pulumi.Input[str]]:
        """
        The image of the container.
        """
        return pulumi.get(self, "image")

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

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The restart policy of the image. Default value: `IfNotPresent`. Valid values: `Always`, `IfNotPresent`, `Never`.
        """
        return pulumi.get(self, "image_pull_policy")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[float]]:
        """
        The amount of memory resources allocated to the container. Default value: `0`.
        """
        return pulumi.get(self, "memory")

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

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

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

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerPortArgs']]]]:
        """
        The structure of port. See `ports` below.
        """
        return pulumi.get(self, "ports")

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

    @property
    @pulumi.getter
    def ready(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the container passed the readiness probe.
        """
        return pulumi.get(self, "ready")

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

    @property
    @pulumi.getter(name="restartCount")
    def restart_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of times that the container restarted.
        """
        return pulumi.get(self, "restart_count")

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

    @property
    @pulumi.getter(name="securityContexts")
    def security_contexts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextArgs']]]]:
        """
        The security context of the container. See `security_context` below.
        """
        return pulumi.get(self, "security_contexts")

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

    @property
    @pulumi.getter(name="volumeMounts")
    def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerVolumeMountArgs']]]]:
        """
        The structure of volumeMounts. See `volume_mounts` below.
        """
        return pulumi.get(self, "volume_mounts")

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

    @property
    @pulumi.getter(name="workingDir")
    def working_dir(self) -> Optional[pulumi.Input[str]]:
        """
        The working directory of the container.
        """
        return pulumi.get(self, "working_dir")

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


if not MYPY:
    class ContainerGroupInitContainerEnvironmentVarArgsDict(TypedDict):
        field_reves: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarFieldRefArgsDict']]]]
        key: NotRequired[pulumi.Input[str]]
        value: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupInitContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerEnvironmentVarArgs:
    def __init__(__self__, *,
                 field_reves: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarFieldRefArgs']]]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if field_reves is not None:
            pulumi.set(__self__, "field_reves", field_reves)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="fieldReves")
    def field_reves(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerEnvironmentVarFieldRefArgs']]]]:
        return pulumi.get(self, "field_reves")

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

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

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

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

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


if not MYPY:
    class ContainerGroupInitContainerEnvironmentVarFieldRefArgsDict(TypedDict):
        field_path: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupInitContainerEnvironmentVarFieldRefArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerEnvironmentVarFieldRefArgs:
    def __init__(__self__, *,
                 field_path: Optional[pulumi.Input[str]] = None):
        if field_path is not None:
            pulumi.set(__self__, "field_path", field_path)

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

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


if not MYPY:
    class ContainerGroupInitContainerPortArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[int]]
        protocol: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupInitContainerPortArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerPortArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 protocol: Optional[pulumi.Input[str]] = None):
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

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

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

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

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


if not MYPY:
    class ContainerGroupInitContainerSecurityContextArgsDict(TypedDict):
        capabilities: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextCapabilityArgsDict']]]]
        run_as_user: NotRequired[pulumi.Input[int]]
elif False:
    ContainerGroupInitContainerSecurityContextArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerSecurityContextArgs:
    def __init__(__self__, *,
                 capabilities: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupInitContainerSecurityContextCapabilityArgs']]]] = None,
                 run_as_user: Optional[pulumi.Input[int]] = None):
        if capabilities is not None:
            pulumi.set(__self__, "capabilities", capabilities)
        if run_as_user is not None:
            pulumi.set(__self__, "run_as_user", run_as_user)

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

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

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

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


if not MYPY:
    class ContainerGroupInitContainerSecurityContextCapabilityArgsDict(TypedDict):
        adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
elif False:
    ContainerGroupInitContainerSecurityContextCapabilityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerSecurityContextCapabilityArgs:
    def __init__(__self__, *,
                 adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if adds is not None:
            pulumi.set(__self__, "adds", adds)

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

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


if not MYPY:
    class ContainerGroupInitContainerVolumeMountArgsDict(TypedDict):
        mount_path: NotRequired[pulumi.Input[str]]
        name: NotRequired[pulumi.Input[str]]
        read_only: NotRequired[pulumi.Input[bool]]
elif False:
    ContainerGroupInitContainerVolumeMountArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupInitContainerVolumeMountArgs:
    def __init__(__self__, *,
                 mount_path: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 read_only: Optional[pulumi.Input[bool]] = None):
        if mount_path is not None:
            pulumi.set(__self__, "mount_path", mount_path)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

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

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

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

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

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

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


if not MYPY:
    class ContainerGroupSecurityContextArgsDict(TypedDict):
        sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupSecurityContextSysctlArgsDict']]]]
        """
        Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. See `sysctl` below.
        """
elif False:
    ContainerGroupSecurityContextArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupSecurityContextArgs:
    def __init__(__self__, *,
                 sysctls: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupSecurityContextSysctlArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupSecurityContextSysctlArgs']]] sysctls: Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. See `sysctl` below.
        """
        if sysctls is not None:
            pulumi.set(__self__, "sysctls", sysctls)

    @property
    @pulumi.getter
    def sysctls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupSecurityContextSysctlArgs']]]]:
        """
        Sysctls hold a list of namespaced sysctls used for the pod. Pods with unsupported sysctls (by the container runtime) might fail to launch. See `sysctl` below.
        """
        return pulumi.get(self, "sysctls")

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


if not MYPY:
    class ContainerGroupSecurityContextSysctlArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[str]]
        value: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupSecurityContextSysctlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupSecurityContextSysctlArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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


if not MYPY:
    class ContainerGroupVolumeArgsDict(TypedDict):
        config_file_volume_config_file_to_paths: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgsDict']]]]
        """
        The paths of the ConfigFile volume. See `config_file_volume_config_file_to_paths` below.
        > **NOTE:** Every volumes mounted must have `name` and `type` attributes.
        """
        disk_volume_disk_id: NotRequired[pulumi.Input[str]]
        """
        The ID of DiskVolume.
        """
        disk_volume_fs_type: NotRequired[pulumi.Input[str]]
        """
        The system type of DiskVolume.
        """
        flex_volume_driver: NotRequired[pulumi.Input[str]]
        """
        The name of the FlexVolume driver.
        """
        flex_volume_fs_type: NotRequired[pulumi.Input[str]]
        """
        The type of the mounted file system. The default value is determined by the script of FlexVolume.
        """
        flex_volume_options: NotRequired[pulumi.Input[str]]
        """
        The list of FlexVolume objects. Each object is a key-value pair contained in a JSON string.
        """
        name: NotRequired[pulumi.Input[str]]
        """
        The name of the volume.
        """
        nfs_volume_path: NotRequired[pulumi.Input[str]]
        """
        The path to the NFS volume.
        """
        nfs_volume_read_only: NotRequired[pulumi.Input[bool]]
        """
        The nfs volume read only. Default value: `false`.
        """
        nfs_volume_server: NotRequired[pulumi.Input[str]]
        """
        The address of the NFS server.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        The type of the volume.
        """
elif False:
    ContainerGroupVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupVolumeArgs:
    def __init__(__self__, *,
                 config_file_volume_config_file_to_paths: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgs']]]] = None,
                 disk_volume_disk_id: Optional[pulumi.Input[str]] = None,
                 disk_volume_fs_type: Optional[pulumi.Input[str]] = None,
                 flex_volume_driver: Optional[pulumi.Input[str]] = None,
                 flex_volume_fs_type: Optional[pulumi.Input[str]] = None,
                 flex_volume_options: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 nfs_volume_path: Optional[pulumi.Input[str]] = None,
                 nfs_volume_read_only: Optional[pulumi.Input[bool]] = None,
                 nfs_volume_server: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgs']]] config_file_volume_config_file_to_paths: The paths of the ConfigFile volume. See `config_file_volume_config_file_to_paths` below.
               > **NOTE:** Every volumes mounted must have `name` and `type` attributes.
        :param pulumi.Input[str] disk_volume_disk_id: The ID of DiskVolume.
        :param pulumi.Input[str] disk_volume_fs_type: The system type of DiskVolume.
        :param pulumi.Input[str] flex_volume_driver: The name of the FlexVolume driver.
        :param pulumi.Input[str] flex_volume_fs_type: The type of the mounted file system. The default value is determined by the script of FlexVolume.
        :param pulumi.Input[str] flex_volume_options: The list of FlexVolume objects. Each object is a key-value pair contained in a JSON string.
        :param pulumi.Input[str] name: The name of the volume.
        :param pulumi.Input[str] nfs_volume_path: The path to the NFS volume.
        :param pulumi.Input[bool] nfs_volume_read_only: The nfs volume read only. Default value: `false`.
        :param pulumi.Input[str] nfs_volume_server: The address of the NFS server.
        :param pulumi.Input[str] type: The type of the volume.
        """
        if config_file_volume_config_file_to_paths is not None:
            pulumi.set(__self__, "config_file_volume_config_file_to_paths", config_file_volume_config_file_to_paths)
        if disk_volume_disk_id is not None:
            pulumi.set(__self__, "disk_volume_disk_id", disk_volume_disk_id)
        if disk_volume_fs_type is not None:
            pulumi.set(__self__, "disk_volume_fs_type", disk_volume_fs_type)
        if flex_volume_driver is not None:
            pulumi.set(__self__, "flex_volume_driver", flex_volume_driver)
        if flex_volume_fs_type is not None:
            pulumi.set(__self__, "flex_volume_fs_type", flex_volume_fs_type)
        if flex_volume_options is not None:
            pulumi.set(__self__, "flex_volume_options", flex_volume_options)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if nfs_volume_path is not None:
            pulumi.set(__self__, "nfs_volume_path", nfs_volume_path)
        if nfs_volume_read_only is not None:
            pulumi.set(__self__, "nfs_volume_read_only", nfs_volume_read_only)
        if nfs_volume_server is not None:
            pulumi.set(__self__, "nfs_volume_server", nfs_volume_server)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="configFileVolumeConfigFileToPaths")
    def config_file_volume_config_file_to_paths(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgs']]]]:
        """
        The paths of the ConfigFile volume. See `config_file_volume_config_file_to_paths` below.
        > **NOTE:** Every volumes mounted must have `name` and `type` attributes.
        """
        return pulumi.get(self, "config_file_volume_config_file_to_paths")

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

    @property
    @pulumi.getter(name="diskVolumeDiskId")
    def disk_volume_disk_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of DiskVolume.
        """
        return pulumi.get(self, "disk_volume_disk_id")

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

    @property
    @pulumi.getter(name="diskVolumeFsType")
    def disk_volume_fs_type(self) -> Optional[pulumi.Input[str]]:
        """
        The system type of DiskVolume.
        """
        return pulumi.get(self, "disk_volume_fs_type")

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

    @property
    @pulumi.getter(name="flexVolumeDriver")
    def flex_volume_driver(self) -> Optional[pulumi.Input[str]]:
        """
        The name of the FlexVolume driver.
        """
        return pulumi.get(self, "flex_volume_driver")

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

    @property
    @pulumi.getter(name="flexVolumeFsType")
    def flex_volume_fs_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of the mounted file system. The default value is determined by the script of FlexVolume.
        """
        return pulumi.get(self, "flex_volume_fs_type")

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

    @property
    @pulumi.getter(name="flexVolumeOptions")
    def flex_volume_options(self) -> Optional[pulumi.Input[str]]:
        """
        The list of FlexVolume objects. Each object is a key-value pair contained in a JSON string.
        """
        return pulumi.get(self, "flex_volume_options")

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

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

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

    @property
    @pulumi.getter(name="nfsVolumePath")
    def nfs_volume_path(self) -> Optional[pulumi.Input[str]]:
        """
        The path to the NFS volume.
        """
        return pulumi.get(self, "nfs_volume_path")

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

    @property
    @pulumi.getter(name="nfsVolumeReadOnly")
    def nfs_volume_read_only(self) -> Optional[pulumi.Input[bool]]:
        """
        The nfs volume read only. Default value: `false`.
        """
        return pulumi.get(self, "nfs_volume_read_only")

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

    @property
    @pulumi.getter(name="nfsVolumeServer")
    def nfs_volume_server(self) -> Optional[pulumi.Input[str]]:
        """
        The address of the NFS server.
        """
        return pulumi.get(self, "nfs_volume_server")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of the volume.
        """
        return pulumi.get(self, "type")

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


if not MYPY:
    class ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgsDict(TypedDict):
        content: NotRequired[pulumi.Input[str]]
        """
        The content of the configuration file. Maximum size: 32 KB.
        """
        path: NotRequired[pulumi.Input[str]]
elif False:
    ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ContainerGroupVolumeConfigFileVolumeConfigFileToPathArgs:
    def __init__(__self__, *,
                 content: Optional[pulumi.Input[str]] = None,
                 path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content: The content of the configuration file. Maximum size: 32 KB.
        """
        if content is not None:
            pulumi.set(__self__, "content", content)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def content(self) -> Optional[pulumi.Input[str]]:
        """
        The content of the configuration file. Maximum size: 32 KB.
        """
        return pulumi.get(self, "content")

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

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

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


if not MYPY:
    class ImageCacheImageRegistryCredentialArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[str]]
        """
        The password of the Image Registry.
        """
        server: NotRequired[pulumi.Input[str]]
        """
        The address of Image Registry without `http://` or `https://`.
        """
        user_name: NotRequired[pulumi.Input[str]]
        """
        The user name of Image Registry.
        """
elif False:
    ImageCacheImageRegistryCredentialArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ImageCacheImageRegistryCredentialArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[str]] = None,
                 server: Optional[pulumi.Input[str]] = None,
                 user_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] password: The password of the Image Registry.
        :param pulumi.Input[str] server: The address of Image Registry without `http://` or `https://`.
        :param pulumi.Input[str] user_name: The user name of Image Registry.
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if server is not None:
            pulumi.set(__self__, "server", server)
        if user_name is not None:
            pulumi.set(__self__, "user_name", user_name)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        The password of the Image Registry.
        """
        return pulumi.get(self, "password")

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

    @property
    @pulumi.getter
    def server(self) -> Optional[pulumi.Input[str]]:
        """
        The address of Image Registry without `http://` or `https://`.
        """
        return pulumi.get(self, "server")

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

    @property
    @pulumi.getter(name="userName")
    def user_name(self) -> Optional[pulumi.Input[str]]:
        """
        The user name of Image Registry.
        """
        return pulumi.get(self, "user_name")

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


if not MYPY:
    class OpenApiImageCacheImageRegistryCredentialArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[str]]
        server: NotRequired[pulumi.Input[str]]
        user_name: NotRequired[pulumi.Input[str]]
elif False:
    OpenApiImageCacheImageRegistryCredentialArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenApiImageCacheImageRegistryCredentialArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[str]] = None,
                 server: Optional[pulumi.Input[str]] = None,
                 user_name: Optional[pulumi.Input[str]] = None):
        if password is not None:
            pulumi.set(__self__, "password", password)
        if server is not None:
            pulumi.set(__self__, "server", server)
        if user_name is not None:
            pulumi.set(__self__, "user_name", user_name)

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

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

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

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

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

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


if not MYPY:
    class VirtualNodeTaintArgsDict(TypedDict):
        effect: NotRequired[pulumi.Input[str]]
        """
        The effect of the taint. Valid values: `NoSchedule`, `NoExecute` and `PreferNoSchedule`.
        """
        key: NotRequired[pulumi.Input[str]]
        """
        The key of the taint.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        The value of the taint.
        """
elif False:
    VirtualNodeTaintArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VirtualNodeTaintArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] effect: The effect of the taint. Valid values: `NoSchedule`, `NoExecute` and `PreferNoSchedule`.
        :param pulumi.Input[str] key: The key of the taint.
        :param pulumi.Input[str] value: The value of the taint.
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[str]]:
        """
        The effect of the taint. Valid values: `NoSchedule`, `NoExecute` and `PreferNoSchedule`.
        """
        return pulumi.get(self, "effect")

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

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

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

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

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


