pulumi-alicloud 3.53.0a1713354491__py3-none-any.whl → 3.73.0a1736832142__py3-none-any.whl

pulumi_alicloud/ess/_inputs.py

@@ -4,36 +4,214 @@
 
 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',
     'ScalingRuleStepAdjustmentArgs',
+    'ScalingRuleStepAdjustmentArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AlarmExpressionArgsDict(TypedDict):
+        comparison_operator: NotRequired[pulumi.Input[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[str]]
+        """
+        The name for the alarm's associated metric. See `dimensions` below for details.
+        """
+        period: NotRequired[pulumi.Input[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[str]]
+        """
+        The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
+        """
+        threshold: NotRequired[pulumi.Input[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[str]] = None,
+                 metric_name: Optional[pulumi.Input[str]] = None,
+                 period: Optional[pulumi.Input[int]] = None,
+                 statistics: Optional[pulumi.Input[str]] = None,
+                 threshold: Optional[pulumi.Input[float]] = None):
+        """
+        :param pulumi.Input[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[str] metric_name: The name for the alarm's associated metric. See `dimensions` below for details.
+        :param pulumi.Input[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[str] statistics: The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
+        :param pulumi.Input[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[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[str]]):
+        pulumi.set(self, "comparison_operator", value)
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "metric_name", value)
+
+    @property
+    @pulumi.getter
+    def period(self) -> Optional[pulumi.Input[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[int]]):
+        pulumi.set(self, "period", value)
+
+    @property
+    @pulumi.getter
+    def statistics(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "statistics", value)
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> Optional[pulumi.Input[float]]:
+        """
+        The value against which the specified statistics is compared.
+        """
+        return pulumi.get(self, "threshold")
+
+    @threshold.setter
+    def threshold(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "threshold", value)
+
+
+if not MYPY:
+    class EciScalingConfigurationAcrRegistryInfoArgsDict(TypedDict):
+        domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[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[str]]
+        """
+        The ID of Container Registry Enterprise Edition instance. It is required
+        when `acr_registry_info` is configured.
+        """
+        instance_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of Container Registry Enterprise Edition instance. It is required when `acr_registry_info` is
+        configured.
+        """
+        region_id: NotRequired[pulumi.Input[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__, *,
@@ -113,6 +291,167 @@ class EciScalingConfigurationAcrRegistryInfoArgs:
         pulumi.set(self, "region_id", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationContainerArgsDict(TypedDict):
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments passed to the commands.
+        """
+        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The commands run by the init container.
+        """
+        cpu: NotRequired[pulumi.Input[float]]
+        """
+        The amount of CPU resources allocated to the container.
+        """
+        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerEnvironmentVarArgsDict']]]]
+        """
+        The structure of environmentVars.
+        See `environment_vars` below for details.
+        """
+        gpu: NotRequired[pulumi.Input[int]]
+        """
+        The number GPUs.
+        """
+        image: NotRequired[pulumi.Input[str]]
+        """
+        The image of the container.
+        """
+        image_pull_policy: NotRequired[pulumi.Input[str]]
+        """
+        The restart policy of the image.
+        """
+        lifecycle_pre_stop_handler_execs: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The commands to be executed in containers when you use the CLI to specify the preStop callback function.
+        """
+        liveness_probe_exec_commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[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[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[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[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[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[int]]
+        """
+        The number of seconds after container has started before liveness probes are initiated.
+        """
+        liveness_probe_period_seconds: NotRequired[pulumi.Input[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[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[int]]
+        """
+        The port detected by TCP sockets when you use TCP sockets to perform liveness probes.
+        """
+        liveness_probe_timeout_seconds: NotRequired[pulumi.Input[int]]
+        """
+        The timeout period for the liveness probe. Unit: seconds. Default value: 1. Minimum value: 1.
+        """
+        memory: NotRequired[pulumi.Input[float]]
+        """
+        The amount of memory resources allocated to the container.
+        """
+        name: NotRequired[pulumi.Input[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[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[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[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[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[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[int]]
+        """
+        The number of seconds after container N has started before readiness probes are initiated.
+        """
+        readiness_probe_period_seconds: NotRequired[pulumi.Input[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[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[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[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[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[bool]]
+        """
+        Mounts the container's root filesystem as read-only.
+        """
+        security_context_run_as_user: NotRequired[pulumi.Input[int]]
+        """
+        Specifies user ID  under which all processes run.
+        """
+        stdin: NotRequired[pulumi.Input[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[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[str]]
+        """
+        The working directory of the container.
+        """
+elif False:
+    EciScalingConfigurationContainerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationContainerArgs:
     def __init__(__self__, *,
@@ -150,6 +489,8 @@ class EciScalingConfigurationContainerArgs:
                  security_context_capability_adds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  security_context_read_only_root_file_system: Optional[pulumi.Input[bool]] = None,
                  security_context_run_as_user: Optional[pulumi.Input[int]] = None,
+                 stdin: Optional[pulumi.Input[bool]] = None,
+                 tty: Optional[pulumi.Input[bool]] = None,
                  volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerVolumeMountArgs']]]] = None,
                  working_dir: Optional[pulumi.Input[str]] = None):
         """
@@ -190,6 +531,8 @@ class EciScalingConfigurationContainerArgs:
                - NET_RAW: Allow raw sockets.
         :param pulumi.Input[bool] security_context_read_only_root_file_system: Mounts the container's root filesystem as read-only.
         :param pulumi.Input[int] security_context_run_as_user: Specifies user ID  under which all processes run.
+        :param pulumi.Input[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[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[str] working_dir: The working directory of the container.
@@ -262,6 +605,10 @@ class EciScalingConfigurationContainerArgs:
             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:
@@ -678,6 +1025,30 @@ class EciScalingConfigurationContainerArgs:
     def security_context_run_as_user(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "security_context_run_as_user", value)
 
+    @property
+    @pulumi.getter
+    def stdin(self) -> Optional[pulumi.Input[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[bool]]):
+        pulumi.set(self, "stdin", value)
+
+    @property
+    @pulumi.getter
+    def tty(self) -> Optional[pulumi.Input[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[bool]]):
+        pulumi.set(self, "tty", value)
+
     @property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationContainerVolumeMountArgs']]]]:
@@ -704,19 +1075,20 @@ class EciScalingConfigurationContainerArgs:
         pulumi.set(self, "working_dir", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationContainerEnvironmentVarArgsDict(TypedDict):
+        field_ref_field_path: NotRequired[pulumi.Input[str]]
+        key: NotRequired[pulumi.Input[str]]
+        value: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationContainerEnvironmentVarArgs:
     def __init__(__self__, *,
                  field_ref_field_path: Optional[pulumi.Input[str]] = None,
                  key: Optional[pulumi.Input[str]] = None,
                  value: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] field_ref_field_path: Environment variable value reference. Optional values: 
-               - status.podIP: IP of pod.
-        :param pulumi.Input[str] key: The name of the variable. The name can be 1 to 128 characters in length and can contain letters,
-               digits, and underscores (_). It cannot start with a digit.
-        :param pulumi.Input[str] value: The value of the variable. The value can be 0 to 256 characters in length.
-        """
         if field_ref_field_path is not None:
             pulumi.set(__self__, "field_ref_field_path", field_ref_field_path)
         if key is not None:
@@ -727,10 +1099,6 @@ class EciScalingConfigurationContainerEnvironmentVarArgs:
     @property
     @pulumi.getter(name="fieldRefFieldPath")
     def field_ref_field_path(self) -> Optional[pulumi.Input[str]]:
-        """
-        Environment variable value reference. Optional values: 
-        - status.podIP: IP of pod.
-        """
         return pulumi.get(self, "field_ref_field_path")
 
     @field_ref_field_path.setter
@@ -740,10 +1108,6 @@ class EciScalingConfigurationContainerEnvironmentVarArgs:
     @property
     @pulumi.getter
     def key(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the variable. The name can be 1 to 128 characters in length and can contain letters,
-        digits, and underscores (_). It cannot start with a digit.
-        """
         return pulumi.get(self, "key")
 
     @key.setter
@@ -753,9 +1117,6 @@ class EciScalingConfigurationContainerEnvironmentVarArgs:
     @property
     @pulumi.getter
     def value(self) -> Optional[pulumi.Input[str]]:
-        """
-        The value of the variable. The value can be 0 to 256 characters in length.
-        """
         return pulumi.get(self, "value")
 
     @value.setter
@@ -763,15 +1124,18 @@ class EciScalingConfigurationContainerEnvironmentVarArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationContainerPortArgsDict(TypedDict):
+        port: NotRequired[pulumi.Input[int]]
+        protocol: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationContainerPortArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationContainerPortArgs:
     def __init__(__self__, *,
                  port: Optional[pulumi.Input[int]] = None,
                  protocol: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[int] port: The port number. Valid values: 1 to 65535.
-        :param pulumi.Input[str] protocol: Valid values: TCP and UDP.
-        """
         if port is not None:
             pulumi.set(__self__, "port", port)
         if protocol is not None:
@@ -780,9 +1144,6 @@ class EciScalingConfigurationContainerPortArgs:
     @property
     @pulumi.getter
     def port(self) -> Optional[pulumi.Input[int]]:
-        """
-        The port number. Valid values: 1 to 65535.
-        """
         return pulumi.get(self, "port")
 
     @port.setter
@@ -792,9 +1153,6 @@ class EciScalingConfigurationContainerPortArgs:
     @property
     @pulumi.getter
     def protocol(self) -> Optional[pulumi.Input[str]]:
-        """
-        Valid values: TCP and UDP.
-        """
         return pulumi.get(self, "protocol")
 
     @protocol.setter
@@ -802,44 +1160,56 @@ class EciScalingConfigurationContainerPortArgs:
         pulumi.set(self, "protocol", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationContainerVolumeMountArgsDict(TypedDict):
+        mount_path: NotRequired[pulumi.Input[str]]
+        mount_propagation: NotRequired[pulumi.Input[str]]
+        name: NotRequired[pulumi.Input[str]]
+        read_only: NotRequired[pulumi.Input[bool]]
+        sub_path: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationContainerVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationContainerVolumeMountArgs:
     def __init__(__self__, *,
                  mount_path: Optional[pulumi.Input[str]] = None,
+                 mount_propagation: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 read_only: Optional[pulumi.Input[bool]] = None):
-        """
-        :param pulumi.Input[str] mount_path: The directory of the mounted volume. Data under this directory will be overwritten by the
-               data in the volume.
-        :param pulumi.Input[str] name: The name of the mounted volume.
-        :param pulumi.Input[bool] read_only: Default to `false`.
-        """
+                 read_only: Optional[pulumi.Input[bool]] = None,
+                 sub_path: Optional[pulumi.Input[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[str]]:
-        """
-        The directory of the mounted volume. Data under this directory will be overwritten by the
-        data in the volume.
-        """
         return pulumi.get(self, "mount_path")
 
     @mount_path.setter
     def mount_path(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "mount_path", value)
 
+    @property
+    @pulumi.getter(name="mountPropagation")
+    def mount_propagation(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "mount_propagation")
+
+    @mount_propagation.setter
+    def mount_propagation(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mount_propagation", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the mounted volume.
-        """
         return pulumi.get(self, "name")
 
     @name.setter
@@ -849,41 +1219,112 @@ class EciScalingConfigurationContainerVolumeMountArgs:
     @property
     @pulumi.getter(name="readOnly")
     def read_only(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Default to `false`.
-        """
         return pulumi.get(self, "read_only")
 
     @read_only.setter
     def read_only(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "read_only", value)
 
+    @property
+    @pulumi.getter(name="subPath")
+    def sub_path(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "sub_path")
+
+    @sub_path.setter
+    def sub_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sub_path", value)
+
+
+if not MYPY:
+    class EciScalingConfigurationDnsConfigOptionArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The option name.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        The option value.
+        """
+elif False:
+    EciScalingConfigurationDnsConfigOptionArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class EciScalingConfigurationHostAliasArgs:
+class EciScalingConfigurationDnsConfigOptionArgs:
     def __init__(__self__, *,
-                 hostnames: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 ip: Optional[pulumi.Input[str]] = None):
+                 name: Optional[pulumi.Input[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] hostnames: Adds a host name.
-        :param pulumi.Input[str] ip: Adds an IP address.
+        :param pulumi.Input[str] name: The option name.
+        :param pulumi.Input[str] value: The option value.
         """
-        if hostnames is not None:
-            pulumi.set(__self__, "hostnames", hostnames)
-        if ip is not None:
-            pulumi.set(__self__, "ip", ip)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
 
     @property
     @pulumi.getter
-    def hostnames(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    def name(self) -> Optional[pulumi.Input[str]]:
         """
-        Adds a host name.
+        The option name.
         """
-        return pulumi.get(self, "hostnames")
+        return pulumi.get(self, "name")
 
-    @hostnames.setter
-    def hostnames(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "hostnames", value)
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[str]]:
+        """
+        The option value.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class EciScalingConfigurationHostAliasArgsDict(TypedDict):
+        hostnames: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Adds a host name.
+        """
+        ip: NotRequired[pulumi.Input[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[str]]]] = None,
+                 ip: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] hostnames: Adds a host name.
+        :param pulumi.Input[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[str]]]]:
+        """
+        Adds a host name.
+        """
+        return pulumi.get(self, "hostnames")
+
+    @hostnames.setter
+    def hostnames(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "hostnames", value)
 
     @property
     @pulumi.getter
@@ -898,6 +1339,26 @@ class EciScalingConfigurationHostAliasArgs:
         pulumi.set(self, "ip", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationImageRegistryCredentialArgsDict(TypedDict):
+        password: NotRequired[pulumi.Input[str]]
+        """
+        The password used to log on to the image repository. It is required
+        when `image_registry_credential` is configured.
+        """
+        server: NotRequired[pulumi.Input[str]]
+        """
+        The address of the image repository. It is required when `image_registry_credential` is
+        configured.
+        """
+        username: NotRequired[pulumi.Input[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__, *,
@@ -959,6 +1420,74 @@ class EciScalingConfigurationImageRegistryCredentialArgs:
         pulumi.set(self, "username", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationInitContainerArgsDict(TypedDict):
+        args: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The arguments passed to the commands.
+        """
+        commands: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The commands run by the init container.
+        """
+        cpu: NotRequired[pulumi.Input[float]]
+        """
+        The amount of CPU resources allocated to the container.
+        """
+        environment_vars: NotRequired[pulumi.Input[Sequence[pulumi.Input['EciScalingConfigurationInitContainerEnvironmentVarArgsDict']]]]
+        """
+        The structure of environmentVars. 
+        See `environment_vars` below for details.
+        """
+        gpu: NotRequired[pulumi.Input[int]]
+        """
+        The number GPUs.
+        """
+        image: NotRequired[pulumi.Input[str]]
+        """
+        The image of the container.
+        """
+        image_pull_policy: NotRequired[pulumi.Input[str]]
+        """
+        The restart policy of the image.
+        """
+        memory: NotRequired[pulumi.Input[float]]
+        """
+        The amount of memory resources allocated to the container.
+        """
+        name: NotRequired[pulumi.Input[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[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[bool]]
+        """
+        Mounts the container's root filesystem as read-only.
+        """
+        security_context_run_as_user: NotRequired[pulumi.Input[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[str]]
+        """
+        The working directory of the container.
+        """
+elif False:
+    EciScalingConfigurationInitContainerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationInitContainerArgs:
     def __init__(__self__, *,
@@ -1212,19 +1741,20 @@ class EciScalingConfigurationInitContainerArgs:
         pulumi.set(self, "working_dir", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationInitContainerEnvironmentVarArgsDict(TypedDict):
+        field_ref_field_path: NotRequired[pulumi.Input[str]]
+        key: NotRequired[pulumi.Input[str]]
+        value: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationInitContainerEnvironmentVarArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationInitContainerEnvironmentVarArgs:
     def __init__(__self__, *,
                  field_ref_field_path: Optional[pulumi.Input[str]] = None,
                  key: Optional[pulumi.Input[str]] = None,
                  value: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] field_ref_field_path: Environment variable value reference. Optional values: 
-               - status.podIP: IP of pod.
-        :param pulumi.Input[str] key: The name of the variable. The name can be 1 to 128 characters in length and can contain letters,
-               digits, and underscores (_). It cannot start with a digit.
-        :param pulumi.Input[str] value: The value of the variable. The value can be 0 to 256 characters in length.
-        """
         if field_ref_field_path is not None:
             pulumi.set(__self__, "field_ref_field_path", field_ref_field_path)
         if key is not None:
@@ -1235,10 +1765,6 @@ class EciScalingConfigurationInitContainerEnvironmentVarArgs:
     @property
     @pulumi.getter(name="fieldRefFieldPath")
     def field_ref_field_path(self) -> Optional[pulumi.Input[str]]:
-        """
-        Environment variable value reference. Optional values: 
-        - status.podIP: IP of pod.
-        """
         return pulumi.get(self, "field_ref_field_path")
 
     @field_ref_field_path.setter
@@ -1248,10 +1774,6 @@ class EciScalingConfigurationInitContainerEnvironmentVarArgs:
     @property
     @pulumi.getter
     def key(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the variable. The name can be 1 to 128 characters in length and can contain letters,
-        digits, and underscores (_). It cannot start with a digit.
-        """
         return pulumi.get(self, "key")
 
     @key.setter
@@ -1261,9 +1783,6 @@ class EciScalingConfigurationInitContainerEnvironmentVarArgs:
     @property
     @pulumi.getter
     def value(self) -> Optional[pulumi.Input[str]]:
-        """
-        The value of the variable. The value can be 0 to 256 characters in length.
-        """
         return pulumi.get(self, "value")
 
     @value.setter
@@ -1271,15 +1790,18 @@ class EciScalingConfigurationInitContainerEnvironmentVarArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationInitContainerPortArgsDict(TypedDict):
+        port: NotRequired[pulumi.Input[int]]
+        protocol: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationInitContainerPortArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationInitContainerPortArgs:
     def __init__(__self__, *,
                  port: Optional[pulumi.Input[int]] = None,
                  protocol: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[int] port: The port number. Valid values: 1 to 65535.
-        :param pulumi.Input[str] protocol: Valid values: TCP and UDP.
-        """
         if port is not None:
             pulumi.set(__self__, "port", port)
         if protocol is not None:
@@ -1288,9 +1810,6 @@ class EciScalingConfigurationInitContainerPortArgs:
     @property
     @pulumi.getter
     def port(self) -> Optional[pulumi.Input[int]]:
-        """
-        The port number. Valid values: 1 to 65535.
-        """
         return pulumi.get(self, "port")
 
     @port.setter
@@ -1300,9 +1819,6 @@ class EciScalingConfigurationInitContainerPortArgs:
     @property
     @pulumi.getter
     def protocol(self) -> Optional[pulumi.Input[str]]:
-        """
-        Valid values: TCP and UDP.
-        """
         return pulumi.get(self, "protocol")
 
     @protocol.setter
@@ -1310,44 +1826,56 @@ class EciScalingConfigurationInitContainerPortArgs:
         pulumi.set(self, "protocol", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationInitContainerVolumeMountArgsDict(TypedDict):
+        mount_path: NotRequired[pulumi.Input[str]]
+        mount_propagation: NotRequired[pulumi.Input[str]]
+        name: NotRequired[pulumi.Input[str]]
+        read_only: NotRequired[pulumi.Input[bool]]
+        sub_path: NotRequired[pulumi.Input[str]]
+elif False:
+    EciScalingConfigurationInitContainerVolumeMountArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationInitContainerVolumeMountArgs:
     def __init__(__self__, *,
                  mount_path: Optional[pulumi.Input[str]] = None,
+                 mount_propagation: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 read_only: Optional[pulumi.Input[bool]] = None):
-        """
-        :param pulumi.Input[str] mount_path: The directory of the mounted volume. Data under this directory will be overwritten by the
-               data in the volume.
-        :param pulumi.Input[str] name: The name of the mounted volume.
-        :param pulumi.Input[bool] read_only: Default to `false`.
-        """
+                 read_only: Optional[pulumi.Input[bool]] = None,
+                 sub_path: Optional[pulumi.Input[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[str]]:
-        """
-        The directory of the mounted volume. Data under this directory will be overwritten by the
-        data in the volume.
-        """
         return pulumi.get(self, "mount_path")
 
     @mount_path.setter
     def mount_path(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "mount_path", value)
 
+    @property
+    @pulumi.getter(name="mountPropagation")
+    def mount_propagation(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "mount_propagation")
+
+    @mount_propagation.setter
+    def mount_propagation(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mount_propagation", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
-        """
-        The name of the mounted volume.
-        """
         return pulumi.get(self, "name")
 
     @name.setter
@@ -1357,26 +1885,167 @@ class EciScalingConfigurationInitContainerVolumeMountArgs:
     @property
     @pulumi.getter(name="readOnly")
     def read_only(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Default to `false`.
-        """
         return pulumi.get(self, "read_only")
 
     @read_only.setter
     def read_only(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "read_only", value)
 
+    @property
+    @pulumi.getter(name="subPath")
+    def sub_path(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "sub_path")
+
+    @sub_path.setter
+    def sub_path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sub_path", value)
+
+
+if not MYPY:
+    class EciScalingConfigurationSecurityContextSysctlArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The system name of the security context in which the elastic container instance is run.
+        """
+        value: NotRequired[pulumi.Input[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[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] name: The system name of the security context in which the elastic container instance is run.
+        :param pulumi.Input[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[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[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[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[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[int]]
+        """
+        The default permissions on the ConfigFileVolume.
+        """
+        disk_volume_disk_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of DiskVolume.
+        """
+        disk_volume_disk_size: NotRequired[pulumi.Input[int]]
+        """
+        The disk size of DiskVolume.
+        """
+        disk_volume_fs_type: NotRequired[pulumi.Input[str]]
+        """
+        The system type of DiskVolume.
+        """
+        empty_dir_volume_medium: NotRequired[pulumi.Input[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[str]]
+        """
+        The storage size of the EmptyDirVolume. Unit: GiB or MiB.
+        """
+        flex_volume_driver: NotRequired[pulumi.Input[str]]
+        """
+        The name of the FlexVolume driver.
+        """
+        flex_volume_fs_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of the mounted file system. The default value is determined by the script
+        of FlexVolume.
+        """
+        flex_volume_options: NotRequired[pulumi.Input[str]]
+        """
+        The list of FlexVolume objects. Each object is a key-value pair contained in a JSON
+        string.
+        """
+        host_path_volume_path: NotRequired[pulumi.Input[str]]
+        """
+        The absolute path on the host.
+        """
+        host_path_volume_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of the host path. Examples: File, Directory, and Socket.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the volume.
+        """
+        nfs_volume_path: NotRequired[pulumi.Input[str]]
+        """
+        The path to the NFS volume.
+        """
+        nfs_volume_read_only: NotRequired[pulumi.Input[bool]]
+        """
+        The nfs volume read only. Default to `false`.
+        """
+        nfs_volume_server: NotRequired[pulumi.Input[str]]
+        """
+        The address of the NFS server.
+
+        > **NOTE:** Every volume mounted must have a name and type attributes.
+        """
+        type: NotRequired[pulumi.Input[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[int]] = None,
                  disk_volume_disk_id: Optional[pulumi.Input[str]] = None,
                  disk_volume_disk_size: Optional[pulumi.Input[int]] = None,
                  disk_volume_fs_type: Optional[pulumi.Input[str]] = None,
+                 empty_dir_volume_medium: Optional[pulumi.Input[str]] = None,
+                 empty_dir_volume_size_limit: Optional[pulumi.Input[str]] = None,
                  flex_volume_driver: Optional[pulumi.Input[str]] = None,
                  flex_volume_fs_type: Optional[pulumi.Input[str]] = None,
                  flex_volume_options: Optional[pulumi.Input[str]] = None,
+                 host_path_volume_path: Optional[pulumi.Input[str]] = None,
+                 host_path_volume_type: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  nfs_volume_path: Optional[pulumi.Input[str]] = None,
                  nfs_volume_read_only: Optional[pulumi.Input[bool]] = None,
@@ -1385,14 +2054,19 @@ class EciScalingConfigurationVolumeArgs:
         """
         :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[int] config_file_volume_default_mode: The default permissions on the ConfigFileVolume.
         :param pulumi.Input[str] disk_volume_disk_id: The ID of DiskVolume.
         :param pulumi.Input[int] disk_volume_disk_size: The disk size of DiskVolume.
         :param pulumi.Input[str] disk_volume_fs_type: The system type of DiskVolume.
+        :param pulumi.Input[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[str] empty_dir_volume_size_limit: The storage size of the EmptyDirVolume. Unit: GiB or MiB.
         :param pulumi.Input[str] flex_volume_driver: The name of the FlexVolume driver.
         :param pulumi.Input[str] flex_volume_fs_type: The type of the mounted file system. The default value is determined by the script
                of FlexVolume.
         :param pulumi.Input[str] flex_volume_options: The list of FlexVolume objects. Each object is a key-value pair contained in a JSON
                string.
+        :param pulumi.Input[str] host_path_volume_path: The absolute path on the host.
+        :param pulumi.Input[str] host_path_volume_type: The type of the host path. Examples: File, Directory, and Socket.
         :param pulumi.Input[str] name: The name of the volume.
         :param pulumi.Input[str] nfs_volume_path: The path to the NFS volume.
         :param pulumi.Input[bool] nfs_volume_read_only: The nfs volume read only. Default to `false`.
@@ -1403,18 +2077,28 @@ class EciScalingConfigurationVolumeArgs:
         """
         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:
@@ -1439,6 +2123,18 @@ class EciScalingConfigurationVolumeArgs:
     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[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[int]]):
+        pulumi.set(self, "config_file_volume_default_mode", value)
+
     @property
     @pulumi.getter(name="diskVolumeDiskId")
     def disk_volume_disk_id(self) -> Optional[pulumi.Input[str]]:
@@ -1475,6 +2171,30 @@ class EciScalingConfigurationVolumeArgs:
     def disk_volume_fs_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "disk_volume_fs_type", value)
 
+    @property
+    @pulumi.getter(name="emptyDirVolumeMedium")
+    def empty_dir_volume_medium(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "empty_dir_volume_medium", value)
+
+    @property
+    @pulumi.getter(name="emptyDirVolumeSizeLimit")
+    def empty_dir_volume_size_limit(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "empty_dir_volume_size_limit", value)
+
     @property
     @pulumi.getter(name="flexVolumeDriver")
     def flex_volume_driver(self) -> Optional[pulumi.Input[str]]:
@@ -1513,6 +2233,30 @@ class EciScalingConfigurationVolumeArgs:
     def flex_volume_options(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "flex_volume_options", value)
 
+    @property
+    @pulumi.getter(name="hostPathVolumePath")
+    def host_path_volume_path(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "host_path_volume_path", value)
+
+    @property
+    @pulumi.getter(name="hostPathVolumeType")
+    def host_path_volume_type(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "host_path_volume_type", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -1576,17 +2320,38 @@ class EciScalingConfigurationVolumeArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict(TypedDict):
+        content: NotRequired[pulumi.Input[str]]
+        """
+        The content of the configuration file. Maximum size: 32 KB.
+        """
+        mode: NotRequired[pulumi.Input[int]]
+        """
+        The permissions on the ConfigFileVolume directory.
+        """
+        path: NotRequired[pulumi.Input[str]]
+        """
+        The relative file path.
+        """
+elif False:
+    EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs:
     def __init__(__self__, *,
                  content: Optional[pulumi.Input[str]] = None,
+                 mode: Optional[pulumi.Input[int]] = None,
                  path: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] content: The content of the configuration file. Maximum size: 32 KB.
+        :param pulumi.Input[int] mode: The permissions on the ConfigFileVolume directory.
         :param pulumi.Input[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)
 
@@ -1602,6 +2367,18 @@ class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs:
     def content(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "content", value)
 
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[int]]:
+        """
+        The permissions on the ConfigFileVolume directory.
+        """
+        return pulumi.get(self, "mode")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "mode", value)
+
     @property
     @pulumi.getter
     def path(self) -> Optional[pulumi.Input[str]]:
@@ -1615,6 +2392,111 @@ class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs:
         pulumi.set(self, "path", value)
 
 
+if not MYPY:
+    class ScalingConfigurationCustomPriorityArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[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[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[str]] = None,
+                 vswitch_id: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[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[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[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[str]]):
+        pulumi.set(self, "instance_type", value)
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[pulumi.Input[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[str]]):
+        pulumi.set(self, "vswitch_id", value)
+
+
+if not MYPY:
+    class ScalingConfigurationDataDiskArgsDict(TypedDict):
+        auto_snapshot_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        The id of auto snapshot policy for data disk.
+        """
+        category: NotRequired[pulumi.Input[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[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[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[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[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[str]]
+        """
+        The CMK ID for data disk N. Valid values of N: 1 to 16.
+        """
+        name: NotRequired[pulumi.Input[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[str]]
+        """
+        The performance level of the ESSD used as data disk.
+        """
+        provisioned_iops: NotRequired[pulumi.Input[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[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[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__, *,
@@ -1627,11 +2509,12 @@ class ScalingConfigurationDataDiskArgs:
                  kms_key_id: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  performance_level: Optional[pulumi.Input[str]] = None,
+                 provisioned_iops: Optional[pulumi.Input[int]] = None,
                  size: Optional[pulumi.Input[int]] = None,
                  snapshot_id: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] auto_snapshot_policy_id: The id of auto snapshot policy for data disk.
-        :param pulumi.Input[str] category: Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` and `cloud`.
+        :param pulumi.Input[str] category: Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
         :param pulumi.Input[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[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[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.
@@ -1639,6 +2522,7 @@ class ScalingConfigurationDataDiskArgs:
         :param pulumi.Input[str] kms_key_id: The CMK ID for data disk N. Valid values of N: 1 to 16.
         :param pulumi.Input[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[str] performance_level: The performance level of the ESSD used as data disk.
+        :param pulumi.Input[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[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[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.
         """
@@ -1663,6 +2547,8 @@ class ScalingConfigurationDataDiskArgs:
             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:
@@ -1684,7 +2570,7 @@ class ScalingConfigurationDataDiskArgs:
     @pulumi.getter
     def category(self) -> Optional[pulumi.Input[str]]:
         """
-        Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` and `cloud`.
+        Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
         """
         return pulumi.get(self, "category")
 
@@ -1718,13 +2604,11 @@ class ScalingConfigurationDataDiskArgs:
 
     @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[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.
         """
-        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.""")
-
         return pulumi.get(self, "device")
 
     @device.setter
@@ -1779,6 +2663,18 @@ class ScalingConfigurationDataDiskArgs:
     def performance_level(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "performance_level", value)
 
+    @property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[pulumi.Input[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[int]]):
+        pulumi.set(self, "provisioned_iops", value)
+
     @property
     @pulumi.getter
     def size(self) -> Optional[pulumi.Input[int]]:
@@ -1804,6 +2700,39 @@ class ScalingConfigurationDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
+if not MYPY:
+    class ScalingConfigurationInstancePatternInfoArgsDict(TypedDict):
+        architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
+        """
+        burstable_performance: NotRequired[pulumi.Input[str]]
+        """
+        Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
+        """
+        cores: NotRequired[pulumi.Input[int]]
+        """
+        The number of vCPUs that are specified for an instance type in instancePatternInfo.
+        """
+        excluded_instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[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[str]]
+        """
+        The instance family level in instancePatternInfo.
+        """
+        max_price: NotRequired[pulumi.Input[float]]
+        """
+        The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
+        """
+        memory: NotRequired[pulumi.Input[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__, *,
@@ -1923,6 +2852,19 @@ class ScalingConfigurationInstancePatternInfoArgs:
         pulumi.set(self, "memory", value)
 
 
+if not MYPY:
+    class ScalingConfigurationInstanceTypeOverrideArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[str]]
+        """
+        The is specified for an instance type in instanceTypeOverride.
+        """
+        weighted_capacity: NotRequired[pulumi.Input[int]]
+        """
+        The weight of instance type in instanceTypeOverride.
+        """
+elif False:
+    ScalingConfigurationInstanceTypeOverrideArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScalingConfigurationInstanceTypeOverrideArgs:
     def __init__(__self__, *,
@@ -1962,6 +2904,111 @@ class ScalingConfigurationInstanceTypeOverrideArgs:
         pulumi.set(self, "weighted_capacity", value)
 
 
+if not MYPY:
+    class ScalingConfigurationNetworkInterfaceArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[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[int]]
+        """
+        The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
+        """
+        network_interface_traffic_mode: NotRequired[pulumi.Input[str]]
+        """
+        The communication mode of the ENI. Valid values: Standard, HighPerformance.
+        """
+        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[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[str]] = None,
+                 ipv6_address_count: Optional[pulumi.Input[int]] = None,
+                 network_interface_traffic_mode: Optional[pulumi.Input[str]] = None,
+                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[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[int] ipv6_address_count: The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
+        :param pulumi.Input[str] network_interface_traffic_mode: The communication mode of the ENI. Valid values: Standard, HighPerformance.
+        :param pulumi.Input[Sequence[pulumi.Input[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[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[str]]):
+        pulumi.set(self, "instance_type", value)
+
+    @property
+    @pulumi.getter(name="ipv6AddressCount")
+    def ipv6_address_count(self) -> Optional[pulumi.Input[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[int]]):
+        pulumi.set(self, "ipv6_address_count", value)
+
+    @property
+    @pulumi.getter(name="networkInterfaceTrafficMode")
+    def network_interface_traffic_mode(self) -> Optional[pulumi.Input[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[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[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[str]]]]):
+        pulumi.set(self, "security_group_ids", value)
+
+
+if not MYPY:
+    class ScalingConfigurationSpotPriceLimitArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[str]]
+        """
+        Resource type of an ECS instance.
+        """
+        price_limit: NotRequired[pulumi.Input[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__, *,
@@ -2001,6 +3048,102 @@ class ScalingConfigurationSpotPriceLimitArgs:
         pulumi.set(self, "price_limit", value)
 
 
+if not MYPY:
+    class ScalingGroupAlbServerGroupArgsDict(TypedDict):
+        alb_server_group_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of ALB server group.
+        """
+        port: NotRequired[pulumi.Input[int]]
+        """
+        The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
+        """
+        weight: NotRequired[pulumi.Input[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[str]] = None,
+                 port: Optional[pulumi.Input[int]] = None,
+                 weight: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] alb_server_group_id: The ID of ALB server group.
+        :param pulumi.Input[int] port: The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
+        :param pulumi.Input[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[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[str]]):
+        pulumi.set(self, "alb_server_group_id", value)
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[pulumi.Input[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[int]]):
+        pulumi.set(self, "port", value)
+
+    @property
+    @pulumi.getter
+    def weight(self) -> Optional[pulumi.Input[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[int]]):
+        pulumi.set(self, "weight", value)
+
+
+if not MYPY:
+    class ScalingGroupLaunchTemplateOverrideArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[str]]
+        """
+        The instance type in launchTemplateOverride.
+        """
+        spot_price_limit: NotRequired[pulumi.Input[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[int]]
+        """
+        The weight of the instance type in launchTemplateOverride.
+        """
+elif False:
+    ScalingGroupLaunchTemplateOverrideArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScalingGroupLaunchTemplateOverrideArgs:
     def __init__(__self__, *,
@@ -2070,6 +3213,19 @@ class ScalingGroupLaunchTemplateOverrideArgs:
         pulumi.set(self, "weighted_capacity", value)
 
 
+if not MYPY:
+    class ScalingGroupVServerGroupsVserverGroupArgsDict(TypedDict):
+        loadbalancer_id: pulumi.Input[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__, *,
@@ -2107,6 +3263,23 @@ class ScalingGroupVServerGroupsVserverGroupArgs:
         pulumi.set(self, "vserver_attributes", value)
 
 
+if not MYPY:
+    class ScalingGroupVServerGroupsVserverGroupVserverAttributeArgsDict(TypedDict):
+        port: pulumi.Input[int]
+        """
+        The port will be used for VServer Group backend server.
+        """
+        vserver_group_id: pulumi.Input[str]
+        """
+        ID of VServer Group.
+        """
+        weight: pulumi.Input[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__, *,
@@ -2159,6 +3332,19 @@ class ScalingGroupVServerGroupsVserverGroupVserverAttributeArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class ScalingRuleAlarmDimensionArgsDict(TypedDict):
+        dimension_key: NotRequired[pulumi.Input[str]]
+        """
+        The dimension key of the metric.
+        """
+        dimension_value: NotRequired[pulumi.Input[str]]
+        """
+        The dimension value of the metric.
+        """
+elif False:
+    ScalingRuleAlarmDimensionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScalingRuleAlarmDimensionArgs:
     def __init__(__self__, *,
@@ -2198,6 +3384,23 @@ class ScalingRuleAlarmDimensionArgs:
         pulumi.set(self, "dimension_value", value)
 
 
+if not MYPY:
+    class ScalingRuleStepAdjustmentArgsDict(TypedDict):
+        metric_interval_lower_bound: NotRequired[pulumi.Input[str]]
+        """
+        The lower bound of step.
+        """
+        metric_interval_upper_bound: NotRequired[pulumi.Input[str]]
+        """
+        The upper bound of step.
+        """
+        scaling_adjustment: NotRequired[pulumi.Input[int]]
+        """
+        The adjust value of step.
+        """
+elif False:
+    ScalingRuleStepAdjustmentArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ScalingRuleStepAdjustmentArgs:
     def __init__(__self__, *,