# 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 builtins
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__ = [
    'AlarmExpressionArgs',
    'AlarmExpressionArgsDict',
    'EciScalingConfigurationAcrRegistryInfoArgs',
    'EciScalingConfigurationAcrRegistryInfoArgsDict',
    'EciScalingConfigurationContainerArgs',
    'EciScalingConfigurationContainerArgsDict',
    'EciScalingConfigurationContainerEnvironmentVarArgs',
    'EciScalingConfigurationContainerEnvironmentVarArgsDict',
    'EciScalingConfigurationContainerPortArgs',
    'EciScalingConfigurationContainerPortArgsDict',
    'EciScalingConfigurationContainerVolumeMountArgs',
    'EciScalingConfigurationContainerVolumeMountArgsDict',
    'EciScalingConfigurationDnsConfigOptionArgs',
    'EciScalingConfigurationDnsConfigOptionArgsDict',
    'EciScalingConfigurationHostAliasArgs',
    'EciScalingConfigurationHostAliasArgsDict',
    'EciScalingConfigurationImageRegistryCredentialArgs',
    'EciScalingConfigurationImageRegistryCredentialArgsDict',
    'EciScalingConfigurationInitContainerArgs',
    'EciScalingConfigurationInitContainerArgsDict',
    'EciScalingConfigurationInitContainerEnvironmentVarArgs',
    'EciScalingConfigurationInitContainerEnvironmentVarArgsDict',
    'EciScalingConfigurationInitContainerPortArgs',
    'EciScalingConfigurationInitContainerPortArgsDict',
    'EciScalingConfigurationInitContainerVolumeMountArgs',
    'EciScalingConfigurationInitContainerVolumeMountArgsDict',
    'EciScalingConfigurationSecurityContextSysctlArgs',
    'EciScalingConfigurationSecurityContextSysctlArgsDict',
    'EciScalingConfigurationVolumeArgs',
    'EciScalingConfigurationVolumeArgsDict',
    'EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs',
    'EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict',
    'ScalingConfigurationCustomPriorityArgs',
    'ScalingConfigurationCustomPriorityArgsDict',
    'ScalingConfigurationDataDiskArgs',
    'ScalingConfigurationDataDiskArgsDict',
    'ScalingConfigurationInstancePatternInfoArgs',
    'ScalingConfigurationInstancePatternInfoArgsDict',
    'ScalingConfigurationInstanceTypeOverrideArgs',
    'ScalingConfigurationInstanceTypeOverrideArgsDict',
    'ScalingConfigurationNetworkInterfaceArgs',
    'ScalingConfigurationNetworkInterfaceArgsDict',
    'ScalingConfigurationSpotPriceLimitArgs',
    'ScalingConfigurationSpotPriceLimitArgsDict',
    'ScalingGroupAlbServerGroupArgs',
    'ScalingGroupAlbServerGroupArgsDict',
    'ScalingGroupLaunchTemplateOverrideArgs',
    'ScalingGroupLaunchTemplateOverrideArgsDict',
    'ScalingGroupVServerGroupsVserverGroupArgs',
    'ScalingGroupVServerGroupsVserverGroupArgsDict',
    'ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs',
    'ScalingGroupVServerGroupsVserverGroupVserverAttributeArgsDict',
    'ScalingRuleAlarmDimensionArgs',
    'ScalingRuleAlarmDimensionArgsDict',
    'ScalingRuleHybridMetricArgs',
    'ScalingRuleHybridMetricArgsDict',
    'ScalingRuleHybridMetricDimensionArgs',
    'ScalingRuleHybridMetricDimensionArgsDict',
    'ScalingRuleStepAdjustmentArgs',
    'ScalingRuleStepAdjustmentArgsDict',
]

MYPY = False

if not MYPY:
    class AlarmExpressionArgsDict(TypedDict):
        comparison_operator: NotRequired[pulumi.Input[builtins.str]]
        """
        The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand. Supported value: >=, <=, >, <. Defaults to >=.
        """
        metric_name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name for the alarm's associated metric. See `dimensions` below for details.
        """
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        The period in seconds over which the specified statistic is applied. Supported value: 60, 120, 300, 900. Defaults to 300.
        """
        statistics: NotRequired[pulumi.Input[builtins.str]]
        """
        The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
        """
        threshold: NotRequired[pulumi.Input[builtins.float]]
        """
        The value against which the specified statistics is compared.
        """
elif False:
    AlarmExpressionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlarmExpressionArgs:
    def __init__(__self__, *,
                 comparison_operator: Optional[pulumi.Input[builtins.str]] = None,
                 metric_name: Optional[pulumi.Input[builtins.str]] = None,
                 period: Optional[pulumi.Input[builtins.int]] = None,
                 statistics: Optional[pulumi.Input[builtins.str]] = None,
                 threshold: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] comparison_operator: The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand. Supported value: >=, <=, >, <. Defaults to >=.
        :param pulumi.Input[builtins.str] metric_name: The name for the alarm's associated metric. See `dimensions` below for details.
        :param pulumi.Input[builtins.int] period: The period in seconds over which the specified statistic is applied. Supported value: 60, 120, 300, 900. Defaults to 300.
        :param pulumi.Input[builtins.str] statistics: The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
        :param pulumi.Input[builtins.float] threshold: The value against which the specified statistics is compared.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if metric_name is not None:
            pulumi.set(__self__, "metric_name", metric_name)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if statistics is not None:
            pulumi.set(__self__, "statistics", statistics)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand. Supported value: >=, <=, >, <. Defaults to >=.
        """
        return pulumi.get(self, "comparison_operator")

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

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name for the alarm's associated metric. See `dimensions` below for details.
        """
        return pulumi.get(self, "metric_name")

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

    @property
    @pulumi.getter
    def period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The period in seconds over which the specified statistic is applied. Supported value: 60, 120, 300, 900. Defaults to 300.
        """
        return pulumi.get(self, "period")

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

    @property
    @pulumi.getter
    def statistics(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
        """
        return pulumi.get(self, "statistics")

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

    @property
    @pulumi.getter
    def threshold(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The value against which the specified statistics is compared.
        """
        return pulumi.get(self, "threshold")

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


if not MYPY:
    class EciScalingConfigurationAcrRegistryInfoArgsDict(TypedDict):
        domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Endpoint of Container Registry Enterprise Edition instance. By default, all endpoints of the Container Registry Enterprise Edition instance are displayed. It is required
        when `acr_registry_info` is configured.
        """
        instance_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The ID of Container Registry Enterprise Edition instance. It is required
        when `acr_registry_info` is configured.
        """
        instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of Container Registry Enterprise Edition instance. It is required when `acr_registry_info` is
        configured.
        """
        region_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The region ID of Container Registry Enterprise Edition instance. It is required
        when `acr_registry_info` is configured.
        """
elif False:
    EciScalingConfigurationAcrRegistryInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationAcrRegistryInfoArgs:
    def __init__(__self__, *,
                 domains: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 instance_id: Optional[pulumi.Input[builtins.str]] = None,
                 instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 region_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] domains: Endpoint of Container Registry Enterprise Edition instance. By default, all endpoints of the Container Registry Enterprise Edition instance are displayed. It is required
               when `acr_registry_info` is configured.
        :param pulumi.Input[builtins.str] instance_id: The ID of Container Registry Enterprise Edition instance. It is required
               when `acr_registry_info` is configured.
        :param pulumi.Input[builtins.str] instance_name: The name of Container Registry Enterprise Edition instance. It is required when `acr_registry_info` is
               configured.
        :param pulumi.Input[builtins.str] region_id: The region ID of Container Registry Enterprise Edition instance. It is required
               when `acr_registry_info` is configured.
        """
        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[builtins.str]]]]:
        """
        Endpoint of Container Registry Enterprise Edition instance. By default, all endpoints of the Container Registry Enterprise Edition instance are displayed. It is required
        when `acr_registry_info` is configured.
        """
        return pulumi.get(self, "domains")

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The ID of Container Registry Enterprise Edition instance. It is required
        when `acr_registry_info` is configured.
        """
        return pulumi.get(self, "instance_id")

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

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of Container Registry Enterprise Edition instance. It is required when `acr_registry_info` is
        configured.
        """
        return pulumi.get(self, "instance_name")

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

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The region ID of Container Registry Enterprise Edition instance. It is required
        when `acr_registry_info` is configured.
        """
        return pulumi.get(self, "region_id")

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


if not MYPY:
    class EciScalingConfigurationContainerArgsDict(TypedDict):
        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The arguments passed to the commands.
        """
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The commands run by the init container.
        """
        cpu: NotRequired[pulumi.Input[builtins.float]]
        """
        The amount of CPU resources allocated to the container.
        """
        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerEnvironmentVarArgsDict']]]]
        """
        The structure of environmentVars.
        See `environment_vars` below for details.
        """
        gpu: NotRequired[pulumi.Input[builtins.int]]
        """
        The number GPUs.
        """
        image: NotRequired[pulumi.Input[builtins.str]]
        """
        The image of the container.
        """
        image_pull_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        The restart policy of the image.
        """
        lifecycle_pre_stop_handler_execs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The commands to be executed in containers when you use the CLI to specify the preStop callback function.
        """
        liveness_probe_exec_commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Commands that you want to run in containers when you use the CLI to perform liveness probes.
        """
        liveness_probe_failure_threshold: NotRequired[pulumi.Input[builtins.int]]
        """
        The minimum number of consecutive failures for the liveness probe to be considered failed after having been successful. Default value: 3.
        """
        liveness_probe_http_get_path: NotRequired[pulumi.Input[builtins.str]]
        """
        The path to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        """
        liveness_probe_http_get_port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        """
        liveness_probe_http_get_scheme: NotRequired[pulumi.Input[builtins.str]]
        """
        The protocol type of HTTP GET requests when you use HTTP requests for liveness probes.Valid values:HTTP and HTTPS.
        """
        liveness_probe_initial_delay_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The number of seconds after container has started before liveness probes are initiated.
        """
        liveness_probe_period_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The interval at which the liveness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        """
        liveness_probe_success_threshold: NotRequired[pulumi.Input[builtins.int]]
        """
        The minimum number of consecutive successes for the liveness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        """
        liveness_probe_tcp_socket_port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port detected by TCP sockets when you use TCP sockets to perform liveness probes.
        """
        liveness_probe_timeout_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The timeout period for the liveness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        """
        memory: NotRequired[pulumi.Input[builtins.float]]
        """
        The amount of memory resources allocated to the container.
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the mounted volume.
        """
        ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerPortArgsDict']]]]
        """
        The structure of port. See `ports` below for details.
        """
        readiness_probe_exec_commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Commands that you want to run in containers when you use the CLI to perform readiness probes.
        """
        readiness_probe_failure_threshold: NotRequired[pulumi.Input[builtins.int]]
        """
        The minimum number of consecutive failures for the readiness probe to be considered failed after having been successful. Default value: 3.
        """
        readiness_probe_http_get_path: NotRequired[pulumi.Input[builtins.str]]
        """
        The path to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        """
        readiness_probe_http_get_port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        """
        readiness_probe_http_get_scheme: NotRequired[pulumi.Input[builtins.str]]
        """
        The protocol type of HTTP GET requests when you use HTTP requests for readiness probes. Valid values: HTTP and HTTPS.
        """
        readiness_probe_initial_delay_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The number of seconds after container N has started before readiness probes are initiated.
        """
        readiness_probe_period_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The interval at which the readiness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        """
        readiness_probe_success_threshold: NotRequired[pulumi.Input[builtins.int]]
        """
        The minimum number of consecutive successes for the readiness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        """
        readiness_probe_tcp_socket_port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port detected by Transmission Control Protocol (TCP) sockets when you use TCP sockets to perform readiness probes.
        """
        readiness_probe_timeout_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The timeout period for the readiness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        """
        security_context_capability_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Grant certain permissions to processes within container. Optional values:
        - NET_ADMIN: Allow network management tasks to be performed.
        - NET_RAW: Allow raw sockets.
        """
        security_context_read_only_root_file_system: NotRequired[pulumi.Input[builtins.bool]]
        """
        Mounts the container's root filesystem as read-only.
        """
        security_context_run_as_user: NotRequired[pulumi.Input[builtins.int]]
        """
        Specifies user ID  under which all processes run.
        """
        stdin: NotRequired[pulumi.Input[builtins.bool]]
        """
        Specifies whether container N allocates buffer resources to standard input streams during its active runtime. If you do not specify this parameter, an end-of-file (EOF) error occurs.
        """
        tty: NotRequired[pulumi.Input[builtins.bool]]
        """
        Specifies whether to enable the Interaction feature. Valid values: true, false.
        """
        volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerVolumeMountArgsDict']]]]
        """
        The structure of volumeMounts. 
        See `volume_mounts` below for details.
        """
        working_dir: NotRequired[pulumi.Input[builtins.str]]
        """
        The working directory of the container.
        """
