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

pulumi_alicloud/emrv2/outputs.py

@@ -4,9 +4,14 @@
 
 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
 
@@ -16,6 +21,22 @@ __all__ = [
     'ClusterBootstrapScriptNodeSelector',
     'ClusterNodeAttribute',
     'ClusterNodeGroup',
+    'ClusterNodeGroupAckConfig',
+    'ClusterNodeGroupAckConfigCustomAnnotation',
+    'ClusterNodeGroupAckConfigCustomLabel',
+    'ClusterNodeGroupAckConfigNodeSelector',
+    'ClusterNodeGroupAckConfigPvc',
+    'ClusterNodeGroupAckConfigToleration',
+    'ClusterNodeGroupAckConfigVolume',
+    'ClusterNodeGroupAckConfigVolumeMount',
+    'ClusterNodeGroupAutoScalingPolicy',
+    'ClusterNodeGroupAutoScalingPolicyConstraints',
+    'ClusterNodeGroupAutoScalingPolicyScalingRule',
+    'ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger',
+    'ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition',
+    'ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionTag',
+    'ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint',
+    'ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger',
     'ClusterNodeGroupCostOptimizedConfig',
     'ClusterNodeGroupDataDisk',
     'ClusterNodeGroupSpotBidPrice',
@@ -194,7 +215,7 @@ class ClusterBootstrapScript(dict):
                  script_path: str,
                  priority: Optional[int] = None):
         """
-        :param str execution_fail_strategy: The bootstrap scripts execution fail strategy, ’FAILED_BLOCKED’ or ‘FAILED_CONTINUE’ .
+        :param str execution_fail_strategy: The bootstrap scripts execution fail strategy, ’FAILED_BLOCK’ or ‘FAILED_CONTINUE’ .
         :param str execution_moment: The bootstrap scripts execution moment, ’BEFORE_INSTALL’ or ‘AFTER_STARTED’ .
         :param 'ClusterBootstrapScriptNodeSelectorArgs' node_selector: The bootstrap scripts execution target. See `node_selector` below.
         :param str script_args: The bootstrap script args, e.g. "--a=b".
@@ -215,7 +236,7 @@ class ClusterBootstrapScript(dict):
     @pulumi.getter(name="executionFailStrategy")
     def execution_fail_strategy(self) -> str:
         """
-        The bootstrap scripts execution fail strategy, ’FAILED_BLOCKED’ or ‘FAILED_CONTINUE’ .
+        The bootstrap scripts execution fail strategy, ’FAILED_BLOCK’ or ‘FAILED_CONTINUE’ .
         """
         return pulumi.get(self, "execution_fail_strategy")
 
@@ -261,6 +282,7 @@ class ClusterBootstrapScript(dict):
 
     @property
     @pulumi.getter
+    @_utilities.deprecated("""Field 'priority' has been deprecated from provider version 1.227.0.""")
     def priority(self) -> Optional[int]:
         """
         The bootstrap scripts priority.
@@ -277,8 +299,12 @@ class ClusterBootstrapScriptNodeSelector(dict):
             suggest = "node_select_type"
         elif key == "nodeGroupId":
             suggest = "node_group_id"
+        elif key == "nodeGroupIds":
+            suggest = "node_group_ids"
         elif key == "nodeGroupName":
             suggest = "node_group_name"
+        elif key == "nodeGroupNames":
+            suggest = "node_group_names"
         elif key == "nodeGroupTypes":
             suggest = "node_group_types"
         elif key == "nodeNames":
@@ -298,21 +324,27 @@ class ClusterBootstrapScriptNodeSelector(dict):
     def __init__(__self__, *,
                  node_select_type: str,
                  node_group_id: Optional[str] = None,
+                 node_group_ids: Optional[Sequence[str]] = None,
                  node_group_name: Optional[str] = None,
+                 node_group_names: Optional[Sequence[str]] = None,
                  node_group_types: Optional[Sequence[str]] = None,
                  node_names: Optional[Sequence[str]] = None):
         """
         :param str node_select_type: The bootstrap scripts execution target node select type. Supported value: NODE, NODEGROUP or CLUSTER.
-        :param str node_group_id: The configuration effected which node group id of emr cluster.
-        :param str node_group_name: The configuration effected which node group name of emr cluster.
+        :param Sequence[str] node_group_ids: The bootstrap scripts execution target node group ids.
+        :param Sequence[str] node_group_names: The bootstrap scripts execution target node group names.
         :param Sequence[str] node_group_types: The bootstrap scripts execution target node group types.
         :param Sequence[str] node_names: The bootstrap scripts execution target node names.
         """
         pulumi.set(__self__, "node_select_type", node_select_type)
         if node_group_id is not None:
             pulumi.set(__self__, "node_group_id", node_group_id)
+        if node_group_ids is not None:
+            pulumi.set(__self__, "node_group_ids", node_group_ids)
         if node_group_name is not None:
             pulumi.set(__self__, "node_group_name", node_group_name)
+        if node_group_names is not None:
+            pulumi.set(__self__, "node_group_names", node_group_names)
         if node_group_types is not None:
             pulumi.set(__self__, "node_group_types", node_group_types)
         if node_names is not None:
@@ -328,19 +360,31 @@ class ClusterBootstrapScriptNodeSelector(dict):
 
     @property
     @pulumi.getter(name="nodeGroupId")
+    @_utilities.deprecated("""Field 'node_group_id' has been deprecated from provider version 1.227.0. New field 'node_group_ids' replaces it.""")
     def node_group_id(self) -> Optional[str]:
+        return pulumi.get(self, "node_group_id")
+
+    @property
+    @pulumi.getter(name="nodeGroupIds")
+    def node_group_ids(self) -> Optional[Sequence[str]]:
         """
-        The configuration effected which node group id of emr cluster.
+        The bootstrap scripts execution target node group ids.
         """
-        return pulumi.get(self, "node_group_id")
+        return pulumi.get(self, "node_group_ids")
 
     @property
     @pulumi.getter(name="nodeGroupName")
+    @_utilities.deprecated("""Field 'node_group_name' has been deprecated from provider version 1.227.0. New field 'node_group_names' replaces it.""")
     def node_group_name(self) -> Optional[str]:
+        return pulumi.get(self, "node_group_name")
+
+    @property
+    @pulumi.getter(name="nodeGroupNames")
+    def node_group_names(self) -> Optional[Sequence[str]]:
         """
-        The configuration effected which node group name of emr cluster.
+        The bootstrap scripts execution target node group names.
         """
-        return pulumi.get(self, "node_group_name")
+        return pulumi.get(self, "node_group_names")
 
     @property
     @pulumi.getter(name="nodeGroupTypes")
@@ -491,8 +535,12 @@ class ClusterNodeGroup(dict):
             suggest = "node_group_type"
         elif key == "systemDisk":
             suggest = "system_disk"
