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

pulumi_alicloud/ess/outputs.py

@@ -4,30 +4,41 @@
 
 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
 from . import outputs
 
 __all__ = [
+    'AlarmExpression',
     'EciScalingConfigurationAcrRegistryInfo',
     'EciScalingConfigurationContainer',
     'EciScalingConfigurationContainerEnvironmentVar',
     'EciScalingConfigurationContainerPort',
     'EciScalingConfigurationContainerVolumeMount',
+    'EciScalingConfigurationDnsConfigOption',
     'EciScalingConfigurationHostAlias',
     'EciScalingConfigurationImageRegistryCredential',
     'EciScalingConfigurationInitContainer',
     'EciScalingConfigurationInitContainerEnvironmentVar',
     'EciScalingConfigurationInitContainerPort',
     'EciScalingConfigurationInitContainerVolumeMount',
+    'EciScalingConfigurationSecurityContextSysctl',
     'EciScalingConfigurationVolume',
     'EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPath',
+    'ScalingConfigurationCustomPriority',
     'ScalingConfigurationDataDisk',
     'ScalingConfigurationInstancePatternInfo',
     'ScalingConfigurationInstanceTypeOverride',
+    'ScalingConfigurationNetworkInterface',
     'ScalingConfigurationSpotPriceLimit',
+    'ScalingGroupAlbServerGroup',
     'ScalingGroupLaunchTemplateOverride',
     'ScalingGroupVServerGroupsVserverGroup',
     'ScalingGroupVServerGroupsVserverGroupVserverAttribute',
@@ -38,12 +49,99 @@ __all__ = [
     'GetNotificationsNotificationResult',
     'GetScalingConfigurationsConfigurationResult',
     'GetScalingConfigurationsConfigurationDataDiskResult',
+    'GetScalingConfigurationsConfigurationInstancePatternInfoResult',
     'GetScalingConfigurationsConfigurationSpotPriceLimitResult',
     'GetScalingGroupsGroupResult',
     'GetScalingRulesRuleResult',
     'GetScheduledTasksTaskResult',
 ]
 
+@pulumi.output_type
+class AlarmExpression(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "comparisonOperator":
+            suggest = "comparison_operator"
+        elif key == "metricName":
+            suggest = "metric_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AlarmExpression. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AlarmExpression.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AlarmExpression.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 comparison_operator: Optional[str] = None,
+                 metric_name: Optional[str] = None,
+                 period: Optional[int] = None,
+                 statistics: Optional[str] = None,
+                 threshold: Optional[float] = None):
+        """
+        :param 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 str metric_name: The name for the alarm's associated metric. See `dimensions` below for details.
+        :param int period: The period in seconds over which the specified statistic is applied. Supported value: 60, 120, 300, 900. Defaults to 300.
+        :param str statistics: The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
+        :param 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[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")
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> Optional[str]:
+        """
+        The name for the alarm's associated metric. See `dimensions` below for details.
+        """
+        return pulumi.get(self, "metric_name")
+
+    @property
+    @pulumi.getter
+    def period(self) -> Optional[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")
+
+    @property
+    @pulumi.getter
+    def statistics(self) -> Optional[str]:
+        """
+        The statistic to apply to the alarm's associated metric. Supported value: Average, Minimum, Maximum. Defaults to Average.
+        """
+        return pulumi.get(self, "statistics")
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> Optional[float]:
+        """
+        The value against which the specified statistics is compared.
+        """
+        return pulumi.get(self, "threshold")
+
+
 @pulumi.output_type
 class EciScalingConfigurationAcrRegistryInfo(dict):
     @staticmethod
@@ -236,6 +334,8 @@ class EciScalingConfigurationContainer(dict):
                  security_context_capability_adds: Optional[Sequence[str]] = None,
                  security_context_read_only_root_file_system: Optional[bool] = None,
                  security_context_run_as_user: Optional[int] = None,
+                 stdin: Optional[bool] = None,
+                 tty: Optional[bool] = None,
                  volume_mounts: Optional[Sequence['outputs.EciScalingConfigurationContainerVolumeMount']] = None,
                  working_dir: Optional[str] = None):
         """
@@ -276,6 +376,8 @@ class EciScalingConfigurationContainer(dict):
                - NET_RAW: Allow raw sockets.
         :param bool security_context_read_only_root_file_system: Mounts the container's root filesystem as read-only.
         :param int security_context_run_as_user: Specifies user ID  under which all processes run.
+        :param 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 bool tty: Specifies whether to enable the Interaction feature. Valid values: true, false.
         :param Sequence['EciScalingConfigurationContainerVolumeMountArgs'] volume_mounts: The structure of volumeMounts. 
                See `volume_mounts` below for details.
         :param str working_dir: The working directory of the container.
@@ -348,6 +450,10 @@ class EciScalingConfigurationContainer(dict):
             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:
@@ -628,6 +734,22 @@ class EciScalingConfigurationContainer(dict):
         """
         return pulumi.get(self, "security_context_run_as_user")
 
+    @property
+    @pulumi.getter
+    def stdin(self) -> Optional[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")
+
+    @property
+    @pulumi.getter
+    def tty(self) -> Optional[bool]:
+        """
+        Specifies whether to enable the Interaction feature. Valid values: true, false.
+        """
+        return pulumi.get(self, "tty")
+
     @property
     @pulumi.getter(name="volumeMounts")
     def volume_mounts(self) -> Optional[Sequence['outputs.EciScalingConfigurationContainerVolumeMount']]:
@@ -669,13 +791,6 @@ class EciScalingConfigurationContainerEnvironmentVar(dict):
                  field_ref_field_path: Optional[str] = None,
                  key: Optional[str] = None,
                  value: Optional[str] = None):
-        """
-        :param str field_ref_field_path: Environment variable value reference. Optional values: 
-               - status.podIP: IP of pod.
-        :param 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 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:
@@ -686,27 +801,16 @@ class EciScalingConfigurationContainerEnvironmentVar(dict):
     @property
     @pulumi.getter(name="fieldRefFieldPath")
     def field_ref_field_path(self) -> Optional[str]:
-        """
-        Environment variable value reference. Optional values: 
-        - status.podIP: IP of pod.
-        """
         return pulumi.get(self, "field_ref_field_path")
 
     @property
     @pulumi.getter
     def key(self) -> Optional[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")
 
     @property
     @pulumi.getter
     def value(self) -> Optional[str]:
-        """
-        The value of the variable. The value can be 0 to 256 characters in length.
-        """
         return pulumi.get(self, "value")
 
 
@@ -715,10 +819,6 @@ class EciScalingConfigurationContainerPort(dict):
     def __init__(__self__, *,
                  port: Optional[int] = None,
                  protocol: Optional[str] = None):
-        """
-        :param int port: The port number. Valid values: 1 to 65535.
-        :param str protocol: Valid values: TCP and UDP.
-        """
         if port is not None:
             pulumi.set(__self__, "port", port)
         if protocol is not None:
@@ -727,17 +827,11 @@ class EciScalingConfigurationContainerPort(dict):
     @property
     @pulumi.getter
     def port(self) -> Optional[int]:
-        """
-        The port number. Valid values: 1 to 65535.
-        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def protocol(self) -> Optional[str]:
-        """
-        Valid values: TCP and UDP.
-        """
         return pulumi.get(self, "protocol")
 
 
@@ -748,8 +842,12 @@ class EciScalingConfigurationContainerVolumeMount(dict):
         suggest = None
         if key == "mountPath":
             suggest = "mount_path"
+        elif key == "mountPropagation":
+            suggest = "mount_propagation"
         elif key == "readOnly":
             suggest = "read_only"
+        elif key == "subPath":
+            suggest = "sub_path"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in EciScalingConfigurationContainerVolumeMount. Access the value via the '{suggest}' property getter instead.")
@@ -764,45 +862,76 @@ class EciScalingConfigurationContainerVolumeMount(dict):
 
     def __init__(__self__, *,
                  mount_path: Optional[str] = None,
+                 mount_propagation: Optional[str] = None,
                  name: Optional[str] = None,
-                 read_only: Optional[bool] = None):
-        """
-        :param str mount_path: The directory of the mounted volume. Data under this directory will be overwritten by the
-               data in the volume.
-        :param str name: The name of the mounted volume.
-        :param bool read_only: Default to `false`.
-        """
+                 read_only: Optional[bool] = None,
+                 sub_path: Optional[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[str]:
+        return pulumi.get(self, "mount_path")
+
+    @property
+    @pulumi.getter(name="mountPropagation")
+    def mount_propagation(self) -> Optional[str]:
+        return pulumi.get(self, "mount_propagation")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[bool]:
+        return pulumi.get(self, "read_only")
+
+    @property
+    @pulumi.getter(name="subPath")
+    def sub_path(self) -> Optional[str]:
+        return pulumi.get(self, "sub_path")
+
+
+@pulumi.output_type
+class EciScalingConfigurationDnsConfigOption(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 value: Optional[str] = None):
         """
-        The directory of the mounted volume. Data under this directory will be overwritten by the
-        data in the volume.
+        :param str name: The option name.
+        :param str value: The option value.
         """
-        return pulumi.get(self, "mount_path")
+        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[str]:
         """
-        The name of the mounted volume.
+        The option name.
         """
         return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[bool]:
+    @pulumi.getter
+    def value(self) -> Optional[str]:
         """
-        Default to `false`.
+        The option value.
         """
-        return pulumi.get(self, "read_only")
+        return pulumi.get(self, "value")
 
 
 @pulumi.output_type
@@ -1130,13 +1259,6 @@ class EciScalingConfigurationInitContainerEnvironmentVar(dict):
                  field_ref_field_path: Optional[str] = None,
                  key: Optional[str] = None,
                  value: Optional[str] = None):
-        """
-        :param str field_ref_field_path: Environment variable value reference. Optional values: 
-               - status.podIP: IP of pod.
-        :param 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 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:
@@ -1147,27 +1269,16 @@ class EciScalingConfigurationInitContainerEnvironmentVar(dict):
     @property
     @pulumi.getter(name="fieldRefFieldPath")
     def field_ref_field_path(self) -> Optional[str]:
-        """
-        Environment variable value reference. Optional values: 
-        - status.podIP: IP of pod.
-        """
         return pulumi.get(self, "field_ref_field_path")
 
     @property
     @pulumi.getter
     def key(self) -> Optional[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")
 
     @property
     @pulumi.getter
     def value(self) -> Optional[str]:
-        """
-        The value of the variable. The value can be 0 to 256 characters in length.
-        """
         return pulumi.get(self, "value")
 
 
@@ -1176,10 +1287,6 @@ class EciScalingConfigurationInitContainerPort(dict):
     def __init__(__self__, *,
                  port: Optional[int] = None,
                  protocol: Optional[str] = None):
-        """
-        :param int port: The port number. Valid values: 1 to 65535.
-        :param str protocol: Valid values: TCP and UDP.
-        """
         if port is not None:
             pulumi.set(__self__, "port", port)
         if protocol is not None:
@@ -1188,17 +1295,11 @@ class EciScalingConfigurationInitContainerPort(dict):
     @property
     @pulumi.getter
     def port(self) -> Optional[int]:
-        """
-        The port number. Valid values: 1 to 65535.
-        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def protocol(self) -> Optional[str]:
-        """
-        Valid values: TCP and UDP.
-        """
         return pulumi.get(self, "protocol")
 
 
@@ -1209,8 +1310,12 @@ class EciScalingConfigurationInitContainerVolumeMount(dict):
         suggest = None
         if key == "mountPath":
             suggest = "mount_path"
+        elif key == "mountPropagation":
+            suggest = "mount_propagation"
         elif key == "readOnly":
             suggest = "read_only"
+        elif key == "subPath":
+            suggest = "sub_path"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in EciScalingConfigurationInitContainerVolumeMount. Access the value via the '{suggest}' property getter instead.")
@@ -1225,45 +1330,76 @@ class EciScalingConfigurationInitContainerVolumeMount(dict):
 
     def __init__(__self__, *,
                  mount_path: Optional[str] = None,
+                 mount_propagation: Optional[str] = None,
                  name: Optional[str] = None,
-                 read_only: Optional[bool] = None):
-        """
-        :param str mount_path: The directory of the mounted volume. Data under this directory will be overwritten by the
-               data in the volume.
-        :param str name: The name of the mounted volume.
-        :param bool read_only: Default to `false`.
-        """
+                 read_only: Optional[bool] = None,
+                 sub_path: Optional[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[str]:
+        return pulumi.get(self, "mount_path")
+
+    @property
+    @pulumi.getter(name="mountPropagation")
+    def mount_propagation(self) -> Optional[str]:
+        return pulumi.get(self, "mount_propagation")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="readOnly")
+    def read_only(self) -> Optional[bool]:
+        return pulumi.get(self, "read_only")
+
+    @property
+    @pulumi.getter(name="subPath")
+    def sub_path(self) -> Optional[str]:
+        return pulumi.get(self, "sub_path")
+
+
+@pulumi.output_type
+class EciScalingConfigurationSecurityContextSysctl(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 value: Optional[str] = None):
         """
-        The directory of the mounted volume. Data under this directory will be overwritten by the
-        data in the volume.
+        :param str name: The system name of the security context in which the elastic container instance is run.
+        :param str value: The system value of the security context in which the elastic container instance is run.
         """
-        return pulumi.get(self, "mount_path")
+        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[str]:
         """
-        The name of the mounted volume.
+        The system name of the security context in which the elastic container instance is run.
         """
         return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[bool]:
+    @pulumi.getter
+    def value(self) -> Optional[str]:
         """
-        Default to `false`.
+        The system value of the security context in which the elastic container instance is run.
         """
-        return pulumi.get(self, "read_only")
+        return pulumi.get(self, "value")
 
 
 @pulumi.output_type
@@ -1273,18 +1409,28 @@ class EciScalingConfigurationVolume(dict):
         suggest = None
         if key == "configFileVolumeConfigFileToPaths":
             suggest = "config_file_volume_config_file_to_paths"
+        elif key == "configFileVolumeDefaultMode":
+            suggest = "config_file_volume_default_mode"
         elif key == "diskVolumeDiskId":
             suggest = "disk_volume_disk_id"
         elif key == "diskVolumeDiskSize":
             suggest = "disk_volume_disk_size"
         elif key == "diskVolumeFsType":
             suggest = "disk_volume_fs_type"
+        elif key == "emptyDirVolumeMedium":
+            suggest = "empty_dir_volume_medium"
+        elif key == "emptyDirVolumeSizeLimit":
+            suggest = "empty_dir_volume_size_limit"
         elif key == "flexVolumeDriver":
             suggest = "flex_volume_driver"
         elif key == "flexVolumeFsType":
             suggest = "flex_volume_fs_type"
         elif key == "flexVolumeOptions":
             suggest = "flex_volume_options"
+        elif key == "hostPathVolumePath":
+            suggest = "host_path_volume_path"
+        elif key == "hostPathVolumeType":
+            suggest = "host_path_volume_type"
         elif key == "nfsVolumePath":
             suggest = "nfs_volume_path"
         elif key == "nfsVolumeReadOnly":
@@ -1305,12 +1451,17 @@ class EciScalingConfigurationVolume(dict):
 
     def __init__(__self__, *,
                  config_file_volume_config_file_to_paths: Optional[Sequence['outputs.EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPath']] = None,
+                 config_file_volume_default_mode: Optional[int] = None,
                  disk_volume_disk_id: Optional[str] = None,
                  disk_volume_disk_size: Optional[int] = None,
                  disk_volume_fs_type: Optional[str] = None,
+                 empty_dir_volume_medium: Optional[str] = None,
+                 empty_dir_volume_size_limit: Optional[str] = None,
                  flex_volume_driver: Optional[str] = None,
                  flex_volume_fs_type: Optional[str] = None,
                  flex_volume_options: Optional[str] = None,
+                 host_path_volume_path: Optional[str] = None,
+                 host_path_volume_type: Optional[str] = None,
                  name: Optional[str] = None,
                  nfs_volume_path: Optional[str] = None,
                  nfs_volume_read_only: Optional[bool] = None,
@@ -1319,14 +1470,19 @@ class EciScalingConfigurationVolume(dict):
         """
         :param Sequence['EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPathArgs'] config_file_volume_config_file_to_paths: ConfigFileVolumeConfigFileToPaths.
                See `config_file_volume_config_file_to_paths` below for details.
+        :param int config_file_volume_default_mode: The default permissions on the ConfigFileVolume.
         :param str disk_volume_disk_id: The ID of DiskVolume.
         :param int disk_volume_disk_size: The disk size of DiskVolume.
         :param str disk_volume_fs_type: The system type of DiskVolume.
+        :param 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 str empty_dir_volume_size_limit: The storage size of the EmptyDirVolume. Unit: GiB or MiB.
         :param str flex_volume_driver: The name of the FlexVolume driver.
         :param str flex_volume_fs_type: The type of the mounted file system. The default value is determined by the script
                of FlexVolume.
         :param str flex_volume_options: The list of FlexVolume objects. Each object is a key-value pair contained in a JSON
                string.
+        :param str host_path_volume_path: The absolute path on the host.
+        :param str host_path_volume_type: The type of the host path. Examples: File, Directory, and Socket.
         :param str name: The name of the volume.
         :param str nfs_volume_path: The path to the NFS volume.
         :param bool nfs_volume_read_only: The nfs volume read only. Default to `false`.
@@ -1337,18 +1493,28 @@ class EciScalingConfigurationVolume(dict):
         """
         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:
@@ -1369,6 +1535,14 @@ class EciScalingConfigurationVolume(dict):
         """
         return pulumi.get(self, "config_file_volume_config_file_to_paths")
 
+    @property
+    @pulumi.getter(name="configFileVolumeDefaultMode")
+    def config_file_volume_default_mode(self) -> Optional[int]:
+        """
+        The default permissions on the ConfigFileVolume.
+        """
+        return pulumi.get(self, "config_file_volume_default_mode")
+
     @property
     @pulumi.getter(name="diskVolumeDiskId")
     def disk_volume_disk_id(self) -> Optional[str]:
@@ -1393,6 +1567,22 @@ class EciScalingConfigurationVolume(dict):
         """
         return pulumi.get(self, "disk_volume_fs_type")
 
+    @property
+    @pulumi.getter(name="emptyDirVolumeMedium")
+    def empty_dir_volume_medium(self) -> Optional[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")
+
+    @property
+    @pulumi.getter(name="emptyDirVolumeSizeLimit")
+    def empty_dir_volume_size_limit(self) -> Optional[str]:
+        """
+        The storage size of the EmptyDirVolume. Unit: GiB or MiB.
+        """
+        return pulumi.get(self, "empty_dir_volume_size_limit")
+
     @property
     @pulumi.getter(name="flexVolumeDriver")
     def flex_volume_driver(self) -> Optional[str]:
@@ -1419,6 +1609,22 @@ class EciScalingConfigurationVolume(dict):
         """
         return pulumi.get(self, "flex_volume_options")
 
+    @property
+    @pulumi.getter(name="hostPathVolumePath")
+    def host_path_volume_path(self) -> Optional[str]:
+        """
+        The absolute path on the host.
+        """
+        return pulumi.get(self, "host_path_volume_path")
+
+    @property
+    @pulumi.getter(name="hostPathVolumeType")
+    def host_path_volume_type(self) -> Optional[str]:
+        """
+        The type of the host path. Examples: File, Directory, and Socket.
+        """
+        return pulumi.get(self, "host_path_volume_type")
+
     @property
     @pulumi.getter
     def name(self) -> Optional[str]:
@@ -1466,13 +1672,17 @@ class EciScalingConfigurationVolume(dict):
 class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPath(dict):
     def __init__(__self__, *,
                  content: Optional[str] = None,
+                 mode: Optional[int] = None,
                  path: Optional[str] = None):
         """
         :param str content: The content of the configuration file. Maximum size: 32 KB.
+        :param int mode: The permissions on the ConfigFileVolume directory.
         :param 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)
 
@@ -1484,6 +1694,14 @@ class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPath(dict):
         """
         return pulumi.get(self, "content")
 
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[int]:
+        """
+        The permissions on the ConfigFileVolume directory.
+        """
+        return pulumi.get(self, "mode")
+
     @property
     @pulumi.getter
     def path(self) -> Optional[str]:
@@ -1493,6 +1711,56 @@ class EciScalingConfigurationVolumeConfigFileVolumeConfigFileToPath(dict):
         return pulumi.get(self, "path")
 
 
+@pulumi.output_type
+class ScalingConfigurationCustomPriority(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "instanceType":
+            suggest = "instance_type"
+        elif key == "vswitchId":
+            suggest = "vswitch_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScalingConfigurationCustomPriority. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScalingConfigurationCustomPriority.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScalingConfigurationCustomPriority.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 instance_type: Optional[str] = None,
+                 vswitch_id: Optional[str] = None):
+        """
+        :param 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 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[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")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[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")
+
+
 @pulumi.output_type
 class ScalingConfigurationDataDisk(dict):
     @staticmethod
@@ -1506,6 +1774,8 @@ class ScalingConfigurationDataDisk(dict):
             suggest = "kms_key_id"
         elif key == "performanceLevel":
             suggest = "performance_level"
+        elif key == "provisionedIops":
+            suggest = "provisioned_iops"
         elif key == "snapshotId":
             suggest = "snapshot_id"
 
@@ -1530,11 +1800,12 @@ class ScalingConfigurationDataDisk(dict):
                  kms_key_id: Optional[str] = None,
                  name: Optional[str] = None,
                  performance_level: Optional[str] = None,
+                 provisioned_iops: Optional[int] = None,
                  size: Optional[int] = None,
                  snapshot_id: Optional[str] = None):
         """
         :param str auto_snapshot_policy_id: The id of auto snapshot policy for data disk.
-        :param str category: Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` and `cloud`.
+        :param str category: Category of data disk. The parameter value options are `ephemeral_ssd`, `cloud_efficiency`, `cloud_ssd` , `cloud_essd` and `cloud`.
         :param 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 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 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.
@@ -1542,6 +1813,7 @@ class ScalingConfigurationDataDisk(dict):
         :param str kms_key_id: The CMK ID for data disk N. Valid values of N: 1 to 16.
         :param 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 str performance_level: The performance level of the ESSD used as data disk.
+        :param int provisioned_iops: IOPS measures the number of read and write operations that an Elastic Block Storage (EBS) device can process per second.
         :param 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 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.
         """
@@ -1563,6 +1835,8 @@ class ScalingConfigurationDataDisk(dict):
             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:
@@ -1580,7 +1854,7 @@ class ScalingConfigurationDataDisk(dict):
     @pulumi.getter
     def category(self) -> Optional[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")
 
@@ -1602,13 +1876,11 @@ class ScalingConfigurationDataDisk(dict):
 
     @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[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")
 
     @property
@@ -1643,6 +1915,14 @@ class ScalingConfigurationDataDisk(dict):
         """
         return pulumi.get(self, "performance_level")
 
+    @property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[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")
+
     @property
     @pulumi.getter
     def size(self) -> Optional[int]:
@@ -1824,6 +2104,84 @@ class ScalingConfigurationInstanceTypeOverride(dict):
         return pulumi.get(self, "weighted_capacity")
 
 
+@pulumi.output_type
+class ScalingConfigurationNetworkInterface(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "instanceType":
+            suggest = "instance_type"
+        elif key == "ipv6AddressCount":
+            suggest = "ipv6_address_count"
+        elif key == "networkInterfaceTrafficMode":
+            suggest = "network_interface_traffic_mode"
+        elif key == "securityGroupIds":
+            suggest = "security_group_ids"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScalingConfigurationNetworkInterface. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScalingConfigurationNetworkInterface.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScalingConfigurationNetworkInterface.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 instance_type: Optional[str] = None,
+                 ipv6_address_count: Optional[int] = None,
+                 network_interface_traffic_mode: Optional[str] = None,
+                 security_group_ids: Optional[Sequence[str]] = None):
+        """
+        :param 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 int ipv6_address_count: The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
+        :param str network_interface_traffic_mode: The communication mode of the ENI. Valid values: Standard, HighPerformance.
+        :param Sequence[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[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")
+
+    @property
+    @pulumi.getter(name="ipv6AddressCount")
+    def ipv6_address_count(self) -> Optional[int]:
+        """
+        The number of randomly generated IPv6 addresses that you want to assign to primary ENI N.
+        """
+        return pulumi.get(self, "ipv6_address_count")
+
+    @property
+    @pulumi.getter(name="networkInterfaceTrafficMode")
+    def network_interface_traffic_mode(self) -> Optional[str]:
+        """
+        The communication mode of the ENI. Valid values: Standard, HighPerformance.
+        """
+        return pulumi.get(self, "network_interface_traffic_mode")
+
+    @property
+    @pulumi.getter(name="securityGroupIds")
+    def security_group_ids(self) -> Optional[Sequence[str]]:
+        """
+        The ID of security group N to which ENI N belongs.
+        """
+        return pulumi.get(self, "security_group_ids")
+
+
 @pulumi.output_type
 class ScalingConfigurationSpotPriceLimit(dict):
     @staticmethod
@@ -1874,6 +2232,66 @@ class ScalingConfigurationSpotPriceLimit(dict):
         return pulumi.get(self, "price_limit")
 
 
+@pulumi.output_type
+class ScalingGroupAlbServerGroup(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "albServerGroupId":
+            suggest = "alb_server_group_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ScalingGroupAlbServerGroup. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ScalingGroupAlbServerGroup.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ScalingGroupAlbServerGroup.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 alb_server_group_id: Optional[str] = None,
+                 port: Optional[int] = None,
+                 weight: Optional[int] = None):
+        """
+        :param str alb_server_group_id: The ID of ALB server group.
+        :param int port: The port number used by an ECS instance after Auto Scaling adds the ECS instance to ALB server group.
+        :param 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[str]:
+        """
+        The ID of ALB server group.
+        """
+        return pulumi.get(self, "alb_server_group_id")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[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")
+
+    @property
+    @pulumi.getter
+    def weight(self) -> Optional[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")
+
+
 @pulumi.output_type
 class ScalingGroupLaunchTemplateOverride(dict):
     @staticmethod
@@ -2178,7 +2596,7 @@ class GetAlarmsAlarmResult(dict):
                  cloud_monitor_group_id: int,
                  comparison_operator: str,
                  description: str,
-                 dimensions: Mapping[str, Any],
+                 dimensions: Mapping[str, str],
                  enable: bool,
                  evaluation_count: int,
                  id: str,
@@ -2195,7 +2613,7 @@ class GetAlarmsAlarmResult(dict):
         :param int cloud_monitor_group_id: Defines the application group id defined by CMS which is assigned when you upload custom metric to CMS, only available for custom metirc.
         :param 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.
         :param str description: The description for the alarm.
-        :param Mapping[str, Any] dimensions: The dimension map for the alarm's associated metric.
+        :param Mapping[str, str] dimensions: The dimension map for the alarm's associated metric.
         :param bool enable: Whether to enable specific ess alarm.
         :param int evaluation_count: The number of times that needs to satisfies comparison condition before transition into ALARM state.
         :param str id: The id of alarm.
@@ -2259,7 +2677,7 @@ class GetAlarmsAlarmResult(dict):
 
     @property
     @pulumi.getter
-    def dimensions(self) -> Mapping[str, Any]:
+    def dimensions(self) -> Mapping[str, str]:
         """
         The dimension map for the alarm's associated metric.
         """
@@ -2510,6 +2928,7 @@ class GetScalingConfigurationsConfigurationResult(dict):
                  id: str,
                  image_id: str,
                  instance_name: str,
+                 instance_pattern_infos: Sequence['outputs.GetScalingConfigurationsConfigurationInstancePatternInfoResult'],
                  instance_type: str,
                  internet_charge_type: str,
                  internet_max_bandwidth_in: int,
@@ -2527,10 +2946,11 @@ class GetScalingConfigurationsConfigurationResult(dict):
         :param str creation_time: Creation time of the scaling configuration.
         :param str credit_specification: Performance mode of the t5 burstable instance.
         :param Sequence['GetScalingConfigurationsConfigurationDataDiskArgs'] data_disks: Data disks of the scaling configuration.
-        :param str host_name: (Optional,Available in 1.143.0+) Hostname of an ECS instance.
+        :param str host_name: (Optional,Available since v1.143.0) Hostname of an ECS instance.
         :param str id: ID of the scaling rule.
         :param str image_id: Image ID of the scaling configuration.
-        :param str instance_name: (Optional,Available in 1.143.0+) InstanceName of an ECS instance.
+        :param str instance_name: (Optional,Available since v1.143.0) InstanceName of an ECS instance.
+        :param Sequence['GetScalingConfigurationsConfigurationInstancePatternInfoArgs'] instance_pattern_infos: (Optional, Available since v1.240.0) intelligent configuration mode. In this mode, you only need to specify the number of vCPUs, memory size, instance family, and maximum price. The system selects an instance type that is provided at the lowest price based on your configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode helps reduce the failures of scale-out activities caused by insufficient inventory of instance types.
         :param str instance_type: Resource type of an ECS instance.
         :param str internet_charge_type: Internet charge type of the scaling configuration.
         :param int internet_max_bandwidth_in: Internet max bandwidth in of the scaling configuration.
@@ -2539,8 +2959,8 @@ class GetScalingConfigurationsConfigurationResult(dict):
         :param str name: Name of the scaling configuration.
         :param str scaling_group_id: Scaling group id the scaling configurations belong to.
         :param str security_group_id: Security group ID of the scaling configuration.
-        :param Sequence['GetScalingConfigurationsConfigurationSpotPriceLimitArgs'] spot_price_limits: (Optional, Available in 1.151.0+) The maximum price hourly for instance types.
-        :param str spot_strategy: (Optional, Available in 1.151.0+) The spot strategy for a Pay-As-You-Go instance.
+        :param Sequence['GetScalingConfigurationsConfigurationSpotPriceLimitArgs'] spot_price_limits: (Optional, Available since v1.151.0) The maximum price hourly for instance types.
+        :param str spot_strategy: (Optional, Available since v1.151.0) The spot strategy for a Pay-As-You-Go instance.
         :param str system_disk_category: System disk category of the scaling configuration.
         :param str system_disk_performance_level: The performance level of the ESSD used as the system disk.
         :param int system_disk_size: System disk size of the scaling configuration.
@@ -2552,6 +2972,7 @@ class GetScalingConfigurationsConfigurationResult(dict):
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "image_id", image_id)
         pulumi.set(__self__, "instance_name", instance_name)
+        pulumi.set(__self__, "instance_pattern_infos", instance_pattern_infos)
         pulumi.set(__self__, "instance_type", instance_type)
         pulumi.set(__self__, "internet_charge_type", internet_charge_type)
         pulumi.set(__self__, "internet_max_bandwidth_in", internet_max_bandwidth_in)
@@ -2594,7 +3015,7 @@ class GetScalingConfigurationsConfigurationResult(dict):
     @pulumi.getter(name="hostName")
     def host_name(self) -> str:
         """
-        (Optional,Available in 1.143.0+) Hostname of an ECS instance.
+        (Optional,Available since v1.143.0) Hostname of an ECS instance.
         """
         return pulumi.get(self, "host_name")
 
@@ -2618,10 +3039,18 @@ class GetScalingConfigurationsConfigurationResult(dict):
     @pulumi.getter(name="instanceName")
     def instance_name(self) -> str:
         """
-        (Optional,Available in 1.143.0+) InstanceName of an ECS instance.
+        (Optional,Available since v1.143.0) InstanceName of an ECS instance.
         """
         return pulumi.get(self, "instance_name")
 
+    @property
+    @pulumi.getter(name="instancePatternInfos")
+    def instance_pattern_infos(self) -> Sequence['outputs.GetScalingConfigurationsConfigurationInstancePatternInfoResult']:
+        """
+        (Optional, Available since v1.240.0) intelligent configuration mode. In this mode, you only need to specify the number of vCPUs, memory size, instance family, and maximum price. The system selects an instance type that is provided at the lowest price based on your configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode helps reduce the failures of scale-out activities caused by insufficient inventory of instance types.
+        """
+        return pulumi.get(self, "instance_pattern_infos")
+
     @property
     @pulumi.getter(name="instanceType")
     def instance_type(self) -> str:
@@ -2690,7 +3119,7 @@ class GetScalingConfigurationsConfigurationResult(dict):
     @pulumi.getter(name="spotPriceLimits")
     def spot_price_limits(self) -> Sequence['outputs.GetScalingConfigurationsConfigurationSpotPriceLimitResult']:
         """
-        (Optional, Available in 1.151.0+) The maximum price hourly for instance types.
+        (Optional, Available since v1.151.0) The maximum price hourly for instance types.
         """
         return pulumi.get(self, "spot_price_limits")
 
@@ -2698,7 +3127,7 @@ class GetScalingConfigurationsConfigurationResult(dict):
     @pulumi.getter(name="spotStrategy")
     def spot_strategy(self) -> str:
         """
-        (Optional, Available in 1.151.0+) The spot strategy for a Pay-As-You-Go instance.
+        (Optional, Available since v1.151.0) The spot strategy for a Pay-As-You-Go instance.
         """
         return pulumi.get(self, "spot_strategy")
 
@@ -2800,6 +3229,90 @@ class GetScalingConfigurationsConfigurationDataDiskResult(dict):
         return pulumi.get(self, "snapshot_id")
 
 
+@pulumi.output_type
+class GetScalingConfigurationsConfigurationInstancePatternInfoResult(dict):
+    def __init__(__self__, *,
+                 architectures: Sequence[str],
+                 burstable_performance: str,
+                 cores: int,
+                 excluded_instance_types: Sequence[str],
+                 instance_family_level: str,
+                 max_price: float,
+                 memory: float):
+        """
+        :param Sequence[str] architectures: Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
+        :param str burstable_performance: Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
+        :param int cores: The number of vCPUs that are specified for an instance type in instancePatternInfo.
+        :param Sequence[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 str instance_family_level: The instance family level in instancePatternInfo.
+        :param float max_price: The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
+        :param float memory: The memory size that is specified for an instance type in instancePatternInfo.
+        """
+        pulumi.set(__self__, "architectures", architectures)
+        pulumi.set(__self__, "burstable_performance", burstable_performance)
+        pulumi.set(__self__, "cores", cores)
+        pulumi.set(__self__, "excluded_instance_types", excluded_instance_types)
+        pulumi.set(__self__, "instance_family_level", instance_family_level)
+        pulumi.set(__self__, "max_price", max_price)
+        pulumi.set(__self__, "memory", memory)
+
+    @property
+    @pulumi.getter
+    def architectures(self) -> Sequence[str]:
+        """
+        Architecture N of instance type N. Valid values: X86, Heterogeneous, BareMetal, Arm, SuperComputeCluster.
+        """
+        return pulumi.get(self, "architectures")
+
+    @property
+    @pulumi.getter(name="burstablePerformance")
+    def burstable_performance(self) -> str:
+        """
+        Specifies whether to include burstable instance types.  Valid values: Exclude, Include, Required.
+        """
+        return pulumi.get(self, "burstable_performance")
+
+    @property
+    @pulumi.getter
+    def cores(self) -> int:
+        """
+        The number of vCPUs that are specified for an instance type in instancePatternInfo.
+        """
+        return pulumi.get(self, "cores")
+
+    @property
+    @pulumi.getter(name="excludedInstanceTypes")
+    def excluded_instance_types(self) -> Sequence[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")
+
+    @property
+    @pulumi.getter(name="instanceFamilyLevel")
+    def instance_family_level(self) -> str:
+        """
+        The instance family level in instancePatternInfo.
+        """
+        return pulumi.get(self, "instance_family_level")
+
+    @property
+    @pulumi.getter(name="maxPrice")
+    def max_price(self) -> float:
+        """
+        The maximum hourly price for a pay-as-you-go instance or a preemptible instance in instancePatternInfo.
+        """
+        return pulumi.get(self, "max_price")
+
+    @property
+    @pulumi.getter
+    def memory(self) -> float:
+        """
+        The memory size that is specified for an instance type in instancePatternInfo.
+        """
+        return pulumi.get(self, "memory")
+
+
 @pulumi.output_type
 class GetScalingConfigurationsConfigurationSpotPriceLimitResult(dict):
     def __init__(__self__, *,
@@ -2858,7 +3371,7 @@ class GetScalingGroupsGroupResult(dict):
                  vpc_id: str,
                  vswitch_id: str,
                  vswitch_ids: Sequence[str],
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param int active_capacity: Number of active instances in scaling group.
         :param str active_scaling_configuration: Active scaling configuration for scaling group.
@@ -2886,7 +3399,7 @@ class GetScalingGroupsGroupResult(dict):
         :param str vpc_id: The ID of the VPC to which the scaling group belongs.
         :param str vswitch_id: The ID of the vSwitch to which the scaling group belongs.
         :param Sequence[str] vswitch_ids: Vswitches id in which the ECS instance launched.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "active_capacity", active_capacity)
         pulumi.set(__self__, "active_scaling_configuration", active_scaling_configuration)
@@ -3127,7 +3640,7 @@ class GetScalingGroupsGroupResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         A mapping of tags to assign to the resource.
         """