elif False:
    EciScalingConfigurationContainerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationContainerArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 cpu: Optional[pulumi.Input[builtins.float]] = None,
                 environment_vars: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerEnvironmentVarArgs']]]] = None,
                 gpu: Optional[pulumi.Input[builtins.int]] = None,
                 image: Optional[pulumi.Input[builtins.str]] = None,
                 image_pull_policy: Optional[pulumi.Input[builtins.str]] = None,
                 lifecycle_pre_stop_handler_execs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 liveness_probe_exec_commands: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 liveness_probe_failure_threshold: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_http_get_path: Optional[pulumi.Input[builtins.str]] = None,
                 liveness_probe_http_get_port: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_http_get_scheme: Optional[pulumi.Input[builtins.str]] = None,
                 liveness_probe_initial_delay_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_period_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_success_threshold: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_tcp_socket_port: Optional[pulumi.Input[builtins.int]] = None,
                 liveness_probe_timeout_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 memory: Optional[pulumi.Input[builtins.float]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerPortArgs']]]] = None,
                 readiness_probe_exec_commands: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 readiness_probe_failure_threshold: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_http_get_path: Optional[pulumi.Input[builtins.str]] = None,
                 readiness_probe_http_get_port: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_http_get_scheme: Optional[pulumi.Input[builtins.str]] = None,
                 readiness_probe_initial_delay_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_period_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_success_threshold: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_tcp_socket_port: Optional[pulumi.Input[builtins.int]] = None,
                 readiness_probe_timeout_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 security_context_capability_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 security_context_read_only_root_file_system: Optional[pulumi.Input[builtins.bool]] = None,
                 security_context_run_as_user: Optional[pulumi.Input[builtins.int]] = None,
                 stdin: Optional[pulumi.Input[builtins.bool]] = None,
                 tty: Optional[pulumi.Input[builtins.bool]] = None,
                 volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerVolumeMountArgs']]]] = None,
                 working_dir: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] args: The arguments passed to the commands.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] commands: The commands run by the init container.
        :param pulumi.Input[builtins.float] cpu: The amount of CPU resources allocated to the container.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerEnvironmentVarArgs']]] environment_vars: The structure of environmentVars.
               See `environment_vars` below for details.
        :param pulumi.Input[builtins.int] gpu: The number GPUs.
        :param pulumi.Input[builtins.str] image: The image of the container.
        :param pulumi.Input[builtins.str] image_pull_policy: The restart policy of the image.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.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[builtins.str]]] liveness_probe_exec_commands: Commands that you want to run in containers when you use the CLI to perform liveness probes.
        :param pulumi.Input[builtins.int] liveness_probe_failure_threshold: The minimum number of consecutive failures for the liveness probe to be considered failed after having been successful. Default value: 3.
        :param pulumi.Input[builtins.str] liveness_probe_http_get_path: The path to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        :param pulumi.Input[builtins.int] liveness_probe_http_get_port: The port to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        :param pulumi.Input[builtins.str] liveness_probe_http_get_scheme: The protocol type of HTTP GET requests when you use HTTP requests for liveness probes.Valid values:HTTP and HTTPS.
        :param pulumi.Input[builtins.int] liveness_probe_initial_delay_seconds: The number of seconds after container has started before liveness probes are initiated.
        :param pulumi.Input[builtins.int] liveness_probe_period_seconds: The interval at which the liveness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        :param pulumi.Input[builtins.int] liveness_probe_success_threshold: The minimum number of consecutive successes for the liveness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        :param pulumi.Input[builtins.int] liveness_probe_tcp_socket_port: The port detected by TCP sockets when you use TCP sockets to perform liveness probes.
        :param pulumi.Input[builtins.int] liveness_probe_timeout_seconds: The timeout period for the liveness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        :param pulumi.Input[builtins.float] memory: The amount of memory resources allocated to the container.
        :param pulumi.Input[builtins.str] name: The name of the mounted volume.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerPortArgs']]] ports: The structure of port. See `ports` below for details.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] readiness_probe_exec_commands: Commands that you want to run in containers when you use the CLI to perform readiness probes.
        :param pulumi.Input[builtins.int] readiness_probe_failure_threshold: The minimum number of consecutive failures for the readiness probe to be considered failed after having been successful. Default value: 3.
        :param pulumi.Input[builtins.str] readiness_probe_http_get_path: The path to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        :param pulumi.Input[builtins.int] readiness_probe_http_get_port: The port to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        :param pulumi.Input[builtins.str] readiness_probe_http_get_scheme: The protocol type of HTTP GET requests when you use HTTP requests for readiness probes. Valid values: HTTP and HTTPS.
        :param pulumi.Input[builtins.int] readiness_probe_initial_delay_seconds: The number of seconds after container N has started before readiness probes are initiated.
        :param pulumi.Input[builtins.int] readiness_probe_period_seconds: The interval at which the readiness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        :param pulumi.Input[builtins.int] readiness_probe_success_threshold: The minimum number of consecutive successes for the readiness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        :param pulumi.Input[builtins.int] readiness_probe_tcp_socket_port: The port detected by Transmission Control Protocol (TCP) sockets when you use TCP sockets to perform readiness probes.
        :param pulumi.Input[builtins.int] readiness_probe_timeout_seconds: The timeout period for the readiness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_context_capability_adds: Grant certain permissions to processes within container. Optional values:
               - NET_ADMIN: Allow network management tasks to be performed.
               - NET_RAW: Allow raw sockets.
        :param pulumi.Input[builtins.bool] security_context_read_only_root_file_system: Mounts the container's root filesystem as read-only.
        :param pulumi.Input[builtins.int] security_context_run_as_user: Specifies user ID  under which all processes run.
        :param pulumi.Input[builtins.bool] stdin: Specifies whether container N allocates buffer resources to standard input streams during its active runtime. If you do not specify this parameter, an end-of-file (EOF) error occurs.
        :param pulumi.Input[builtins.bool] tty: Specifies whether to enable the Interaction feature. Valid values: true, false.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerVolumeMountArgs']]] volume_mounts: The structure of volumeMounts. 
               See `volume_mounts` below for details.
        :param pulumi.Input[builtins.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 lifecycle_pre_stop_handler_execs is not None:
            pulumi.set(__self__, "lifecycle_pre_stop_handler_execs", lifecycle_pre_stop_handler_execs)
        if liveness_probe_exec_commands is not None:
            pulumi.set(__self__, "liveness_probe_exec_commands", liveness_probe_exec_commands)
        if liveness_probe_failure_threshold is not None:
            pulumi.set(__self__, "liveness_probe_failure_threshold", liveness_probe_failure_threshold)
        if liveness_probe_http_get_path is not None:
            pulumi.set(__self__, "liveness_probe_http_get_path", liveness_probe_http_get_path)
        if liveness_probe_http_get_port is not None:
            pulumi.set(__self__, "liveness_probe_http_get_port", liveness_probe_http_get_port)
        if liveness_probe_http_get_scheme is not None:
            pulumi.set(__self__, "liveness_probe_http_get_scheme", liveness_probe_http_get_scheme)
        if liveness_probe_initial_delay_seconds is not None:
            pulumi.set(__self__, "liveness_probe_initial_delay_seconds", liveness_probe_initial_delay_seconds)
        if liveness_probe_period_seconds is not None:
            pulumi.set(__self__, "liveness_probe_period_seconds", liveness_probe_period_seconds)
        if liveness_probe_success_threshold is not None:
            pulumi.set(__self__, "liveness_probe_success_threshold", liveness_probe_success_threshold)
        if liveness_probe_tcp_socket_port is not None:
            pulumi.set(__self__, "liveness_probe_tcp_socket_port", liveness_probe_tcp_socket_port)
        if liveness_probe_timeout_seconds is not None:
            pulumi.set(__self__, "liveness_probe_timeout_seconds", liveness_probe_timeout_seconds)
        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 readiness_probe_exec_commands is not None:
            pulumi.set(__self__, "readiness_probe_exec_commands", readiness_probe_exec_commands)
        if readiness_probe_failure_threshold is not None:
            pulumi.set(__self__, "readiness_probe_failure_threshold", readiness_probe_failure_threshold)
        if readiness_probe_http_get_path is not None:
            pulumi.set(__self__, "readiness_probe_http_get_path", readiness_probe_http_get_path)
        if readiness_probe_http_get_port is not None:
            pulumi.set(__self__, "readiness_probe_http_get_port", readiness_probe_http_get_port)
        if readiness_probe_http_get_scheme is not None:
            pulumi.set(__self__, "readiness_probe_http_get_scheme", readiness_probe_http_get_scheme)
        if readiness_probe_initial_delay_seconds is not None:
            pulumi.set(__self__, "readiness_probe_initial_delay_seconds", readiness_probe_initial_delay_seconds)
        if readiness_probe_period_seconds is not None:
            pulumi.set(__self__, "readiness_probe_period_seconds", readiness_probe_period_seconds)
        if readiness_probe_success_threshold is not None:
            pulumi.set(__self__, "readiness_probe_success_threshold", readiness_probe_success_threshold)
        if readiness_probe_tcp_socket_port is not None:
            pulumi.set(__self__, "readiness_probe_tcp_socket_port", readiness_probe_tcp_socket_port)
        if readiness_probe_timeout_seconds is not None:
            pulumi.set(__self__, "readiness_probe_timeout_seconds", readiness_probe_timeout_seconds)
        if security_context_capability_adds is not None:
            pulumi.set(__self__, "security_context_capability_adds", security_context_capability_adds)
        if security_context_read_only_root_file_system is not None:
            pulumi.set(__self__, "security_context_read_only_root_file_system", security_context_read_only_root_file_system)
        if security_context_run_as_user is not None:
            pulumi.set(__self__, "security_context_run_as_user", security_context_run_as_user)
        if stdin is not None:
            pulumi.set(__self__, "stdin", stdin)
        if tty is not None:
            pulumi.set(__self__, "tty", tty)
        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[builtins.str]]]]:
        """
        The arguments passed to the commands.
        """
        return pulumi.get(self, "args")

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

    @property
    @pulumi.getter
    def commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.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[builtins.str]]]]):
        pulumi.set(self, "commands", value)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The restart policy of the image.
        """
        return pulumi.get(self, "image_pull_policy")

    @image_pull_policy.setter
    def image_pull_policy(self, value: Optional[pulumi.Input[builtins.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[builtins.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[builtins.str]]]]):
        pulumi.set(self, "lifecycle_pre_stop_handler_execs", value)

    @property
    @pulumi.getter(name="livenessProbeExecCommands")
    def liveness_probe_exec_commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Commands that you want to run in containers when you use the CLI to perform liveness probes.
        """
        return pulumi.get(self, "liveness_probe_exec_commands")

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

    @property
    @pulumi.getter(name="livenessProbeFailureThreshold")
    def liveness_probe_failure_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The minimum number of consecutive failures for the liveness probe to be considered failed after having been successful. Default value: 3.
        """
        return pulumi.get(self, "liveness_probe_failure_threshold")

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

    @property
    @pulumi.getter(name="livenessProbeHttpGetPath")
    def liveness_probe_http_get_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The path to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        """
        return pulumi.get(self, "liveness_probe_http_get_path")

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

    @property
    @pulumi.getter(name="livenessProbeHttpGetPort")
    def liveness_probe_http_get_port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port to which HTTP GET requests are sent when you use HTTP requests to perform liveness probes.
        """
        return pulumi.get(self, "liveness_probe_http_get_port")

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

    @property
    @pulumi.getter(name="livenessProbeHttpGetScheme")
    def liveness_probe_http_get_scheme(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The protocol type of HTTP GET requests when you use HTTP requests for liveness probes.Valid values:HTTP and HTTPS.
        """
        return pulumi.get(self, "liveness_probe_http_get_scheme")

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

    @property
    @pulumi.getter(name="livenessProbeInitialDelaySeconds")
    def liveness_probe_initial_delay_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The number of seconds after container has started before liveness probes are initiated.
        """
        return pulumi.get(self, "liveness_probe_initial_delay_seconds")

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

    @property
    @pulumi.getter(name="livenessProbePeriodSeconds")
    def liveness_probe_period_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The interval at which the liveness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        """
        return pulumi.get(self, "liveness_probe_period_seconds")

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

    @property
    @pulumi.getter(name="livenessProbeSuccessThreshold")
    def liveness_probe_success_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The minimum number of consecutive successes for the liveness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        """
        return pulumi.get(self, "liveness_probe_success_threshold")

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

    @property
    @pulumi.getter(name="livenessProbeTcpSocketPort")
    def liveness_probe_tcp_socket_port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port detected by TCP sockets when you use TCP sockets to perform liveness probes.
        """
        return pulumi.get(self, "liveness_probe_tcp_socket_port")

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

    @property
    @pulumi.getter(name="livenessProbeTimeoutSeconds")
    def liveness_probe_timeout_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The timeout period for the liveness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        """
        return pulumi.get(self, "liveness_probe_timeout_seconds")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="readinessProbeExecCommands")
    def readiness_probe_exec_commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Commands that you want to run in containers when you use the CLI to perform readiness probes.
        """
        return pulumi.get(self, "readiness_probe_exec_commands")

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

    @property
    @pulumi.getter(name="readinessProbeFailureThreshold")
    def readiness_probe_failure_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The minimum number of consecutive failures for the readiness probe to be considered failed after having been successful. Default value: 3.
        """
        return pulumi.get(self, "readiness_probe_failure_threshold")

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

    @property
    @pulumi.getter(name="readinessProbeHttpGetPath")
    def readiness_probe_http_get_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The path to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        """
        return pulumi.get(self, "readiness_probe_http_get_path")

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

    @property
    @pulumi.getter(name="readinessProbeHttpGetPort")
    def readiness_probe_http_get_port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port to which HTTP GET requests are sent when you use HTTP requests to perform readiness probes.
        """
        return pulumi.get(self, "readiness_probe_http_get_port")

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

    @property
    @pulumi.getter(name="readinessProbeHttpGetScheme")
    def readiness_probe_http_get_scheme(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The protocol type of HTTP GET requests when you use HTTP requests for readiness probes. Valid values: HTTP and HTTPS.
        """
        return pulumi.get(self, "readiness_probe_http_get_scheme")

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

    @property
    @pulumi.getter(name="readinessProbeInitialDelaySeconds")
    def readiness_probe_initial_delay_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The number of seconds after container N has started before readiness probes are initiated.
        """
        return pulumi.get(self, "readiness_probe_initial_delay_seconds")

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

    @property
    @pulumi.getter(name="readinessProbePeriodSeconds")
    def readiness_probe_period_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The interval at which the readiness probe is performed. Unit: seconds. Default value: 10. Minimum value: 1.
        """
        return pulumi.get(self, "readiness_probe_period_seconds")

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

    @property
    @pulumi.getter(name="readinessProbeSuccessThreshold")
    def readiness_probe_success_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The minimum number of consecutive successes for the readiness probe to be considered successful after having failed. Default value: 1. Set the value to 1.
        """
        return pulumi.get(self, "readiness_probe_success_threshold")

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

    @property
    @pulumi.getter(name="readinessProbeTcpSocketPort")
    def readiness_probe_tcp_socket_port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port detected by Transmission Control Protocol (TCP) sockets when you use TCP sockets to perform readiness probes.
        """
        return pulumi.get(self, "readiness_probe_tcp_socket_port")

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

    @property
    @pulumi.getter(name="readinessProbeTimeoutSeconds")
    def readiness_probe_timeout_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The timeout period for the readiness probe. Unit: seconds. Default value: 1. Minimum value: 1.
        """
        return pulumi.get(self, "readiness_probe_timeout_seconds")

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

    @property
    @pulumi.getter(name="securityContextCapabilityAdds")
    def security_context_capability_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Grant certain permissions to processes within container. Optional values:
        - NET_ADMIN: Allow network management tasks to be performed.
        - NET_RAW: Allow raw sockets.
        """
        return pulumi.get(self, "security_context_capability_adds")

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

    @property
    @pulumi.getter(name="securityContextReadOnlyRootFileSystem")
    def security_context_read_only_root_file_system(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Mounts the container's root filesystem as read-only.
        """
        return pulumi.get(self, "security_context_read_only_root_file_system")

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

    @property
    @pulumi.getter(name="securityContextRunAsUser")
    def security_context_run_as_user(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Specifies user ID  under which all processes run.
        """
        return pulumi.get(self, "security_context_run_as_user")

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

    @property
    @pulumi.getter
    def stdin(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Specifies whether container N allocates buffer resources to standard input streams during its active runtime. If you do not specify this parameter, an end-of-file (EOF) error occurs.
        """
        return pulumi.get(self, "stdin")

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

    @property
    @pulumi.getter
    def tty(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Specifies whether to enable the Interaction feature. Valid values: true, false.
        """
        return pulumi.get(self, "tty")

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

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

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

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

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


if not MYPY:
    class EciScalingConfigurationContainerEnvironmentVarArgsDict(TypedDict):
        field_ref_field_path: NotRequired[pulumi.Input[builtins.str]]
        key: NotRequired[pulumi.Input[builtins.str]]
        value: NotRequired[pulumi.Input[builtins.str]]
elif False:
    EciScalingConfigurationContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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

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

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


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

@pulumi.input_type
class EciScalingConfigurationContainerPortArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[builtins.int]] = None,
                 protocol: Optional[pulumi.Input[builtins.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[builtins.int]]:
        return pulumi.get(self, "port")

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

@pulumi.input_type
class EciScalingConfigurationDnsConfigOptionArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: The option name.
        :param pulumi.Input[builtins.str] value: The option value.
        """
        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[builtins.str]]:
        """
        The option name.
        """
        return pulumi.get(self, "name")

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

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

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


if not MYPY:
    class EciScalingConfigurationHostAliasArgsDict(TypedDict):
        hostnames: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Adds a host name.
        """
        ip: NotRequired[pulumi.Input[builtins.str]]
        """
        Adds an IP address.
        """
elif False:
    EciScalingConfigurationHostAliasArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationHostAliasArgs:
    def __init__(__self__, *,
                 hostnames: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 ip: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] hostnames: Adds a host name.
        :param pulumi.Input[builtins.str] ip: Adds an IP address.
        """
        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[builtins.str]]]]:
        """
        Adds a host name.
        """
        return pulumi.get(self, "hostnames")

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

    @property
    @pulumi.getter
    def ip(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Adds an IP address.
        """
        return pulumi.get(self, "ip")

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


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

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

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[builtins.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: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter
    def server(self) -> Optional[pulumi.Input[builtins.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: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "server", value)

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

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


if not MYPY:
    class EciScalingConfigurationInitContainerArgsDict(TypedDict):
        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The arguments passed to the commands.
        """
        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The commands run by the init container.
        """
        cpu: NotRequired[pulumi.Input[builtins.float]]
        """
        The amount of CPU resources allocated to the container.
        """
        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerEnvironmentVarArgsDict']]]]
        """
        The structure of environmentVars. 
        See `environment_vars` below for details.
        """
        gpu: NotRequired[pulumi.Input[builtins.int]]
        """
        The number GPUs.
        """
        image: NotRequired[pulumi.Input[builtins.str]]
        """
        The image of the container.
        """
        image_pull_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        The restart policy of the image.
        """
        memory: NotRequired[pulumi.Input[builtins.float]]
        """
        The amount of memory resources allocated to the container.
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the mounted volume.
        """
        ports: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerPortArgsDict']]]]
        """
        The structure of port. See `ports` below for details.
        """
        security_context_capability_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Grant certain permissions to processes within container. Optional values:
        - NET_ADMIN: Allow network management tasks to be performed.
        - NET_RAW: Allow raw sockets.
        """
        security_context_read_only_root_file_system: NotRequired[pulumi.Input[builtins.bool]]
        """
        Mounts the container's root filesystem as read-only.
        """
        security_context_run_as_user: NotRequired[pulumi.Input[builtins.int]]
        """
        Specifies user ID  under which all processes run.
        """
        volume_mounts: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerVolumeMountArgsDict']]]]
        """
        The structure of volumeMounts. See `volume_mounts` below for details.
        """
        working_dir: NotRequired[pulumi.Input[builtins.str]]
        """
        The working directory of the container.
        """
elif False:
    EciScalingConfigurationInitContainerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationInitContainerArgs:
    def __init__(__self__, *,
                 args: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 commands: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 cpu: Optional[pulumi.Input[builtins.float]] = None,
                 environment_vars: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerEnvironmentVarArgs']]]] = None,
                 gpu: Optional[pulumi.Input[builtins.int]] = None,
                 image: Optional[pulumi.Input[builtins.str]] = None,
                 image_pull_policy: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.float]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerPortArgs']]]] = None,
                 security_context_capability_adds: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 security_context_read_only_root_file_system: Optional[pulumi.Input[builtins.bool]] = None,
                 security_context_run_as_user: Optional[pulumi.Input[builtins.int]] = None,
                 volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerVolumeMountArgs']]]] = None,
                 working_dir: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] args: The arguments passed to the commands.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] commands: The commands run by the init container.
        :param pulumi.Input[builtins.float] cpu: The amount of CPU resources allocated to the container.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerEnvironmentVarArgs']]] environment_vars: The structure of environmentVars. 
               See `environment_vars` below for details.
        :param pulumi.Input[builtins.int] gpu: The number GPUs.
        :param pulumi.Input[builtins.str] image: The image of the container.
        :param pulumi.Input[builtins.str] image_pull_policy: The restart policy of the image.
        :param pulumi.Input[builtins.float] memory: The amount of memory resources allocated to the container.
        :param pulumi.Input[builtins.str] name: The name of the mounted volume.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerPortArgs']]] ports: The structure of port. See `ports` below for details.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_context_capability_adds: Grant certain permissions to processes within container. Optional values:
               - NET_ADMIN: Allow network management tasks to be performed.
               - NET_RAW: Allow raw sockets.
        :param pulumi.Input[builtins.bool] security_context_read_only_root_file_system: Mounts the container's root filesystem as read-only.
        :param pulumi.Input[builtins.int] security_context_run_as_user: Specifies user ID  under which all processes run.
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerVolumeMountArgs']]] volume_mounts: The structure of volumeMounts. See `volume_mounts` below for details.
        :param pulumi.Input[builtins.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 security_context_capability_adds is not None:
            pulumi.set(__self__, "security_context_capability_adds", security_context_capability_adds)
        if security_context_read_only_root_file_system is not None:
            pulumi.set(__self__, "security_context_read_only_root_file_system", security_context_read_only_root_file_system)
        if security_context_run_as_user is not None:
            pulumi.set(__self__, "security_context_run_as_user", security_context_run_as_user)
        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[builtins.str]]]]:
        """
        The arguments passed to the commands.
        """
        return pulumi.get(self, "args")

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

    @property
    @pulumi.getter
    def commands(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.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[builtins.str]]]]):
        pulumi.set(self, "commands", value)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The restart policy of the image.
        """
        return pulumi.get(self, "image_pull_policy")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="securityContextCapabilityAdds")
    def security_context_capability_adds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Grant certain permissions to processes within container. Optional values:
        - NET_ADMIN: Allow network management tasks to be performed.
        - NET_RAW: Allow raw sockets.
        """
        return pulumi.get(self, "security_context_capability_adds")

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

    @property
    @pulumi.getter(name="securityContextReadOnlyRootFileSystem")
    def security_context_read_only_root_file_system(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Mounts the container's root filesystem as read-only.
        """
        return pulumi.get(self, "security_context_read_only_root_file_system")

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

    @property
    @pulumi.getter(name="securityContextRunAsUser")
    def security_context_run_as_user(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Specifies user ID  under which all processes run.
        """
        return pulumi.get(self, "security_context_run_as_user")

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

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

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

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

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


if not MYPY:
    class EciScalingConfigurationInitContainerEnvironmentVarArgsDict(TypedDict):
        field_ref_field_path: NotRequired[pulumi.Input[builtins.str]]
        key: NotRequired[pulumi.Input[builtins.str]]
        value: NotRequired[pulumi.Input[builtins.str]]
elif False:
    EciScalingConfigurationInitContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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

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

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


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

@pulumi.input_type
class EciScalingConfigurationInitContainerPortArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[builtins.int]] = None,
                 protocol: Optional[pulumi.Input[builtins.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[builtins.int]]:
        return pulumi.get(self, "port")

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class EciScalingConfigurationSecurityContextSysctlArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        The system name of the security context in which the elastic container instance is run.
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        The system value of the security context in which the elastic container instance is run.
        """
elif False:
    EciScalingConfigurationSecurityContextSysctlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationSecurityContextSysctlArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: The system name of the security context in which the elastic container instance is run.
        :param pulumi.Input[builtins.str] value: The system value of the security context in which the elastic container instance is run.
        """
        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[builtins.str]]:
        """
        The system name of the security context in which the elastic container instance is run.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The system value of the security context in which the elastic container instance is run.
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class EciScalingConfigurationVolumeArgsDict(TypedDict):
        config_file_volume_config_file_to_paths: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict']]]]
        """
        ConfigFileVolumeConfigFileToPaths.
        See `config_file_volume_config_file_to_paths` below for details.
        """
        config_file_volume_default_mode: NotRequired[pulumi.Input[builtins.int]]
        """
        The default permissions on the ConfigFileVolume.
        """
        disk_volume_disk_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The ID of DiskVolume.
        """
        disk_volume_disk_size: NotRequired[pulumi.Input[builtins.int]]
        """
        The disk size of DiskVolume.
        """
        disk_volume_fs_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The system type of DiskVolume.
        """
        empty_dir_volume_medium: NotRequired[pulumi.Input[builtins.str]]
        """
        The storage medium of the EmptyDirVolume. If you leave this parameter empty, the file system of the node is used as the storage medium. If you set this parameter to memory, the memory is used as the storage medium.
        """
        empty_dir_volume_size_limit: NotRequired[pulumi.Input[builtins.str]]
        """
        The storage size of the EmptyDirVolume. Unit: GiB or MiB.
        """
        flex_volume_driver: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the FlexVolume driver.
        """
        flex_volume_fs_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The type of the mounted file system. The default value is determined by the script
        of FlexVolume.
        """
        flex_volume_options: NotRequired[pulumi.Input[builtins.str]]
        """
        The list of FlexVolume objects. Each object is a key-value pair contained in a JSON
        string.
        """
        host_path_volume_path: NotRequired[pulumi.Input[builtins.str]]
        """
        The absolute path on the host.
        """
        host_path_volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The type of the host path. Examples: File, Directory, and Socket.
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the volume.
        """
        nfs_volume_path: NotRequired[pulumi.Input[builtins.str]]
        """
        The path to the NFS volume.
        """
        nfs_volume_read_only: NotRequired[pulumi.Input[builtins.bool]]
        """
        The nfs volume read only. Default to `false`.
        """
        nfs_volume_server: NotRequired[pulumi.Input[builtins.str]]
        """
        The address of the NFS server.

        > **NOTE:** Every volume mounted must have a name and type attributes.
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        The type of the volume.
        """