+        elif key == "ackConfig":
+            suggest = "ack_config"
         elif key == "additionalSecurityGroupIds":
             suggest = "additional_security_group_ids"
+        elif key == "autoScalingPolicy":
+            suggest = "auto_scaling_policy"
         elif key == "costOptimizedConfig":
             suggest = "cost_optimized_config"
         elif key == "deploymentSetStrategy":
@@ -507,6 +555,8 @@ class ClusterNodeGroup(dict):
             suggest = "spot_bid_prices"
         elif key == "spotInstanceRemedy":
             suggest = "spot_instance_remedy"
+        elif key == "spotStrategy":
+            suggest = "spot_strategy"
         elif key == "subscriptionConfig":
             suggest = "subscription_config"
         elif key == "vswitchIds":
@@ -532,7 +582,9 @@ class ClusterNodeGroup(dict):
                  node_group_name: str,
                  node_group_type: str,
                  system_disk: 'outputs.ClusterNodeGroupSystemDisk',
+                 ack_config: Optional['outputs.ClusterNodeGroupAckConfig'] = None,
                  additional_security_group_ids: Optional[Sequence[str]] = None,
+                 auto_scaling_policy: Optional['outputs.ClusterNodeGroupAutoScalingPolicy'] = None,
                  cost_optimized_config: Optional['outputs.ClusterNodeGroupCostOptimizedConfig'] = None,
                  deployment_set_strategy: Optional[str] = None,
                  graceful_shutdown: Optional[bool] = None,
@@ -540,27 +592,31 @@ class ClusterNodeGroup(dict):
                  payment_type: Optional[str] = None,
                  spot_bid_prices: Optional[Sequence['outputs.ClusterNodeGroupSpotBidPrice']] = None,
                  spot_instance_remedy: Optional[bool] = None,
+                 spot_strategy: Optional[str] = None,
                  subscription_config: Optional['outputs.ClusterNodeGroupSubscriptionConfig'] = None,
                  vswitch_ids: Optional[Sequence[str]] = None,
                  with_public_ip: Optional[bool] = None):
         """
         :param Sequence['ClusterNodeGroupDataDiskArgs'] data_disks: Host Ecs data disks information in this node group. See `data_disks` below.
-        :param Sequence[str] instance_types: Host Ecs instance types.
+        :param Sequence[str] instance_types: Host Ecs instance types. **NOTE:** From version 1.236.0, `instance_types` can be modified.
         :param int node_count: Host Ecs number in this node group.
         :param str node_group_name: The node group name of emr cluster.
         :param str node_group_type: The node group type of emr cluster, supported value: MASTER, CORE or TASK. Node group type of GATEWAY is available since v1.219.0.
         :param 'ClusterNodeGroupSystemDiskArgs' system_disk: Host Ecs system disk information in this node group. See `system_disk` below.
-        :param Sequence[str] additional_security_group_ids: Additional security Group IDS for Cluster, you can also specify this key for each node group.
-        :param 'ClusterNodeGroupCostOptimizedConfigArgs' cost_optimized_config: The detail cost optimized configuration of emr cluster. See `cost_optimized_config` below.
-        :param str deployment_set_strategy: Deployment set strategy for this cluster node group. Supported value: NONE, CLUSTER or NODE_GROUP.
+        :param 'ClusterNodeGroupAckConfigArgs' ack_config: The node group of ack configuration for emr cluster to deploying on kubernetes. See `ack_config` below.
+        :param Sequence[str] additional_security_group_ids: Additional security Group IDS for Cluster, you can also specify this key for each node group. **NOTE:** From version 1.236.0, `additional_security_group_ids` can be modified.
+        :param 'ClusterNodeGroupAutoScalingPolicyArgs' auto_scaling_policy: The node group auto scaling policy for emr cluster. See `auto_scaling_policy` below.
+        :param 'ClusterNodeGroupCostOptimizedConfigArgs' cost_optimized_config: The detail cost optimized configuration of emr cluster. See `cost_optimized_config` below. **NOTE:** From version 1.236.0, `cost_optimized_config` can be modified.
+        :param str deployment_set_strategy: Deployment set strategy for this cluster node group. Supported value: NONE, CLUSTER or NODE_GROUP. **NOTE:** From version 1.236.0, `deployment_set_strategy` can be modified.
         :param bool graceful_shutdown: Enable emr cluster of task node graceful decommission, ’true’ or ‘false’ .
         :param str node_resize_strategy: Node resize strategy for this cluster node group. Supported value: PRIORITY, COST_OPTIMIZED.
         :param str payment_type: Payment Type for this cluster. Supported value: PayAsYouGo or Subscription.
         :param Sequence['ClusterNodeGroupSpotBidPriceArgs'] spot_bid_prices: The spot bid prices of a PayAsYouGo instance. See `spot_bid_prices` below.
         :param bool spot_instance_remedy: Whether to replace spot instances with newly created spot/onDemand instance when receive a spot recycling message.
+        :param str spot_strategy: The spot strategy configuration of emr cluster. Valid values: `NoSpot`, `SpotWithPriceLimit`, `SpotAsPriceGo`.
         :param 'ClusterNodeGroupSubscriptionConfigArgs' subscription_config: The detail configuration of subscription payment type. See `subscription_config` below.
-        :param Sequence[str] vswitch_ids: Global vSwitch ids, you can also specify it in node group.
-        :param bool with_public_ip: Whether the node has a public IP address enabled.
+        :param Sequence[str] vswitch_ids: Global vSwitch ids, you can also specify it in node group. **NOTE:** From version 1.236.0, `vswitch_ids` can be modified.
+        :param bool with_public_ip: Whether the node has a public IP address enabled. **NOTE:** From version 1.236.0, `with_public_ip` can be modified.
         """
         pulumi.set(__self__, "data_disks", data_disks)
         pulumi.set(__self__, "instance_types", instance_types)
@@ -568,8 +624,12 @@ class ClusterNodeGroup(dict):
         pulumi.set(__self__, "node_group_name", node_group_name)
         pulumi.set(__self__, "node_group_type", node_group_type)
         pulumi.set(__self__, "system_disk", system_disk)
+        if ack_config is not None:
+            pulumi.set(__self__, "ack_config", ack_config)
         if additional_security_group_ids is not None:
             pulumi.set(__self__, "additional_security_group_ids", additional_security_group_ids)
+        if auto_scaling_policy is not None:
+            pulumi.set(__self__, "auto_scaling_policy", auto_scaling_policy)
         if cost_optimized_config is not None:
             pulumi.set(__self__, "cost_optimized_config", cost_optimized_config)
         if deployment_set_strategy is not None:
@@ -584,6 +644,8 @@ class ClusterNodeGroup(dict):
             pulumi.set(__self__, "spot_bid_prices", spot_bid_prices)
         if spot_instance_remedy is not None:
             pulumi.set(__self__, "spot_instance_remedy", spot_instance_remedy)
+        if spot_strategy is not None:
+            pulumi.set(__self__, "spot_strategy", spot_strategy)
         if subscription_config is not None:
             pulumi.set(__self__, "subscription_config", subscription_config)
         if vswitch_ids is not None:
@@ -603,7 +665,7 @@ class ClusterNodeGroup(dict):
     @pulumi.getter(name="instanceTypes")
     def instance_types(self) -> Sequence[str]:
         """
-        Host Ecs instance types.
+        Host Ecs instance types. **NOTE:** From version 1.236.0, `instance_types` can be modified.
         """
         return pulumi.get(self, "instance_types")
 
@@ -639,19 +701,35 @@ class ClusterNodeGroup(dict):
         """
         return pulumi.get(self, "system_disk")
 
+    @property
+    @pulumi.getter(name="ackConfig")
+    def ack_config(self) -> Optional['outputs.ClusterNodeGroupAckConfig']:
+        """
+        The node group of ack configuration for emr cluster to deploying on kubernetes. See `ack_config` below.
+        """
+        return pulumi.get(self, "ack_config")
+
     @property
     @pulumi.getter(name="additionalSecurityGroupIds")
     def additional_security_group_ids(self) -> Optional[Sequence[str]]:
         """
-        Additional security Group IDS for Cluster, you can also specify this key for each node group.
+        Additional security Group IDS for Cluster, you can also specify this key for each node group. **NOTE:** From version 1.236.0, `additional_security_group_ids` can be modified.
         """
         return pulumi.get(self, "additional_security_group_ids")
 
+    @property
+    @pulumi.getter(name="autoScalingPolicy")
+    def auto_scaling_policy(self) -> Optional['outputs.ClusterNodeGroupAutoScalingPolicy']:
+        """
+        The node group auto scaling policy for emr cluster. See `auto_scaling_policy` below.
+        """
+        return pulumi.get(self, "auto_scaling_policy")
+
     @property
     @pulumi.getter(name="costOptimizedConfig")
     def cost_optimized_config(self) -> Optional['outputs.ClusterNodeGroupCostOptimizedConfig']:
         """
-        The detail cost optimized configuration of emr cluster. See `cost_optimized_config` below.
+        The detail cost optimized configuration of emr cluster. See `cost_optimized_config` below. **NOTE:** From version 1.236.0, `cost_optimized_config` can be modified.
         """
         return pulumi.get(self, "cost_optimized_config")
 
@@ -659,7 +737,7 @@ class ClusterNodeGroup(dict):
     @pulumi.getter(name="deploymentSetStrategy")
     def deployment_set_strategy(self) -> Optional[str]:
         """
-        Deployment set strategy for this cluster node group. Supported value: NONE, CLUSTER or NODE_GROUP.
+        Deployment set strategy for this cluster node group. Supported value: NONE, CLUSTER or NODE_GROUP. **NOTE:** From version 1.236.0, `deployment_set_strategy` can be modified.
         """
         return pulumi.get(self, "deployment_set_strategy")
 
@@ -703,6 +781,14 @@ class ClusterNodeGroup(dict):
         """
         return pulumi.get(self, "spot_instance_remedy")
 
+    @property
+    @pulumi.getter(name="spotStrategy")
+    def spot_strategy(self) -> Optional[str]:
+        """
+        The spot strategy configuration of emr cluster. Valid values: `NoSpot`, `SpotWithPriceLimit`, `SpotAsPriceGo`.
+        """
+        return pulumi.get(self, "spot_strategy")
+
     @property
     @pulumi.getter(name="subscriptionConfig")
     def subscription_config(self) -> Optional['outputs.ClusterNodeGroupSubscriptionConfig']:
@@ -715,7 +801,7 @@ class ClusterNodeGroup(dict):
     @pulumi.getter(name="vswitchIds")
     def vswitch_ids(self) -> Optional[Sequence[str]]:
         """
-        Global vSwitch ids, you can also specify it in node group.
+        Global vSwitch ids, you can also specify it in node group. **NOTE:** From version 1.236.0, `vswitch_ids` can be modified.
         """
         return pulumi.get(self, "vswitch_ids")
 
@@ -723,11 +809,1138 @@ class ClusterNodeGroup(dict):
     @pulumi.getter(name="withPublicIp")
     def with_public_ip(self) -> Optional[bool]:
         """
-        Whether the node has a public IP address enabled.
+        Whether the node has a public IP address enabled. **NOTE:** From version 1.236.0, `with_public_ip` can be modified.
         """
         return pulumi.get(self, "with_public_ip")
 
 