elif False:
    EciScalingConfigurationVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationVolumeArgs:
    def __init__(__self__, *,
                 config_file_volume_config_file_to_paths: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs']]]] = None,
                 config_file_volume_default_mode: Optional[pulumi.Input[builtins.int]] = None,
                 disk_volume_disk_id: Optional[pulumi.Input[builtins.str]] = None,
                 disk_volume_disk_size: Optional[pulumi.Input[builtins.int]] = None,
                 disk_volume_fs_type: Optional[pulumi.Input[builtins.str]] = None,
                 empty_dir_volume_medium: Optional[pulumi.Input[builtins.str]] = None,
                 empty_dir_volume_size_limit: Optional[pulumi.Input[builtins.str]] = None,
                 flex_volume_driver: Optional[pulumi.Input[builtins.str]] = None,
                 flex_volume_fs_type: Optional[pulumi.Input[builtins.str]] = None,
                 flex_volume_options: Optional[pulumi.Input[builtins.str]] = None,
                 host_path_volume_path: Optional[pulumi.Input[builtins.str]] = None,
                 host_path_volume_type: Optional[pulumi.Input[builtins.str]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 nfs_volume_path: Optional[pulumi.Input[builtins.str]] = None,
                 nfs_volume_read_only: Optional[pulumi.Input[builtins.bool]] = None,
                 nfs_volume_server: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs']]] config_file_volume_config_file_to_paths: ConfigFileVolumeConfigFileToPaths.
               See `config_file_volume_config_file_to_paths` below for details.
        :param pulumi.Input[builtins.int] config_file_volume_default_mode: The default permissions on the ConfigFileVolume.
        :param pulumi.Input[builtins.str] disk_volume_disk_id: The ID of DiskVolume.
        :param pulumi.Input[builtins.int] disk_volume_disk_size: The disk size of DiskVolume.
        :param pulumi.Input[builtins.str] disk_volume_fs_type: The system type of DiskVolume.
        :param pulumi.Input[builtins.str] empty_dir_volume_medium: The storage medium of the EmptyDirVolume. If you leave this parameter empty, the file system of the node is used as the storage medium. If you set this parameter to memory, the memory is used as the storage medium.
        :param pulumi.Input[builtins.str] empty_dir_volume_size_limit: The storage size of the EmptyDirVolume. Unit: GiB or MiB.
        :param pulumi.Input[builtins.str] flex_volume_driver: The name of the FlexVolume driver.
        :param pulumi.Input[builtins.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[builtins.str] flex_volume_options: The list of FlexVolume objects. Each object is a key-value pair contained in a JSON
               string.
        :param pulumi.Input[builtins.str] host_path_volume_path: The absolute path on the host.
        :param pulumi.Input[builtins.str] host_path_volume_type: The type of the host path. Examples: File, Directory, and Socket.
        :param pulumi.Input[builtins.str] name: The name of the volume.
        :param pulumi.Input[builtins.str] nfs_volume_path: The path to the NFS volume.
        :param pulumi.Input[builtins.bool] nfs_volume_read_only: The nfs volume read only. Default to `false`.
        :param pulumi.Input[builtins.str] nfs_volume_server: The address of the NFS server.
               
               > **NOTE:** Every volume mounted must have a name and type attributes.
        :param pulumi.Input[builtins.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 config_file_volume_default_mode is not None:
            pulumi.set(__self__, "config_file_volume_default_mode", config_file_volume_default_mode)
        if disk_volume_disk_id is not None:
            pulumi.set(__self__, "disk_volume_disk_id", disk_volume_disk_id)
        if disk_volume_disk_size is not None:
            pulumi.set(__self__, "disk_volume_disk_size", disk_volume_disk_size)
        if disk_volume_fs_type is not None:
            pulumi.set(__self__, "disk_volume_fs_type", disk_volume_fs_type)
        if empty_dir_volume_medium is not None:
            pulumi.set(__self__, "empty_dir_volume_medium", empty_dir_volume_medium)
        if empty_dir_volume_size_limit is not None:
            pulumi.set(__self__, "empty_dir_volume_size_limit", empty_dir_volume_size_limit)
        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 host_path_volume_path is not None:
            pulumi.set(__self__, "host_path_volume_path", host_path_volume_path)
        if host_path_volume_type is not None:
            pulumi.set(__self__, "host_path_volume_type", host_path_volume_type)
        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['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs']]]]:
        """
        ConfigFileVolumeConfigFileToPaths.
        See `config_file_volume_config_file_to_paths` below for details.
        """
        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['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs']]]]):
        pulumi.set(self, "config_file_volume_config_file_to_paths", value)

    @property
    @pulumi.getter(name="configFileVolumeDefaultMode")
    def config_file_volume_default_mode(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The default permissions on the ConfigFileVolume.
        """
        return pulumi.get(self, "config_file_volume_default_mode")

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

    @property
    @pulumi.getter(name="diskVolumeDiskId")
    def disk_volume_disk_id(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "disk_volume_disk_id", value)

    @property
    @pulumi.getter(name="diskVolumeDiskSize")
    def disk_volume_disk_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The disk size of DiskVolume.
        """
        return pulumi.get(self, "disk_volume_disk_size")

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

    @property
    @pulumi.getter(name="diskVolumeFsType")
    def disk_volume_fs_type(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "disk_volume_fs_type", value)

    @property
    @pulumi.getter(name="emptyDirVolumeMedium")
    def empty_dir_volume_medium(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The storage medium of the EmptyDirVolume. If you leave this parameter empty, the file system of the node is used as the storage medium. If you set this parameter to memory, the memory is used as the storage medium.
        """
        return pulumi.get(self, "empty_dir_volume_medium")

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

    @property
    @pulumi.getter(name="emptyDirVolumeSizeLimit")
    def empty_dir_volume_size_limit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The storage size of the EmptyDirVolume. Unit: GiB or MiB.
        """
        return pulumi.get(self, "empty_dir_volume_size_limit")

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

    @property
    @pulumi.getter(name="flexVolumeDriver")
    def flex_volume_driver(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "flex_volume_driver", value)

    @property
    @pulumi.getter(name="flexVolumeFsType")
    def flex_volume_fs_type(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "flex_volume_fs_type", value)

    @property
    @pulumi.getter(name="flexVolumeOptions")
    def flex_volume_options(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "flex_volume_options", value)

    @property
    @pulumi.getter(name="hostPathVolumePath")
    def host_path_volume_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The absolute path on the host.
        """
        return pulumi.get(self, "host_path_volume_path")

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

    @property
    @pulumi.getter(name="hostPathVolumeType")
    def host_path_volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The type of the host path. Examples: File, Directory, and Socket.
        """
        return pulumi.get(self, "host_path_volume_type")

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

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

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

    @property
    @pulumi.getter(name="nfsVolumePath")
    def nfs_volume_path(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "nfs_volume_path", value)

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

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

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

        > **NOTE:** Every volume mounted must have a name and type attributes.
        """
        return pulumi.get(self, "nfs_volume_server")

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

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

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


if not MYPY:
    class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict(TypedDict):
        content: NotRequired[pulumi.Input[builtins.str]]
        """
        The content of the configuration file. Maximum size: 32 KB.
        """
        mode: NotRequired[pulumi.Input[builtins.int]]
        """
        The permissions on the ConfigFileVolume directory.
        """
        path: NotRequired[pulumi.Input[builtins.str]]
        """
        The relative file path.
        """
elif False:
    EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs:
    def __init__(__self__, *,
                 content: Optional[pulumi.Input[builtins.str]] = None,
                 mode: Optional[pulumi.Input[builtins.int]] = None,
                 path: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] content: The content of the configuration file. Maximum size: 32 KB.
        :param pulumi.Input[builtins.int] mode: The permissions on the ConfigFileVolume directory.
        :param pulumi.Input[builtins.str] path: The relative file path.
        """
        if content is not None:
            pulumi.set(__self__, "content", content)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def content(self) -> Optional[pulumi.Input[builtins.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[builtins.str]]):
        pulumi.set(self, "content", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The permissions on the ConfigFileVolume directory.
        """
        return pulumi.get(self, "mode")

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

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

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


if not MYPY:
    class ScalingConfigurationCustomPriorityArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        This parameter takes effect only if you set Scaling Policy to Priority Policy and the instance type specified by CustomPriorities.N.InstanceType is contained in the scaling configuration.
        """
        vswitch_id: NotRequired[pulumi.Input[builtins.str]]
        """
        This parameter takes effect only if you set Scaling Policy to Priority Policy and the vSwitch specified by CustomPriorities.N.VswitchId is included in the vSwitch list of your scaling group.
        """
elif False:
    ScalingConfigurationCustomPriorityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationCustomPriorityArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 vswitch_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: This parameter takes effect only if you set Scaling Policy to Priority Policy and the instance type specified by CustomPriorities.N.InstanceType is contained in the scaling configuration.
        :param pulumi.Input[builtins.str] vswitch_id: This parameter takes effect only if you set Scaling Policy to Priority Policy and the vSwitch specified by CustomPriorities.N.VswitchId is included in the vSwitch list of your scaling group.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if vswitch_id is not None:
            pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        This parameter takes effect only if you set Scaling Policy to Priority Policy and the instance type specified by CustomPriorities.N.InstanceType is contained in the scaling configuration.
        """
        return pulumi.get(self, "instance_type")

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

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        This parameter takes effect only if you set Scaling Policy to Priority Policy and the vSwitch specified by CustomPriorities.N.VswitchId is included in the vSwitch list of your scaling group.
        """
        return pulumi.get(self, "vswitch_id")

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


if not MYPY:
    class ScalingConfigurationDataDiskArgsDict(TypedDict):
        auto_snapshot_policy_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The id of auto snapshot policy for data disk.
        """
        category: NotRequired[pulumi.Input[builtins.str]]
        """
        Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
        """
        delete_with_instance: NotRequired[pulumi.Input[builtins.bool]]
        """
        Whether to delete data disks attached on ecs when release ecs instance. Optional value: `true` or `false`, default to `true`.
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        The description of data disk N. Valid values of N: 1 to 16. The description must be 2 to 256 characters in length and cannot start with http:// or https://.
        """
        device: NotRequired[pulumi.Input[builtins.str]]
        """
        The mount point of data disk N. Valid values of N: 1 to 16. If this parameter is not specified, the system automatically allocates a mount point to created ECS instances. The name of the mount point ranges from /dev/xvdb to /dev/xvdz in alphabetical order.
        """
        encrypted: NotRequired[pulumi.Input[builtins.bool]]
        """
        Specifies whether data disk N is to be encrypted. Valid values of N: 1 to 16. Valid values: `true`: encrypted, `false`: not encrypted. Default value: `false`.
        """
        kms_key_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The CMK ID for data disk N. Valid values of N: 1 to 16.
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of data disk N. Valid values of N: 1 to 16. It must be 2 to 128 characters in length. It must start with a letter and cannot start with http:// or https://. It can contain letters, digits, colons (:), underscores (_), and hyphens (-). Default value: null.
        """
        performance_level: NotRequired[pulumi.Input[builtins.str]]
        """
        The performance level of the ESSD used as data disk.
        """
        provisioned_iops: NotRequired[pulumi.Input[builtins.int]]
        """
        IOPS measures the number of read and write operations that an Elastic Block Storage (EBS) device can process per second.
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        Size of data disk, in GB. The value ranges [5,2000] for a cloud disk, [5,1024] for an ephemeral disk, [5,800] for an ephemeral_ssd disk, [20,32768] for cloud_efficiency, cloud_ssd, cloud_essd disk.
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Snapshot used for creating the data disk. If this parameter is specified, the size parameter is neglected, and the size of the created disk is the size of the snapshot.
        """
elif False:
    ScalingConfigurationDataDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationDataDiskArgs:
    def __init__(__self__, *,
                 auto_snapshot_policy_id: Optional[pulumi.Input[builtins.str]] = None,
                 category: Optional[pulumi.Input[builtins.str]] = None,
                 delete_with_instance: Optional[pulumi.Input[builtins.bool]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 device: Optional[pulumi.Input[builtins.str]] = None,
                 encrypted: Optional[pulumi.Input[builtins.bool]] = None,
                 kms_key_id: Optional[pulumi.Input[builtins.str]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 performance_level: Optional[pulumi.Input[builtins.str]] = None,
                 provisioned_iops: Optional[pulumi.Input[builtins.int]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 snapshot_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] auto_snapshot_policy_id: The id of auto snapshot policy for data disk.
        :param pulumi.Input[builtins.str] category: Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
        :param pulumi.Input[builtins.bool] delete_with_instance: Whether to delete data disks attached on ecs when release ecs instance. Optional value: `true` or `false`, default to `true`.
        :param pulumi.Input[builtins.str] description: The description of data disk N. Valid values of N: 1 to 16. The description must be 2 to 256 characters in length and cannot start with http:// or https://.
        :param pulumi.Input[builtins.str] device: The mount point of data disk N. Valid values of N: 1 to 16. If this parameter is not specified, the system automatically allocates a mount point to created ECS instances. The name of the mount point ranges from /dev/xvdb to /dev/xvdz in alphabetical order.
        :param pulumi.Input[builtins.bool] encrypted: Specifies whether data disk N is to be encrypted. Valid values of N: 1 to 16. Valid values: `true`: encrypted, `false`: not encrypted. Default value: `false`.
        :param pulumi.Input[builtins.str] kms_key_id: The CMK ID for data disk N. Valid values of N: 1 to 16.
        :param pulumi.Input[builtins.str] name: The name of data disk N. Valid values of N: 1 to 16. It must be 2 to 128 characters in length. It must start with a letter and cannot start with http:// or https://. It can contain letters, digits, colons (:), underscores (_), and hyphens (-). Default value: null.
        :param pulumi.Input[builtins.str] performance_level: The performance level of the ESSD used as data disk.
        :param pulumi.Input[builtins.int] provisioned_iops: IOPS measures the number of read and write operations that an Elastic Block Storage (EBS) device can process per second.
        :param pulumi.Input[builtins.int] size: Size of data disk, in GB. The value ranges [5,2000] for a cloud disk, [5,1024] for an ephemeral disk, [5,800] for an ephemeral_ssd disk, [20,32768] for cloud_efficiency, cloud_ssd, cloud_essd disk.
        :param pulumi.Input[builtins.str] snapshot_id: Snapshot used for creating the data disk. If this parameter is specified, the size parameter is neglected, and the size of the created disk is the size of the snapshot.
        """
        if auto_snapshot_policy_id is not None:
            pulumi.set(__self__, "auto_snapshot_policy_id", auto_snapshot_policy_id)
        if category is not None:
            pulumi.set(__self__, "category", category)
        if delete_with_instance is not None:
            pulumi.set(__self__, "delete_with_instance", delete_with_instance)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if device is not None:
            warnings.warn("""Attribute device has been deprecated on disk attachment resource. Suggest to remove it from your template.""", DeprecationWarning)
            pulumi.log.warn("""device is deprecated: Attribute device has been deprecated on disk attachment resource. Suggest to remove it from your template.""")
        if device is not None:
            pulumi.set(__self__, "device", device)
        if encrypted is not None:
            pulumi.set(__self__, "encrypted", encrypted)
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if performance_level is not None:
            pulumi.set(__self__, "performance_level", performance_level)
        if provisioned_iops is not None:
            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)

    @property
    @pulumi.getter(name="autoSnapshotPolicyId")
    def auto_snapshot_policy_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The id of auto snapshot policy for data disk.
        """
        return pulumi.get(self, "auto_snapshot_policy_id")

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

    @property
    @pulumi.getter
    def category(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
        """
        return pulumi.get(self, "category")

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

    @property
    @pulumi.getter(name="deleteWithInstance")
    def delete_with_instance(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Whether to delete data disks attached on ecs when release ecs instance. Optional value: `true` or `false`, default to `true`.
        """
        return pulumi.get(self, "delete_with_instance")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The description of data disk N. Valid values of N: 1 to 16. The description must be 2 to 256 characters in length and cannot start with http:// or https://.
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter
    @_utilities.deprecated("""Attribute device has been deprecated on disk attachment resource. Suggest to remove it from your template.""")
    def device(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The mount point of data disk N. Valid values of N: 1 to 16. If this parameter is not specified, the system automatically allocates a mount point to created ECS instances. The name of the mount point ranges from /dev/xvdb to /dev/xvdz in alphabetical order.
        """
        return pulumi.get(self, "device")

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

    @property
    @pulumi.getter
    def encrypted(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Specifies whether data disk N is to be encrypted. Valid values of N: 1 to 16. Valid values: `true`: encrypted, `false`: not encrypted. Default value: `false`.
        """
        return pulumi.get(self, "encrypted")

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

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The CMK ID for data disk N. Valid values of N: 1 to 16.
        """
        return pulumi.get(self, "kms_key_id")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of data disk N. Valid values of N: 1 to 16. It must be 2 to 128 characters in length. It must start with a letter and cannot start with http:// or https://. It can contain letters, digits, colons (:), underscores (_), and hyphens (-). Default value: null.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="performanceLevel")
    def performance_level(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The performance level of the ESSD used as data disk.
        """
        return pulumi.get(self, "performance_level")

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

    @property
    @pulumi.getter(name="provisionedIops")
    def provisioned_iops(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        IOPS measures the number of read and write operations that an Elastic Block Storage (EBS) device can process per second.
        """
        return pulumi.get(self, "provisioned_iops")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Size of data disk, in GB. The value ranges [5,2000] for a cloud disk, [5,1024] for an ephemeral disk, [5,800] for an ephemeral_ssd disk, [20,32768] for cloud_efficiency, cloud_ssd, cloud_essd disk.
        """
        return pulumi.get(self, "size")

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

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Snapshot used for creating the data disk. If this parameter is specified, the size parameter is neglected, and the size of the created disk is the size of the snapshot.
        """
        return pulumi.get(self, "snapshot_id")

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


if not MYPY:
    class ScalingConfigurationInstancePatternInfoArgsDict(TypedDict):
        architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
        """
        burstable_performance: NotRequired[pulumi.Input[builtins.str]]
        """
        Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
        """
        cores: NotRequired[pulumi.Input[builtins.int]]
        """
        The number of vCPUs that are specified for an instance type in instancePatternInfo.
        """
        excluded_instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Instance type N that you want to exclude. You can use wildcard characters, such as an asterisk (*), to exclude an instance type or an instance family.
        """
        instance_family_level: NotRequired[pulumi.Input[builtins.str]]
        """
        The instance family level in instancePatternInfo.
        """
        max_price: NotRequired[pulumi.Input[builtins.float]]
        """
        The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
        """
        memory: NotRequired[pulumi.Input[builtins.float]]
        """
        The memory size that is specified for an instance type in instancePatternInfo.
        """
elif False:
    ScalingConfigurationInstancePatternInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationInstancePatternInfoArgs:
    def __init__(__self__, *,
                 architectures: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 burstable_performance: Optional[pulumi.Input[builtins.str]] = None,
                 cores: Optional[pulumi.Input[builtins.int]] = None,
                 excluded_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 instance_family_level: Optional[pulumi.Input[builtins.str]] = None,
                 max_price: Optional[pulumi.Input[builtins.float]] = None,
                 memory: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] architectures: Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
        :param pulumi.Input[builtins.str] burstable_performance: Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
        :param pulumi.Input[builtins.int] cores: The number of vCPUs that are specified for an instance type in instancePatternInfo.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] excluded_instance_types: Instance type N that you want to exclude. You can use wildcard characters, such as an asterisk (*), to exclude an instance type or an instance family.
        :param pulumi.Input[builtins.str] instance_family_level: The instance family level in instancePatternInfo.
        :param pulumi.Input[builtins.float] max_price: The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
        :param pulumi.Input[builtins.float] memory: The memory size that is specified for an instance type in instancePatternInfo.
        """
        if architectures is not None:
            pulumi.set(__self__, "architectures", architectures)
        if burstable_performance is not None:
            pulumi.set(__self__, "burstable_performance", burstable_performance)
        if cores is not None:
            pulumi.set(__self__, "cores", cores)
        if excluded_instance_types is not None:
            pulumi.set(__self__, "excluded_instance_types", excluded_instance_types)
        if instance_family_level is not None:
            pulumi.set(__self__, "instance_family_level", instance_family_level)
        if max_price is not None:
            pulumi.set(__self__, "max_price", max_price)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
        """
        return pulumi.get(self, "architectures")

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

    @property
    @pulumi.getter(name="burstablePerformance")
    def burstable_performance(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
        """
        return pulumi.get(self, "burstable_performance")

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

    @property
    @pulumi.getter
    def cores(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The number of vCPUs that are specified for an instance type in instancePatternInfo.
        """
        return pulumi.get(self, "cores")

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

    @property
    @pulumi.getter(name="excludedInstanceTypes")
    def excluded_instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Instance type N that you want to exclude. You can use wildcard characters, such as an asterisk (*), to exclude an instance type or an instance family.
        """
        return pulumi.get(self, "excluded_instance_types")

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

    @property
    @pulumi.getter(name="instanceFamilyLevel")
    def instance_family_level(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The instance family level in instancePatternInfo.
        """
        return pulumi.get(self, "instance_family_level")

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

    @property
    @pulumi.getter(name="maxPrice")
    def max_price(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
        """
        return pulumi.get(self, "max_price")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The memory size that is specified for an instance type in instancePatternInfo.
        """
        return pulumi.get(self, "memory")

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


if not MYPY:
    class ScalingConfigurationInstanceTypeOverrideArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The is specified for an instance type in instanceTypeOverride.
        """
        weighted_capacity: NotRequired[pulumi.Input[builtins.int]]
        """
        The weight of instance type in instanceTypeOverride.
        """
elif False:
    ScalingConfigurationInstanceTypeOverrideArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationInstanceTypeOverrideArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 weighted_capacity: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: The is specified for an instance type in instanceTypeOverride.
        :param pulumi.Input[builtins.int] weighted_capacity: The weight of instance type in instanceTypeOverride.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The is specified for an instance type in instanceTypeOverride.
        """
        return pulumi.get(self, "instance_type")

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

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The weight of instance type in instanceTypeOverride.
        """
        return pulumi.get(self, "weighted_capacity")

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


if not MYPY:
    class ScalingConfigurationNetworkInterfaceArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The ENI type. If you specify NetworkInterfaces.N, specify at least one primary ENI. You cannot specify SecurityGroupId or SecurityGroupIds.N. Valid values: Primary, Secondary.
        """
        ipv6_address_count: NotRequired[pulumi.Input[builtins.int]]
        """
        The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
        """
        network_interface_traffic_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        The communication mode of the ENI. Valid values: Standard, HighPerformance.
        """
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        The ID of security group N to which ENI N belongs.
        """
elif False:
    ScalingConfigurationNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationNetworkInterfaceArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 ipv6_address_count: Optional[pulumi.Input[builtins.int]] = None,
                 network_interface_traffic_mode: Optional[pulumi.Input[builtins.str]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: The ENI type. If you specify NetworkInterfaces.N, specify at least one primary ENI. You cannot specify SecurityGroupId or SecurityGroupIds.N. Valid values: Primary, Secondary.
        :param pulumi.Input[builtins.int] ipv6_address_count: The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
        :param pulumi.Input[builtins.str] network_interface_traffic_mode: The communication mode of the ENI. Valid values: Standard, HighPerformance.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: The ID of security group N to which ENI N belongs.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if ipv6_address_count is not None:
            pulumi.set(__self__, "ipv6_address_count", ipv6_address_count)
        if network_interface_traffic_mode is not None:
            pulumi.set(__self__, "network_interface_traffic_mode", network_interface_traffic_mode)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The ENI type. If you specify NetworkInterfaces.N, specify at least one primary ENI. You cannot specify SecurityGroupId or SecurityGroupIds.N. Valid values: Primary, Secondary.
        """
        return pulumi.get(self, "instance_type")

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

    @property
    @pulumi.getter(name="ipv6AddressCount")
    def ipv6_address_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
        """
        return pulumi.get(self, "ipv6_address_count")

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

    @property
    @pulumi.getter(name="networkInterfaceTrafficMode")
    def network_interface_traffic_mode(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The communication mode of the ENI. Valid values: Standard, HighPerformance.
        """
        return pulumi.get(self, "network_interface_traffic_mode")

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

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        The ID of security group N to which ENI N belongs.
        """
        return pulumi.get(self, "security_group_ids")

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


if not MYPY:
    class ScalingConfigurationSpotPriceLimitArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        Resource type of an ECS instance.
        """
        price_limit: NotRequired[pulumi.Input[builtins.float]]
        """
        Price limit hourly of instance type, 2 decimals is allowed at most.
        """
elif False:
    ScalingConfigurationSpotPriceLimitArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingConfigurationSpotPriceLimitArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 price_limit: Optional[pulumi.Input[builtins.float]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: Resource type of an ECS instance.
        :param pulumi.Input[builtins.float] price_limit: Price limit hourly of instance type, 2 decimals is allowed at most.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if price_limit is not None:
            pulumi.set(__self__, "price_limit", price_limit)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Resource type of an ECS instance.
        """
        return pulumi.get(self, "instance_type")

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

    @property
    @pulumi.getter(name="priceLimit")
    def price_limit(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        Price limit hourly of instance type, 2 decimals is allowed at most.
        """
        return pulumi.get(self, "price_limit")

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


if not MYPY:
    class ScalingGroupAlbServerGroupArgsDict(TypedDict):
        alb_server_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        The ID of ALB server group.
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        The weight of the ECS instance as a backend server after Auto Scaling adds the ECS instance to ALB server group.
        """
elif False:
    ScalingGroupAlbServerGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupAlbServerGroupArgs:
    def __init__(__self__, *,
                 alb_server_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None,
                 weight: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] alb_server_group_id: The ID of ALB server group.
        :param pulumi.Input[builtins.int] port: The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
        :param pulumi.Input[builtins.int] weight: The weight of the ECS instance as a backend server after Auto Scaling adds the ECS instance to ALB server group.
        """
        if alb_server_group_id is not None:
            pulumi.set(__self__, "alb_server_group_id", alb_server_group_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="albServerGroupId")
    def alb_server_group_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The ID of ALB server group.
        """
        return pulumi.get(self, "alb_server_group_id")

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

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The weight of the ECS instance as a backend server after Auto Scaling adds the ECS instance to ALB server group.
        """
        return pulumi.get(self, "weight")

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


if not MYPY:
    class ScalingGroupLaunchTemplateOverrideArgsDict(TypedDict):
        instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        The instance type in launchTemplateOverride.
        """
        spot_price_limit: NotRequired[pulumi.Input[builtins.float]]
        """
        The maximum bid price of instance type in launchTemplateOverride.


        > **NOTE:** When detach loadbalancers, instances in group will be remove from loadbalancer's `Default Server Group`; On the contrary, When attach loadbalancers, instances in group will be added to loadbalancer's `Default Server Group`.

        > **NOTE:** When detach dbInstances, private ip of instances in group will be remove from dbInstance's `WhiteList`; On the contrary, When attach dbInstances, private ip of instances in group will be added to dbInstance's `WhiteList`.

        > **NOTE:** `on_demand_base_capacity`,`on_demand_percentage_above_base_capacity`,`spot_instance_pools`,`spot_instance_remedy` are valid only if `multi_az_policy` is 'COST_OPTIMIZED'.
        """
        weighted_capacity: NotRequired[pulumi.Input[builtins.int]]
        """
        The weight of the instance type in launchTemplateOverride.
        """
elif False:
    ScalingGroupLaunchTemplateOverrideArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupLaunchTemplateOverrideArgs:
    def __init__(__self__, *,
                 instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 spot_price_limit: Optional[pulumi.Input[builtins.float]] = None,
                 weighted_capacity: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] instance_type: The instance type in launchTemplateOverride.
        :param pulumi.Input[builtins.float] spot_price_limit: The maximum bid price of instance type in launchTemplateOverride.
               
               
               > **NOTE:** When detach loadbalancers, instances in group will be remove from loadbalancer's `Default Server Group`; On the contrary, When attach loadbalancers, instances in group will be added to loadbalancer's `Default Server Group`.
               
               > **NOTE:** When detach dbInstances, private ip of instances in group will be remove from dbInstance's `WhiteList`; On the contrary, When attach dbInstances, private ip of instances in group will be added to dbInstance's `WhiteList`.
               
               > **NOTE:** `on_demand_base_capacity`,`on_demand_percentage_above_base_capacity`,`spot_instance_pools`,`spot_instance_remedy` are valid only if `multi_az_policy` is 'COST_OPTIMIZED'.
        :param pulumi.Input[builtins.int] weighted_capacity: The weight of the instance type in launchTemplateOverride.
        """
        if instance_type is not None:
            pulumi.set(__self__, "instance_type", instance_type)
        if spot_price_limit is not None:
            pulumi.set(__self__, "spot_price_limit", spot_price_limit)
        if weighted_capacity is not None:
            pulumi.set(__self__, "weighted_capacity", weighted_capacity)

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The instance type in launchTemplateOverride.
        """
        return pulumi.get(self, "instance_type")

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

    @property
    @pulumi.getter(name="spotPriceLimit")
    def spot_price_limit(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        The maximum bid price of instance type in launchTemplateOverride.


        > **NOTE:** When detach loadbalancers, instances in group will be remove from loadbalancer's `Default Server Group`; On the contrary, When attach loadbalancers, instances in group will be added to loadbalancer's `Default Server Group`.

        > **NOTE:** When detach dbInstances, private ip of instances in group will be remove from dbInstance's `WhiteList`; On the contrary, When attach dbInstances, private ip of instances in group will be added to dbInstance's `WhiteList`.

        > **NOTE:** `on_demand_base_capacity`,`on_demand_percentage_above_base_capacity`,`spot_instance_pools`,`spot_instance_remedy` are valid only if `multi_az_policy` is 'COST_OPTIMIZED'.
        """
        return pulumi.get(self, "spot_price_limit")

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

    @property
    @pulumi.getter(name="weightedCapacity")
    def weighted_capacity(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The weight of the instance type in launchTemplateOverride.
        """
        return pulumi.get(self, "weighted_capacity")

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


if not MYPY:
    class ScalingGroupVServerGroupsVserverGroupArgsDict(TypedDict):
        loadbalancer_id: pulumi.Input[builtins.str]
        """
        Loadbalancer server ID of VServer Group.
        """
        vserver_attributes: pulumi.Input[Sequence[pulumi.Input['ScalingGroupVServerGroupsVserverGroupVserverAttributeArgsDict']]]
        """
        A list of VServer Group attributes. See `vserver_attributes` below.
        """
elif False:
    ScalingGroupVServerGroupsVserverGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupVServerGroupsVserverGroupArgs:
    def __init__(__self__, *,
                 loadbalancer_id: pulumi.Input[builtins.str],
                 vserver_attributes: pulumi.Input[Sequence[pulumi.Input['ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs']]]):
        """
        :param pulumi.Input[builtins.str] loadbalancer_id: Loadbalancer server ID of VServer Group.
        :param pulumi.Input[Sequence[pulumi.Input['ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs']]] vserver_attributes: A list of VServer Group attributes. See `vserver_attributes` below.
        """
        pulumi.set(__self__, "loadbalancer_id", loadbalancer_id)
        pulumi.set(__self__, "vserver_attributes", vserver_attributes)

    @property
    @pulumi.getter(name="loadbalancerId")
    def loadbalancer_id(self) -> pulumi.Input[builtins.str]:
        """
        Loadbalancer server ID of VServer Group.
        """
        return pulumi.get(self, "loadbalancer_id")

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

    @property
    @pulumi.getter(name="vserverAttributes")
    def vserver_attributes(self) -> pulumi.Input[Sequence[pulumi.Input['ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs']]]:
        """
        A list of VServer Group attributes. See `vserver_attributes` below.
        """
        return pulumi.get(self, "vserver_attributes")

    @vserver_attributes.setter
    def vserver_attributes(self, value: pulumi.Input[Sequence[pulumi.Input['ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs']]]):
        pulumi.set(self, "vserver_attributes", value)


if not MYPY:
    class ScalingGroupVServerGroupsVserverGroupVserverAttributeArgsDict(TypedDict):
        port: pulumi.Input[builtins.int]
        """
        The port will be used for VServer Group backend server.
        """
        vserver_group_id: pulumi.Input[builtins.str]
        """
        ID of VServer Group.
        """
        weight: pulumi.Input[builtins.int]
        """
        The weight of an ECS instance attached to the VServer Group.
        """
elif False:
    ScalingGroupVServerGroupsVserverGroupVserverAttributeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs:
    def __init__(__self__, *,
                 port: pulumi.Input[builtins.int],
                 vserver_group_id: pulumi.Input[builtins.str],
                 weight: pulumi.Input[builtins.int]):
        """
        :param pulumi.Input[builtins.int] port: The port will be used for VServer Group backend server.
        :param pulumi.Input[builtins.str] vserver_group_id: ID of VServer Group.
        :param pulumi.Input[builtins.int] weight: The weight of an ECS instance attached to the VServer Group.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "vserver_group_id", vserver_group_id)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[builtins.int]:
        """
        The port will be used for VServer Group backend server.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter(name="vserverGroupId")
    def vserver_group_id(self) -> pulumi.Input[builtins.str]:
        """
        ID of VServer Group.
        """
        return pulumi.get(self, "vserver_group_id")

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

    @property
    @pulumi.getter
    def weight(self) -> pulumi.Input[builtins.int]:
        """
        The weight of an ECS instance attached to the VServer Group.
        """
        return pulumi.get(self, "weight")

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


if not MYPY:
    class ScalingRuleAlarmDimensionArgsDict(TypedDict):
        dimension_key: NotRequired[pulumi.Input[builtins.str]]
        """
        The dimension key of the metric.
        """
        dimension_value: NotRequired[pulumi.Input[builtins.str]]
        """
        The dimension value of the metric.
        """
elif False:
    ScalingRuleAlarmDimensionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingRuleAlarmDimensionArgs:
    def __init__(__self__, *,
                 dimension_key: Optional[pulumi.Input[builtins.str]] = None,
                 dimension_value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] dimension_key: The dimension key of the metric.
        :param pulumi.Input[builtins.str] dimension_value: The dimension value of the metric.
        """
        if dimension_key is not None:
            pulumi.set(__self__, "dimension_key", dimension_key)
        if dimension_value is not None:
            pulumi.set(__self__, "dimension_value", dimension_value)

    @property
    @pulumi.getter(name="dimensionKey")
    def dimension_key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The dimension key of the metric.
        """
        return pulumi.get(self, "dimension_key")

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

    @property
    @pulumi.getter(name="dimensionValue")
    def dimension_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The dimension value of the metric.
        """
        return pulumi.get(self, "dimension_value")

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


if not MYPY:
    class ScalingRuleHybridMetricArgsDict(TypedDict):
        dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ScalingRuleHybridMetricDimensionArgsDict']]]]
        """
        The structure of volumeMounts.
        See `dimensions` below for details.
        """
        expression: NotRequired[pulumi.Input[builtins.str]]
        """
        The metric expression that consists of multiple Hybrid Cloud Monitoring metrics. It calculates a result used to trigger scaling events. The expression must comply with the Reverse Polish Notation (RPN) specification, and the operators can only be + - × /.
        """
        id: NotRequired[pulumi.Input[builtins.str]]
        """
        The reference ID of the metric in the metric expression.
        """
        metric_name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the Hybrid Cloud Monitoring metric.
        """
        statistic: NotRequired[pulumi.Input[builtins.str]]
        """
        The statistical method of the metric value. Valid values: Average, Minimum, Maximum.
        """
elif False:
    ScalingRuleHybridMetricArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingRuleHybridMetricArgs:
    def __init__(__self__, *,
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['ScalingRuleHybridMetricDimensionArgs']]]] = None,
                 expression: Optional[pulumi.Input[builtins.str]] = None,
                 id: Optional[pulumi.Input[builtins.str]] = None,
                 metric_name: Optional[pulumi.Input[builtins.str]] = None,
                 statistic: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ScalingRuleHybridMetricDimensionArgs']]] dimensions: The structure of volumeMounts.
               See `dimensions` below for details.
        :param pulumi.Input[builtins.str] expression: The metric expression that consists of multiple Hybrid Cloud Monitoring metrics. It calculates a result used to trigger scaling events. The expression must comply with the Reverse Polish Notation (RPN) specification, and the operators can only be + - × /.
        :param pulumi.Input[builtins.str] id: The reference ID of the metric in the metric expression.
        :param pulumi.Input[builtins.str] metric_name: The name of the Hybrid Cloud Monitoring metric.
        :param pulumi.Input[builtins.str] statistic: The statistical method of the metric value. Valid values: Average, Minimum, Maximum.
        """
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if expression is not None:
            pulumi.set(__self__, "expression", expression)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if metric_name is not None:
            pulumi.set(__self__, "metric_name", metric_name)
        if statistic is not None:
            pulumi.set(__self__, "statistic", statistic)

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

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

    @property
    @pulumi.getter
    def expression(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The metric expression that consists of multiple Hybrid Cloud Monitoring metrics. It calculates a result used to trigger scaling events. The expression must comply with the Reverse Polish Notation (RPN) specification, and the operators can only be + - × /.
        """
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The reference ID of the metric in the metric expression.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of the Hybrid Cloud Monitoring metric.
        """
        return pulumi.get(self, "metric_name")

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

    @property
    @pulumi.getter
    def statistic(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The statistical method of the metric value. Valid values: Average, Minimum, Maximum.
        """
        return pulumi.get(self, "statistic")

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


if not MYPY:
    class ScalingRuleHybridMetricDimensionArgsDict(TypedDict):
        dimension_key: NotRequired[pulumi.Input[builtins.str]]
        dimension_value: NotRequired[pulumi.Input[builtins.str]]
elif False:
    ScalingRuleHybridMetricDimensionArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class ScalingRuleStepAdjustmentArgsDict(TypedDict):
        metric_interval_lower_bound: NotRequired[pulumi.Input[builtins.str]]
        """
        The lower bound of step.
        """
        metric_interval_upper_bound: NotRequired[pulumi.Input[builtins.str]]
        """
        The upper bound of step.
        """
        scaling_adjustment: NotRequired[pulumi.Input[builtins.int]]
        """
        The adjust value of step.
        """
elif False:
    ScalingRuleStepAdjustmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ScalingRuleStepAdjustmentArgs:
    def __init__(__self__, *,
                 metric_interval_lower_bound: Optional[pulumi.Input[builtins.str]] = None,
                 metric_interval_upper_bound: Optional[pulumi.Input[builtins.str]] = None,
                 scaling_adjustment: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] metric_interval_lower_bound: The lower bound of step.
        :param pulumi.Input[builtins.str] metric_interval_upper_bound: The upper bound of step.
        :param pulumi.Input[builtins.int] scaling_adjustment: The adjust value of step.
        """
        if metric_interval_lower_bound is not None:
            pulumi.set(__self__, "metric_interval_lower_bound", metric_interval_lower_bound)
        if metric_interval_upper_bound is not None:
            pulumi.set(__self__, "metric_interval_upper_bound", metric_interval_upper_bound)
        if scaling_adjustment is not None:
            pulumi.set(__self__, "scaling_adjustment", scaling_adjustment)

    @property
    @pulumi.getter(name="metricIntervalLowerBound")
    def metric_interval_lower_bound(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The lower bound of step.
        """
        return pulumi.get(self, "metric_interval_lower_bound")

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

    @property
    @pulumi.getter(name="metricIntervalUpperBound")
    def metric_interval_upper_bound(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The upper bound of step.
        """
        return pulumi.get(self, "metric_interval_upper_bound")

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

    @property
    @pulumi.getter(name="scalingAdjustment")
    def scaling_adjustment(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The adjust value of step.
        """
        return pulumi.get(self, "scaling_adjustment")

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