+@pulumi.output_type
+class ClusterNodeGroupAckConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ackInstanceId":
+            suggest = "ack_instance_id"
+        elif key == "limitCpu":
+            suggest = "limit_cpu"
+        elif key == "limitMemory":
+            suggest = "limit_memory"
+        elif key == "requestCpu":
+            suggest = "request_cpu"
+        elif key == "requestMemory":
+            suggest = "request_memory"
+        elif key == "customAnnotations":
+            suggest = "custom_annotations"
+        elif key == "customLabels":
+            suggest = "custom_labels"
+        elif key == "nodeAffinity":
+            suggest = "node_affinity"
+        elif key == "nodeSelectors":
+            suggest = "node_selectors"
+        elif key == "podAffinity":
+            suggest = "pod_affinity"
+        elif key == "podAntiAffinity":
+            suggest = "pod_anti_affinity"
+        elif key == "preStartCommands":
+            suggest = "pre_start_commands"
+        elif key == "volumeMounts":
+            suggest = "volume_mounts"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAckConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAckConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAckConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ack_instance_id: str,
+                 limit_cpu: float,
+                 limit_memory: float,
+                 namespace: str,
+                 request_cpu: float,
+                 request_memory: float,
+                 custom_annotations: Optional[Sequence['outputs.ClusterNodeGroupAckConfigCustomAnnotation']] = None,
+                 custom_labels: Optional[Sequence['outputs.ClusterNodeGroupAckConfigCustomLabel']] = None,
+                 node_affinity: Optional[str] = None,
+                 node_selectors: Optional[Sequence['outputs.ClusterNodeGroupAckConfigNodeSelector']] = None,
+                 pod_affinity: Optional[str] = None,
+                 pod_anti_affinity: Optional[str] = None,
+                 pre_start_commands: Optional[Sequence[str]] = None,
+                 pvcs: Optional[Sequence['outputs.ClusterNodeGroupAckConfigPvc']] = None,
+                 tolerations: Optional[Sequence['outputs.ClusterNodeGroupAckConfigToleration']] = None,
+                 volume_mounts: Optional[Sequence['outputs.ClusterNodeGroupAckConfigVolumeMount']] = None,
+                 volumes: Optional[Sequence['outputs.ClusterNodeGroupAckConfigVolume']] = None):
+        """
+        :param str ack_instance_id: The ack cluster instance id.
+        :param float limit_cpu: The job pod resource of limit cpu.
+        :param float limit_memory: The job pod resource of limit memory.
+        :param str namespace: The ack cluster namespace.
+        :param float request_cpu: The job pod resource of request cpu.
+        :param float request_memory: The job pod resource of request memory.
+        :param Sequence['ClusterNodeGroupAckConfigCustomAnnotationArgs'] custom_annotations: The ack cluster custom annotations. See `custom_annotations` below.
+        :param Sequence['ClusterNodeGroupAckConfigCustomLabelArgs'] custom_labels: The ack cluster custom labels. See `custom_labels` below.
+        :param str node_affinity: The ack cluster node affinity.
+        :param Sequence['ClusterNodeGroupAckConfigNodeSelectorArgs'] node_selectors: The ack cluster node selectors for job pods scheduling. See `node_selectors` below.
+        :param str pod_affinity: The job pod affinity.
+        :param str pod_anti_affinity: The job pod anti-affinity.
+        :param Sequence[str] pre_start_commands: The job pod pre start command.
+        :param Sequence['ClusterNodeGroupAckConfigPvcArgs'] pvcs: The ack cluster persistent volume claim. See `pvcs` below.
+        :param Sequence['ClusterNodeGroupAckConfigTolerationArgs'] tolerations: The ack cluster tolerations. See `tolerations` below.
+        :param Sequence['ClusterNodeGroupAckConfigVolumeMountArgs'] volume_mounts: The ack cluster volume mounts. See `volume_mounts` below.
+        :param Sequence['ClusterNodeGroupAckConfigVolumeArgs'] volumes: The ack cluster volumes. See `volumes` below.
+        """
+        pulumi.set(__self__, "ack_instance_id", ack_instance_id)
+        pulumi.set(__self__, "limit_cpu", limit_cpu)
+        pulumi.set(__self__, "limit_memory", limit_memory)
+        pulumi.set(__self__, "namespace", namespace)
+        pulumi.set(__self__, "request_cpu", request_cpu)
+        pulumi.set(__self__, "request_memory", request_memory)
+        if custom_annotations is not None:
+            pulumi.set(__self__, "custom_annotations", custom_annotations)
+        if custom_labels is not None:
+            pulumi.set(__self__, "custom_labels", custom_labels)
+        if node_affinity is not None:
+            pulumi.set(__self__, "node_affinity", node_affinity)
+        if node_selectors is not None:
+            pulumi.set(__self__, "node_selectors", node_selectors)
+        if pod_affinity is not None:
+            pulumi.set(__self__, "pod_affinity", pod_affinity)
+        if pod_anti_affinity is not None:
+            pulumi.set(__self__, "pod_anti_affinity", pod_anti_affinity)
+        if pre_start_commands is not None:
+            pulumi.set(__self__, "pre_start_commands", pre_start_commands)
+        if pvcs is not None:
+            pulumi.set(__self__, "pvcs", pvcs)
+        if tolerations is not None:
+            pulumi.set(__self__, "tolerations", tolerations)
+        if volume_mounts is not None:
+            pulumi.set(__self__, "volume_mounts", volume_mounts)
+        if volumes is not None:
+            pulumi.set(__self__, "volumes", volumes)
+
+    @property
+    @pulumi.getter(name="ackInstanceId")
+    def ack_instance_id(self) -> str:
+        """
+        The ack cluster instance id.
+        """
+        return pulumi.get(self, "ack_instance_id")
+
+    @property
+    @pulumi.getter(name="limitCpu")
+    def limit_cpu(self) -> float:
+        """
+        The job pod resource of limit cpu.
+        """
+        return pulumi.get(self, "limit_cpu")
+
+    @property
+    @pulumi.getter(name="limitMemory")
+    def limit_memory(self) -> float:
+        """
+        The job pod resource of limit memory.
+        """
+        return pulumi.get(self, "limit_memory")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> str:
+        """
+        The ack cluster namespace.
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter(name="requestCpu")
+    def request_cpu(self) -> float:
+        """
+        The job pod resource of request cpu.
+        """
+        return pulumi.get(self, "request_cpu")
+
+    @property
+    @pulumi.getter(name="requestMemory")
+    def request_memory(self) -> float:
+        """
+        The job pod resource of request memory.
+        """
+        return pulumi.get(self, "request_memory")
+
+    @property
+    @pulumi.getter(name="customAnnotations")
+    def custom_annotations(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigCustomAnnotation']]:
+        """
+        The ack cluster custom annotations. See `custom_annotations` below.
+        """
+        return pulumi.get(self, "custom_annotations")
+
+    @property
+    @pulumi.getter(name="customLabels")
+    def custom_labels(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigCustomLabel']]:
+        """
+        The ack cluster custom labels. See `custom_labels` below.
+        """
+        return pulumi.get(self, "custom_labels")
+
+    @property
+    @pulumi.getter(name="nodeAffinity")
+    def node_affinity(self) -> Optional[str]:
+        """
+        The ack cluster node affinity.
+        """
+        return pulumi.get(self, "node_affinity")
+
+    @property
+    @pulumi.getter(name="nodeSelectors")
+    def node_selectors(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigNodeSelector']]:
+        """
+        The ack cluster node selectors for job pods scheduling. See `node_selectors` below.
+        """
+        return pulumi.get(self, "node_selectors")
+
+    @property
+    @pulumi.getter(name="podAffinity")
+    def pod_affinity(self) -> Optional[str]:
+        """
+        The job pod affinity.
+        """
+        return pulumi.get(self, "pod_affinity")
+
+    @property
+    @pulumi.getter(name="podAntiAffinity")
+    def pod_anti_affinity(self) -> Optional[str]:
+        """
+        The job pod anti-affinity.
+        """
+        return pulumi.get(self, "pod_anti_affinity")
+
+    @property
+    @pulumi.getter(name="preStartCommands")
+    def pre_start_commands(self) -> Optional[Sequence[str]]:
+        """
+        The job pod pre start command.
+        """
+        return pulumi.get(self, "pre_start_commands")
+
+    @property
+    @pulumi.getter
+    def pvcs(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigPvc']]:
+        """
+        The ack cluster persistent volume claim. See `pvcs` below.
+        """
+        return pulumi.get(self, "pvcs")
+
+    @property
+    @pulumi.getter
+    def tolerations(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigToleration']]:
+        """
+        The ack cluster tolerations. See `tolerations` below.
+        """
+        return pulumi.get(self, "tolerations")
+
+    @property
+    @pulumi.getter(name="volumeMounts")
+    def volume_mounts(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigVolumeMount']]:
+        """
+        The ack cluster volume mounts. See `volume_mounts` below.
+        """
+        return pulumi.get(self, "volume_mounts")
+
+    @property
+    @pulumi.getter
+    def volumes(self) -> Optional[Sequence['outputs.ClusterNodeGroupAckConfigVolume']]:
+        """
+        The ack cluster volumes. See `volumes` below.
+        """
+        return pulumi.get(self, "volumes")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigCustomAnnotation(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: Optional[str] = None):
+        """
+        :param str key: The tag key for this scaling rule specific metrics trigger.
+        :param str value: The tag value for this scaling rule specific metrics trigger.
+        """
+        pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        The tag key for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The tag value for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigCustomLabel(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: Optional[str] = None):
+        """
+        :param str key: The tag key for this scaling rule specific metrics trigger.
+        :param str value: The tag value for this scaling rule specific metrics trigger.
+        """
+        pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        The tag key for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The tag value for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigNodeSelector(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: Optional[str] = None):
+        """
+        :param str key: The tag key for this scaling rule specific metrics trigger.
+        :param str value: The tag value for this scaling rule specific metrics trigger.
+        """
+        pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        The tag key for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The tag value for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigPvc(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dataDiskSize":
+            suggest = "data_disk_size"
+        elif key == "dataDiskStorageClass":
+            suggest = "data_disk_storage_class"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAckConfigPvc. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAckConfigPvc.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAckConfigPvc.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 data_disk_size: int,
+                 data_disk_storage_class: str,
+                 name: str,
+                 path: str):
+        """
+        :param int data_disk_size: The ack cluster job pod data disk size of persistent volume claim.
+        :param str data_disk_storage_class: The ack cluster job pod data disk storage class of persistent volume claim.
+        :param str name: The name of ack cluster job pod volume mounts.
+        :param str path: The path of ack cluster job pod volume mounts.
+        """
+        pulumi.set(__self__, "data_disk_size", data_disk_size)
+        pulumi.set(__self__, "data_disk_storage_class", data_disk_storage_class)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter(name="dataDiskSize")
+    def data_disk_size(self) -> int:
+        """
+        The ack cluster job pod data disk size of persistent volume claim.
+        """
+        return pulumi.get(self, "data_disk_size")
+
+    @property
+    @pulumi.getter(name="dataDiskStorageClass")
+    def data_disk_storage_class(self) -> str:
+        """
+        The ack cluster job pod data disk storage class of persistent volume claim.
+        """
+        return pulumi.get(self, "data_disk_storage_class")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def path(self) -> str:
+        """
+        The path of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "path")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigToleration(dict):
+    def __init__(__self__, *,
+                 effect: Optional[str] = None,
+                 key: Optional[str] = None,
+                 operator: Optional[str] = None,
+                 value: Optional[str] = None):
+        """
+        :param str effect: The effect of ack cluster tolerations.
+        :param str key: The tag key for this scaling rule specific metrics trigger.
+        :param str operator: The operator of ack cluster tolerations.
+        :param str value: The tag value for this scaling rule specific metrics trigger.
+        """
+        if effect is not None:
+            pulumi.set(__self__, "effect", effect)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if operator is not None:
+            pulumi.set(__self__, "operator", operator)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def effect(self) -> Optional[str]:
+        """
+        The effect of ack cluster tolerations.
+        """
+        return pulumi.get(self, "effect")
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[str]:
+        """
+        The tag key for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def operator(self) -> Optional[str]:
+        """
+        The operator of ack cluster tolerations.
+        """
+        return pulumi.get(self, "operator")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The tag value for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigVolume(dict):
+    def __init__(__self__, *,
+                 name: str,
+                 path: str,
+                 type: str):
+        """
+        :param str name: The name of ack cluster job pod volume mounts.
+        :param str path: The path of ack cluster job pod volume mounts.
+        :param str type: The ack cluster job pod volumes type.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def path(self) -> str:
+        """
+        The path of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The ack cluster job pod volumes type.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAckConfigVolumeMount(dict):
+    def __init__(__self__, *,
+                 name: str,
+                 path: str):
+        """
+        :param str name: The name of ack cluster job pod volume mounts.
+        :param str path: The path of ack cluster job pod volume mounts.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "path", path)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def path(self) -> str:
+        """
+        The path of ack cluster job pod volume mounts.
+        """
+        return pulumi.get(self, "path")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "scalingRules":
+            suggest = "scaling_rules"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 constraints: Optional['outputs.ClusterNodeGroupAutoScalingPolicyConstraints'] = None,
+                 scaling_rules: Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRule']] = None):
+        """
+        :param 'ClusterNodeGroupAutoScalingPolicyConstraintsArgs' constraints: The constraints of auto scaling policy. See `constraints` below.
+        :param Sequence['ClusterNodeGroupAutoScalingPolicyScalingRuleArgs'] scaling_rules: The scaling rules of auto scaling policy. See `scaling_rules` below.
+        """
+        if constraints is not None:
+            pulumi.set(__self__, "constraints", constraints)
+        if scaling_rules is not None:
+            pulumi.set(__self__, "scaling_rules", scaling_rules)
+
+    @property
+    @pulumi.getter
+    def constraints(self) -> Optional['outputs.ClusterNodeGroupAutoScalingPolicyConstraints']:
+        """
+        The constraints of auto scaling policy. See `constraints` below.
+        """
+        return pulumi.get(self, "constraints")
+
+    @property
+    @pulumi.getter(name="scalingRules")
+    def scaling_rules(self) -> Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRule']]:
+        """
+        The scaling rules of auto scaling policy. See `scaling_rules` below.
+        """
+        return pulumi.get(self, "scaling_rules")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyConstraints(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxCapacity":
+            suggest = "max_capacity"
+        elif key == "minCapacity":
+            suggest = "min_capacity"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicyConstraints. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyConstraints.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyConstraints.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_capacity: Optional[int] = None,
+                 min_capacity: Optional[int] = None):
+        """
+        :param int max_capacity: The maximum capacity of constraints for emr node group auto scaling policy.
+        :param int min_capacity: The minimum capacity of constraints for emr node group auto scaling policy.
+        """
+        if max_capacity is not None:
+            pulumi.set(__self__, "max_capacity", max_capacity)
+        if min_capacity is not None:
+            pulumi.set(__self__, "min_capacity", min_capacity)
+
+    @property
+    @pulumi.getter(name="maxCapacity")
+    def max_capacity(self) -> Optional[int]:
+        """
+        The maximum capacity of constraints for emr node group auto scaling policy.
+        """
+        return pulumi.get(self, "max_capacity")
+
+    @property
+    @pulumi.getter(name="minCapacity")
+    def min_capacity(self) -> Optional[int]:
+        """
+        The minimum capacity of constraints for emr node group auto scaling policy.
+        """
+        return pulumi.get(self, "min_capacity")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRule(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "activityType":
+            suggest = "activity_type"
+        elif key == "adjustmentValue":
+            suggest = "adjustment_value"
+        elif key == "ruleName":
+            suggest = "rule_name"
+        elif key == "triggerType":
+            suggest = "trigger_type"
+        elif key == "adjustmentType":
+            suggest = "adjustment_type"
+        elif key == "metricsTrigger":
+            suggest = "metrics_trigger"
+        elif key == "minAdjustmentValue":
+            suggest = "min_adjustment_value"
+        elif key == "timeTrigger":
+            suggest = "time_trigger"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicyScalingRule. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRule.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRule.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 activity_type: str,
+                 adjustment_value: int,
+                 rule_name: str,
+                 trigger_type: str,
+                 adjustment_type: Optional[str] = None,
+                 metrics_trigger: Optional['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger'] = None,
+                 min_adjustment_value: Optional[int] = None,
+                 time_trigger: Optional['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger'] = None):
+        """
+        :param str activity_type: The activity type of auto scaling policy. Valid values: `SCALE_OUT` and `SCALE_IN`.
+        :param int adjustment_value: The adjustment value of auto scaling policy. The value should between 1 and 5000.
+        :param str rule_name: The rule name of auto scaling policy.
+        :param str trigger_type: The trigger type of auto scaling policy. Valid values: `TIME_TRIGGER` and `METRICS_TRIGGER`.
+        :param str adjustment_type: The adjustment type of auto scaling policy. Valid values: `CHANGE_IN_CAPACITY` and `EXACT_CAPACITY`.
+        :param 'ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerArgs' metrics_trigger: The trigger metrics of scaling rules for emr node group auto scaling policy. See `metrics_trigger` below.
+        :param int min_adjustment_value: The minimum adjustment value of auto scaling policy.
+        :param 'ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTriggerArgs' time_trigger: The trigger time of scaling rules for emr node group auto scaling policy. See `time_trigger` below.
+        """
+        pulumi.set(__self__, "activity_type", activity_type)
+        pulumi.set(__self__, "adjustment_value", adjustment_value)
+        pulumi.set(__self__, "rule_name", rule_name)
+        pulumi.set(__self__, "trigger_type", trigger_type)
+        if adjustment_type is not None:
+            pulumi.set(__self__, "adjustment_type", adjustment_type)
+        if metrics_trigger is not None:
+            pulumi.set(__self__, "metrics_trigger", metrics_trigger)
+        if min_adjustment_value is not None:
+            pulumi.set(__self__, "min_adjustment_value", min_adjustment_value)
+        if time_trigger is not None:
+            pulumi.set(__self__, "time_trigger", time_trigger)
+
+    @property
+    @pulumi.getter(name="activityType")
+    def activity_type(self) -> str:
+        """
+        The activity type of auto scaling policy. Valid values: `SCALE_OUT` and `SCALE_IN`.
+        """
+        return pulumi.get(self, "activity_type")
+
+    @property
+    @pulumi.getter(name="adjustmentValue")
+    def adjustment_value(self) -> int:
+        """
+        The adjustment value of auto scaling policy. The value should between 1 and 5000.
+        """
+        return pulumi.get(self, "adjustment_value")
+
+    @property
+    @pulumi.getter(name="ruleName")
+    def rule_name(self) -> str:
+        """
+        The rule name of auto scaling policy.
+        """
+        return pulumi.get(self, "rule_name")
+
+    @property
+    @pulumi.getter(name="triggerType")
+    def trigger_type(self) -> str:
+        """
+        The trigger type of auto scaling policy. Valid values: `TIME_TRIGGER` and `METRICS_TRIGGER`.
+        """
+        return pulumi.get(self, "trigger_type")
+
+    @property
+    @pulumi.getter(name="adjustmentType")
+    def adjustment_type(self) -> Optional[str]:
+        """
+        The adjustment type of auto scaling policy. Valid values: `CHANGE_IN_CAPACITY` and `EXACT_CAPACITY`.
+        """
+        return pulumi.get(self, "adjustment_type")
+
+    @property
+    @pulumi.getter(name="metricsTrigger")
+    def metrics_trigger(self) -> Optional['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger']:
+        """
+        The trigger metrics of scaling rules for emr node group auto scaling policy. See `metrics_trigger` below.
+        """
+        return pulumi.get(self, "metrics_trigger")
+
+    @property
+    @pulumi.getter(name="minAdjustmentValue")
+    def min_adjustment_value(self) -> Optional[int]:
+        """
+        The minimum adjustment value of auto scaling policy.
+        """
+        return pulumi.get(self, "min_adjustment_value")
+
+    @property
+    @pulumi.getter(name="timeTrigger")
+    def time_trigger(self) -> Optional['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger']:
+        """
+        The trigger time of scaling rules for emr node group auto scaling policy. See `time_trigger` below.
+        """
+        return pulumi.get(self, "time_trigger")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "evaluationCount":
+            suggest = "evaluation_count"
+        elif key == "timeWindow":
+            suggest = "time_window"
+        elif key == "conditionLogicOperator":
+            suggest = "condition_logic_operator"
+        elif key == "coolDownInterval":
+            suggest = "cool_down_interval"
+        elif key == "timeConstraints":
+            suggest = "time_constraints"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTrigger.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 evaluation_count: int,
+                 time_window: int,
+                 condition_logic_operator: Optional[str] = None,
+                 conditions: Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition']] = None,
+                 cool_down_interval: Optional[int] = None,
+                 time_constraints: Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint']] = None):
+        """
+        :param int evaluation_count: The evaluation count for this scaling rule specific metrics trigger.
+        :param int time_window: The time window for this scaling rule specific metrics trigger.
+        :param str condition_logic_operator: The condition logic operator for this scaling rule specific metrics trigger. Valid values: `And` and `Or`.
+        :param Sequence['ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionArgs'] conditions: The conditions for this scaling rule specific metrics trigger. See `conditions` below.
+        :param int cool_down_interval: The time of cool down interval for this scaling rule specific metrics trigger.
+        :param Sequence['ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraintArgs'] time_constraints: The time constraints for this scaling rule specific metrics trigger. See `time_constraints` below.
+        """
+        pulumi.set(__self__, "evaluation_count", evaluation_count)
+        pulumi.set(__self__, "time_window", time_window)
+        if condition_logic_operator is not None:
+            pulumi.set(__self__, "condition_logic_operator", condition_logic_operator)
+        if conditions is not None:
+            pulumi.set(__self__, "conditions", conditions)
+        if cool_down_interval is not None:
+            pulumi.set(__self__, "cool_down_interval", cool_down_interval)
+        if time_constraints is not None:
+            pulumi.set(__self__, "time_constraints", time_constraints)
+
+    @property
+    @pulumi.getter(name="evaluationCount")
+    def evaluation_count(self) -> int:
+        """
+        The evaluation count for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "evaluation_count")
+
+    @property
+    @pulumi.getter(name="timeWindow")
+    def time_window(self) -> int:
+        """
+        The time window for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "time_window")
+
+    @property
+    @pulumi.getter(name="conditionLogicOperator")
+    def condition_logic_operator(self) -> Optional[str]:
+        """
+        The condition logic operator for this scaling rule specific metrics trigger. Valid values: `And` and `Or`.
+        """
+        return pulumi.get(self, "condition_logic_operator")
+
+    @property
+    @pulumi.getter
+    def conditions(self) -> Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition']]:
+        """
+        The conditions for this scaling rule specific metrics trigger. See `conditions` below.
+        """
+        return pulumi.get(self, "conditions")
+
+    @property
+    @pulumi.getter(name="coolDownInterval")
+    def cool_down_interval(self) -> Optional[int]:
+        """
+        The time of cool down interval for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "cool_down_interval")
+
+    @property
+    @pulumi.getter(name="timeConstraints")
+    def time_constraints(self) -> Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint']]:
+        """
+        The time constraints for this scaling rule specific metrics trigger. See `time_constraints` below.
+        """
+        return pulumi.get(self, "time_constraints")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition(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 ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerCondition.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 comparison_operator: str,
+                 metric_name: str,
+                 statistics: str,
+                 threshold: float,
+                 tags: Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionTag']] = None):
+        """
+        :param str comparison_operator: The comparison operator for this scaling rule specific metrics trigger. Invalid values: `EQ`, `NE`, `GT`, `LT`, `GE`, `LE`.
+        :param str metric_name: The metric name for this scaling rule specific metrics trigger.
+        :param str statistics: The statistics for this scaling rule specific metrics trigger.
+        :param float threshold: The threshold for this scaling rule specific metrics trigger.
+        :param Sequence['ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionTagArgs'] tags: A mapping of tags to assign to the resource.
+        """
+        pulumi.set(__self__, "comparison_operator", comparison_operator)
+        pulumi.set(__self__, "metric_name", metric_name)
+        pulumi.set(__self__, "statistics", statistics)
+        pulumi.set(__self__, "threshold", threshold)
+        if tags is not None:
+            pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter(name="comparisonOperator")
+    def comparison_operator(self) -> str:
+        """
+        The comparison operator for this scaling rule specific metrics trigger. Invalid values: `EQ`, `NE`, `GT`, `LT`, `GE`, `LE`.
+        """
+        return pulumi.get(self, "comparison_operator")
+
+    @property
+    @pulumi.getter(name="metricName")
+    def metric_name(self) -> str:
+        """
+        The metric name for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "metric_name")
+
+    @property
+    @pulumi.getter
+    def statistics(self) -> str:
+        """
+        The statistics for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "statistics")
+
+    @property
+    @pulumi.getter
+    def threshold(self) -> float:
+        """
+        The threshold for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "threshold")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Optional[Sequence['outputs.ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionTag']]:
+        """
+        A mapping of tags to assign to the resource.
+        """
+        return pulumi.get(self, "tags")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerConditionTag(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: Optional[str] = None):
+        """
+        :param str key: The tag key for this scaling rule specific metrics trigger.
+        :param str value: The tag value for this scaling rule specific metrics trigger.
+        """
+        pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        The tag key for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The tag value for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endTime":
+            suggest = "end_time"
+        elif key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleMetricsTriggerTimeConstraint.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 end_time: Optional[str] = None,
+                 start_time: Optional[str] = None):
+        """
+        :param str end_time: The end time for this scaling rule specific metrics trigger.
+        :param str start_time: The start time for this scaling rule specific metrics trigger.
+        """
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[str]:
+        """
+        The end time for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "end_time")
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[str]:
+        """
+        The start time for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "start_time")
+
+
+@pulumi.output_type
+class ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "launchTime":
+            suggest = "launch_time"
+        elif key == "endTime":
+            suggest = "end_time"
+        elif key == "launchExpirationTime":
+            suggest = "launch_expiration_time"
+        elif key == "recurrenceType":
+            suggest = "recurrence_type"
+        elif key == "recurrenceValue":
+            suggest = "recurrence_value"
+        elif key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeGroupAutoScalingPolicyScalingRuleTimeTrigger.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 launch_time: str,
+                 end_time: Optional[str] = None,
+                 launch_expiration_time: Optional[int] = None,
+                 recurrence_type: Optional[str] = None,
+                 recurrence_value: Optional[str] = None,
+                 start_time: Optional[str] = None):
+        """
+        :param str launch_time: The launch time for this scaling rule specific time trigger.
+        :param str end_time: The end time for this scaling rule specific metrics trigger.
+        :param int launch_expiration_time: The launch expiration time for this scaling rule specific time trigger. The value should between 0 and 3600.
+        :param str recurrence_type: The recurrence type for this scaling rule specific time trigger. Valid values: `MINUTELY`, `HOURLY`, `DAILY`, `WEEKLY`, `MONTHLY`.
+        :param str recurrence_value: The recurrence value for this scaling rule specific time trigger.
+        :param str start_time: The start time for this scaling rule specific metrics trigger.
+        """
+        pulumi.set(__self__, "launch_time", launch_time)
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
+        if launch_expiration_time is not None:
+            pulumi.set(__self__, "launch_expiration_time", launch_expiration_time)
+        if recurrence_type is not None:
+            pulumi.set(__self__, "recurrence_type", recurrence_type)
+        if recurrence_value is not None:
+            pulumi.set(__self__, "recurrence_value", recurrence_value)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+
+    @property
+    @pulumi.getter(name="launchTime")
+    def launch_time(self) -> str:
+        """
+        The launch time for this scaling rule specific time trigger.
+        """
+        return pulumi.get(self, "launch_time")
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[str]:
+        """
+        The end time for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "end_time")
+
+    @property
+    @pulumi.getter(name="launchExpirationTime")
+    def launch_expiration_time(self) -> Optional[int]:
+        """
+        The launch expiration time for this scaling rule specific time trigger. The value should between 0 and 3600.
+        """
+        return pulumi.get(self, "launch_expiration_time")
+
+    @property
+    @pulumi.getter(name="recurrenceType")
+    def recurrence_type(self) -> Optional[str]:
+        """
+        The recurrence type for this scaling rule specific time trigger. Valid values: `MINUTELY`, `HOURLY`, `DAILY`, `WEEKLY`, `MONTHLY`.
+        """
+        return pulumi.get(self, "recurrence_type")
+
+    @property
+    @pulumi.getter(name="recurrenceValue")
+    def recurrence_value(self) -> Optional[str]:
+        """
+        The recurrence value for this scaling rule specific time trigger.
+        """
+        return pulumi.get(self, "recurrence_value")
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[str]:
+        """
+        The start time for this scaling rule specific metrics trigger.
+        """
+        return pulumi.get(self, "start_time")
+
+
 @pulumi.output_type
 class ClusterNodeGroupCostOptimizedConfig(dict):
     @staticmethod
@@ -814,7 +2027,7 @@ class ClusterNodeGroupDataDisk(dict):
                  count: Optional[int] = None,
                  performance_level: Optional[str] = None):
         """
-        :param str category: The type of the data disk. Valid values: `cloud_efficiency` and `cloud_essd`.
+        :param str category: The type of the data disk. Valid values: `cloud_efficiency`, `cloud_essd`, `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro`. **NOTE:** Since version v1.230.0, the categories `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro` are available.
         :param int size: The size of a data disk, at least 40. Unit: GiB.
         :param int count: The count of a data disk.
         :param str performance_level: Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity.
@@ -830,7 +2043,7 @@ class ClusterNodeGroupDataDisk(dict):
     @pulumi.getter
     def category(self) -> str:
         """
-        The type of the data disk. Valid values: `cloud_efficiency` and `cloud_essd`.
+        The type of the data disk. Valid values: `cloud_efficiency`, `cloud_essd`, `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro`. **NOTE:** Since version v1.230.0, the categories `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro` are available.
         """
         return pulumi.get(self, "category")
 
@@ -946,7 +2159,7 @@ class ClusterNodeGroupSubscriptionConfig(dict):
         """
         :param int payment_duration: If paymentType is Subscription, this should be specified. Supported value: 1、2、3、4、5、6、7、8、9、12、24、36、48.
         :param str payment_duration_unit: If paymentType is Subscription, this should be specified. Supported value: Month or Year.
-        :param bool auto_pay_order: Auto pay order for payment type of subscription, ’true’ or ‘false’ .
+        :param bool auto_pay_order: Auto pay order for payment type of subscription, ’true’ or ‘false’ .  Default value is ’true’.
         :param bool auto_renew: Auto renew for prepaid, ’true’ or ‘false’ . Default value: false.
         :param int auto_renew_duration: If paymentType is Subscription, this should be specified. Supported value: 1、2、3、4、5、6、7、8、9、12、24、36、48.
         :param str auto_renew_duration_unit: If paymentType is Subscription, this should be specified. Supported value: Month or Year.
@@ -982,7 +2195,7 @@ class ClusterNodeGroupSubscriptionConfig(dict):
     @pulumi.getter(name="autoPayOrder")
     def auto_pay_order(self) -> Optional[bool]:
         """
-        Auto pay order for payment type of subscription, ’true’ or ‘false’ .
+        Auto pay order for payment type of subscription, ’true’ or ‘false’ .  Default value is ’true’.
         """
         return pulumi.get(self, "auto_pay_order")
 
@@ -1036,7 +2249,7 @@ class ClusterNodeGroupSystemDisk(dict):
                  count: Optional[int] = None,
                  performance_level: Optional[str] = None):
         """
-        :param str category: The type of the data disk. Valid values: `cloud_efficiency` and `cloud_essd`.
+        :param str category: The type of the data disk. Valid values: `cloud_efficiency`, `cloud_essd`, `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro`. **NOTE:** Since version v1.230.0, the categories `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro` are available.
         :param int size: The size of a data disk, at least 40. Unit: GiB.
         :param int count: The count of a data disk.
         :param str performance_level: Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity.
@@ -1052,7 +2265,7 @@ class ClusterNodeGroupSystemDisk(dict):
     @pulumi.getter
     def category(self) -> str:
         """
-        The type of the data disk. Valid values: `cloud_efficiency` and `cloud_essd`.
+        The type of the data disk. Valid values: `cloud_efficiency`, `cloud_essd`, `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro`. **NOTE:** Since version v1.230.0, the categories `cloud`, `local_hdd_pro`, `local_disk`, `local_ssd_pro` are available.
         """
         return pulumi.get(self, "category")
 
@@ -1120,7 +2333,7 @@ class ClusterSubscriptionConfig(dict):
         """
         :param int payment_duration: If paymentType is Subscription, this should be specified. Supported value: 1、2、3、4、5、6、7、8、9、12、24、36、48.
         :param str payment_duration_unit: If paymentType is Subscription, this should be specified. Supported value: Month or Year.
-        :param bool auto_pay_order: Auto pay order for payment type of subscription, ’true’ or ‘false’ .
+        :param bool auto_pay_order: Auto pay order for payment type of subscription, ’true’ or ‘false’ .  Default value is ’true’.
         :param bool auto_renew: Auto renew for prepaid, ’true’ or ‘false’ . Default value: false.
         :param int auto_renew_duration: If paymentType is Subscription, this should be specified. Supported value: 1、2、3、4、5、6、7、8、9、12、24、36、48.
         :param str auto_renew_duration_unit: If paymentType is Subscription, this should be specified. Supported value: Month or Year.
@@ -1156,7 +2369,7 @@ class ClusterSubscriptionConfig(dict):
     @pulumi.getter(name="autoPayOrder")
     def auto_pay_order(self) -> Optional[bool]:
         """
-        Auto pay order for payment type of subscription, ’true’ or ‘false’ .
+        Auto pay order for payment type of subscription, ’true’ or ‘false’ .  Default value is ’true’.
         """
         return pulumi.get(self, "auto_pay_order")
 
@@ -1200,11 +2413,11 @@ class GetClustersClusterResult(dict):
                  ready_time: str,
                  release_version: str,
                  resource_group_id: str,
-                 state_change_reason: Mapping[str, Any],
+                 state_change_reason: Mapping[str, str],
                  tags: Sequence['outputs.GetClustersClusterTagResult']):
         """
         :param str cluster_id: The first ID of the resource.
-        :param str cluster_name: The name of the emr cluster.
+        :param str cluster_name: The cluster name.
         :param str cluster_state: The state of the emr cluster.
         :param str cluster_type: The type of the emr cluster.
         :param str create_time: The creation time of the resource.
@@ -1214,8 +2427,8 @@ class GetClustersClusterResult(dict):
         :param str payment_type: The payment type of the emr cluster.
         :param str ready_time: The ready time of the resource.
         :param str release_version: The release version of the resource.
-        :param str resource_group_id: The resource group id of the resource.
-        :param Mapping[str, Any] state_change_reason: The cluster state change reason.
+        :param str resource_group_id: The Resource Group ID.
+        :param Mapping[str, str] state_change_reason: The cluster state change reason.
         :param Sequence['GetClustersClusterTagArgs'] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "cluster_id", cluster_id)
@@ -1245,7 +2458,7 @@ class GetClustersClusterResult(dict):
     @pulumi.getter(name="clusterName")
     def cluster_name(self) -> str:
         """
-        The name of the emr cluster.
+        The cluster name.
         """
         return pulumi.get(self, "cluster_name")
 
@@ -1325,13 +2538,13 @@ class GetClustersClusterResult(dict):
     @pulumi.getter(name="resourceGroupId")
     def resource_group_id(self) -> str:
         """
-        The resource group id of the resource.
+        The Resource Group ID.
         """
         return pulumi.get(self, "resource_group_id")
 
     @property
     @pulumi.getter(name="stateChangeReason")
-    def state_change_reason(self) -> Mapping[str, Any]:
+    def state_change_reason(self) -> Mapping[str, str]:
         """
         The cluster state change reason.
         """