@alicloud/ess20220222 1.3.2 → 1.4.1

package/src/client.ts

@@ -3618,6 +3618,108 @@ export class DescribeNotificationTypesResponse extends $tea.Model {
   }
 }
 
+export class DescribePatternTypesRequest extends $tea.Model {
+  architecture?: string[];
+  burstablePerformance?: string;
+  channelId?: number;
+  cores?: number;
+  coresList?: number[];
+  excludedInstanceType?: string[];
+  instanceFamilyLevel?: string;
+  maxPrice?: number;
+  memory?: number;
+  memoryList?: number[];
+  regionId?: string;
+  spotStrategy?: string;
+  vSwitchId?: string[];
+  static names(): { [key: string]: string } {
+    return {
+      architecture: 'Architecture',
+      burstablePerformance: 'BurstablePerformance',
+      channelId: 'ChannelId',
+      cores: 'Cores',
+      coresList: 'CoresList',
+      excludedInstanceType: 'ExcludedInstanceType',
+      instanceFamilyLevel: 'InstanceFamilyLevel',
+      maxPrice: 'MaxPrice',
+      memory: 'Memory',
+      memoryList: 'MemoryList',
+      regionId: 'RegionId',
+      spotStrategy: 'SpotStrategy',
+      vSwitchId: 'VSwitchId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      architecture: { 'type': 'array', 'itemType': 'string' },
+      burstablePerformance: 'string',
+      channelId: 'number',
+      cores: 'number',
+      coresList: { 'type': 'array', 'itemType': 'number' },
+      excludedInstanceType: { 'type': 'array', 'itemType': 'string' },
+      instanceFamilyLevel: 'string',
+      maxPrice: 'number',
+      memory: 'number',
+      memoryList: { 'type': 'array', 'itemType': 'number' },
+      regionId: 'string',
+      spotStrategy: 'string',
+      vSwitchId: { 'type': 'array', 'itemType': 'string' },
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribePatternTypesResponseBody extends $tea.Model {
+  patternTypes?: DescribePatternTypesResponseBodyPatternTypes[];
+  requestId?: string;
+  static names(): { [key: string]: string } {
+    return {
+      patternTypes: 'PatternTypes',
+      requestId: 'RequestId',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      patternTypes: { 'type': 'array', 'itemType': DescribePatternTypesResponseBodyPatternTypes },
+      requestId: 'string',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
+export class DescribePatternTypesResponse extends $tea.Model {
+  headers?: { [key: string]: string };
+  statusCode?: number;
+  body?: DescribePatternTypesResponseBody;
+  static names(): { [key: string]: string } {
+    return {
+      headers: 'headers',
+      statusCode: 'statusCode',
+      body: 'body',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      headers: { 'type': 'map', 'keyType': 'string', 'valueType': 'string' },
+      statusCode: 'number',
+      body: DescribePatternTypesResponseBody,
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeRegionsRequest extends $tea.Model {
   acceptLanguage?: string;
   ownerId?: number;
@@ -4675,6 +4777,7 @@ export class DetachInstancesRequest extends $tea.Model {
   clientToken?: string;
   decreaseDesiredCapacity?: boolean;
   detachOption?: string;
+  ignoreInvalidInstance?: boolean;
   instanceIds?: string[];
   lifecycleHook?: boolean;
   ownerAccount?: string;
@@ -4687,6 +4790,7 @@ export class DetachInstancesRequest extends $tea.Model {
       clientToken: 'ClientToken',
       decreaseDesiredCapacity: 'DecreaseDesiredCapacity',
       detachOption: 'DetachOption',
+      ignoreInvalidInstance: 'IgnoreInvalidInstance',
       instanceIds: 'InstanceIds',
       lifecycleHook: 'LifecycleHook',
       ownerAccount: 'OwnerAccount',
@@ -4702,6 +4806,7 @@ export class DetachInstancesRequest extends $tea.Model {
       clientToken: 'string',
       decreaseDesiredCapacity: 'boolean',
       detachOption: 'string',
+      ignoreInvalidInstance: 'boolean',
       instanceIds: { 'type': 'array', 'itemType': 'string' },
       lifecycleHook: 'boolean',
       ownerAccount: 'string',
@@ -7393,6 +7498,7 @@ export class RecordLifecycleActionHeartbeatResponse extends $tea.Model {
 export class RemoveInstancesRequest extends $tea.Model {
   clientToken?: string;
   decreaseDesiredCapacity?: boolean;
+  ignoreInvalidInstance?: boolean;
   instanceIds?: string[];
   ownerAccount?: string;
   ownerId?: number;
@@ -7405,6 +7511,7 @@ export class RemoveInstancesRequest extends $tea.Model {
     return {
       clientToken: 'ClientToken',
       decreaseDesiredCapacity: 'DecreaseDesiredCapacity',
+      ignoreInvalidInstance: 'IgnoreInvalidInstance',
       instanceIds: 'InstanceIds',
       ownerAccount: 'OwnerAccount',
       ownerId: 'OwnerId',
@@ -7420,6 +7527,7 @@ export class RemoveInstancesRequest extends $tea.Model {
     return {
       clientToken: 'string',
       decreaseDesiredCapacity: 'boolean',
+      ignoreInvalidInstance: 'boolean',
       instanceIds: { 'type': 'array', 'itemType': 'string' },
       ownerAccount: 'string',
       ownerId: 'number',
@@ -12087,6 +12195,37 @@ export class DescribeNotificationConfigurationsResponseBodyNotificationConfigura
   }
 }
 
+export class DescribePatternTypesResponseBodyPatternTypes extends $tea.Model {
+  cores?: number;
+  instanceFamilyLevel?: string;
+  instanceType?: string;
+  instanceTypeFamily?: string;
+  memory?: number;
+  static names(): { [key: string]: string } {
+    return {
+      cores: 'Cores',
+      instanceFamilyLevel: 'InstanceFamilyLevel',
+      instanceType: 'InstanceType',
+      instanceTypeFamily: 'InstanceTypeFamily',
+      memory: 'Memory',
+    };
+  }
+
+  static types(): { [key: string]: any } {
+    return {
+      cores: 'number',
+      instanceFamilyLevel: 'string',
+      instanceType: 'string',
+      instanceTypeFamily: 'string',
+      memory: 'number',
+    };
+  }
+
+  constructor(map?: { [key: string]: any }) {
+    super(map);
+  }
+}
+
 export class DescribeRegionsResponseBodyRegions extends $tea.Model {
   classicUnavailable?: boolean;
   localName?: string;
@@ -15811,6 +15950,16 @@ export default class Client extends OpenApi {
     return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
   }
 
+  /**
+   * @summary Manages scaling configurations of the Elastic Container Instance type. If you want to efficiently create or update a scaling configuration of the Elastic Container Instance type by using a configuration file, you can call the ApplyEciScalingConfiguration operation.
+   *
+   * @description You can manage scaling configurations of the Elastic Container Instance type by using a YAML configuration file based on the following logic:
+   * If you specify the ID of a scaling configuration, you can update the scaling configuration by using the YAML configuration file. If you do not specify the ID of a scaling configuration, you can create a scaling configuration by using the YAML configuration file.
+   *
+   * @param request ApplyEciScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ApplyEciScalingConfigurationResponse
+   */
   async applyEciScalingConfigurationWithOptions(request: ApplyEciScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<ApplyEciScalingConfigurationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -15851,11 +16000,61 @@ export default class Client extends OpenApi {
     return $tea.cast<ApplyEciScalingConfigurationResponse>(await this.callApi(params, req, runtime), new ApplyEciScalingConfigurationResponse({}));
   }
 
+  /**
+   * @summary Manages scaling configurations of the Elastic Container Instance type. If you want to efficiently create or update a scaling configuration of the Elastic Container Instance type by using a configuration file, you can call the ApplyEciScalingConfiguration operation.
+   *
+   * @description You can manage scaling configurations of the Elastic Container Instance type by using a YAML configuration file based on the following logic:
+   * If you specify the ID of a scaling configuration, you can update the scaling configuration by using the YAML configuration file. If you do not specify the ID of a scaling configuration, you can create a scaling configuration by using the YAML configuration file.
+   *
+   * @param request ApplyEciScalingConfigurationRequest
+   * @return ApplyEciScalingConfigurationResponse
+   */
   async applyEciScalingConfiguration(request: ApplyEciScalingConfigurationRequest): Promise<ApplyEciScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.applyEciScalingConfigurationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary 基于yaml配置进行弹性伸缩管理
+   *
+   * @description You can call the ApplyScalingGroup operation to create scaling groups of the Elastic Container Instance type with ease. The resources of the scaling groups are defined in Kubernetes Deployment YAML files. You can also call this operation to extend annotations for elastic container instances in Kubernetes Deployment YAML files. For more information, see "Supported annotations" in this topic.
+   * Mapping between YAML files and scaling groups: You can map the triplet of namespace, kind, and name in a YAML file to a scaling group name. A YAML file and a scaling group have a one-to-one mapping relationship in a region. For example, if you use the Kubernetes Deployment YAML file whose name is NGINX in the default namespace to create a scaling group in a region, the unique name of the mapped scaling group is k8s_default_Deployment_nginx.
+   * You can use a Kubernetes Deployment YAML file to manage a scaling group based on the following logic:
+   * * If an existing scaling group has a mapping relationship with your Kubernetes Deployment YAML file, you can update the scaling group by using the YAML file.
+   * * If no scaling group that has a mapping relationship with your Kubernetes Deployment YAML file exists, you can create a scaling group with ease by using the YAML file.
+   * ### Precautions
+   * 1. If you do not specify a virtual private cloud (VPC), vSwitch, security group, or annotation in your Kubernetes Deployment YAML file, the system creates a default VPC that has default vSwitches and uses the default security group ess-default-sg of Auto Scaling. By default, the security group rule allows traffic on Transmission Control Protocol (TCP)-based port 22 and port 3389 and enables Internet Control Message Protocol (ICMP) for IPv4 addresses. If you want to enable other ports or protocols, you can create custom security group rules.
+   * 2. If you want to use a public image, you must enable the Internet access feature and configure the k8s.aliyun.com/eci-with-eip pod annotation to enable the elastic IP address (EIP) feature.
+   * 3. After you call the ApplyScalingGroup operation to apply a Kubernetes Deployment YAML file, the scaling group immediately enters the Enabled state and the scaling configuration immediately enters the Active state. If the number of replicas that you specified in the YAML file is grater than 0, elastic container instances are automatically created.
+   * ### Supported annotations
+   * For more information about annotations, see [ECI Pod Annotation](https://help.aliyun.com/document_detail/186939.html).
+   * |Annotation|Example|Description|
+   * |---|---|---|
+   * |k8s.aliyun.com/ess-scaling-group-min-size|1|The minimum size of the scaling group that you want to create. Default value: 0.|
+   * |k8s.aliyun.com/ess-scaling-group-max-size|20|The maximum size of the scaling group that you want to create. Default value: maximum number of replicas or 30, whichever is greater.|
+   * |k8s.aliyun.com/eci-ntp-server|100.100.*.*|The IP address of the Network Time Protocol (NTP) server.|
+   * |k8s.aliyun.com/eci-use-specs|2-4Gi|The specifications of 2 vCPUs and 4 GB memory. For more information, see [Create pods by specifying multiple specifications](https://help.aliyun.com/document_detail/451267.html).|
+   * |k8s.aliyun.com/eci-vswitch|vsw-bp1xpiowfm5vo8o3c\\*\\*\\*\\*|The ID of the vSwitch. You can specify multiple vSwitches to specify multiple zones.|
+   * |k8s.aliyun.com/eci-security-group|sg-bp1dktddjsg5nktv\\*\\*\\*\\*|The ID of the security group. Before you configure this annotation, take note of the following requirements:<ul data-sourcepos="26:74-26:168"><li data-sourcepos="26:78-26:114">You can specify one or more security groups. You can specify up to five security groups for each scaling group.</li><li data-sourcepos="26:114-26:140">If you specify multiple security groups, the security groups must belong to the same VPC.</li><li data-sourcepos="26:140-26:163">If you specify multiple security groups, the security groups must be of the same type.</li></ul>|
+   * |k8s.aliyun.com/eci-sls-enable|"false"|If you set the value to false, the log collection feature is disabled.
+   * If you do not want to use Custom Resource Definition (CRD) for Simple Log Service to collect logs of specific pods, you can configure this annotation for the pods and set the value to false. This prevents resource wastes caused by Logtails created by the system.|
+   * |k8s.aliyun.com/eci-spot-strategy|SpotAsPriceGo|The bidding policy for the preemptible instance. Valid values:<ul data-sourcepos="28:69-28:204"><li data-sourcepos="28:73-28:158">SpotWithPriceLimit: The instance is created as a preemptible instance for which you specify the maximum hourly price If you set the value to SpotWithPriceLimit, you must configure the k8s.aliyun.com/eci-spot-price-limit annotation.</li><li data-sourcepos="28:158-28:199">SpotAsPriceGo: The instance is a preemptible instance for which the market price at the time of purchase is used as the bid price.</li></ul>|
+   * |k8s.aliyun.com/eci-spot-price-limit|"0.5"|The maximum hourly price of the preemptible instance. This value can be accurate to up to three decimal places.
+   * This annotation takes effect only when you set the k8s.aliyun.com/eci-spot-strategy annotation to SpotWithPriceLimit.|
+   * |k8s.aliyun.com/eci-with-eip|"true"|If you set the value to true, an EIP is automatically created and bound to each elastic container instance.|
+   * |k8s.aliyun.com/eci-data-cache-bucket|default|The bucket of the specified DataCache. If you want to use a DataCache to create a pod, you must configure this annotation.|
+   * |k8s.aliyun.com/eci-data-cache-pl|PL1|The performance level (PL) of the cloud disk that you want to create by using the specified DataCache.
+   * By default, enhanced SSDs (ESSDs) are created. Default value: PL1.|
+   * |k8s.aliyun.com/eci-data-cache-provisionedIops|"40000"|The provisioned read/write IOPS of the ESSD AutoPL disk. Valid values: 0 to min{50000, 1000 × Capacity - Baseline IOPS}. Baseline IOPS = min{1,800 + 50 × Capacity, 50,000}. For more information, see [ESSD AutoPL](https://help.aliyun.com/document_detail/368372.html).
+   * If you configure this annotation, the cloud disk that is created by using the specified DataCache is of the ESSD AutoPL type.|
+   * |k8s.aliyun.com/eci-data-cache-burstingEnabled|"true"|Specifies whether the Burst feature is enabled for the ESSD AutoPL disk. For more information, see [ESSD AutoPL](https://help.aliyun.com/document_detail/368372.html).
+   * If you configure this annotation, the cloud disk that is created by using the specified DataCache is of the ESSD AutoPL type.|
+   * |k8s.aliyun.com/eci-custom-tags|"env:test,name:alice"|The tags that you want to add to each elastic container instance. You can add up to three tags for each elastic container instance. Separate a tag key and a tag value with a colon (:). Separate multiple tags with commas (,).|
+   *
+   * @param request ApplyScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ApplyScalingGroupResponse
+   */
   async applyScalingGroupWithOptions(request: ApplyScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<ApplyScalingGroupResponse> {
     Util.validateModel(request);
     let query = { };
@@ -15888,20 +16087,62 @@ export default class Client extends OpenApi {
     return $tea.cast<ApplyScalingGroupResponse>(await this.callApi(params, req, runtime), new ApplyScalingGroupResponse({}));
   }
 
+  /**
+   * @summary 基于yaml配置进行弹性伸缩管理
+   *
+   * @description You can call the ApplyScalingGroup operation to create scaling groups of the Elastic Container Instance type with ease. The resources of the scaling groups are defined in Kubernetes Deployment YAML files. You can also call this operation to extend annotations for elastic container instances in Kubernetes Deployment YAML files. For more information, see "Supported annotations" in this topic.
+   * Mapping between YAML files and scaling groups: You can map the triplet of namespace, kind, and name in a YAML file to a scaling group name. A YAML file and a scaling group have a one-to-one mapping relationship in a region. For example, if you use the Kubernetes Deployment YAML file whose name is NGINX in the default namespace to create a scaling group in a region, the unique name of the mapped scaling group is k8s_default_Deployment_nginx.
+   * You can use a Kubernetes Deployment YAML file to manage a scaling group based on the following logic:
+   * * If an existing scaling group has a mapping relationship with your Kubernetes Deployment YAML file, you can update the scaling group by using the YAML file.
+   * * If no scaling group that has a mapping relationship with your Kubernetes Deployment YAML file exists, you can create a scaling group with ease by using the YAML file.
+   * ### Precautions
+   * 1. If you do not specify a virtual private cloud (VPC), vSwitch, security group, or annotation in your Kubernetes Deployment YAML file, the system creates a default VPC that has default vSwitches and uses the default security group ess-default-sg of Auto Scaling. By default, the security group rule allows traffic on Transmission Control Protocol (TCP)-based port 22 and port 3389 and enables Internet Control Message Protocol (ICMP) for IPv4 addresses. If you want to enable other ports or protocols, you can create custom security group rules.
+   * 2. If you want to use a public image, you must enable the Internet access feature and configure the k8s.aliyun.com/eci-with-eip pod annotation to enable the elastic IP address (EIP) feature.
+   * 3. After you call the ApplyScalingGroup operation to apply a Kubernetes Deployment YAML file, the scaling group immediately enters the Enabled state and the scaling configuration immediately enters the Active state. If the number of replicas that you specified in the YAML file is grater than 0, elastic container instances are automatically created.
+   * ### Supported annotations
+   * For more information about annotations, see [ECI Pod Annotation](https://help.aliyun.com/document_detail/186939.html).
+   * |Annotation|Example|Description|
+   * |---|---|---|
+   * |k8s.aliyun.com/ess-scaling-group-min-size|1|The minimum size of the scaling group that you want to create. Default value: 0.|
+   * |k8s.aliyun.com/ess-scaling-group-max-size|20|The maximum size of the scaling group that you want to create. Default value: maximum number of replicas or 30, whichever is greater.|
+   * |k8s.aliyun.com/eci-ntp-server|100.100.*.*|The IP address of the Network Time Protocol (NTP) server.|
+   * |k8s.aliyun.com/eci-use-specs|2-4Gi|The specifications of 2 vCPUs and 4 GB memory. For more information, see [Create pods by specifying multiple specifications](https://help.aliyun.com/document_detail/451267.html).|
+   * |k8s.aliyun.com/eci-vswitch|vsw-bp1xpiowfm5vo8o3c\\*\\*\\*\\*|The ID of the vSwitch. You can specify multiple vSwitches to specify multiple zones.|
+   * |k8s.aliyun.com/eci-security-group|sg-bp1dktddjsg5nktv\\*\\*\\*\\*|The ID of the security group. Before you configure this annotation, take note of the following requirements:<ul data-sourcepos="26:74-26:168"><li data-sourcepos="26:78-26:114">You can specify one or more security groups. You can specify up to five security groups for each scaling group.</li><li data-sourcepos="26:114-26:140">If you specify multiple security groups, the security groups must belong to the same VPC.</li><li data-sourcepos="26:140-26:163">If you specify multiple security groups, the security groups must be of the same type.</li></ul>|
+   * |k8s.aliyun.com/eci-sls-enable|"false"|If you set the value to false, the log collection feature is disabled.
+   * If you do not want to use Custom Resource Definition (CRD) for Simple Log Service to collect logs of specific pods, you can configure this annotation for the pods and set the value to false. This prevents resource wastes caused by Logtails created by the system.|
+   * |k8s.aliyun.com/eci-spot-strategy|SpotAsPriceGo|The bidding policy for the preemptible instance. Valid values:<ul data-sourcepos="28:69-28:204"><li data-sourcepos="28:73-28:158">SpotWithPriceLimit: The instance is created as a preemptible instance for which you specify the maximum hourly price If you set the value to SpotWithPriceLimit, you must configure the k8s.aliyun.com/eci-spot-price-limit annotation.</li><li data-sourcepos="28:158-28:199">SpotAsPriceGo: The instance is a preemptible instance for which the market price at the time of purchase is used as the bid price.</li></ul>|
+   * |k8s.aliyun.com/eci-spot-price-limit|"0.5"|The maximum hourly price of the preemptible instance. This value can be accurate to up to three decimal places.
+   * This annotation takes effect only when you set the k8s.aliyun.com/eci-spot-strategy annotation to SpotWithPriceLimit.|
+   * |k8s.aliyun.com/eci-with-eip|"true"|If you set the value to true, an EIP is automatically created and bound to each elastic container instance.|
+   * |k8s.aliyun.com/eci-data-cache-bucket|default|The bucket of the specified DataCache. If you want to use a DataCache to create a pod, you must configure this annotation.|
+   * |k8s.aliyun.com/eci-data-cache-pl|PL1|The performance level (PL) of the cloud disk that you want to create by using the specified DataCache.
+   * By default, enhanced SSDs (ESSDs) are created. Default value: PL1.|
+   * |k8s.aliyun.com/eci-data-cache-provisionedIops|"40000"|The provisioned read/write IOPS of the ESSD AutoPL disk. Valid values: 0 to min{50000, 1000 × Capacity - Baseline IOPS}. Baseline IOPS = min{1,800 + 50 × Capacity, 50,000}. For more information, see [ESSD AutoPL](https://help.aliyun.com/document_detail/368372.html).
+   * If you configure this annotation, the cloud disk that is created by using the specified DataCache is of the ESSD AutoPL type.|
+   * |k8s.aliyun.com/eci-data-cache-burstingEnabled|"true"|Specifies whether the Burst feature is enabled for the ESSD AutoPL disk. For more information, see [ESSD AutoPL](https://help.aliyun.com/document_detail/368372.html).
+   * If you configure this annotation, the cloud disk that is created by using the specified DataCache is of the ESSD AutoPL type.|
+   * |k8s.aliyun.com/eci-custom-tags|"env:test,name:alice"|The tags that you want to add to each elastic container instance. You can add up to three tags for each elastic container instance. Separate a tag key and a tag value with a colon (:). Separate multiple tags with commas (,).|
+   *
+   * @param request ApplyScalingGroupRequest
+   * @return ApplyScalingGroupResponse
+   */
   async applyScalingGroup(request: ApplyScalingGroupRequest): Promise<ApplyScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.applyScalingGroupWithOptions(request, runtime);
   }
 
   /**
-    * Before you associate an ALB server group with a scaling group, make sure that the following requirements are met:
-    * *   The scaling group resides in a virtual private cloud (VPC). The scaling group and the ALB server group must reside in the same VPC.
-    * *   The ALB server group is in the Available state.
-    * *   You can associate only a limited number of ALB server groups with a scaling group. To view the quota or manually request a quota increase, go to [Quota Center](https://quotas.console.aliyun.com/products/ess/quotas).
-    *
-    * @param request AttachAlbServerGroupsRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return AttachAlbServerGroupsResponse
+   * @summary Associates Application Load Balancer (ALB) server groups with a scaling group.
+   *
+   * @description Before you associate an ALB server group with a scaling group, make sure that the following requirements are met:
+   * *   The scaling group resides in a virtual private cloud (VPC). The scaling group and the ALB server group must reside in the same VPC.
+   * *   The ALB server group is in the Available state.
+   * *   You can associate only a limited number of ALB server groups with a scaling group. To view the quota or manually request a quota increase, go to [Quota Center](https://quotas.console.aliyun.com/products/ess/quotas).
+   *
+   * @param request AttachAlbServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachAlbServerGroupsResponse
    */
   async attachAlbServerGroupsWithOptions(request: AttachAlbServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<AttachAlbServerGroupsResponse> {
     Util.validateModel(request);
@@ -15952,13 +16193,15 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you associate an ALB server group with a scaling group, make sure that the following requirements are met:
-    * *   The scaling group resides in a virtual private cloud (VPC). The scaling group and the ALB server group must reside in the same VPC.
-    * *   The ALB server group is in the Available state.
-    * *   You can associate only a limited number of ALB server groups with a scaling group. To view the quota or manually request a quota increase, go to [Quota Center](https://quotas.console.aliyun.com/products/ess/quotas).
-    *
-    * @param request AttachAlbServerGroupsRequest
-    * @return AttachAlbServerGroupsResponse
+   * @summary Associates Application Load Balancer (ALB) server groups with a scaling group.
+   *
+   * @description Before you associate an ALB server group with a scaling group, make sure that the following requirements are met:
+   * *   The scaling group resides in a virtual private cloud (VPC). The scaling group and the ALB server group must reside in the same VPC.
+   * *   The ALB server group is in the Available state.
+   * *   You can associate only a limited number of ALB server groups with a scaling group. To view the quota or manually request a quota increase, go to [Quota Center](https://quotas.console.aliyun.com/products/ess/quotas).
+   *
+   * @param request AttachAlbServerGroupsRequest
+   * @return AttachAlbServerGroupsResponse
    */
   async attachAlbServerGroups(request: AttachAlbServerGroupsRequest): Promise<AttachAlbServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -15966,15 +16209,17 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you associate an ApsaraDB RDS instance with a scaling group, make sure that the ApsaraDB RDS instance meets the following requirements:
-    * *   The ApsaraDB RDS instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The ApsaraDB RDS instance must be unlocked. For more information about the lock policy, see [ApsaraDB RDS usage notes](~~41872~~).
-    * *   The ApsaraDB RDS instance must be in the Running state.
-    * After an ApsaraDB RDS instance is associated with the scaling group, the default IP address whitelist of the ApsaraDB RDS instance can contain no more than 1,000 IP addresses. For more information, see [Set the whitelist](~~43185~~).
-    *
-    * @param request AttachDBInstancesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return AttachDBInstancesResponse
+   * @summary Associates one or more ApsaraDB RDS instances with a scaling group.
+   *
+   * @description Before you associate an ApsaraDB RDS instance with a scaling group, make sure that the ApsaraDB RDS instance meets the following requirements:
+   * *   The ApsaraDB RDS instance and the scaling group must belong to the same Alibaba Cloud account.
+   * *   The ApsaraDB RDS instance must be unlocked. For more information about the lock policy, see [ApsaraDB RDS usage notes](https://help.aliyun.com/document_detail/41872.html).
+   * *   The ApsaraDB RDS instance must be in the Running state.
+   * After an ApsaraDB RDS instance is associated with the scaling group, the default IP address whitelist of the ApsaraDB RDS instance can contain no more than 1,000 IP addresses. For more information, see [Set the whitelist](https://help.aliyun.com/document_detail/43185.html).
+   *
+   * @param request AttachDBInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachDBInstancesResponse
    */
   async attachDBInstancesWithOptions(request: AttachDBInstancesRequest, runtime: $Util.RuntimeOptions): Promise<AttachDBInstancesResponse> {
     Util.validateModel(request);
@@ -16033,14 +16278,16 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you associate an ApsaraDB RDS instance with a scaling group, make sure that the ApsaraDB RDS instance meets the following requirements:
-    * *   The ApsaraDB RDS instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The ApsaraDB RDS instance must be unlocked. For more information about the lock policy, see [ApsaraDB RDS usage notes](~~41872~~).
-    * *   The ApsaraDB RDS instance must be in the Running state.
-    * After an ApsaraDB RDS instance is associated with the scaling group, the default IP address whitelist of the ApsaraDB RDS instance can contain no more than 1,000 IP addresses. For more information, see [Set the whitelist](~~43185~~).
-    *
-    * @param request AttachDBInstancesRequest
-    * @return AttachDBInstancesResponse
+   * @summary Associates one or more ApsaraDB RDS instances with a scaling group.
+   *
+   * @description Before you associate an ApsaraDB RDS instance with a scaling group, make sure that the ApsaraDB RDS instance meets the following requirements:
+   * *   The ApsaraDB RDS instance and the scaling group must belong to the same Alibaba Cloud account.
+   * *   The ApsaraDB RDS instance must be unlocked. For more information about the lock policy, see [ApsaraDB RDS usage notes](https://help.aliyun.com/document_detail/41872.html).
+   * *   The ApsaraDB RDS instance must be in the Running state.
+   * After an ApsaraDB RDS instance is associated with the scaling group, the default IP address whitelist of the ApsaraDB RDS instance can contain no more than 1,000 IP addresses. For more information, see [Set the whitelist](https://help.aliyun.com/document_detail/43185.html).
+   *
+   * @param request AttachDBInstancesRequest
+   * @return AttachDBInstancesResponse
    */
   async attachDBInstances(request: AttachDBInstancesRequest): Promise<AttachDBInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -16048,24 +16295,26 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation, take note of the following items:
-    * *   The scaling group is in the Active state.
-    * *   No scaling activities in the scaling group are in progress.
-    * The ECS instances or the elastic container instances that you want to add to a scaling group must meet the following requirements:
-    * *   The instances reside in the same region as the scaling group.
-    * *   The instances must be in the Running state.
-    * *   The instances are not added to other scaling groups.
-    * *   The instances use the subscription or pay-as-you-go billing method, or are preemptible instances.
-    * *   If the VswitchID parameter is specified for a scaling group, the instances that are in the classic network or those that are not in the same virtual private cloud (VPC) as the specified vSwitch cannot be added to the scaling group.
-    * *   If the VswitchID parameter is not specified for a scaling group, the instances that are in VPCs cannot be added to the scaling group.
-    * If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
-    * If the sum of the number of instances that you want to add and the number of existing instances in the scaling group is greater than the value of the MaxSize parameter, the call fails.
-    * Instances that are manually added by calling the AttachInstances operation are not associated with the active scaling configuration of the scaling group.
-    *
-    * @param request AttachInstancesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return AttachInstancesResponse
+   * @summary Adds instances to a scaling group. You can call the AttachInstances operation to add independent Elastic Compute Service (ECS) instances, elastic container instances, or non-Alibaba Cloud instances to your scaling group to provide services. You can also call this operation to change the state of ECS instances in your scaling group from Economical Mode to In Service.
+   *
+   * @description Before you call this operation, take note of the following items:
+   * *   The scaling group is in the Active state.
+   * *   No scaling activities in the scaling group are in progress.
+   * The ECS instances or the elastic container instances that you want to add to a scaling group must meet the following requirements:
+   * *   The instances reside in the same region as the scaling group.
+   * *   The instances must be in the Running state.
+   * *   The instances are not added to other scaling groups.
+   * *   The instances use the subscription or pay-as-you-go billing method, or are preemptible instances.
+   * *   If the VswitchID parameter is specified for a scaling group, the instances that are in the classic network or those that are not in the same virtual private cloud (VPC) as the specified vSwitch cannot be added to the scaling group.
+   * *   If the VswitchID parameter is not specified for a scaling group, the instances that are in VPCs cannot be added to the scaling group.
+   * If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
+   * If the sum of the number of instances that you want to add and the number of existing instances in the scaling group is greater than the value of the MaxSize parameter, the call fails.
+   * Instances that are manually added by calling the AttachInstances operation are not associated with the active scaling configuration of the scaling group.
+   *
+   * @param request AttachInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachInstancesResponse
    */
   async attachInstancesWithOptions(request: AttachInstancesRequest, runtime: $Util.RuntimeOptions): Promise<AttachInstancesResponse> {
     Util.validateModel(request);
@@ -16132,23 +16381,25 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation, take note of the following items:
-    * *   The scaling group is in the Active state.
-    * *   No scaling activities in the scaling group are in progress.
-    * The ECS instances or the elastic container instances that you want to add to a scaling group must meet the following requirements:
-    * *   The instances reside in the same region as the scaling group.
-    * *   The instances must be in the Running state.
-    * *   The instances are not added to other scaling groups.
-    * *   The instances use the subscription or pay-as-you-go billing method, or are preemptible instances.
-    * *   If the VswitchID parameter is specified for a scaling group, the instances that are in the classic network or those that are not in the same virtual private cloud (VPC) as the specified vSwitch cannot be added to the scaling group.
-    * *   If the VswitchID parameter is not specified for a scaling group, the instances that are in VPCs cannot be added to the scaling group.
-    * If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
-    * If the sum of the number of instances that you want to add and the number of existing instances in the scaling group is greater than the value of the MaxSize parameter, the call fails.
-    * Instances that are manually added by calling the AttachInstances operation are not associated with the active scaling configuration of the scaling group.
-    *
-    * @param request AttachInstancesRequest
-    * @return AttachInstancesResponse
+   * @summary Adds instances to a scaling group. You can call the AttachInstances operation to add independent Elastic Compute Service (ECS) instances, elastic container instances, or non-Alibaba Cloud instances to your scaling group to provide services. You can also call this operation to change the state of ECS instances in your scaling group from Economical Mode to In Service.
+   *
+   * @description Before you call this operation, take note of the following items:
+   * *   The scaling group is in the Active state.
+   * *   No scaling activities in the scaling group are in progress.
+   * The ECS instances or the elastic container instances that you want to add to a scaling group must meet the following requirements:
+   * *   The instances reside in the same region as the scaling group.
+   * *   The instances must be in the Running state.
+   * *   The instances are not added to other scaling groups.
+   * *   The instances use the subscription or pay-as-you-go billing method, or are preemptible instances.
+   * *   If the VswitchID parameter is specified for a scaling group, the instances that are in the classic network or those that are not in the same virtual private cloud (VPC) as the specified vSwitch cannot be added to the scaling group.
+   * *   If the VswitchID parameter is not specified for a scaling group, the instances that are in VPCs cannot be added to the scaling group.
+   * If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
+   * If the sum of the number of instances that you want to add and the number of existing instances in the scaling group is greater than the value of the MaxSize parameter, the call fails.
+   * Instances that are manually added by calling the AttachInstances operation are not associated with the active scaling configuration of the scaling group.
+   *
+   * @param request AttachInstancesRequest
+   * @return AttachInstancesResponse
    */
   async attachInstances(request: AttachInstancesRequest): Promise<AttachInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -16156,18 +16407,19 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation to attach a CLB instance to your scaling group, take note of the following items:
-    * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The CLB instance and the scaling group must reside in the same region.
-    * *   The CLB instance must be in the Running state.
-    * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
-    * *   The CLB instance and the scaling group must be in the same virtual private cloud (VPC) if their network type is VPC.
-    * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the CLB backend server groups contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
-    * *   You can attach only a limited number of CLB instances to a scaling group. Fore more information, see [Limits](~~25863~~).
-    *
-    * @param request AttachLoadBalancersRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return AttachLoadBalancersResponse
+   * @summary Attaches load balancers to a scaling group. Auto Scaling supports the attachment of load balancers to scaling groups. Load balancers help distribute the access traffic to the instances in scaling groups, which effectively improves the service performance of the scaling groups. You can call the AttachLoadBalancers operation to attach one or more load balancers to your scaling group.
+   *
+   * @description Before you call this operation, make sure that the following requirements are met:
+   * *   The load balancer and the scaling group belong to the same Alibaba Cloud account and region.
+   * *   The load balancer is in the `Running` state.
+   * *   At least one listener is configured for the load balancer, and the health check feature is enabled for the load balancer.
+   * *   If the network type of the load balancer and the scaling group is virtual private cloud (VPC), they use the same VPC.
+   * *   If the network type of the scaling group is VPC, and that of the load balancer is classic network and a backend server of the load balancer uses a VPC, the scaling group and the backend server use the same VPC.
+   * *   The attachment of load balancers ensures that the cumulative number of load balancers attached to the scaling group stays within the predefined maximum limit. For information about the load balancer quota, see [Limits](https://help.aliyun.com/document_detail/25863.html).
+   *
+   * @param request AttachLoadBalancersRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachLoadBalancersResponse
    */
   async attachLoadBalancersWithOptions(request: AttachLoadBalancersRequest, runtime: $Util.RuntimeOptions): Promise<AttachLoadBalancersResponse> {
     Util.validateModel(request);
@@ -16222,23 +16474,31 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation to attach a CLB instance to your scaling group, take note of the following items:
-    * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The CLB instance and the scaling group must reside in the same region.
-    * *   The CLB instance must be in the Running state.
-    * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
-    * *   The CLB instance and the scaling group must be in the same virtual private cloud (VPC) if their network type is VPC.
-    * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the CLB backend server groups contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
-    * *   You can attach only a limited number of CLB instances to a scaling group. Fore more information, see [Limits](~~25863~~).
-    *
-    * @param request AttachLoadBalancersRequest
-    * @return AttachLoadBalancersResponse
+   * @summary Attaches load balancers to a scaling group. Auto Scaling supports the attachment of load balancers to scaling groups. Load balancers help distribute the access traffic to the instances in scaling groups, which effectively improves the service performance of the scaling groups. You can call the AttachLoadBalancers operation to attach one or more load balancers to your scaling group.
+   *
+   * @description Before you call this operation, make sure that the following requirements are met:
+   * *   The load balancer and the scaling group belong to the same Alibaba Cloud account and region.
+   * *   The load balancer is in the `Running` state.
+   * *   At least one listener is configured for the load balancer, and the health check feature is enabled for the load balancer.
+   * *   If the network type of the load balancer and the scaling group is virtual private cloud (VPC), they use the same VPC.
+   * *   If the network type of the scaling group is VPC, and that of the load balancer is classic network and a backend server of the load balancer uses a VPC, the scaling group and the backend server use the same VPC.
+   * *   The attachment of load balancers ensures that the cumulative number of load balancers attached to the scaling group stays within the predefined maximum limit. For information about the load balancer quota, see [Limits](https://help.aliyun.com/document_detail/25863.html).
+   *
+   * @param request AttachLoadBalancersRequest
+   * @return AttachLoadBalancersResponse
    */
   async attachLoadBalancers(request: AttachLoadBalancersRequest): Promise<AttachLoadBalancersResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.attachLoadBalancersWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Attaches one or more server groups to a scaling group. You can attach the following server groups to a scaling group: Application Load Balancer (ALB) and Network Load Balancer (NLB) server groups.
+   *
+   * @param request AttachServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachServerGroupsResponse
+   */
   async attachServerGroupsWithOptions(request: AttachServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<AttachServerGroupsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -16287,30 +16547,38 @@ export default class Client extends OpenApi {
     return $tea.cast<AttachServerGroupsResponse>(await this.callApi(params, req, runtime), new AttachServerGroupsResponse({}));
   }
 
+  /**
+   * @summary Attaches one or more server groups to a scaling group. You can attach the following server groups to a scaling group: Application Load Balancer (ALB) and Network Load Balancer (NLB) server groups.
+   *
+   * @param request AttachServerGroupsRequest
+   * @return AttachServerGroupsResponse
+   */
   async attachServerGroups(request: AttachServerGroupsRequest): Promise<AttachServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.attachServerGroupsWithOptions(request, runtime);
   }
 
   /**
-    * Before you call this operation to attach a vServer group to your scaling group, take note of the following items:
-    * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The CLB instance and the scaling group must reside in the same region.
-    * *   The CLB instance must be in the Running state.
-    * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
-    * *   The CLB instance and the scaling group must be in the same VPC if their network type is VPC.
-    * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the vServer groups of the CLB instance contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
-    * *   The vServer group that you want to attach to your scaling group must belong to the CLB instance.
-    * *   You can attach only a limited number of vServer groups to a scaling group. For information about the quota on vServer groups, see [Limits](~~25863~~).
-    * When you call this operation, you must specify the following parameters:
-    * *   LoadBalancerId: the ID of the CLB instance.
-    * *   VServerGroupId: the ID of the vServer group.
-    * *   Port: the port number of the vServer group.
-    * If a vServer group is attached to a scaling group by using different ports, Auto Scaling considers that more than one vServer group is attached to the scaling group. If multiple vServer groups with the same group ID and port number are specified in the request parameters, only the first vServer group is used. The other vServer groups are ignored.
-    *
-    * @param request AttachVServerGroupsRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return AttachVServerGroupsResponse
+   * @summary Associates Sever Load Balancer (SLB) vServer groups with a scaling group.
+   *
+   * @description Before you call this operation to attach a vServer group to your scaling group, take note of the following items:
+   * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
+   * *   The CLB instance and the scaling group must reside in the same region.
+   * *   The CLB instance must be in the Running state.
+   * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
+   * *   The CLB instance and the scaling group must be in the same VPC if their network type is VPC.
+   * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the vServer groups of the CLB instance contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
+   * *   The vServer group that you want to attach to your scaling group must belong to the CLB instance.
+   * *   You can attach only a limited number of vServer groups to a scaling group. For information about the quota on vServer groups, see [Limits](https://help.aliyun.com/document_detail/25863.html).
+   * When you call this operation, you must specify the following parameters:
+   * *   LoadBalancerId: the ID of the CLB instance.
+   * *   VServerGroupId: the ID of the vServer group.
+   * *   Port: the port number of the vServer group.
+   * If a vServer group is attached to a scaling group by using different ports, Auto Scaling considers that more than one vServer group is attached to the scaling group. If multiple vServer groups with the same group ID and port number are specified in the request parameters, only the first vServer group is used. The other vServer groups are ignored.
+   *
+   * @param request AttachVServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return AttachVServerGroupsResponse
    */
   async attachVServerGroupsWithOptions(request: AttachVServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<AttachVServerGroupsResponse> {
     Util.validateModel(request);
@@ -16361,29 +16629,38 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation to attach a vServer group to your scaling group, take note of the following items:
-    * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
-    * *   The CLB instance and the scaling group must reside in the same region.
-    * *   The CLB instance must be in the Running state.
-    * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
-    * *   The CLB instance and the scaling group must be in the same VPC if their network type is VPC.
-    * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the vServer groups of the CLB instance contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
-    * *   The vServer group that you want to attach to your scaling group must belong to the CLB instance.
-    * *   You can attach only a limited number of vServer groups to a scaling group. For information about the quota on vServer groups, see [Limits](~~25863~~).
-    * When you call this operation, you must specify the following parameters:
-    * *   LoadBalancerId: the ID of the CLB instance.
-    * *   VServerGroupId: the ID of the vServer group.
-    * *   Port: the port number of the vServer group.
-    * If a vServer group is attached to a scaling group by using different ports, Auto Scaling considers that more than one vServer group is attached to the scaling group. If multiple vServer groups with the same group ID and port number are specified in the request parameters, only the first vServer group is used. The other vServer groups are ignored.
-    *
-    * @param request AttachVServerGroupsRequest
-    * @return AttachVServerGroupsResponse
+   * @summary Associates Sever Load Balancer (SLB) vServer groups with a scaling group.
+   *
+   * @description Before you call this operation to attach a vServer group to your scaling group, take note of the following items:
+   * *   The CLB instance and the scaling group must belong to the same Alibaba Cloud account.
+   * *   The CLB instance and the scaling group must reside in the same region.
+   * *   The CLB instance must be in the Running state.
+   * *   The CLB instance must be configured with at least one listener. Health check is enabled for the CLB instance.
+   * *   The CLB instance and the scaling group must be in the same VPC if their network type is VPC.
+   * *   If the network type of the scaling group is VPC, the network type of the CLB instance is classic network, and the vServer groups of the CLB instance contain instances of the VPC network type, the instances and the scaling group must be in the same VPC.
+   * *   The vServer group that you want to attach to your scaling group must belong to the CLB instance.
+   * *   You can attach only a limited number of vServer groups to a scaling group. For information about the quota on vServer groups, see [Limits](https://help.aliyun.com/document_detail/25863.html).
+   * When you call this operation, you must specify the following parameters:
+   * *   LoadBalancerId: the ID of the CLB instance.
+   * *   VServerGroupId: the ID of the vServer group.
+   * *   Port: the port number of the vServer group.
+   * If a vServer group is attached to a scaling group by using different ports, Auto Scaling considers that more than one vServer group is attached to the scaling group. If multiple vServer groups with the same group ID and port number are specified in the request parameters, only the first vServer group is used. The other vServer groups are ignored.
+   *
+   * @param request AttachVServerGroupsRequest
+   * @return AttachVServerGroupsResponse
    */
   async attachVServerGroups(request: AttachVServerGroupsRequest): Promise<AttachVServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.attachVServerGroupsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Adds a scaling group to a resource group.
+   *
+   * @param request ChangeResourceGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ChangeResourceGroupResponse
+   */
   async changeResourceGroupWithOptions(request: ChangeResourceGroupRequest, runtime: $Util.RuntimeOptions): Promise<ChangeResourceGroupResponse> {
     Util.validateModel(request);
     let query = { };
@@ -16428,17 +16705,25 @@ export default class Client extends OpenApi {
     return $tea.cast<ChangeResourceGroupResponse>(await this.callApi(params, req, runtime), new ChangeResourceGroupResponse({}));
   }
 
+  /**
+   * @summary Adds a scaling group to a resource group.
+   *
+   * @param request ChangeResourceGroupRequest
+   * @return ChangeResourceGroupResponse
+   */
   async changeResourceGroup(request: ChangeResourceGroupRequest): Promise<ChangeResourceGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.changeResourceGroupWithOptions(request, runtime);
   }
 
   /**
-    * If you set the LifecycleActionResult parameter for a lifecycle hook of a scaling group to CONTINUE in the operation, Auto Scaling continues to complete the scaling activity in the scaling group after the lifecycle hook times out. If you set the LifecycleActionResult parameter to ABANDON, Auto Scaling stops the scaling activity in the scaling group after the lifecycle hook times out.
-    *
-    * @param request CompleteLifecycleActionRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CompleteLifecycleActionResponse
+   * @summary Ends the timeout period of a lifecycle hook ahead of schedule. If you have created a lifecycle hook for your scaling group, you can call the CompleteLifecycleAction operation to end the timeout period of the lifecycle hook ahead of schedule based on your business requirements.
+   *
+   * @description When you manually cut short the timeout period of a lifecycle hook, Auto Scaling proceeds with one of the following actions based on the predefined settings: responding to the scaling request, aborting the scaling request, and initiating a rollback process.
+   *
+   * @param request CompleteLifecycleActionRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CompleteLifecycleActionResponse
    */
   async completeLifecycleActionWithOptions(request: CompleteLifecycleActionRequest, runtime: $Util.RuntimeOptions): Promise<CompleteLifecycleActionResponse> {
     Util.validateModel(request);
@@ -16493,16 +16778,31 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * If you set the LifecycleActionResult parameter for a lifecycle hook of a scaling group to CONTINUE in the operation, Auto Scaling continues to complete the scaling activity in the scaling group after the lifecycle hook times out. If you set the LifecycleActionResult parameter to ABANDON, Auto Scaling stops the scaling activity in the scaling group after the lifecycle hook times out.
-    *
-    * @param request CompleteLifecycleActionRequest
-    * @return CompleteLifecycleActionResponse
+   * @summary Ends the timeout period of a lifecycle hook ahead of schedule. If you have created a lifecycle hook for your scaling group, you can call the CompleteLifecycleAction operation to end the timeout period of the lifecycle hook ahead of schedule based on your business requirements.
+   *
+   * @description When you manually cut short the timeout period of a lifecycle hook, Auto Scaling proceeds with one of the following actions based on the predefined settings: responding to the scaling request, aborting the scaling request, and initiating a rollback process.
+   *
+   * @param request CompleteLifecycleActionRequest
+   * @return CompleteLifecycleActionResponse
    */
   async completeLifecycleAction(request: CompleteLifecycleActionRequest): Promise<CompleteLifecycleActionResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.completeLifecycleActionWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Creates an event-triggered task.
+   *
+   * @description *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using custom metrics. For more information, see [Custom monitoring event-triggered tasks](https://help.aliyun.com/document_detail/74861.html).
+   * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
+   *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
+   *     *   For information about the supported metrics when you set the MetricType parameter to system, see [Event-triggered task for system monitoring](https://help.aliyun.com/document_detail/74854.html).
+   * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
+   *
+   * @param request CreateAlarmRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateAlarmResponse
+   */
   async createAlarmWithOptions(request: CreateAlarmRequest, runtime: $Util.RuntimeOptions): Promise<CreateAlarmResponse> {
     Util.validateModel(request);
     let query = { };
@@ -16599,18 +16899,32 @@ export default class Client extends OpenApi {
     return $tea.cast<CreateAlarmResponse>(await this.callApi(params, req, runtime), new CreateAlarmResponse({}));
   }
 
+  /**
+   * @summary Creates an event-triggered task.
+   *
+   * @description *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using custom metrics. For more information, see [Custom monitoring event-triggered tasks](https://help.aliyun.com/document_detail/74861.html).
+   * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
+   *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
+   *     *   For information about the supported metrics when you set the MetricType parameter to system, see [Event-triggered task for system monitoring](https://help.aliyun.com/document_detail/74854.html).
+   * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
+   *
+   * @param request CreateAlarmRequest
+   * @return CreateAlarmResponse
+   */
   async createAlarm(request: CreateAlarmRequest): Promise<CreateAlarmResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.createAlarmWithOptions(request, runtime);
   }
 
   /**
-    * A scaling configuration is a template that is used to create elastic container instances during scale-out activities.
-    * You can specify the Cpu and Memory parameters to determine the range of instance types. If you specify the parameters, Auto Scaling determines the available instance types based on factors such as I/O optimization requirements and zones. Auto Scaling preferentially creates elastic container instances of the instance type that is provided at the lowest price. This scaling mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
-    *
-    * @param request CreateEciScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateEciScalingConfigurationResponse
+   * @summary Creates a scaling configuration of the Elastic Container Instance type. Auto Scaling uses the scaling configuration as a template to create elastic container instances to meet your business requirements during scale-outs.
+   *
+   * @description A scaling configuration is a template that is used to create elastic container instances during scale-out activities.
+   * You can specify the Cpu and Memory parameters to determine the range of instance types. If you specify the parameters, Auto Scaling determines the available instance types based on factors such as I/O optimization requirements and zones. Auto Scaling preferentially creates elastic container instances of the instance type that is provided at the lowest price. This scaling mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
+   *
+   * @param request CreateEciScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateEciScalingConfigurationResponse
    */
   async createEciScalingConfigurationWithOptions(request: CreateEciScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<CreateEciScalingConfigurationResponse> {
     Util.validateModel(request);
@@ -16829,11 +17143,13 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * A scaling configuration is a template that is used to create elastic container instances during scale-out activities.
-    * You can specify the Cpu and Memory parameters to determine the range of instance types. If you specify the parameters, Auto Scaling determines the available instance types based on factors such as I/O optimization requirements and zones. Auto Scaling preferentially creates elastic container instances of the instance type that is provided at the lowest price. This scaling mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
-    *
-    * @param request CreateEciScalingConfigurationRequest
-    * @return CreateEciScalingConfigurationResponse
+   * @summary Creates a scaling configuration of the Elastic Container Instance type. Auto Scaling uses the scaling configuration as a template to create elastic container instances to meet your business requirements during scale-outs.
+   *
+   * @description A scaling configuration is a template that is used to create elastic container instances during scale-out activities.
+   * You can specify the Cpu and Memory parameters to determine the range of instance types. If you specify the parameters, Auto Scaling determines the available instance types based on factors such as I/O optimization requirements and zones. Auto Scaling preferentially creates elastic container instances of the instance type that is provided at the lowest price. This scaling mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
+   *
+   * @param request CreateEciScalingConfigurationRequest
+   * @return CreateEciScalingConfigurationResponse
    */
   async createEciScalingConfiguration(request: CreateEciScalingConfigurationRequest): Promise<CreateEciScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -16841,14 +17157,16 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can create up to six lifecycle hooks for each scaling group. Elastic Compute Service (ECS) instances are not immediately added to or removed from scaling groups that have effective lifecycle hooks during scaling activities. The ECS instances are added to or removed from the scaling groups only after the lifecycle hooks time out. The period of time before the lifecycle hooks time out is specified by the HeartbeatTimeout parameter. Before lifecycle hooks time out, you can initialize the configurations of ECS instances and query data on the ECS instances.
-    * If lifecycle hooks take effect for scale-out activities, the private IP addresses of ECS instances are added to the IP address whitelists of the associated ApsaraDB RDS instances and the ECS instances are added to the backend server groups of the associated Server Load Balancer (SLB) instances only after the lifecycle hooks time out. If lifecycle hooks take effect for scale-in activities, the private IP addresses of ECS instances are removed from the IP address whitelists of the disassociated ApsaraDB RDS instances and the ECS instances are removed from the backend server groups of the disassociated SLB instances only after the lifecycle hooks time out.
-    * You can configure a notification method for a lifecycle hook. When the lifecycle hook takes effect, a notification can be sent by using a Message Service (MNS) topic, an MNS queue, or an Operation Orchestration Service (OOS) template. If you want to configure an OOS template, you must create a RAM role for OOS. For more information, see [Grant RAM permissions to OOS](~~120810~~).
-    * > If your scaling group contains ECS instances and you configure an OOS template to add the private IP addresses of the ECS instances to or remove the private IP addresses of the ECS instances from the IP address whitelists of cloud databases other than ApsaraDB RDS databases, you must manually add the private IP addresses of the ECS instances to the IP address whitelists of the cloud databases.
-    *
-    * @param request CreateLifecycleHookRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateLifecycleHookResponse
+   * @summary Creates one or more lifecycle hooks.
+   *
+   * @description You can create up to six lifecycle hooks for each scaling group. After a lifecycle hook is created for a scaling group, Elastic Compute Service (ECS) instances in the scaling group waits to be added to or removed from the scaling group during scaling activities. You can use the HeartbeatTimeout parameter to specify the timeout period of the lifecycle hook. During the timeout period of a lifecycle hook, you can perform custom operations such as initialize ECS instance configurations and download ECS instance data on the ECS instances for which the lifecycle hook is applied.
+   * During a scale-out activity and the timeout period of a lifecycle hook, the private IP addresses of ECS instances wait to be added to the associated whitelist that manages access to the ApsaraDB RDS instance. The ECS instances also wait to be added to the backend server group of the associated Classic Load Balancer (CLB) instance. After the lifecycle hook times out, the private IP addresses of the ECS instances are added to the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances are also added to the backend server group of the associated CLB instance. During a scale-in activity and the timeout period of a lifecycle hook, the private IP addresses of ECS instances wait to be removed from the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances also wait to be removed from the backend server group of the associated CLB instance. After the lifecycle hook times out, the private IP addresses of the ECS instances are removed from the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances are also removed from the backend server group of the associated CLB instance.
+   * You can configure a notification method for a lifecycle hook. When the lifecycle hook is triggered, a notification can be sent to the specified Message Service (MNS) topic or queue, or an operation can be performed based on the specified Operation Orchestration Service (OOS) template. If you want to configure an OOS template, you must create a Resource Access Management (RAM) role for OOS. For more information, see [Grant RAM permissions to OOS](https://help.aliyun.com/document_detail/120810.html).
+   * > If your scaling group has existing ECS instances and you configured an OOS template that is used to add the private IP addresses of ECS instances to or remove the private IP addresses of ECS instances from the whitelists that manage access to cloud databases that are not ApsaraDB RDS databases, you must manually add the private IP addresses of the ECS instances to or remove the private IP addresses of the ECS instances from the whitelists that manage access to the cloud databases.
+   *
+   * @param request CreateLifecycleHookRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateLifecycleHookResponse
    */
   async createLifecycleHookWithOptions(request: CreateLifecycleHookRequest, runtime: $Util.RuntimeOptions): Promise<CreateLifecycleHookResponse> {
     Util.validateModel(request);
@@ -16911,13 +17229,15 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can create up to six lifecycle hooks for each scaling group. Elastic Compute Service (ECS) instances are not immediately added to or removed from scaling groups that have effective lifecycle hooks during scaling activities. The ECS instances are added to or removed from the scaling groups only after the lifecycle hooks time out. The period of time before the lifecycle hooks time out is specified by the HeartbeatTimeout parameter. Before lifecycle hooks time out, you can initialize the configurations of ECS instances and query data on the ECS instances.
-    * If lifecycle hooks take effect for scale-out activities, the private IP addresses of ECS instances are added to the IP address whitelists of the associated ApsaraDB RDS instances and the ECS instances are added to the backend server groups of the associated Server Load Balancer (SLB) instances only after the lifecycle hooks time out. If lifecycle hooks take effect for scale-in activities, the private IP addresses of ECS instances are removed from the IP address whitelists of the disassociated ApsaraDB RDS instances and the ECS instances are removed from the backend server groups of the disassociated SLB instances only after the lifecycle hooks time out.
-    * You can configure a notification method for a lifecycle hook. When the lifecycle hook takes effect, a notification can be sent by using a Message Service (MNS) topic, an MNS queue, or an Operation Orchestration Service (OOS) template. If you want to configure an OOS template, you must create a RAM role for OOS. For more information, see [Grant RAM permissions to OOS](~~120810~~).
-    * > If your scaling group contains ECS instances and you configure an OOS template to add the private IP addresses of the ECS instances to or remove the private IP addresses of the ECS instances from the IP address whitelists of cloud databases other than ApsaraDB RDS databases, you must manually add the private IP addresses of the ECS instances to the IP address whitelists of the cloud databases.
-    *
-    * @param request CreateLifecycleHookRequest
-    * @return CreateLifecycleHookResponse
+   * @summary Creates one or more lifecycle hooks.
+   *
+   * @description You can create up to six lifecycle hooks for each scaling group. After a lifecycle hook is created for a scaling group, Elastic Compute Service (ECS) instances in the scaling group waits to be added to or removed from the scaling group during scaling activities. You can use the HeartbeatTimeout parameter to specify the timeout period of the lifecycle hook. During the timeout period of a lifecycle hook, you can perform custom operations such as initialize ECS instance configurations and download ECS instance data on the ECS instances for which the lifecycle hook is applied.
+   * During a scale-out activity and the timeout period of a lifecycle hook, the private IP addresses of ECS instances wait to be added to the associated whitelist that manages access to the ApsaraDB RDS instance. The ECS instances also wait to be added to the backend server group of the associated Classic Load Balancer (CLB) instance. After the lifecycle hook times out, the private IP addresses of the ECS instances are added to the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances are also added to the backend server group of the associated CLB instance. During a scale-in activity and the timeout period of a lifecycle hook, the private IP addresses of ECS instances wait to be removed from the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances also wait to be removed from the backend server group of the associated CLB instance. After the lifecycle hook times out, the private IP addresses of the ECS instances are removed from the whitelist that manages access to the associated ApsaraDB RDS instance. The ECS instances are also removed from the backend server group of the associated CLB instance.
+   * You can configure a notification method for a lifecycle hook. When the lifecycle hook is triggered, a notification can be sent to the specified Message Service (MNS) topic or queue, or an operation can be performed based on the specified Operation Orchestration Service (OOS) template. If you want to configure an OOS template, you must create a Resource Access Management (RAM) role for OOS. For more information, see [Grant RAM permissions to OOS](https://help.aliyun.com/document_detail/120810.html).
+   * > If your scaling group has existing ECS instances and you configured an OOS template that is used to add the private IP addresses of ECS instances to or remove the private IP addresses of ECS instances from the whitelists that manage access to cloud databases that are not ApsaraDB RDS databases, you must manually add the private IP addresses of the ECS instances to or remove the private IP addresses of the ECS instances from the whitelists that manage access to the cloud databases.
+   *
+   * @param request CreateLifecycleHookRequest
+   * @return CreateLifecycleHookResponse
    */
   async createLifecycleHook(request: CreateLifecycleHookRequest): Promise<CreateLifecycleHookResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -16925,12 +17245,14 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * ## Description
-    * You can configure CloudMonitor system events, Message Service (MNS) queues, or MNS topics to receive notifications. When a specified type of scaling activity or resource change occurs in a scaling group, Auto Scaling sends notifications by using CloudMonitor or MNS.
-    *
-    * @param request CreateNotificationConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateNotificationConfigurationResponse
+   * @summary Creates a notification rule. You can call the CreateNotificationConfiguration operation to create a notification rule to stay informed about scaling events or resource changes. This helps you learn about the dynamic status of your scaling group in real time and further automates the management of scaling events.
+   *
+   * @description ## Description
+   * You can configure CloudMonitor system events, Message Service (MNS) queues, or MNS topics to receive notifications. When a specified type of scaling activity or resource change occurs in a scaling group, Auto Scaling sends notifications by using CloudMonitor or MNS.
+   *
+   * @param request CreateNotificationConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateNotificationConfigurationResponse
    */
   async createNotificationConfigurationWithOptions(request: CreateNotificationConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<CreateNotificationConfigurationResponse> {
     Util.validateModel(request);
@@ -16977,11 +17299,13 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * ## Description
-    * You can configure CloudMonitor system events, Message Service (MNS) queues, or MNS topics to receive notifications. When a specified type of scaling activity or resource change occurs in a scaling group, Auto Scaling sends notifications by using CloudMonitor or MNS.
-    *
-    * @param request CreateNotificationConfigurationRequest
-    * @return CreateNotificationConfigurationResponse
+   * @summary Creates a notification rule. You can call the CreateNotificationConfiguration operation to create a notification rule to stay informed about scaling events or resource changes. This helps you learn about the dynamic status of your scaling group in real time and further automates the management of scaling events.
+   *
+   * @description ## Description
+   * You can configure CloudMonitor system events, Message Service (MNS) queues, or MNS topics to receive notifications. When a specified type of scaling activity or resource change occurs in a scaling group, Auto Scaling sends notifications by using CloudMonitor or MNS.
+   *
+   * @param request CreateNotificationConfigurationRequest
+   * @return CreateNotificationConfigurationResponse
    */
   async createNotificationConfiguration(request: CreateNotificationConfigurationRequest): Promise<CreateNotificationConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -16989,17 +17313,19 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Auto Scaling automatically creates Elastic Compute Service (ECS) instances based on the specified scaling configuration. ECS instances can be created in the following modes:
-    * *   InstancePatternInfos: intelligent configuration mode. In this mode, you need to only specify the number of vCPUs, memory size, instance family, and maximum price. Auto Scaling selects the instance type that has the lowest price based on the configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode reduces scale-out failures caused by insufficient inventory of instance types.
-    * *   InstanceType: In this mode, you must specify one instance type.
-    * *   InstanceTypes: In this mode, you can specify more than one instance type.
-    * *   InstanceTypeOverrides: In this mode, you can specify multiple instance types and weights for the instance types.
-    * *   Cpu and Memory: In this mode, you must specify the number of vCPUs and the memory size. Auto Scaling determines the range of available instance types based on factors such as I/O optimization requirements and zones. Then, Auto Scaling creates ECS instances by using the lowest-priced instance type. This mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
-    * > You cannot specify InstanceType, InstanceTypes, InstanceTypeOverrides, and Cpu and Memory at the same time. You can specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfo at the same time. If you specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfos at the same time, Auto Scaling preferentially uses the instance types that are specified by InstanceType or InstanceTypes for scale-outs. If the instance types that are specified by InstanceType or InstanceTypes do not have sufficient inventory, Auto Scaling uses the instance types that are specified by InstancePatternInfos for scale-outs.
-    *
-    * @param tmpReq CreateScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateScalingConfigurationResponse
+   * @summary Creates a scaling configuration.
+   *
+   * @description Auto Scaling automatically creates Elastic Compute Service (ECS) instances based on the specified scaling configuration. ECS instances can be created in the following modes:
+   * *   InstancePatternInfos: intelligent configuration mode. In this mode, you need to only specify the number of vCPUs, memory size, instance family, and maximum price. Auto Scaling selects the instance type that has the lowest price based on the configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode reduces scale-out failures caused by insufficient inventory of instance types.
+   * *   InstanceType: In this mode, you must specify one instance type.
+   * *   InstanceTypes: In this mode, you can specify more than one instance type.
+   * *   InstanceTypeOverrides: In this mode, you can specify multiple instance types and weights for the instance types.
+   * *   Cpu and Memory: In this mode, you must specify the number of vCPUs and the memory size. Auto Scaling determines the range of available instance types based on factors such as I/O optimization requirements and zones. Then, Auto Scaling creates ECS instances by using the lowest-priced instance type. This mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
+   * > You cannot specify InstanceType, InstanceTypes, InstanceTypeOverrides, and Cpu and Memory at the same time. You can specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfo at the same time. If you specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfos at the same time, Auto Scaling preferentially uses the instance types that are specified by InstanceType or InstanceTypes for scale-outs. If the instance types that are specified by InstanceType or InstanceTypes do not have sufficient inventory, Auto Scaling uses the instance types that are specified by InstancePatternInfos for scale-outs.
+   *
+   * @param tmpReq CreateScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateScalingConfigurationResponse
    */
   async createScalingConfigurationWithOptions(tmpReq: CreateScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<CreateScalingConfigurationResponse> {
     Util.validateModel(tmpReq);
@@ -17256,16 +17582,18 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Auto Scaling automatically creates Elastic Compute Service (ECS) instances based on the specified scaling configuration. ECS instances can be created in the following modes:
-    * *   InstancePatternInfos: intelligent configuration mode. In this mode, you need to only specify the number of vCPUs, memory size, instance family, and maximum price. Auto Scaling selects the instance type that has the lowest price based on the configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode reduces scale-out failures caused by insufficient inventory of instance types.
-    * *   InstanceType: In this mode, you must specify one instance type.
-    * *   InstanceTypes: In this mode, you can specify more than one instance type.
-    * *   InstanceTypeOverrides: In this mode, you can specify multiple instance types and weights for the instance types.
-    * *   Cpu and Memory: In this mode, you must specify the number of vCPUs and the memory size. Auto Scaling determines the range of available instance types based on factors such as I/O optimization requirements and zones. Then, Auto Scaling creates ECS instances by using the lowest-priced instance type. This mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
-    * > You cannot specify InstanceType, InstanceTypes, InstanceTypeOverrides, and Cpu and Memory at the same time. You can specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfo at the same time. If you specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfos at the same time, Auto Scaling preferentially uses the instance types that are specified by InstanceType or InstanceTypes for scale-outs. If the instance types that are specified by InstanceType or InstanceTypes do not have sufficient inventory, Auto Scaling uses the instance types that are specified by InstancePatternInfos for scale-outs.
-    *
-    * @param request CreateScalingConfigurationRequest
-    * @return CreateScalingConfigurationResponse
+   * @summary Creates a scaling configuration.
+   *
+   * @description Auto Scaling automatically creates Elastic Compute Service (ECS) instances based on the specified scaling configuration. ECS instances can be created in the following modes:
+   * *   InstancePatternInfos: intelligent configuration mode. In this mode, you need to only specify the number of vCPUs, memory size, instance family, and maximum price. Auto Scaling selects the instance type that has the lowest price based on the configurations to create ECS instances. This mode is available only for scaling groups that reside in virtual private clouds (VPCs). This mode reduces scale-out failures caused by insufficient inventory of instance types.
+   * *   InstanceType: In this mode, you must specify one instance type.
+   * *   InstanceTypes: In this mode, you can specify more than one instance type.
+   * *   InstanceTypeOverrides: In this mode, you can specify multiple instance types and weights for the instance types.
+   * *   Cpu and Memory: In this mode, you must specify the number of vCPUs and the memory size. Auto Scaling determines the range of available instance types based on factors such as I/O optimization requirements and zones. Then, Auto Scaling creates ECS instances by using the lowest-priced instance type. This mode is available only if Scaling Policy is set to Cost Optimization Policy and no instance type is specified in the scaling configuration.
+   * > You cannot specify InstanceType, InstanceTypes, InstanceTypeOverrides, and Cpu and Memory at the same time. You can specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfo at the same time. If you specify InstanceType and InstancePatternInfos or specify InstanceTypes and InstancePatternInfos at the same time, Auto Scaling preferentially uses the instance types that are specified by InstanceType or InstanceTypes for scale-outs. If the instance types that are specified by InstanceType or InstanceTypes do not have sufficient inventory, Auto Scaling uses the instance types that are specified by InstancePatternInfos for scale-outs.
+   *
+   * @param request CreateScalingConfigurationRequest
+   * @return CreateScalingConfigurationResponse
    */
   async createScalingConfiguration(request: CreateScalingConfigurationRequest): Promise<CreateScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -17273,32 +17601,34 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * A scaling group is a group of Elastic Compute Service (ECS) instances that can be used in similar business scenarios.
-    * You can create only a limited number of scaling groups in a region. Go to Quota Center to check the quota of the scaling groups.
-    * A scaling group does not immediately take effect after you create the scaling group. You must call the EnableScalingGroup operation to enable the scaling group. After you enable the scaling group, Auto Scaling can execute scaling rules to trigger scaling activities in the scaling group.
-    * The Classic Load Balancer (CLB) instances and ApsaraDB RDS instances that you want to associate with a scaling group must reside in the same region as the scaling group. CLB instances are formerly known as Server Load Balancer (SLB) instances. For more information, see the [Regions and zones](~~40654~~) topic.
-    * If you associate a CLB instance when you create a scaling group, Auto Scaling automatically adds ECS instances in the scaling group to the backend server group of the associated CLB instance. You can specify a server group to which ECS instances can be added. You can add ECS instances to the following types of server groups:
-    * *   Default server group: a group of ECS instances that are used to receive requests. If you do not specify a vServer group or a primary/secondary server group for a listener, requests are forwarded to the ECS instances in the default server group.
-    * *   vServer group: If you want to forward requests to backend servers that are not in the default server group or configure domain name-based or URL-based forwarding rules, you can use vServer groups.
-    * > If you specify the default server group and multiple vServer groups at the same time, ECS instances are added to all specified server groups.
-    * The default weight of an ECS instance that is added as a backend server of a CLB instance is 50. The CLB instance that you want to associate with your scaling group must meet the following requirements:
-    * *   The CLB instance must be in the Active state. You can call the DescribeLoadBalancers operation to query the state of the CLB instance.
-    * *   The health check feature must be enabled on all listener ports that are configured for the CLB instance. Otherwise, the scaling group fails to be created.
-    * If you associate an Application Load Balancer (ALB) server group with a scaling group, Auto Scaling automatically adds ECS instances that are in the scaling group to the ALB server group to process requests distributed by the ALB instance to which the ALB server group belongs. You can specify multiple ALB server groups. The server groups must reside in the same virtual private cloud (VPC) as the scaling group. For more information, see the "AttachAlbServerGroups" topic.
-    * If you associate an ApsaraDB RDS instance with a scaling group, Auto Scaling automatically adds the private IP addresses of the ECS instances in the scaling group to the IP address whitelist of the ApsaraDB RDS instance. The ApsaraDB RDS instance that you want to associate with your scaling group must meet the following requirements:
-    * *   The ApsaraDB RDS instance must be in the Running state. You can call the DescribeDBInstances operation to query the state of the ApsaraDB RDS instance.
-    * *   The number of IP addresses in the IP address whitelist of the ApsaraDB RDS instance cannot exceed the upper limit. For more information, see the "Configure whitelists" topic.
-    * If you set the MultiAZPolicy parameter of the scaling group to COST_OPTIMIZED, take note of the following items:
-    * *   You can use the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, and SpotInstancePools parameters to specify the instance allocation method based on the cost optimization policy. This instance allocation method is prioritized during scaling.
-    * *   If you do not specify the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, or SpotInstancePools parameter, the instance types that are provided at the lowest price are used to create instances based on the cost optimization policy.
-    * If you set the `Tags.Propagate` parameter of the scaling group to true, the following rules apply:
-    * *   Tags that you add to the scaling group cannot be propagated to existing instances in the scaling group. Tags that you add to the scaling group are propagated to only new instances.
-    * *   If you specify instance tags in the scaling configuration that is used to create instances and propagate the tags that you add to the scaling group to the instances, all tags exist at the same time.
-    * *   If the tag key that you specify in a scaling configuration and the tag key that you add to the scaling group of the scaling configuration are the same, the tag value that you specify in the scaling configuration is preferentially used.
-    *
-    * @param request CreateScalingGroupRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateScalingGroupResponse
+   * @summary Creates a scaling group.
+   *
+   * @description A scaling group is a group of Elastic Compute Service (ECS) instances that can be used in similar business scenarios.
+   * You can create only a limited number of scaling groups in a region. Go to Quota Center to check the quota of the scaling groups.
+   * A scaling group does not immediately take effect after you create the scaling group. You must call the EnableScalingGroup operation to enable the scaling group. After you enable the scaling group, Auto Scaling can execute scaling rules to trigger scaling activities in the scaling group.
+   * The Classic Load Balancer (CLB) instances and ApsaraDB RDS instances that you want to associate with a scaling group must reside in the same region as the scaling group. CLB instances are formerly known as Server Load Balancer (SLB) instances. For more information, see the [Regions and zones](https://help.aliyun.com/document_detail/40654.html) topic.
+   * If you associate a CLB instance when you create a scaling group, Auto Scaling automatically adds ECS instances in the scaling group to the backend server group of the associated CLB instance. You can specify a server group to which ECS instances can be added. You can add ECS instances to the following types of server groups:
+   * *   Default server group: a group of ECS instances that are used to receive requests. If you do not specify a vServer group or a primary/secondary server group for a listener, requests are forwarded to the ECS instances in the default server group.
+   * *   vServer group: If you want to forward requests to backend servers that are not in the default server group or configure domain name-based or URL-based forwarding rules, you can use vServer groups.
+   * > If you specify the default server group and multiple vServer groups at the same time, ECS instances are added to all specified server groups.
+   * The default weight of an ECS instance that is added as a backend server of a CLB instance is 50. The CLB instance that you want to associate with your scaling group must meet the following requirements:
+   * *   The CLB instance must be in the Active state. You can call the DescribeLoadBalancers operation to query the state of the CLB instance.
+   * *   The health check feature must be enabled on all listener ports that are configured for the CLB instance. Otherwise, the scaling group fails to be created.
+   * If you associate an Application Load Balancer (ALB) server group with a scaling group, Auto Scaling automatically adds ECS instances that are in the scaling group to the ALB server group to process requests distributed by the ALB instance to which the ALB server group belongs. You can specify multiple ALB server groups. The server groups must reside in the same virtual private cloud (VPC) as the scaling group. For more information, see the "AttachAlbServerGroups" topic.
+   * If you associate an ApsaraDB RDS instance with a scaling group, Auto Scaling automatically adds the private IP addresses of the ECS instances in the scaling group to the IP address whitelist of the ApsaraDB RDS instance. The ApsaraDB RDS instance that you want to associate with your scaling group must meet the following requirements:
+   * *   The ApsaraDB RDS instance must be in the Running state. You can call the DescribeDBInstances operation to query the state of the ApsaraDB RDS instance.
+   * *   The number of IP addresses in the IP address whitelist of the ApsaraDB RDS instance cannot exceed the upper limit. For more information, see the "Configure whitelists" topic.
+   * If you set the MultiAZPolicy parameter of the scaling group to COST_OPTIMIZED, take note of the following items:
+   * *   You can use the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, and SpotInstancePools parameters to specify the instance allocation method based on the cost optimization policy. This instance allocation method is prioritized during scaling.
+   * *   If you do not specify the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, or SpotInstancePools parameter, the instance types that are provided at the lowest price are used to create instances based on the cost optimization policy.
+   * If you set the `Tags.Propagate` parameter of the scaling group to true, the following rules apply:
+   * *   Tags that you add to the scaling group cannot be propagated to existing instances in the scaling group. Tags that you add to the scaling group are propagated to only new instances.
+   * *   If you specify instance tags in the scaling configuration that is used to create instances and propagate the tags that you add to the scaling group to the instances, all tags exist at the same time.
+   * *   If the tag key that you specify in a scaling configuration and the tag key that you add to the scaling group of the scaling configuration are the same, the tag value that you specify in the scaling configuration is preferentially used.
+   *
+   * @param request CreateScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateScalingGroupResponse
    */
   async createScalingGroupWithOptions(request: CreateScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<CreateScalingGroupResponse> {
     Util.validateModel(request);
@@ -17501,31 +17831,33 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * A scaling group is a group of Elastic Compute Service (ECS) instances that can be used in similar business scenarios.
-    * You can create only a limited number of scaling groups in a region. Go to Quota Center to check the quota of the scaling groups.
-    * A scaling group does not immediately take effect after you create the scaling group. You must call the EnableScalingGroup operation to enable the scaling group. After you enable the scaling group, Auto Scaling can execute scaling rules to trigger scaling activities in the scaling group.
-    * The Classic Load Balancer (CLB) instances and ApsaraDB RDS instances that you want to associate with a scaling group must reside in the same region as the scaling group. CLB instances are formerly known as Server Load Balancer (SLB) instances. For more information, see the [Regions and zones](~~40654~~) topic.
-    * If you associate a CLB instance when you create a scaling group, Auto Scaling automatically adds ECS instances in the scaling group to the backend server group of the associated CLB instance. You can specify a server group to which ECS instances can be added. You can add ECS instances to the following types of server groups:
-    * *   Default server group: a group of ECS instances that are used to receive requests. If you do not specify a vServer group or a primary/secondary server group for a listener, requests are forwarded to the ECS instances in the default server group.
-    * *   vServer group: If you want to forward requests to backend servers that are not in the default server group or configure domain name-based or URL-based forwarding rules, you can use vServer groups.
-    * > If you specify the default server group and multiple vServer groups at the same time, ECS instances are added to all specified server groups.
-    * The default weight of an ECS instance that is added as a backend server of a CLB instance is 50. The CLB instance that you want to associate with your scaling group must meet the following requirements:
-    * *   The CLB instance must be in the Active state. You can call the DescribeLoadBalancers operation to query the state of the CLB instance.
-    * *   The health check feature must be enabled on all listener ports that are configured for the CLB instance. Otherwise, the scaling group fails to be created.
-    * If you associate an Application Load Balancer (ALB) server group with a scaling group, Auto Scaling automatically adds ECS instances that are in the scaling group to the ALB server group to process requests distributed by the ALB instance to which the ALB server group belongs. You can specify multiple ALB server groups. The server groups must reside in the same virtual private cloud (VPC) as the scaling group. For more information, see the "AttachAlbServerGroups" topic.
-    * If you associate an ApsaraDB RDS instance with a scaling group, Auto Scaling automatically adds the private IP addresses of the ECS instances in the scaling group to the IP address whitelist of the ApsaraDB RDS instance. The ApsaraDB RDS instance that you want to associate with your scaling group must meet the following requirements:
-    * *   The ApsaraDB RDS instance must be in the Running state. You can call the DescribeDBInstances operation to query the state of the ApsaraDB RDS instance.
-    * *   The number of IP addresses in the IP address whitelist of the ApsaraDB RDS instance cannot exceed the upper limit. For more information, see the "Configure whitelists" topic.
-    * If you set the MultiAZPolicy parameter of the scaling group to COST_OPTIMIZED, take note of the following items:
-    * *   You can use the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, and SpotInstancePools parameters to specify the instance allocation method based on the cost optimization policy. This instance allocation method is prioritized during scaling.
-    * *   If you do not specify the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, or SpotInstancePools parameter, the instance types that are provided at the lowest price are used to create instances based on the cost optimization policy.
-    * If you set the `Tags.Propagate` parameter of the scaling group to true, the following rules apply:
-    * *   Tags that you add to the scaling group cannot be propagated to existing instances in the scaling group. Tags that you add to the scaling group are propagated to only new instances.
-    * *   If you specify instance tags in the scaling configuration that is used to create instances and propagate the tags that you add to the scaling group to the instances, all tags exist at the same time.
-    * *   If the tag key that you specify in a scaling configuration and the tag key that you add to the scaling group of the scaling configuration are the same, the tag value that you specify in the scaling configuration is preferentially used.
-    *
-    * @param request CreateScalingGroupRequest
-    * @return CreateScalingGroupResponse
+   * @summary Creates a scaling group.
+   *
+   * @description A scaling group is a group of Elastic Compute Service (ECS) instances that can be used in similar business scenarios.
+   * You can create only a limited number of scaling groups in a region. Go to Quota Center to check the quota of the scaling groups.
+   * A scaling group does not immediately take effect after you create the scaling group. You must call the EnableScalingGroup operation to enable the scaling group. After you enable the scaling group, Auto Scaling can execute scaling rules to trigger scaling activities in the scaling group.
+   * The Classic Load Balancer (CLB) instances and ApsaraDB RDS instances that you want to associate with a scaling group must reside in the same region as the scaling group. CLB instances are formerly known as Server Load Balancer (SLB) instances. For more information, see the [Regions and zones](https://help.aliyun.com/document_detail/40654.html) topic.
+   * If you associate a CLB instance when you create a scaling group, Auto Scaling automatically adds ECS instances in the scaling group to the backend server group of the associated CLB instance. You can specify a server group to which ECS instances can be added. You can add ECS instances to the following types of server groups:
+   * *   Default server group: a group of ECS instances that are used to receive requests. If you do not specify a vServer group or a primary/secondary server group for a listener, requests are forwarded to the ECS instances in the default server group.
+   * *   vServer group: If you want to forward requests to backend servers that are not in the default server group or configure domain name-based or URL-based forwarding rules, you can use vServer groups.
+   * > If you specify the default server group and multiple vServer groups at the same time, ECS instances are added to all specified server groups.
+   * The default weight of an ECS instance that is added as a backend server of a CLB instance is 50. The CLB instance that you want to associate with your scaling group must meet the following requirements:
+   * *   The CLB instance must be in the Active state. You can call the DescribeLoadBalancers operation to query the state of the CLB instance.
+   * *   The health check feature must be enabled on all listener ports that are configured for the CLB instance. Otherwise, the scaling group fails to be created.
+   * If you associate an Application Load Balancer (ALB) server group with a scaling group, Auto Scaling automatically adds ECS instances that are in the scaling group to the ALB server group to process requests distributed by the ALB instance to which the ALB server group belongs. You can specify multiple ALB server groups. The server groups must reside in the same virtual private cloud (VPC) as the scaling group. For more information, see the "AttachAlbServerGroups" topic.
+   * If you associate an ApsaraDB RDS instance with a scaling group, Auto Scaling automatically adds the private IP addresses of the ECS instances in the scaling group to the IP address whitelist of the ApsaraDB RDS instance. The ApsaraDB RDS instance that you want to associate with your scaling group must meet the following requirements:
+   * *   The ApsaraDB RDS instance must be in the Running state. You can call the DescribeDBInstances operation to query the state of the ApsaraDB RDS instance.
+   * *   The number of IP addresses in the IP address whitelist of the ApsaraDB RDS instance cannot exceed the upper limit. For more information, see the "Configure whitelists" topic.
+   * If you set the MultiAZPolicy parameter of the scaling group to COST_OPTIMIZED, take note of the following items:
+   * *   You can use the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, and SpotInstancePools parameters to specify the instance allocation method based on the cost optimization policy. This instance allocation method is prioritized during scaling.
+   * *   If you do not specify the OnDemandBaseCapacity, OnDemandPercentageAboveBaseCapacity, or SpotInstancePools parameter, the instance types that are provided at the lowest price are used to create instances based on the cost optimization policy.
+   * If you set the `Tags.Propagate` parameter of the scaling group to true, the following rules apply:
+   * *   Tags that you add to the scaling group cannot be propagated to existing instances in the scaling group. Tags that you add to the scaling group are propagated to only new instances.
+   * *   If you specify instance tags in the scaling configuration that is used to create instances and propagate the tags that you add to the scaling group to the instances, all tags exist at the same time.
+   * *   If the tag key that you specify in a scaling configuration and the tag key that you add to the scaling group of the scaling configuration are the same, the tag value that you specify in the scaling configuration is preferentially used.
+   *
+   * @param request CreateScalingGroupRequest
+   * @return CreateScalingGroupResponse
    */
   async createScalingGroup(request: CreateScalingGroupRequest): Promise<CreateScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -17533,23 +17865,25 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * ## Description
-    * A scaling rule defines a specific scaling activity, such as adding or removing N instances. If the number of Elastic Compute Service (ECS) instances in a scaling group is less than the minimum number allowed or greater than the maximum number allowed after a scaling rule is executed, Auto Scaling adjusts the number of ECS instances that you want to add or remove. This way, the number of ECS instances can be maintained within the valid range after the scaling rule is executed. The number of ECS instances that is specified in the scaling rule remains unchanged. Example:
-    * *   If your scaling group contains two ECS instances and allows up to three ECS instances, only one ECS instance is added to your scaling group after you execute a scale-out rule in which three ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
-    * *   If your scaling group contains three ECS instances and requires at least two ECS instances, only one ECS instance is removed from your scaling group after you execute a scale-in rule in which five ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
-    * Before you call this operation, take note of the following items:
-    * *   If you set the AdjustmentType parameter to TotalCapacity, the number of ECS instances in the scaling group is adjusted to the specified value. The value of the AdjustmentValue parameter must be greater than or equal to 0.
-    * *   If you set the AdjustmentType parameter to QuantityChangeInCapacity or PercentChangeInCapacity, a positive value of AdjustmentValue specifies the number of ECS instances that are added to the scaling group, and a negative value of AdjustmentValue specifies the number of ECS instances that are removed from the scaling group.
-    * *   If you set the AdjustmentType parameter to PercentChangeInCapacity, Auto Scaling uses the following formula to calculate a value, and then rounds the value to the nearest integer to obtain the number of ECS instances that need to be scaled: Value of TotalCapacity × Value of AdjustmentValue/100.
-    * *   If the cooldown time is specified in a scaling rule, the specified time applies to the scaling group after the rule is executed. Otherwise, the value of the DefaultCooldown parameter of the scaling group applies to the scaling group.
-    * *   You can create only a limited number of scaling rules for a scaling group. For more information, see the "Limits" topic.
-    * *   The unique identifier (ScalingRuleAri) of a scaling rule can be used by the following operations:
-    *     *   ExecuteScalingRule: You can call this operation to manually execute a specific scaling rule by setting the ScalingRuleAri parameter to the unique identifier of the scaling rule.
-    *     *   CreateScheduledTask: You can call this operation to create a scheduled task for a specific scaling rule by setting the ScheduledAction parameter to the unique identifier of the scaling rule.
-    *
-    * @param request CreateScalingRuleRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateScalingRuleResponse
+   * @summary Creates a scaling rule.
+   *
+   * @description ## Description
+   * A scaling rule defines a specific scaling activity, such as adding or removing N instances. If the number of Elastic Compute Service (ECS) instances in a scaling group is less than the minimum number allowed or greater than the maximum number allowed after a scaling rule is executed, Auto Scaling adjusts the number of ECS instances that you want to add or remove. This way, the number of ECS instances can be maintained within the valid range after the scaling rule is executed. The number of ECS instances that is specified in the scaling rule remains unchanged. Example:
+   * *   If your scaling group contains two ECS instances and allows up to three ECS instances, only one ECS instance is added to your scaling group after you execute a scale-out rule in which three ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
+   * *   If your scaling group contains three ECS instances and requires at least two ECS instances, only one ECS instance is removed from your scaling group after you execute a scale-in rule in which five ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
+   * Before you call this operation, take note of the following items:
+   * *   If you set the AdjustmentType parameter to TotalCapacity, the number of ECS instances in the scaling group is adjusted to the specified value. The value of the AdjustmentValue parameter must be greater than or equal to 0.
+   * *   If you set the AdjustmentType parameter to QuantityChangeInCapacity or PercentChangeInCapacity, a positive value of AdjustmentValue specifies the number of ECS instances that are added to the scaling group, and a negative value of AdjustmentValue specifies the number of ECS instances that are removed from the scaling group.
+   * *   If you set the AdjustmentType parameter to PercentChangeInCapacity, Auto Scaling uses the following formula to calculate a value, and then rounds the value to the nearest integer to obtain the number of ECS instances that need to be scaled: Value of TotalCapacity × Value of AdjustmentValue/100.
+   * *   If the cooldown time is specified in a scaling rule, the specified time applies to the scaling group after the rule is executed. Otherwise, the value of the DefaultCooldown parameter of the scaling group applies to the scaling group.
+   * *   You can create only a limited number of scaling rules for a scaling group. For more information, see the "Limits" topic.
+   * *   The unique identifier (ScalingRuleAri) of a scaling rule can be used by the following operations:
+   *     *   ExecuteScalingRule: You can call this operation to manually execute a specific scaling rule by setting the ScalingRuleAri parameter to the unique identifier of the scaling rule.
+   *     *   CreateScheduledTask: You can call this operation to create a scheduled task for a specific scaling rule by setting the ScheduledAction parameter to the unique identifier of the scaling rule.
+   *
+   * @param request CreateScalingRuleRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateScalingRuleResponse
    */
   async createScalingRuleWithOptions(request: CreateScalingRuleRequest, runtime: $Util.RuntimeOptions): Promise<CreateScalingRuleResponse> {
     Util.validateModel(request);
@@ -17668,22 +18002,24 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * ## Description
-    * A scaling rule defines a specific scaling activity, such as adding or removing N instances. If the number of Elastic Compute Service (ECS) instances in a scaling group is less than the minimum number allowed or greater than the maximum number allowed after a scaling rule is executed, Auto Scaling adjusts the number of ECS instances that you want to add or remove. This way, the number of ECS instances can be maintained within the valid range after the scaling rule is executed. The number of ECS instances that is specified in the scaling rule remains unchanged. Example:
-    * *   If your scaling group contains two ECS instances and allows up to three ECS instances, only one ECS instance is added to your scaling group after you execute a scale-out rule in which three ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
-    * *   If your scaling group contains three ECS instances and requires at least two ECS instances, only one ECS instance is removed from your scaling group after you execute a scale-in rule in which five ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
-    * Before you call this operation, take note of the following items:
-    * *   If you set the AdjustmentType parameter to TotalCapacity, the number of ECS instances in the scaling group is adjusted to the specified value. The value of the AdjustmentValue parameter must be greater than or equal to 0.
-    * *   If you set the AdjustmentType parameter to QuantityChangeInCapacity or PercentChangeInCapacity, a positive value of AdjustmentValue specifies the number of ECS instances that are added to the scaling group, and a negative value of AdjustmentValue specifies the number of ECS instances that are removed from the scaling group.
-    * *   If you set the AdjustmentType parameter to PercentChangeInCapacity, Auto Scaling uses the following formula to calculate a value, and then rounds the value to the nearest integer to obtain the number of ECS instances that need to be scaled: Value of TotalCapacity × Value of AdjustmentValue/100.
-    * *   If the cooldown time is specified in a scaling rule, the specified time applies to the scaling group after the rule is executed. Otherwise, the value of the DefaultCooldown parameter of the scaling group applies to the scaling group.
-    * *   You can create only a limited number of scaling rules for a scaling group. For more information, see the "Limits" topic.
-    * *   The unique identifier (ScalingRuleAri) of a scaling rule can be used by the following operations:
-    *     *   ExecuteScalingRule: You can call this operation to manually execute a specific scaling rule by setting the ScalingRuleAri parameter to the unique identifier of the scaling rule.
-    *     *   CreateScheduledTask: You can call this operation to create a scheduled task for a specific scaling rule by setting the ScheduledAction parameter to the unique identifier of the scaling rule.
-    *
-    * @param request CreateScalingRuleRequest
-    * @return CreateScalingRuleResponse
+   * @summary Creates a scaling rule.
+   *
+   * @description ## Description
+   * A scaling rule defines a specific scaling activity, such as adding or removing N instances. If the number of Elastic Compute Service (ECS) instances in a scaling group is less than the minimum number allowed or greater than the maximum number allowed after a scaling rule is executed, Auto Scaling adjusts the number of ECS instances that you want to add or remove. This way, the number of ECS instances can be maintained within the valid range after the scaling rule is executed. The number of ECS instances that is specified in the scaling rule remains unchanged. Example:
+   * *   If your scaling group contains two ECS instances and allows up to three ECS instances, only one ECS instance is added to your scaling group after you execute a scale-out rule in which three ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
+   * *   If your scaling group contains three ECS instances and requires at least two ECS instances, only one ECS instance is removed from your scaling group after you execute a scale-in rule in which five ECS instances are specified. The number of ECS instances that is specified in the scaling rule remains unchanged.
+   * Before you call this operation, take note of the following items:
+   * *   If you set the AdjustmentType parameter to TotalCapacity, the number of ECS instances in the scaling group is adjusted to the specified value. The value of the AdjustmentValue parameter must be greater than or equal to 0.
+   * *   If you set the AdjustmentType parameter to QuantityChangeInCapacity or PercentChangeInCapacity, a positive value of AdjustmentValue specifies the number of ECS instances that are added to the scaling group, and a negative value of AdjustmentValue specifies the number of ECS instances that are removed from the scaling group.
+   * *   If you set the AdjustmentType parameter to PercentChangeInCapacity, Auto Scaling uses the following formula to calculate a value, and then rounds the value to the nearest integer to obtain the number of ECS instances that need to be scaled: Value of TotalCapacity × Value of AdjustmentValue/100.
+   * *   If the cooldown time is specified in a scaling rule, the specified time applies to the scaling group after the rule is executed. Otherwise, the value of the DefaultCooldown parameter of the scaling group applies to the scaling group.
+   * *   You can create only a limited number of scaling rules for a scaling group. For more information, see the "Limits" topic.
+   * *   The unique identifier (ScalingRuleAri) of a scaling rule can be used by the following operations:
+   *     *   ExecuteScalingRule: You can call this operation to manually execute a specific scaling rule by setting the ScalingRuleAri parameter to the unique identifier of the scaling rule.
+   *     *   CreateScheduledTask: You can call this operation to create a scheduled task for a specific scaling rule by setting the ScheduledAction parameter to the unique identifier of the scaling rule.
+   *
+   * @param request CreateScalingRuleRequest
+   * @return CreateScalingRuleResponse
    */
   async createScalingRule(request: CreateScalingRuleRequest): Promise<CreateScalingRuleResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -17691,16 +18027,18 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   If a scheduled task fails to trigger a scaling activity due to an ongoing scaling activity in a scaling group or because the scaling group is disabled, the scheduled task is automatically retried during the period that is specified by the LaunchExpirationTime parameter. If the scheduled task still fails to trigger a scaling activity after the period ends, the task is automatically skipped.
-    * *   If multiple tasks are scheduled at similar points in time to trigger scaling activities in the same scaling group, the earliest task triggers the scaling activity first. Other tasks trigger scaling activities within their launch expiration time. Only one scaling activity can be triggered in a scaling group at a time.`` If the previous scaling activity is complete and another scheduled task attempts to trigger a scaling activity, Auto Scaling executes the scaling rule that is specified in the scheduled task and then triggers a scaling activity.``
-    * *   A scheduled task supports the following scaling methods:
-    *     *   `ScheduledAction`: Specify an existing scaling rule that you want Auto Scaling to execute when the scheduled task is triggered.
-    *     *   `ScalingGroupId`: Specify the minimum number, maximum number, or expected number of instances for the scaling group for which you created the scheduled task.
-    * > You cannot specify the `ScheduledAction` and ScalingGroupId parameters at the same time.
-    *
-    * @param request CreateScheduledTaskRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return CreateScheduledTaskResponse
+   * @summary Creates a scheduled task. A scheduled task is a type of scaling task that enables automatic execution of a specific scaling rule at a specified point in time. You can call the CreateScheduledTask operation to create a scheduled task to implement automatic scaling of computing resources. This ensures your business continuity and minimizes resource costs.
+   *
+   * @description *   If a scheduled task fails to trigger a scaling activity due to an ongoing scaling activity in a scaling group or because the scaling group is disabled, the scheduled task is automatically retried during the period that is specified by the LaunchExpirationTime parameter. If the scheduled task still fails to trigger a scaling activity after the period ends, the task is automatically skipped.
+   * *   If multiple tasks are scheduled at similar points in time to trigger scaling activities in the same scaling group, the earliest task triggers the scaling activity first. Other tasks trigger scaling activities within their launch expiration time. Only one scaling activity can be triggered in a scaling group at a time.`` If the previous scaling activity is complete and another scheduled task attempts to trigger a scaling activity, Auto Scaling executes the scaling rule that is specified in the scheduled task and then triggers a scaling activity.``
+   * *   A scheduled task supports the following scaling methods:
+   *     *   `ScheduledAction`: Specify an existing scaling rule that you want Auto Scaling to execute when the scheduled task is triggered.
+   *     *   `ScalingGroupId`: Specify the minimum number, maximum number, or expected number of instances for the scaling group for which you created the scheduled task.
+   * > You cannot specify the `ScheduledAction` and ScalingGroupId parameters at the same time.
+   *
+   * @param request CreateScheduledTaskRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return CreateScheduledTaskResponse
    */
   async createScheduledTaskWithOptions(request: CreateScheduledTaskRequest, runtime: $Util.RuntimeOptions): Promise<CreateScheduledTaskResponse> {
     Util.validateModel(request);
@@ -17791,21 +18129,32 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   If a scheduled task fails to trigger a scaling activity due to an ongoing scaling activity in a scaling group or because the scaling group is disabled, the scheduled task is automatically retried during the period that is specified by the LaunchExpirationTime parameter. If the scheduled task still fails to trigger a scaling activity after the period ends, the task is automatically skipped.
-    * *   If multiple tasks are scheduled at similar points in time to trigger scaling activities in the same scaling group, the earliest task triggers the scaling activity first. Other tasks trigger scaling activities within their launch expiration time. Only one scaling activity can be triggered in a scaling group at a time.`` If the previous scaling activity is complete and another scheduled task attempts to trigger a scaling activity, Auto Scaling executes the scaling rule that is specified in the scheduled task and then triggers a scaling activity.``
-    * *   A scheduled task supports the following scaling methods:
-    *     *   `ScheduledAction`: Specify an existing scaling rule that you want Auto Scaling to execute when the scheduled task is triggered.
-    *     *   `ScalingGroupId`: Specify the minimum number, maximum number, or expected number of instances for the scaling group for which you created the scheduled task.
-    * > You cannot specify the `ScheduledAction` and ScalingGroupId parameters at the same time.
-    *
-    * @param request CreateScheduledTaskRequest
-    * @return CreateScheduledTaskResponse
+   * @summary Creates a scheduled task. A scheduled task is a type of scaling task that enables automatic execution of a specific scaling rule at a specified point in time. You can call the CreateScheduledTask operation to create a scheduled task to implement automatic scaling of computing resources. This ensures your business continuity and minimizes resource costs.
+   *
+   * @description *   If a scheduled task fails to trigger a scaling activity due to an ongoing scaling activity in a scaling group or because the scaling group is disabled, the scheduled task is automatically retried during the period that is specified by the LaunchExpirationTime parameter. If the scheduled task still fails to trigger a scaling activity after the period ends, the task is automatically skipped.
+   * *   If multiple tasks are scheduled at similar points in time to trigger scaling activities in the same scaling group, the earliest task triggers the scaling activity first. Other tasks trigger scaling activities within their launch expiration time. Only one scaling activity can be triggered in a scaling group at a time.`` If the previous scaling activity is complete and another scheduled task attempts to trigger a scaling activity, Auto Scaling executes the scaling rule that is specified in the scheduled task and then triggers a scaling activity.``
+   * *   A scheduled task supports the following scaling methods:
+   *     *   `ScheduledAction`: Specify an existing scaling rule that you want Auto Scaling to execute when the scheduled task is triggered.
+   *     *   `ScalingGroupId`: Specify the minimum number, maximum number, or expected number of instances for the scaling group for which you created the scheduled task.
+   * > You cannot specify the `ScheduledAction` and ScalingGroupId parameters at the same time.
+   *
+   * @param request CreateScheduledTaskRequest
+   * @return CreateScheduledTaskResponse
    */
   async createScheduledTask(request: CreateScheduledTaskRequest): Promise<CreateScheduledTaskResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.createScheduledTaskWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deactivates a scaling configuration.
+   *
+   * @description *   You can call this operation to deactivate a scaling configuration only in a disabled scaling group.
+   *
+   * @param request DeactivateScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeactivateScalingConfigurationResponse
+   */
   async deactivateScalingConfigurationWithOptions(request: DeactivateScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<DeactivateScalingConfigurationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -17842,11 +18191,26 @@ export default class Client extends OpenApi {
     return $tea.cast<DeactivateScalingConfigurationResponse>(await this.callApi(params, req, runtime), new DeactivateScalingConfigurationResponse({}));
   }
 
+  /**
+   * @summary Deactivates a scaling configuration.
+   *
+   * @description *   You can call this operation to deactivate a scaling configuration only in a disabled scaling group.
+   *
+   * @param request DeactivateScalingConfigurationRequest
+   * @return DeactivateScalingConfigurationResponse
+   */
   async deactivateScalingConfiguration(request: DeactivateScalingConfigurationRequest): Promise<DeactivateScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deactivateScalingConfigurationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you no longer need an event-triggered task, you can call the DeleteAlarm operation to delete it.
+   *
+   * @param request DeleteAlarmRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteAlarmResponse
+   */
   async deleteAlarmWithOptions(request: DeleteAlarmRequest, runtime: $Util.RuntimeOptions): Promise<DeleteAlarmResponse> {
     Util.validateModel(request);
     let query = { };
@@ -17883,19 +18247,27 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteAlarmResponse>(await this.callApi(params, req, runtime), new DeleteAlarmResponse({}));
   }
 
+  /**
+   * @summary Deletes an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you no longer need an event-triggered task, you can call the DeleteAlarm operation to delete it.
+   *
+   * @param request DeleteAlarmRequest
+   * @return DeleteAlarmResponse
+   */
   async deleteAlarm(request: DeleteAlarmRequest): Promise<DeleteAlarmResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteAlarmWithOptions(request, runtime);
   }
 
   /**
-    * You cannot delete a scaling configuration that is used to create elastic container instances in the following scenarios:
-    * *   The scaling configuration is in the Active state.
-    * *   The scaling group contains elastic container instances that are created based on the scaling configuration.
-    *
-    * @param request DeleteEciScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DeleteEciScalingConfigurationResponse
+   * @summary Deletes a scaling configuration of the Elastic Container Instance type. If the scaling configuration of a scaling group is in the Inactive state and the scaling group contains no elastic container instances created from the scaling configuration, you can call the DeleteEciScalingConfiguration operation to delete the scaling configuration to free up the scaling configuration quota.
+   *
+   * @description You cannot call this operation to delete a scaling configuration in the following scenarios:
+   * *   The scaling configuration is in the Active state.
+   * *   The scaling group contains elastic container instances created from the scaling configuration.
+   *
+   * @param request DeleteEciScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteEciScalingConfigurationResponse
    */
   async deleteEciScalingConfigurationWithOptions(request: DeleteEciScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<DeleteEciScalingConfigurationResponse> {
     Util.validateModel(request);
@@ -17938,18 +18310,31 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You cannot delete a scaling configuration that is used to create elastic container instances in the following scenarios:
-    * *   The scaling configuration is in the Active state.
-    * *   The scaling group contains elastic container instances that are created based on the scaling configuration.
-    *
-    * @param request DeleteEciScalingConfigurationRequest
-    * @return DeleteEciScalingConfigurationResponse
+   * @summary Deletes a scaling configuration of the Elastic Container Instance type. If the scaling configuration of a scaling group is in the Inactive state and the scaling group contains no elastic container instances created from the scaling configuration, you can call the DeleteEciScalingConfiguration operation to delete the scaling configuration to free up the scaling configuration quota.
+   *
+   * @description You cannot call this operation to delete a scaling configuration in the following scenarios:
+   * *   The scaling configuration is in the Active state.
+   * *   The scaling group contains elastic container instances created from the scaling configuration.
+   *
+   * @param request DeleteEciScalingConfigurationRequest
+   * @return DeleteEciScalingConfigurationResponse
    */
   async deleteEciScalingConfiguration(request: DeleteEciScalingConfigurationRequest): Promise<DeleteEciScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteEciScalingConfigurationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes a lifecycle hook.
+   *
+   * @description If you delete a lifecycle hook that is in effect in a scaling group, instances exit the Pending state in advance. You can use one of the following methods to specify the lifecycle hooks that you want to delete:
+   * *   Specify the scaling group ID of the lifecycle hook that you want to delete by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter.
+   * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. In this case, the ScalingGroupId parameter and the LifecycleHookName parameter are ignored.
+   *
+   * @param request DeleteLifecycleHookRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteLifecycleHookResponse
+   */
   async deleteLifecycleHookWithOptions(request: DeleteLifecycleHookRequest, runtime: $Util.RuntimeOptions): Promise<DeleteLifecycleHookResponse> {
     Util.validateModel(request);
     let query = { };
@@ -17998,11 +18383,28 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteLifecycleHookResponse>(await this.callApi(params, req, runtime), new DeleteLifecycleHookResponse({}));
   }
 
+  /**
+   * @summary Deletes a lifecycle hook.
+   *
+   * @description If you delete a lifecycle hook that is in effect in a scaling group, instances exit the Pending state in advance. You can use one of the following methods to specify the lifecycle hooks that you want to delete:
+   * *   Specify the scaling group ID of the lifecycle hook that you want to delete by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter.
+   * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. In this case, the ScalingGroupId parameter and the LifecycleHookName parameter are ignored.
+   *
+   * @param request DeleteLifecycleHookRequest
+   * @return DeleteLifecycleHookResponse
+   */
   async deleteLifecycleHook(request: DeleteLifecycleHookRequest): Promise<DeleteLifecycleHookResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteLifecycleHookWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes event notification rules. The event notification feature facilitates efficient issue identification and event management by automatically forwarding notifications from Auto Scaling to designated endpoints such as CloudMonitor or Message Service (MNS) topics and queues. If you no longer require an event notification rule, you can call the DeleteNotificationConfiguration operation to delete it.
+   *
+   * @param request DeleteNotificationConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteNotificationConfigurationResponse
+   */
   async deleteNotificationConfigurationWithOptions(request: DeleteNotificationConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<DeleteNotificationConfigurationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18043,19 +18445,27 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteNotificationConfigurationResponse>(await this.callApi(params, req, runtime), new DeleteNotificationConfigurationResponse({}));
   }
 
+  /**
+   * @summary Deletes event notification rules. The event notification feature facilitates efficient issue identification and event management by automatically forwarding notifications from Auto Scaling to designated endpoints such as CloudMonitor or Message Service (MNS) topics and queues. If you no longer require an event notification rule, you can call the DeleteNotificationConfiguration operation to delete it.
+   *
+   * @param request DeleteNotificationConfigurationRequest
+   * @return DeleteNotificationConfigurationResponse
+   */
   async deleteNotificationConfiguration(request: DeleteNotificationConfigurationRequest): Promise<DeleteNotificationConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteNotificationConfigurationWithOptions(request, runtime);
   }
 
   /**
-    * You cannot delete a scaling configuration in one of the following scenarios:
-    * *   The scaling configuration in your scaling group is in the Active state.
-    * *   The scaling group contains ECS instances that were created based on the scaling configuration.
-    *
-    * @param request DeleteScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DeleteScalingConfigurationResponse
+   * @summary Deletes a scaling configuration that is used to create Elastic Compute Service (ECS) instances.
+   *
+   * @description You cannot delete a scaling configuration in one of the following scenarios:
+   * *   The scaling configuration in your scaling group is in the Active state.
+   * *   The scaling group contains ECS instances that were created based on the scaling configuration.
+   *
+   * @param request DeleteScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteScalingConfigurationResponse
    */
   async deleteScalingConfigurationWithOptions(request: DeleteScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<DeleteScalingConfigurationResponse> {
     Util.validateModel(request);
@@ -18094,18 +18504,38 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You cannot delete a scaling configuration in one of the following scenarios:
-    * *   The scaling configuration in your scaling group is in the Active state.
-    * *   The scaling group contains ECS instances that were created based on the scaling configuration.
-    *
-    * @param request DeleteScalingConfigurationRequest
-    * @return DeleteScalingConfigurationResponse
+   * @summary Deletes a scaling configuration that is used to create Elastic Compute Service (ECS) instances.
+   *
+   * @description You cannot delete a scaling configuration in one of the following scenarios:
+   * *   The scaling configuration in your scaling group is in the Active state.
+   * *   The scaling group contains ECS instances that were created based on the scaling configuration.
+   *
+   * @param request DeleteScalingConfigurationRequest
+   * @return DeleteScalingConfigurationResponse
    */
   async deleteScalingConfiguration(request: DeleteScalingConfigurationRequest): Promise<DeleteScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteScalingConfigurationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes a scaling group. If you want to enable policy-based automatic addition or removal of instances of a specific type to meet evolving business requirements, you can create scaling groups to manage your computing power with ease. The computing power refers to the instances that provide the computing capability. If you no longer require a scaling group, you can call the DeleteScalingGroup operation to delete it to free up the scaling group quota.
+   *
+   * @description Before you call the DeleteScalingGroup operation, take note of the following items:
+   * *   If you delete a scaling group, the scaling configurations, scaling rules, scaling activities, and scaling requests related to the scaling group are also deleted.
+   * *   If you delete a scaling group, the scheduled tasks and event-triggered tasks of the scaling group are not deleted. The Server Load Balancer (SLB) instances and ApsaraDB RDS instances that are attached to the scaling group are also not deleted.
+   * *   If the scaling group that you want to delete contains ECS instances or elastic container instances that are in the In Service state, Auto Scaling stops the instances and then removes all manually added instances from the scaling group or releases all automatically created instances in the scaling group before the scaling group is deleted.
+   *     **
+   *     **Note** Before you delete a scaling group, make sure that the Deletion Protection feature is disabled. If you have enabled the Deletion Protection feature for a scaling group, disable the feature on the Modify Scaling Group page before you delete the scaling group.
+   * *   If you do not disable the Deletion Protection feature for a scaling group, you cannot delete the scaling group by using the Auto Scaling console or calling this operation. The Deletion Protection feature is an effective measure to safeguard scaling groups against unintended deletion.
+   * *   Prior to deleting a scaling group, make sure that your ECS instances within the scaling group are safeguarded against unintended release. Even if you have already enabled the Release Protection feature for the ECS instances, you must manually put these ECS instances into the Protected state. Doing so guarantees that the ECS instances will not be forcibly released during the deletion process of the scaling group, providing an extra layer of security.
+   *     **
+   *     **Note** Before you delete a scaling group, we recommend that you enable the Deletion Protection feature for ECS instances that you want to retain. This action guarantees that the ECS instances are not forcibly released after you delete the scaling group. For more information, see [SetInstancesProtection](https://help.aliyun.com/document_detail/459342.html).
+   *
+   * @param request DeleteScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteScalingGroupResponse
+   */
   async deleteScalingGroupWithOptions(request: DeleteScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<DeleteScalingGroupResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18150,11 +18580,35 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteScalingGroupResponse>(await this.callApi(params, req, runtime), new DeleteScalingGroupResponse({}));
   }
 
+  /**
+   * @summary Deletes a scaling group. If you want to enable policy-based automatic addition or removal of instances of a specific type to meet evolving business requirements, you can create scaling groups to manage your computing power with ease. The computing power refers to the instances that provide the computing capability. If you no longer require a scaling group, you can call the DeleteScalingGroup operation to delete it to free up the scaling group quota.
+   *
+   * @description Before you call the DeleteScalingGroup operation, take note of the following items:
+   * *   If you delete a scaling group, the scaling configurations, scaling rules, scaling activities, and scaling requests related to the scaling group are also deleted.
+   * *   If you delete a scaling group, the scheduled tasks and event-triggered tasks of the scaling group are not deleted. The Server Load Balancer (SLB) instances and ApsaraDB RDS instances that are attached to the scaling group are also not deleted.
+   * *   If the scaling group that you want to delete contains ECS instances or elastic container instances that are in the In Service state, Auto Scaling stops the instances and then removes all manually added instances from the scaling group or releases all automatically created instances in the scaling group before the scaling group is deleted.
+   *     **
+   *     **Note** Before you delete a scaling group, make sure that the Deletion Protection feature is disabled. If you have enabled the Deletion Protection feature for a scaling group, disable the feature on the Modify Scaling Group page before you delete the scaling group.
+   * *   If you do not disable the Deletion Protection feature for a scaling group, you cannot delete the scaling group by using the Auto Scaling console or calling this operation. The Deletion Protection feature is an effective measure to safeguard scaling groups against unintended deletion.
+   * *   Prior to deleting a scaling group, make sure that your ECS instances within the scaling group are safeguarded against unintended release. Even if you have already enabled the Release Protection feature for the ECS instances, you must manually put these ECS instances into the Protected state. Doing so guarantees that the ECS instances will not be forcibly released during the deletion process of the scaling group, providing an extra layer of security.
+   *     **
+   *     **Note** Before you delete a scaling group, we recommend that you enable the Deletion Protection feature for ECS instances that you want to retain. This action guarantees that the ECS instances are not forcibly released after you delete the scaling group. For more information, see [SetInstancesProtection](https://help.aliyun.com/document_detail/459342.html).
+   *
+   * @param request DeleteScalingGroupRequest
+   * @return DeleteScalingGroupResponse
+   */
   async deleteScalingGroup(request: DeleteScalingGroupRequest): Promise<DeleteScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteScalingGroupWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes a scaling rule.
+   *
+   * @param request DeleteScalingRuleRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteScalingRuleResponse
+   */
   async deleteScalingRuleWithOptions(request: DeleteScalingRuleRequest, runtime: $Util.RuntimeOptions): Promise<DeleteScalingRuleResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18195,11 +18649,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteScalingRuleResponse>(await this.callApi(params, req, runtime), new DeleteScalingRuleResponse({}));
   }
 
+  /**
+   * @summary Deletes a scaling rule.
+   *
+   * @param request DeleteScalingRuleRequest
+   * @return DeleteScalingRuleResponse
+   */
   async deleteScalingRule(request: DeleteScalingRuleRequest): Promise<DeleteScalingRuleResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteScalingRuleWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Deletes scheduled tasks. For workloads with predictable patterns, you can create scheduled tasks to align with your business requirements and optimize resource utilization for cost savings. These tasks automatically ensure that sufficient computing resources are provisioned in anticipation of peak hours and efficiently release unused resources during off-peak hours, thereby streamlining operational efficiency and reducing expenses. If you no longer require a scheduled task, you can call the DeleteScheduledTask operation to delete it.
+   *
+   * @param request DeleteScheduledTaskRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DeleteScheduledTaskResponse
+   */
   async deleteScheduledTaskWithOptions(request: DeleteScheduledTaskRequest, runtime: $Util.RuntimeOptions): Promise<DeleteScheduledTaskResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18240,11 +18707,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DeleteScheduledTaskResponse>(await this.callApi(params, req, runtime), new DeleteScheduledTaskResponse({}));
   }
 
+  /**
+   * @summary Deletes scheduled tasks. For workloads with predictable patterns, you can create scheduled tasks to align with your business requirements and optimize resource utilization for cost savings. These tasks automatically ensure that sufficient computing resources are provisioned in anticipation of peak hours and efficiently release unused resources during off-peak hours, thereby streamlining operational efficiency and reducing expenses. If you no longer require a scheduled task, you can call the DeleteScheduledTask operation to delete it.
+   *
+   * @param request DeleteScheduledTaskRequest
+   * @return DeleteScheduledTaskResponse
+   */
   async deleteScheduledTask(request: DeleteScheduledTaskRequest): Promise<DeleteScheduledTaskResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.deleteScheduledTaskWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries event-triggered tasks.
+   *
+   * @param request DescribeAlarmsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeAlarmsResponse
+   */
   async describeAlarmsWithOptions(request: DescribeAlarmsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeAlarmsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18309,11 +18789,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeAlarmsResponse>(await this.callApi(params, req, runtime), new DescribeAlarmsResponse({}));
   }
 
+  /**
+   * @summary Queries event-triggered tasks.
+   *
+   * @param request DescribeAlarmsRequest
+   * @return DescribeAlarmsResponse
+   */
   async describeAlarms(request: DescribeAlarmsRequest): Promise<DescribeAlarmsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeAlarmsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries scaling configurations of the Elastic Container Instance type to learn the scaling configuration details. This allows you to select an appropriate template when you create elastic container instances. If you set OutputFormat to yaml, the output is a Kubernetes Deployment file in the YAML format.
+   *
+   * @param request DescribeEciScalingConfigurationDetailRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeEciScalingConfigurationDetailResponse
+   */
   async describeEciScalingConfigurationDetailWithOptions(request: DescribeEciScalingConfigurationDetailRequest, runtime: $Util.RuntimeOptions): Promise<DescribeEciScalingConfigurationDetailResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18350,11 +18843,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeEciScalingConfigurationDetailResponse>(await this.callApi(params, req, runtime), new DescribeEciScalingConfigurationDetailResponse({}));
   }
 
+  /**
+   * @summary Queries scaling configurations of the Elastic Container Instance type to learn the scaling configuration details. This allows you to select an appropriate template when you create elastic container instances. If you set OutputFormat to yaml, the output is a Kubernetes Deployment file in the YAML format.
+   *
+   * @param request DescribeEciScalingConfigurationDetailRequest
+   * @return DescribeEciScalingConfigurationDetailResponse
+   */
   async describeEciScalingConfigurationDetail(request: DescribeEciScalingConfigurationDetailRequest): Promise<DescribeEciScalingConfigurationDetailResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeEciScalingConfigurationDetailWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries scaling configurations of the Elastic Container Instance type to learn the scaling configuration details. This allows you to select an appropriate template when you create elastic container instances.
+   *
+   * @param request DescribeEciScalingConfigurationsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeEciScalingConfigurationsResponse
+   */
   async describeEciScalingConfigurationsWithOptions(request: DescribeEciScalingConfigurationsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeEciScalingConfigurationsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18415,21 +18921,29 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeEciScalingConfigurationsResponse>(await this.callApi(params, req, runtime), new DescribeEciScalingConfigurationsResponse({}));
   }
 
+  /**
+   * @summary Queries scaling configurations of the Elastic Container Instance type to learn the scaling configuration details. This allows you to select an appropriate template when you create elastic container instances.
+   *
+   * @param request DescribeEciScalingConfigurationsRequest
+   * @return DescribeEciScalingConfigurationsResponse
+   */
   async describeEciScalingConfigurations(request: DescribeEciScalingConfigurationsRequest): Promise<DescribeEciScalingConfigurationsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeEciScalingConfigurationsWithOptions(request, runtime);
   }
 
   /**
-    * If a scaling activity is executed and a lifecycle hook is created for the scaling activity, the lifecycle hook triggers a lifecycle action. A lifecycle action can be in one of the following states:
-    * *   If a lifecycle action is in the Pending state, Elastic Compute Service (ECS) instances are waiting to be added to a scaling group or waiting to be removed from a scaling group.
-    * *   If a lifecycle action is in the Timeout state, the lifecycle hook that triggers the lifecycle action expires and ECS instances are added to or removed from a scaling group.
-    * *   If a lifecycle action is in the Completed state, you manually end the lifecycle hook that triggers the lifecycle action ahead of schedule.
-    * If you do not specify the action to perform, such as execute a specific OOS template, after a lifecycle hook ends, you can call this operation to obtain the token of the lifecycle action that corresponds to the lifecycle hook. Then, you can specify a custom action to perform after the lifecycle hook ends.
-    *
-    * @param request DescribeLifecycleActionsRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DescribeLifecycleActionsResponse
+   * @summary Queries lifecycle actions.
+   *
+   * @description If a scaling activity is executed and a lifecycle hook is created for the scaling activity, the lifecycle hook triggers a lifecycle action. A lifecycle action can be in one of the following states:
+   * *   If a lifecycle action is in the Pending state, Elastic Compute Service (ECS) instances are waiting to be added to a scaling group or waiting to be removed from a scaling group.
+   * *   If a lifecycle action is in the Timeout state, the lifecycle hook that triggers the lifecycle action expires and ECS instances are added to or removed from a scaling group.
+   * *   If a lifecycle action is in the Completed state, you manually end the lifecycle hook that triggers the lifecycle action ahead of schedule.
+   * If you do not specify the action to perform, such as execute a specific OOS template, after a lifecycle hook ends, you can call this operation to obtain the token of the lifecycle action that corresponds to the lifecycle hook. Then, you can specify a custom action to perform after the lifecycle hook ends.
+   *
+   * @param request DescribeLifecycleActionsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeLifecycleActionsResponse
    */
   async describeLifecycleActionsWithOptions(request: DescribeLifecycleActionsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeLifecycleActionsResponse> {
     Util.validateModel(request);
@@ -18480,20 +18994,34 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * If a scaling activity is executed and a lifecycle hook is created for the scaling activity, the lifecycle hook triggers a lifecycle action. A lifecycle action can be in one of the following states:
-    * *   If a lifecycle action is in the Pending state, Elastic Compute Service (ECS) instances are waiting to be added to a scaling group or waiting to be removed from a scaling group.
-    * *   If a lifecycle action is in the Timeout state, the lifecycle hook that triggers the lifecycle action expires and ECS instances are added to or removed from a scaling group.
-    * *   If a lifecycle action is in the Completed state, you manually end the lifecycle hook that triggers the lifecycle action ahead of schedule.
-    * If you do not specify the action to perform, such as execute a specific OOS template, after a lifecycle hook ends, you can call this operation to obtain the token of the lifecycle action that corresponds to the lifecycle hook. Then, you can specify a custom action to perform after the lifecycle hook ends.
-    *
-    * @param request DescribeLifecycleActionsRequest
-    * @return DescribeLifecycleActionsResponse
+   * @summary Queries lifecycle actions.
+   *
+   * @description If a scaling activity is executed and a lifecycle hook is created for the scaling activity, the lifecycle hook triggers a lifecycle action. A lifecycle action can be in one of the following states:
+   * *   If a lifecycle action is in the Pending state, Elastic Compute Service (ECS) instances are waiting to be added to a scaling group or waiting to be removed from a scaling group.
+   * *   If a lifecycle action is in the Timeout state, the lifecycle hook that triggers the lifecycle action expires and ECS instances are added to or removed from a scaling group.
+   * *   If a lifecycle action is in the Completed state, you manually end the lifecycle hook that triggers the lifecycle action ahead of schedule.
+   * If you do not specify the action to perform, such as execute a specific OOS template, after a lifecycle hook ends, you can call this operation to obtain the token of the lifecycle action that corresponds to the lifecycle hook. Then, you can specify a custom action to perform after the lifecycle hook ends.
+   *
+   * @param request DescribeLifecycleActionsRequest
+   * @return DescribeLifecycleActionsResponse
    */
   async describeLifecycleActions(request: DescribeLifecycleActionsRequest): Promise<DescribeLifecycleActionsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeLifecycleActionsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries lifecycle hooks.
+   *
+   * @description You can use one of the following methods to query lifecycle hooks:
+   * *   Specify a list of lifecycle hook IDs by using the LifecycleHookIds parameter. In this case, you do not need to specify the ScalingGroupId and LifecycleHookName parameters.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter at the same time.
+   *
+   * @param request DescribeLifecycleHooksRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeLifecycleHooksResponse
+   */
   async describeLifecycleHooksWithOptions(request: DescribeLifecycleHooksRequest, runtime: $Util.RuntimeOptions): Promise<DescribeLifecycleHooksResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18550,11 +19078,29 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeLifecycleHooksResponse>(await this.callApi(params, req, runtime), new DescribeLifecycleHooksResponse({}));
   }
 
+  /**
+   * @summary Queries lifecycle hooks.
+   *
+   * @description You can use one of the following methods to query lifecycle hooks:
+   * *   Specify a list of lifecycle hook IDs by using the LifecycleHookIds parameter. In this case, you do not need to specify the ScalingGroupId and LifecycleHookName parameters.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter at the same time.
+   *
+   * @param request DescribeLifecycleHooksRequest
+   * @return DescribeLifecycleHooksResponse
+   */
   async describeLifecycleHooks(request: DescribeLifecycleHooksRequest): Promise<DescribeLifecycleHooksResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeLifecycleHooksWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries resource quotas. You can call the DescribeLimitation operation to query the upper limits on resources such as scheduled tasks that can be created in a scaling group, load balancers that can be attached to a scaling group, instances that can be contained in a scaling group, and scaling configurations that can be created in a scaling group.
+   *
+   * @param request DescribeLimitationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeLimitationResponse
+   */
   async describeLimitationWithOptions(request: DescribeLimitationRequest, runtime: $Util.RuntimeOptions): Promise<DescribeLimitationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18583,11 +19129,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeLimitationResponse>(await this.callApi(params, req, runtime), new DescribeLimitationResponse({}));
   }
 
+  /**
+   * @summary Queries resource quotas. You can call the DescribeLimitation operation to query the upper limits on resources such as scheduled tasks that can be created in a scaling group, load balancers that can be attached to a scaling group, instances that can be contained in a scaling group, and scaling configurations that can be created in a scaling group.
+   *
+   * @param request DescribeLimitationRequest
+   * @return DescribeLimitationResponse
+   */
   async describeLimitation(request: DescribeLimitationRequest): Promise<DescribeLimitationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeLimitationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries event notifications.
+   *
+   * @param request DescribeNotificationConfigurationsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeNotificationConfigurationsResponse
+   */
   async describeNotificationConfigurationsWithOptions(request: DescribeNotificationConfigurationsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeNotificationConfigurationsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18624,11 +19183,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeNotificationConfigurationsResponse>(await this.callApi(params, req, runtime), new DescribeNotificationConfigurationsResponse({}));
   }
 
+  /**
+   * @summary Queries event notifications.
+   *
+   * @param request DescribeNotificationConfigurationsRequest
+   * @return DescribeNotificationConfigurationsResponse
+   */
   async describeNotificationConfigurations(request: DescribeNotificationConfigurationsRequest): Promise<DescribeNotificationConfigurationsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeNotificationConfigurationsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries notification types.
+   *
+   * @param request DescribeNotificationTypesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeNotificationTypesResponse
+   */
   async describeNotificationTypesWithOptions(request: DescribeNotificationTypesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeNotificationTypesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18657,11 +19229,62 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeNotificationTypesResponse>(await this.callApi(params, req, runtime), new DescribeNotificationTypesResponse({}));
   }
 
+  /**
+   * @summary Queries notification types.
+   *
+   * @param request DescribeNotificationTypesRequest
+   * @return DescribeNotificationTypesResponse
+   */
   async describeNotificationTypes(request: DescribeNotificationTypesRequest): Promise<DescribeNotificationTypesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeNotificationTypesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary DescribePatternTypes
+   *
+   * @param request DescribePatternTypesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribePatternTypesResponse
+   */
+  async describePatternTypesWithOptions(request: DescribePatternTypesRequest, runtime: $Util.RuntimeOptions): Promise<DescribePatternTypesResponse> {
+    Util.validateModel(request);
+    let query = OpenApiUtil.query(Util.toMap(request));
+    let req = new $OpenApi.OpenApiRequest({
+      query: OpenApiUtil.query(query),
+    });
+    let params = new $OpenApi.Params({
+      action: "DescribePatternTypes",
+      version: "2022-02-22",
+      protocol: "HTTPS",
+      pathname: "/",
+      method: "GET",
+      authType: "AK",
+      style: "RPC",
+      reqBodyType: "formData",
+      bodyType: "json",
+    });
+    return $tea.cast<DescribePatternTypesResponse>(await this.callApi(params, req, runtime), new DescribePatternTypesResponse({}));
+  }
+
+  /**
+   * @summary DescribePatternTypes
+   *
+   * @param request DescribePatternTypesRequest
+   * @return DescribePatternTypesResponse
+   */
+  async describePatternTypes(request: DescribePatternTypesRequest): Promise<DescribePatternTypesResponse> {
+    let runtime = new $Util.RuntimeOptions({ });
+    return await this.describePatternTypesWithOptions(request, runtime);
+  }
+
+  /**
+   * @summary Queries regions. Before you activate Auto Scaling, you can call the DescribeRegions operation to query the regions where Auto Scaling is officially launched. This preliminary step facilitates the strategic selection of both the optimal region and availability zones for activating Auto Scaling, thereby guaranteeing the finest access speeds and operational efficiency within your chosen geographical area.
+   *
+   * @param request DescribeRegionsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeRegionsResponse
+   */
   async describeRegionsWithOptions(request: DescribeRegionsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeRegionsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18698,19 +19321,27 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeRegionsResponse>(await this.callApi(params, req, runtime), new DescribeRegionsResponse({}));
   }
 
+  /**
+   * @summary Queries regions. Before you activate Auto Scaling, you can call the DescribeRegions operation to query the regions where Auto Scaling is officially launched. This preliminary step facilitates the strategic selection of both the optimal region and availability zones for activating Auto Scaling, thereby guaranteeing the finest access speeds and operational efficiency within your chosen geographical area.
+   *
+   * @param request DescribeRegionsRequest
+   * @return DescribeRegionsResponse
+   */
   async describeRegions(request: DescribeRegionsRequest): Promise<DescribeRegionsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeRegionsWithOptions(request, runtime);
   }
 
   /**
-    * You can specify a scaling group ID to query all scaling activities in the scaling group.
-    * You can filter query results based on the status of scaling activities.
-    * You can query scaling activities that are executed in the previous 30 days.
-    *
-    * @param request DescribeScalingActivitiesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DescribeScalingActivitiesResponse
+   * @summary Queries scaling activities.
+   *
+   * @description You can specify a scaling group ID to query all scaling activities in the scaling group.
+   * You can filter query results based on the status of scaling activities.
+   * You can query scaling activities that are executed in the previous 30 days.
+   *
+   * @param request DescribeScalingActivitiesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingActivitiesResponse
    */
   async describeScalingActivitiesWithOptions(request: DescribeScalingActivitiesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingActivitiesResponse> {
     Util.validateModel(request);
@@ -18773,18 +19404,27 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can specify a scaling group ID to query all scaling activities in the scaling group.
-    * You can filter query results based on the status of scaling activities.
-    * You can query scaling activities that are executed in the previous 30 days.
-    *
-    * @param request DescribeScalingActivitiesRequest
-    * @return DescribeScalingActivitiesResponse
+   * @summary Queries scaling activities.
+   *
+   * @description You can specify a scaling group ID to query all scaling activities in the scaling group.
+   * You can filter query results based on the status of scaling activities.
+   * You can query scaling activities that are executed in the previous 30 days.
+   *
+   * @param request DescribeScalingActivitiesRequest
+   * @return DescribeScalingActivitiesResponse
    */
   async describeScalingActivities(request: DescribeScalingActivitiesRequest): Promise<DescribeScalingActivitiesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingActivitiesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries the details about a scaling activity.
+   *
+   * @param request DescribeScalingActivityDetailRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingActivityDetailResponse
+   */
   async describeScalingActivityDetailWithOptions(request: DescribeScalingActivityDetailRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingActivityDetailResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18821,11 +19461,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScalingActivityDetailResponse>(await this.callApi(params, req, runtime), new DescribeScalingActivityDetailResponse({}));
   }
 
+  /**
+   * @summary Queries the details about a scaling activity.
+   *
+   * @param request DescribeScalingActivityDetailRequest
+   * @return DescribeScalingActivityDetailResponse
+   */
   async describeScalingActivityDetail(request: DescribeScalingActivityDetailRequest): Promise<DescribeScalingActivityDetailResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingActivityDetailWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries scaling configurations.
+   *
+   * @param request DescribeScalingConfigurationsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingConfigurationsResponse
+   */
   async describeScalingConfigurationsWithOptions(request: DescribeScalingConfigurationsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingConfigurationsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18886,11 +19539,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScalingConfigurationsResponse>(await this.callApi(params, req, runtime), new DescribeScalingConfigurationsResponse({}));
   }
 
+  /**
+   * @summary Queries scaling configurations.
+   *
+   * @param request DescribeScalingConfigurationsRequest
+   * @return DescribeScalingConfigurationsResponse
+   */
   async describeScalingConfigurations(request: DescribeScalingConfigurationsRequest): Promise<DescribeScalingConfigurationsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingConfigurationsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries a scaling group. You can call the DescribeScalingGroupDetail operation to query the basic information, instances, and scaling configurations of a scaling group. If you set OutputFormat to yaml, a Kubernetes Deployment file that is in the YAML format is returned.
+   *
+   * @param request DescribeScalingGroupDetailRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingGroupDetailResponse
+   */
   async describeScalingGroupDetailWithOptions(request: DescribeScalingGroupDetailRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingGroupDetailResponse> {
     Util.validateModel(request);
     let query = { };
@@ -18927,11 +19593,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScalingGroupDetailResponse>(await this.callApi(params, req, runtime), new DescribeScalingGroupDetailResponse({}));
   }
 
+  /**
+   * @summary Queries a scaling group. You can call the DescribeScalingGroupDetail operation to query the basic information, instances, and scaling configurations of a scaling group. If you set OutputFormat to yaml, a Kubernetes Deployment file that is in the YAML format is returned.
+   *
+   * @param request DescribeScalingGroupDetailRequest
+   * @return DescribeScalingGroupDetailResponse
+   */
   async describeScalingGroupDetail(request: DescribeScalingGroupDetailRequest): Promise<DescribeScalingGroupDetailResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingGroupDetailWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries scaling groups. If you want to query the basic information, instances, and scaling configurations of a scaling group, you can call the DescribeScalingGroups operation.
+   *
+   * @param request DescribeScalingGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingGroupsResponse
+   */
   async describeScalingGroupsWithOptions(request: DescribeScalingGroupsRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingGroupsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19004,11 +19683,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScalingGroupsResponse>(await this.callApi(params, req, runtime), new DescribeScalingGroupsResponse({}));
   }
 
+  /**
+   * @summary Queries scaling groups. If you want to query the basic information, instances, and scaling configurations of a scaling group, you can call the DescribeScalingGroups operation.
+   *
+   * @param request DescribeScalingGroupsRequest
+   * @return DescribeScalingGroupsResponse
+   */
   async describeScalingGroups(request: DescribeScalingGroupsRequest): Promise<DescribeScalingGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingGroupsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries the Elastic Compute Service (ECS) instances in a scaling group
+   *
+   * @param request DescribeScalingInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingInstancesResponse
+   */
   async describeScalingInstancesWithOptions(request: DescribeScalingInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingInstancesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19093,17 +19785,25 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScalingInstancesResponse>(await this.callApi(params, req, runtime), new DescribeScalingInstancesResponse({}));
   }
 
+  /**
+   * @summary Queries the Elastic Compute Service (ECS) instances in a scaling group
+   *
+   * @param request DescribeScalingInstancesRequest
+   * @return DescribeScalingInstancesResponse
+   */
   async describeScalingInstances(request: DescribeScalingInstancesRequest): Promise<DescribeScalingInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingInstancesWithOptions(request, runtime);
   }
 
   /**
-    * You can specify a scaling group ID to query all scaling rules in the scaling group. You can also specify the scaling rule ID, name, unique identifier, and type in the request parameters as filter conditions.
-    *
-    * @param request DescribeScalingRulesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DescribeScalingRulesResponse
+   * @summary Queries all scaling rules in a scaling group.
+   *
+   * @description You can specify a scaling group ID to query all scaling rules in the scaling group. You can also specify the scaling rule ID, name, unique identifier, and type in the request parameters as filter conditions.
+   *
+   * @param request DescribeScalingRulesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScalingRulesResponse
    */
   async describeScalingRulesWithOptions(request: DescribeScalingRulesRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScalingRulesResponse> {
     Util.validateModel(request);
@@ -19178,16 +19878,27 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can specify a scaling group ID to query all scaling rules in the scaling group. You can also specify the scaling rule ID, name, unique identifier, and type in the request parameters as filter conditions.
-    *
-    * @param request DescribeScalingRulesRequest
-    * @return DescribeScalingRulesResponse
+   * @summary Queries all scaling rules in a scaling group.
+   *
+   * @description You can specify a scaling group ID to query all scaling rules in the scaling group. You can also specify the scaling rule ID, name, unique identifier, and type in the request parameters as filter conditions.
+   *
+   * @param request DescribeScalingRulesRequest
+   * @return DescribeScalingRulesResponse
    */
   async describeScalingRules(request: DescribeScalingRulesRequest): Promise<DescribeScalingRulesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScalingRulesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries scheduled tasks.
+   *
+   * @description You can query scheduled tasks by scaling rule, task ID, or task name.
+   *
+   * @param request DescribeScheduledTasksRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DescribeScheduledTasksResponse
+   */
   async describeScheduledTasksWithOptions(request: DescribeScheduledTasksRequest, runtime: $Util.RuntimeOptions): Promise<DescribeScheduledTasksResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19252,11 +19963,26 @@ export default class Client extends OpenApi {
     return $tea.cast<DescribeScheduledTasksResponse>(await this.callApi(params, req, runtime), new DescribeScheduledTasksResponse({}));
   }
 
+  /**
+   * @summary Queries scheduled tasks.
+   *
+   * @description You can query scheduled tasks by scaling rule, task ID, or task name.
+   *
+   * @param request DescribeScheduledTasksRequest
+   * @return DescribeScheduledTasksResponse
+   */
   async describeScheduledTasks(request: DescribeScheduledTasksRequest): Promise<DescribeScheduledTasksResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.describeScheduledTasksWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Disassociates one or more Application Load Balancer (ALB) server groups from a scaling group.
+   *
+   * @param request DetachAlbServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachAlbServerGroupsResponse
+   */
   async detachAlbServerGroupsWithOptions(request: DetachAlbServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<DetachAlbServerGroupsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19305,11 +20031,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DetachAlbServerGroupsResponse>(await this.callApi(params, req, runtime), new DetachAlbServerGroupsResponse({}));
   }
 
+  /**
+   * @summary Disassociates one or more Application Load Balancer (ALB) server groups from a scaling group.
+   *
+   * @param request DetachAlbServerGroupsRequest
+   * @return DetachAlbServerGroupsResponse
+   */
   async detachAlbServerGroups(request: DetachAlbServerGroupsRequest): Promise<DetachAlbServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachAlbServerGroupsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Disassociates one or more ApsaraDB RDS instances from a scaling group.
+   *
+   * @param request DetachDBInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachDBInstancesResponse
+   */
   async detachDBInstancesWithOptions(request: DetachDBInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DetachDBInstancesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19362,24 +20101,32 @@ export default class Client extends OpenApi {
     return $tea.cast<DetachDBInstancesResponse>(await this.callApi(params, req, runtime), new DetachDBInstancesResponse({}));
   }
 
+  /**
+   * @summary Disassociates one or more ApsaraDB RDS instances from a scaling group.
+   *
+   * @param request DetachDBInstancesRequest
+   * @return DetachDBInstancesResponse
+   */
   async detachDBInstances(request: DetachDBInstancesRequest): Promise<DetachDBInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachDBInstancesWithOptions(request, runtime);
   }
 
   /**
-    * After ECS instances or elastic container instances are removed from a scaling group, you can call the AttachInstances operation to add the ECS instances or elastic container instances that are removed from the scaling group to other scaling groups.
-    * After you remove an ECS instance or elastic container instance by calling the DetachInstances operation, the instance is not stopped or released.
-    * Before you call this operation, make sure that the following conditions are met:
-    * *   The specified scaling group is enabled.
-    * *   No scaling activities in the specified scaling group are in progress.
-    * > If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates only that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
-    * The number of ECS instances or elastic container instances in a scaling group after you remove a specific number of instances from the scaling group must be equal to or greater than the value of the MinSize parameter. Otherwise, an error is reported when you call the DetachInstances operation.
-    *
-    * @param request DetachInstancesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DetachInstancesResponse
+   * @summary Removes one or more Elastic Compute Service (ECS) instances or elastic container instances from a scaling group.
+   *
+   * @description After ECS instances or elastic container instances are removed from a scaling group, you can call the AttachInstances operation to add the ECS instances or elastic container instances that are removed from the scaling group to other scaling groups.
+   * After you remove an ECS instance or elastic container instance by calling the DetachInstances operation, the instance is not stopped or released.
+   * Before you call this operation, make sure that the following conditions are met:
+   * *   The specified scaling group is enabled.
+   * *   No scaling activities in the specified scaling group are in progress.
+   * > If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates only that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
+   * The number of ECS instances or elastic container instances in a scaling group after you remove a specific number of instances from the scaling group must be equal to or greater than the value of the MinSize parameter. Otherwise, an error is reported when you call the DetachInstances operation.
+   *
+   * @param request DetachInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachInstancesResponse
    */
   async detachInstancesWithOptions(request: DetachInstancesRequest, runtime: $Util.RuntimeOptions): Promise<DetachInstancesResponse> {
     Util.validateModel(request);
@@ -19396,6 +20143,10 @@ export default class Client extends OpenApi {
       query["DetachOption"] = request.detachOption;
     }
 
+    if (!Util.isUnset(request.ignoreInvalidInstance)) {
+      query["IgnoreInvalidInstance"] = request.ignoreInvalidInstance;
+    }
+
     if (!Util.isUnset(request.instanceIds)) {
       query["InstanceIds"] = request.instanceIds;
     }
@@ -19442,23 +20193,32 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * After ECS instances or elastic container instances are removed from a scaling group, you can call the AttachInstances operation to add the ECS instances or elastic container instances that are removed from the scaling group to other scaling groups.
-    * After you remove an ECS instance or elastic container instance by calling the DetachInstances operation, the instance is not stopped or released.
-    * Before you call this operation, make sure that the following conditions are met:
-    * *   The specified scaling group is enabled.
-    * *   No scaling activities in the specified scaling group are in progress.
-    * > If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates only that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
-    * The number of ECS instances or elastic container instances in a scaling group after you remove a specific number of instances from the scaling group must be equal to or greater than the value of the MinSize parameter. Otherwise, an error is reported when you call the DetachInstances operation.
-    *
-    * @param request DetachInstancesRequest
-    * @return DetachInstancesResponse
+   * @summary Removes one or more Elastic Compute Service (ECS) instances or elastic container instances from a scaling group.
+   *
+   * @description After ECS instances or elastic container instances are removed from a scaling group, you can call the AttachInstances operation to add the ECS instances or elastic container instances that are removed from the scaling group to other scaling groups.
+   * After you remove an ECS instance or elastic container instance by calling the DetachInstances operation, the instance is not stopped or released.
+   * Before you call this operation, make sure that the following conditions are met:
+   * *   The specified scaling group is enabled.
+   * *   No scaling activities in the specified scaling group are in progress.
+   * > If no scaling activities in the specified scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates only that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
+   * The number of ECS instances or elastic container instances in a scaling group after you remove a specific number of instances from the scaling group must be equal to or greater than the value of the MinSize parameter. Otherwise, an error is reported when you call the DetachInstances operation.
+   *
+   * @param request DetachInstancesRequest
+   * @return DetachInstancesResponse
    */
   async detachInstances(request: DetachInstancesRequest): Promise<DetachInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachInstancesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Detaches one or more Classic Load Balancer (CLB) instances from a scaling group.
+   *
+   * @param request DetachLoadBalancersRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachLoadBalancersResponse
+   */
   async detachLoadBalancersWithOptions(request: DetachLoadBalancersRequest, runtime: $Util.RuntimeOptions): Promise<DetachLoadBalancersResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19511,11 +20271,24 @@ export default class Client extends OpenApi {
     return $tea.cast<DetachLoadBalancersResponse>(await this.callApi(params, req, runtime), new DetachLoadBalancersResponse({}));
   }
 
+  /**
+   * @summary Detaches one or more Classic Load Balancer (CLB) instances from a scaling group.
+   *
+   * @param request DetachLoadBalancersRequest
+   * @return DetachLoadBalancersResponse
+   */
   async detachLoadBalancers(request: DetachLoadBalancersRequest): Promise<DetachLoadBalancersResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachLoadBalancersWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Detaches one or more server groups from a scaling group. You can attach and detach the following server groups from a scaling group: Application Load Balancer (ALB) and Network Load Balancer (NLB) server groups.
+   *
+   * @param request DetachServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachServerGroupsResponse
+   */
   async detachServerGroupsWithOptions(request: DetachServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<DetachServerGroupsResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19564,21 +20337,30 @@ export default class Client extends OpenApi {
     return $tea.cast<DetachServerGroupsResponse>(await this.callApi(params, req, runtime), new DetachServerGroupsResponse({}));
   }
 
+  /**
+   * @summary Detaches one or more server groups from a scaling group. You can attach and detach the following server groups from a scaling group: Application Load Balancer (ALB) and Network Load Balancer (NLB) server groups.
+   *
+   * @param request DetachServerGroupsRequest
+   * @return DetachServerGroupsResponse
+   */
   async detachServerGroups(request: DetachServerGroupsRequest): Promise<DetachServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachServerGroupsWithOptions(request, runtime);
   }
 
   /**
-    * You can use the following parameters to specify the vServer groups that you want to detach from your scaling group.
-    * *   LoadBalancerId: the ID of the Classic Load Balancer (CLB) instance.
-    * *   VServerGroupId: the ID of the vServer group.
-    * *   Port: the port number of the vServer group.
-    * If the vServer group that is specified in this call matches the vServer group associated with your scaling group, the vServer group can be detached. Otherwise, the request for detaching the vServer group is ignored, and no error is reported.
-    *
-    * @param request DetachVServerGroupsRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return DetachVServerGroupsResponse
+   * @summary Detaches vServer groups from a scaling group. Auto Scaling supports the attachment of load balancers to scaling groups to improve service performance. If the load balancer currently attached to your scaling group is no longer needed to distribute the access traffic to the instances in your scaling group, you can call the DetachVServerGroups operation to detach one or more vServer groups of this load balancer from the scaling group.
+   *
+   * @description *   When you call the DetachVServerGroups operation, you must use the following parameters to specify the vServer groups that you want to detach from your scaling group:
+   *     *   LoadBalancerId: the ID of the load balancer
+   *     *   VServerGroupId: the ID of the vServer group
+   *     *   Port: the port number of the vServer group
+   * *   When the vServer group specified by the request parameters matches that attached to your scaling group, this operation yields a favorable result. Otherwise, the request is ignored and no error is reported.
+   * *   Before you call this operation, you must make sure that the load balancer has ceased routing the access traffic to the instances in the scaling group. Failure to do so may lead to service requests being dropped or lost during the detachment process.
+   *
+   * @param request DetachVServerGroupsRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DetachVServerGroupsResponse
    */
   async detachVServerGroupsWithOptions(request: DetachVServerGroupsRequest, runtime: $Util.RuntimeOptions): Promise<DetachVServerGroupsResponse> {
     Util.validateModel(request);
@@ -19629,20 +20411,32 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can use the following parameters to specify the vServer groups that you want to detach from your scaling group.
-    * *   LoadBalancerId: the ID of the Classic Load Balancer (CLB) instance.
-    * *   VServerGroupId: the ID of the vServer group.
-    * *   Port: the port number of the vServer group.
-    * If the vServer group that is specified in this call matches the vServer group associated with your scaling group, the vServer group can be detached. Otherwise, the request for detaching the vServer group is ignored, and no error is reported.
-    *
-    * @param request DetachVServerGroupsRequest
-    * @return DetachVServerGroupsResponse
+   * @summary Detaches vServer groups from a scaling group. Auto Scaling supports the attachment of load balancers to scaling groups to improve service performance. If the load balancer currently attached to your scaling group is no longer needed to distribute the access traffic to the instances in your scaling group, you can call the DetachVServerGroups operation to detach one or more vServer groups of this load balancer from the scaling group.
+   *
+   * @description *   When you call the DetachVServerGroups operation, you must use the following parameters to specify the vServer groups that you want to detach from your scaling group:
+   *     *   LoadBalancerId: the ID of the load balancer
+   *     *   VServerGroupId: the ID of the vServer group
+   *     *   Port: the port number of the vServer group
+   * *   When the vServer group specified by the request parameters matches that attached to your scaling group, this operation yields a favorable result. Otherwise, the request is ignored and no error is reported.
+   * *   Before you call this operation, you must make sure that the load balancer has ceased routing the access traffic to the instances in the scaling group. Failure to do so may lead to service requests being dropped or lost during the detachment process.
+   *
+   * @param request DetachVServerGroupsRequest
+   * @return DetachVServerGroupsResponse
    */
   async detachVServerGroups(request: DetachVServerGroupsRequest): Promise<DetachVServerGroupsResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.detachVServerGroupsWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Disables an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you currently do not need an event-triggered task, you can call the DisableAlarm operation to disable it.
+   *
+   * @description Before you disable an event-triggered task, make sure that the task is in the `Normal`, `Alert`, or `Insufficient Data` state.
+   *
+   * @param request DisableAlarmRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DisableAlarmResponse
+   */
   async disableAlarmWithOptions(request: DisableAlarmRequest, runtime: $Util.RuntimeOptions): Promise<DisableAlarmResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19679,11 +20473,30 @@ export default class Client extends OpenApi {
     return $tea.cast<DisableAlarmResponse>(await this.callApi(params, req, runtime), new DisableAlarmResponse({}));
   }
 
+  /**
+   * @summary Disables an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you currently do not need an event-triggered task, you can call the DisableAlarm operation to disable it.
+   *
+   * @description Before you disable an event-triggered task, make sure that the task is in the `Normal`, `Alert`, or `Insufficient Data` state.
+   *
+   * @param request DisableAlarmRequest
+   * @return DisableAlarmResponse
+   */
   async disableAlarm(request: DisableAlarmRequest): Promise<DisableAlarmResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.disableAlarmWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Disables a scaling group.
+   *
+   * @description Before you call this operation to disable a scaling group, take note of the following items:
+   * *   When you call this operation, ongoing scaling activities will continue until they are complete, but new activities will be rejected.
+   * *   You can disable only scaling groups that are in the Active state.
+   *
+   * @param request DisableScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return DisableScalingGroupResponse
+   */
   async disableScalingGroupWithOptions(request: DisableScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<DisableScalingGroupResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19724,11 +20537,28 @@ export default class Client extends OpenApi {
     return $tea.cast<DisableScalingGroupResponse>(await this.callApi(params, req, runtime), new DisableScalingGroupResponse({}));
   }
 
+  /**
+   * @summary Disables a scaling group.
+   *
+   * @description Before you call this operation to disable a scaling group, take note of the following items:
+   * *   When you call this operation, ongoing scaling activities will continue until they are complete, but new activities will be rejected.
+   * *   You can disable only scaling groups that are in the Active state.
+   *
+   * @param request DisableScalingGroupRequest
+   * @return DisableScalingGroupResponse
+   */
   async disableScalingGroup(request: DisableScalingGroupRequest): Promise<DisableScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.disableScalingGroupWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Enables an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you want to reuse an event-triggered task that is in the Disabled state, you can call the EnableAlarm operation to enable it.
+   *
+   * @param request EnableAlarmRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return EnableAlarmResponse
+   */
   async enableAlarmWithOptions(request: EnableAlarmRequest, runtime: $Util.RuntimeOptions): Promise<EnableAlarmResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19765,21 +20595,29 @@ export default class Client extends OpenApi {
     return $tea.cast<EnableAlarmResponse>(await this.callApi(params, req, runtime), new EnableAlarmResponse({}));
   }
 
+  /**
+   * @summary Enables an event-triggered task. If your business pattern is unpredictable or prone to unforeseen traffic spikes, you can create event-triggered tasks by associating CloudMonitor metrics to effectively monitor fluctuations in your business workload. Upon detecting that the criteria for alerts, as specified in event-triggered tasks, are fulfilled, Auto Scaling promptly issues alerts and executes the scaling rules predefined within those tasks. This process occurs within the predefined effective time windows of the tasks, thereby facilitating the automatic increase or decrease of Elastic Compute Service (ECS) instances or elastic container instances within your scaling groups. Ultimately, this mechanism ensures the dynamic optimization of resources based on real-time workload demands. If you want to reuse an event-triggered task that is in the Disabled state, you can call the EnableAlarm operation to enable it.
+   *
+   * @param request EnableAlarmRequest
+   * @return EnableAlarmResponse
+   */
   async enableAlarm(request: EnableAlarmRequest): Promise<EnableAlarmResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.enableAlarmWithOptions(request, runtime);
   }
 
   /**
-    * You can call this operation to enable a scaling group that is in the Inactive state and has an instance configuration source. The instance configuration source can be a scaling configuration, a launch template, or an Elastic Compute Service (ECS) instance that you specified when you created the scaling group. If a scaling group is not in the Inactive state or does not have an active instance configuration source, you cannot call this operation to enable the scaling group.
-    * > A scaling group can have only one active instance configuration source. When you call this operation to enable a scaling group, you can specify a scaling configuration or a launch template for the scaling group. If an instance configuration source has been configured for the scaling group before you call this operation, the scaling configuration or launch template that you specify in the request overwrites the original scaling configuration or launch template.
-    * If you specify a value for the InstanceIds parameter when you call the operation, Auto Scaling checks whether the total number of ECS instances is within the range allowed in the scaling group after you call the operation.
-    * *   If the total number of ECS instances is less than the minimum number of instances required in the scaling group after you call the operation, Auto Scaling automatically creates the required number of pay-as-you-go ECS instances and adds the instances to the scaling group to reach the minimum number. For example, if the minimum number of instances required in your scaling group is five, and you specify the InstanceIds parameter to add two ECS instances to the scaling group, Auto Scaling automatically creates three instances in the scaling group after the two instances are added.
-    * *   If the value of the TotalCapacity parameter is greater than the value of the MaxSize parameter, the call fails.
-    *
-    * @param request EnableScalingGroupRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return EnableScalingGroupResponse
+   * @summary Enables a scaling group.
+   *
+   * @description You can call this operation to enable a scaling group that is in the Inactive state and has an instance configuration source. The instance configuration source can be a scaling configuration, a launch template, or an Elastic Compute Service (ECS) instance that you specified when you created the scaling group. If a scaling group is not in the Inactive state or does not have an active instance configuration source, you cannot call this operation to enable the scaling group.
+   * > A scaling group can have only one active instance configuration source. When you call this operation to enable a scaling group, you can specify a scaling configuration or a launch template for the scaling group. If an instance configuration source has been configured for the scaling group before you call this operation, the scaling configuration or launch template that you specify in the request overwrites the original scaling configuration or launch template.
+   * If you specify a value for the InstanceId parameter when you call the operation, Auto Scaling checks whether the total number of ECS instances is within the range allowed in the scaling group after you call the operation.
+   * *   If the total number of ECS instances is less than the minimum number of instances allowed in the scaling group after you call the operation, Auto Scaling automatically creates the required number of pay-as-you-go ECS instances and adds the instances to the scaling group to reach the minimum number. For example, if the minimum number of instances allowed in your scaling group is five, and you specify the InstanceId parameter to add two created ECS instances to the scaling group, Auto Scaling automatically creates three instances in the scaling group after the two instances are added.
+   * *   If the value of the TotalCapactiy parameter is greater than the value of the MaxSize parameter, the call fails.
+   *
+   * @param request EnableScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return EnableScalingGroupResponse
    */
   async enableScalingGroupWithOptions(request: EnableScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<EnableScalingGroupResponse> {
     Util.validateModel(request);
@@ -19850,20 +20688,35 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can call this operation to enable a scaling group that is in the Inactive state and has an instance configuration source. The instance configuration source can be a scaling configuration, a launch template, or an Elastic Compute Service (ECS) instance that you specified when you created the scaling group. If a scaling group is not in the Inactive state or does not have an active instance configuration source, you cannot call this operation to enable the scaling group.
-    * > A scaling group can have only one active instance configuration source. When you call this operation to enable a scaling group, you can specify a scaling configuration or a launch template for the scaling group. If an instance configuration source has been configured for the scaling group before you call this operation, the scaling configuration or launch template that you specify in the request overwrites the original scaling configuration or launch template.
-    * If you specify a value for the InstanceIds parameter when you call the operation, Auto Scaling checks whether the total number of ECS instances is within the range allowed in the scaling group after you call the operation.
-    * *   If the total number of ECS instances is less than the minimum number of instances required in the scaling group after you call the operation, Auto Scaling automatically creates the required number of pay-as-you-go ECS instances and adds the instances to the scaling group to reach the minimum number. For example, if the minimum number of instances required in your scaling group is five, and you specify the InstanceIds parameter to add two ECS instances to the scaling group, Auto Scaling automatically creates three instances in the scaling group after the two instances are added.
-    * *   If the value of the TotalCapacity parameter is greater than the value of the MaxSize parameter, the call fails.
-    *
-    * @param request EnableScalingGroupRequest
-    * @return EnableScalingGroupResponse
+   * @summary Enables a scaling group.
+   *
+   * @description You can call this operation to enable a scaling group that is in the Inactive state and has an instance configuration source. The instance configuration source can be a scaling configuration, a launch template, or an Elastic Compute Service (ECS) instance that you specified when you created the scaling group. If a scaling group is not in the Inactive state or does not have an active instance configuration source, you cannot call this operation to enable the scaling group.
+   * > A scaling group can have only one active instance configuration source. When you call this operation to enable a scaling group, you can specify a scaling configuration or a launch template for the scaling group. If an instance configuration source has been configured for the scaling group before you call this operation, the scaling configuration or launch template that you specify in the request overwrites the original scaling configuration or launch template.
+   * If you specify a value for the InstanceId parameter when you call the operation, Auto Scaling checks whether the total number of ECS instances is within the range allowed in the scaling group after you call the operation.
+   * *   If the total number of ECS instances is less than the minimum number of instances allowed in the scaling group after you call the operation, Auto Scaling automatically creates the required number of pay-as-you-go ECS instances and adds the instances to the scaling group to reach the minimum number. For example, if the minimum number of instances allowed in your scaling group is five, and you specify the InstanceId parameter to add two created ECS instances to the scaling group, Auto Scaling automatically creates three instances in the scaling group after the two instances are added.
+   * *   If the value of the TotalCapactiy parameter is greater than the value of the MaxSize parameter, the call fails.
+   *
+   * @param request EnableScalingGroupRequest
+   * @return EnableScalingGroupResponse
    */
   async enableScalingGroup(request: EnableScalingGroupRequest): Promise<EnableScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.enableScalingGroupWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Puts an Elastic Compute Service (ECS) instance into the Standby state.
+   *
+   * @description ## Description
+   * *   If you call the operation to put an ECS instance in a scaling group that is associated with a Classic Load Balancer (CLB) instance into the Standby state, the weight of the ECS instance as a backend server of the CLB instance is set to 0.
+   * *   You can remove an instance that is in the Standby state from a scaling group, and then release the instance.
+   * *   ECS instances that are in the Standby state are not removed from the scaling group during scale-in activities triggered by event-triggered tasks.
+   * *   If Auto Scaling considers an ECS instance that is in the Standby state unhealthy, for example, the ECS instance is being stopped or being restarted, Auto Scaling does not update the health status of the ECS instance or trigger scale-in activities to remove the ECS instance from the scaling group. Auto Scaling updates the health status of the ECS instance only when the ECS instance is no longer in the Standby state.
+   *
+   * @param request EnterStandbyRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return EnterStandbyResponse
+   */
   async enterStandbyWithOptions(request: EnterStandbyRequest, runtime: $Util.RuntimeOptions): Promise<EnterStandbyResponse> {
     Util.validateModel(request);
     let query = { };
@@ -19908,24 +20761,38 @@ export default class Client extends OpenApi {
     return $tea.cast<EnterStandbyResponse>(await this.callApi(params, req, runtime), new EnterStandbyResponse({}));
   }
 
+  /**
+   * @summary Puts an Elastic Compute Service (ECS) instance into the Standby state.
+   *
+   * @description ## Description
+   * *   If you call the operation to put an ECS instance in a scaling group that is associated with a Classic Load Balancer (CLB) instance into the Standby state, the weight of the ECS instance as a backend server of the CLB instance is set to 0.
+   * *   You can remove an instance that is in the Standby state from a scaling group, and then release the instance.
+   * *   ECS instances that are in the Standby state are not removed from the scaling group during scale-in activities triggered by event-triggered tasks.
+   * *   If Auto Scaling considers an ECS instance that is in the Standby state unhealthy, for example, the ECS instance is being stopped or being restarted, Auto Scaling does not update the health status of the ECS instance or trigger scale-in activities to remove the ECS instance from the scaling group. Auto Scaling updates the health status of the ECS instance only when the ECS instance is no longer in the Standby state.
+   *
+   * @param request EnterStandbyRequest
+   * @return EnterStandbyResponse
+   */
   async enterStandby(request: EnterStandbyRequest): Promise<EnterStandbyResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.enterStandbyWithOptions(request, runtime);
   }
 
   /**
-    * Before you call this operation, take note of the following items:
-    * *   The scaling group is in the Active state.
-    * *   No scaling activities in the scaling group are in progress.
-    * If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
-    * If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
-    * If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
-    * You can specify only a limited number of ECS instances in each adjustment. For more information, see the description of the AdjustmentValue parameter in the CreateScalingRule topic.
-    *
-    * @param request ExecuteScalingRuleRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ExecuteScalingRuleResponse
+   * @summary Executes a scaling rule.
+   *
+   * @description Before you call this operation, take note of the following items:
+   * *   The scaling group is in the Active state.
+   * *   No scaling activities in the scaling group are in progress.
+   * If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
+   * If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
+   * If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
+   * You can specify only a limited number of ECS instances in each adjustment. For more information, see the description of the AdjustmentValue parameter in the CreateScalingRule topic.
+   *
+   * @param request ExecuteScalingRuleRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ExecuteScalingRuleResponse
    */
   async executeScalingRuleWithOptions(request: ExecuteScalingRuleRequest, runtime: $Util.RuntimeOptions): Promise<ExecuteScalingRuleResponse> {
     Util.validateModel(request);
@@ -19984,23 +20851,35 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Before you call this operation, take note of the following items:
-    * *   The scaling group is in the Active state.
-    * *   No scaling activities in the scaling group are in progress.
-    * If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
-    * If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
-    * If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
-    * You can specify only a limited number of ECS instances in each adjustment. For more information, see the description of the AdjustmentValue parameter in the CreateScalingRule topic.
-    *
-    * @param request ExecuteScalingRuleRequest
-    * @return ExecuteScalingRuleResponse
+   * @summary Executes a scaling rule.
+   *
+   * @description Before you call this operation, take note of the following items:
+   * *   The scaling group is in the Active state.
+   * *   No scaling activities in the scaling group are in progress.
+   * If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the ScalingActivityId parameter in the response.
+   * If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
+   * If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
+   * You can specify only a limited number of ECS instances in each adjustment. For more information, see the description of the AdjustmentValue parameter in the CreateScalingRule topic.
+   *
+   * @param request ExecuteScalingRuleRequest
+   * @return ExecuteScalingRuleResponse
    */
   async executeScalingRule(request: ExecuteScalingRuleRequest): Promise<ExecuteScalingRuleResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.executeScalingRuleWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Moves an Elastic Compute Service (ECS) instance out of the Standby state.
+   *
+   * @description ## Description
+   * If your scaling group is associated with a Classic Load Balancer (CLB) instance and you move an ECS instance in your scaling group out of the Standby state, the weight of the ECS instance is reset to the value that is specified in the scaling configuration of your scaling group.
+   *
+   * @param request ExitStandbyRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ExitStandbyResponse
+   */
   async exitStandbyWithOptions(request: ExitStandbyRequest, runtime: $Util.RuntimeOptions): Promise<ExitStandbyResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20049,11 +20928,27 @@ export default class Client extends OpenApi {
     return $tea.cast<ExitStandbyResponse>(await this.callApi(params, req, runtime), new ExitStandbyResponse({}));
   }
 
+  /**
+   * @summary Moves an Elastic Compute Service (ECS) instance out of the Standby state.
+   *
+   * @description ## Description
+   * If your scaling group is associated with a Classic Load Balancer (CLB) instance and you move an ECS instance in your scaling group out of the Standby state, the weight of the ECS instance is reset to the value that is specified in the scaling configuration of your scaling group.
+   *
+   * @param request ExitStandbyRequest
+   * @return ExitStandbyResponse
+   */
   async exitStandby(request: ExitStandbyRequest): Promise<ExitStandbyResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.exitStandbyWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries the tag keys added to Auto Scaling resources. Querying tag keys facilitates easier classification, identification, and monitoring of your Auto Scaling resources, thereby enhancing the flexibility and convenience of your resource management processes.
+   *
+   * @param request ListTagKeysRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ListTagKeysResponse
+   */
   async listTagKeysWithOptions(request: ListTagKeysRequest, runtime: $Util.RuntimeOptions): Promise<ListTagKeysResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20098,11 +20993,24 @@ export default class Client extends OpenApi {
     return $tea.cast<ListTagKeysResponse>(await this.callApi(params, req, runtime), new ListTagKeysResponse({}));
   }
 
+  /**
+   * @summary Queries the tag keys added to Auto Scaling resources. Querying tag keys facilitates easier classification, identification, and monitoring of your Auto Scaling resources, thereby enhancing the flexibility and convenience of your resource management processes.
+   *
+   * @param request ListTagKeysRequest
+   * @return ListTagKeysResponse
+   */
   async listTagKeys(request: ListTagKeysRequest): Promise<ListTagKeysResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.listTagKeysWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries tags that are added to one or more Auto Scaling resources.
+   *
+   * @param request ListTagResourcesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ListTagResourcesResponse
+   */
   async listTagResourcesWithOptions(request: ListTagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<ListTagResourcesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20151,11 +21059,24 @@ export default class Client extends OpenApi {
     return $tea.cast<ListTagResourcesResponse>(await this.callApi(params, req, runtime), new ListTagResourcesResponse({}));
   }
 
+  /**
+   * @summary Queries tags that are added to one or more Auto Scaling resources.
+   *
+   * @param request ListTagResourcesRequest
+   * @return ListTagResourcesResponse
+   */
   async listTagResources(request: ListTagResourcesRequest): Promise<ListTagResourcesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.listTagResourcesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Queries the tag keys associated with Auto Scaling resources to facilitate a deeper comprehension of those resources. By doing so, you can categorize and manage your Auto Scaling resources more efficiently.
+   *
+   * @param request ListTagValuesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ListTagValuesResponse
+   */
   async listTagValuesWithOptions(request: ListTagValuesRequest, runtime: $Util.RuntimeOptions): Promise<ListTagValuesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20204,21 +21125,29 @@ export default class Client extends OpenApi {
     return $tea.cast<ListTagValuesResponse>(await this.callApi(params, req, runtime), new ListTagValuesResponse({}));
   }
 
+  /**
+   * @summary Queries the tag keys associated with Auto Scaling resources to facilitate a deeper comprehension of those resources. By doing so, you can categorize and manage your Auto Scaling resources more efficiently.
+   *
+   * @param request ListTagValuesRequest
+   * @return ListTagValuesResponse
+   */
   async listTagValues(request: ListTagValuesRequest): Promise<ListTagValuesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.listTagValuesWithOptions(request, runtime);
   }
 
   /**
-    * *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using the custom metrics. For more information, see [Custom monitoring event-triggered tasks](~~74861~~).
-    * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
-    *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
-    *     *   For information about the metrics that are supported if you set the MetricType parameter to system, see[ Event-triggered task for system monitoring](~~74854~~).
-    * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
-    *
-    * @param request ModifyAlarmRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyAlarmResponse
+   * @summary Modifies an event-triggered task.
+   *
+   * @description *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using the custom metrics. For more information, see [Custom monitoring event-triggered tasks](https://help.aliyun.com/document_detail/74861.html).
+   * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
+   *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
+   *     *   For information about the metrics that are supported if you set the MetricType parameter to system, see[ Event-triggered task for system monitoring](https://help.aliyun.com/document_detail/74854.html).
+   * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
+   *
+   * @param request ModifyAlarmRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyAlarmResponse
    */
   async modifyAlarmWithOptions(request: ModifyAlarmRequest, runtime: $Util.RuntimeOptions): Promise<ModifyAlarmResponse> {
     Util.validateModel(request);
@@ -20317,14 +21246,16 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using the custom metrics. For more information, see [Custom monitoring event-triggered tasks](~~74861~~).
-    * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
-    *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
-    *     *   For information about the metrics that are supported if you set the MetricType parameter to system, see[ Event-triggered task for system monitoring](~~74854~~).
-    * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
-    *
-    * @param request ModifyAlarmRequest
-    * @return ModifyAlarmResponse
+   * @summary Modifies an event-triggered task.
+   *
+   * @description *   If you set the MetricType parameter to custom, you must report your custom metrics to CloudMonitor before you can create event-triggered tasks by using the custom metrics. For more information, see [Custom monitoring event-triggered tasks](https://help.aliyun.com/document_detail/74861.html).
+   * *   When you create an event-triggered task, you must specify the MetricName, DimensionKey, and DimensionValue parameters to determine the range of statistics that you want to aggregate for the metrics of the scaling group. For example, you can specify the user_id and scaling_group dimensions for an event-triggered task to aggregate monitoring data of all Elastic Compute Service (ECS) instances or elastic container instances in a scaling group within an Alibaba Cloud account.
+   *     *   If you set the MetricType parameter to custom, the valid values are your custom metrics.
+   *     *   For information about the metrics that are supported if you set the MetricType parameter to system, see[ Event-triggered task for system monitoring](https://help.aliyun.com/document_detail/74854.html).
+   * > The user_id and scaling_group dimensions are automatically populated. You need to only specify the device and state dimensions. For more information, see the `DimensionKey` and `DimensionValue` parameters in the "Request parameters" section of this topic.
+   *
+   * @param request ModifyAlarmRequest
+   * @return ModifyAlarmResponse
    */
   async modifyAlarm(request: ModifyAlarmRequest): Promise<ModifyAlarmResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -20332,11 +21263,13 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * If you want to change the name of a scaling configuration in a scaling group, make sure that the new name is unique within the scaling group.
-    *
-    * @param request ModifyEciScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyEciScalingConfigurationResponse
+   * @summary Modifies a scaling configuration for a scaling group that contains elastic container instances.
+   *
+   * @description If you want to change the name of a scaling configuration in a scaling group, make sure that the new name is unique within the scaling group.
+   *
+   * @param request ModifyEciScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyEciScalingConfigurationResponse
    */
   async modifyEciScalingConfigurationWithOptions(request: ModifyEciScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<ModifyEciScalingConfigurationResponse> {
     Util.validateModel(request);
@@ -20559,16 +21492,25 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * If you want to change the name of a scaling configuration in a scaling group, make sure that the new name is unique within the scaling group.
-    *
-    * @param request ModifyEciScalingConfigurationRequest
-    * @return ModifyEciScalingConfigurationResponse
+   * @summary Modifies a scaling configuration for a scaling group that contains elastic container instances.
+   *
+   * @description If you want to change the name of a scaling configuration in a scaling group, make sure that the new name is unique within the scaling group.
+   *
+   * @param request ModifyEciScalingConfigurationRequest
+   * @return ModifyEciScalingConfigurationResponse
    */
   async modifyEciScalingConfiguration(request: ModifyEciScalingConfigurationRequest): Promise<ModifyEciScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyEciScalingConfigurationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Modifies the attributes of an Elastic Compute Service (ECS) instance in a scaling group. You can call the ModifyInstanceAttribute operation to modify the lifecycle management attribute of a manually added ECS instance in a scaling group.
+   *
+   * @param request ModifyInstanceAttributeRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyInstanceAttributeResponse
+   */
   async modifyInstanceAttributeWithOptions(request: ModifyInstanceAttributeRequest, runtime: $Util.RuntimeOptions): Promise<ModifyInstanceAttributeResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20613,19 +21555,27 @@ export default class Client extends OpenApi {
     return $tea.cast<ModifyInstanceAttributeResponse>(await this.callApi(params, req, runtime), new ModifyInstanceAttributeResponse({}));
   }
 
+  /**
+   * @summary Modifies the attributes of an Elastic Compute Service (ECS) instance in a scaling group. You can call the ModifyInstanceAttribute operation to modify the lifecycle management attribute of a manually added ECS instance in a scaling group.
+   *
+   * @param request ModifyInstanceAttributeRequest
+   * @return ModifyInstanceAttributeResponse
+   */
   async modifyInstanceAttribute(request: ModifyInstanceAttributeRequest): Promise<ModifyInstanceAttributeResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyInstanceAttributeWithOptions(request, runtime);
   }
 
   /**
-    * You can use one of the following methods to specify the lifecycle hook that you want to modify:
-    * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. When you use this method, the ScalingGroupId and LifecycleHookName parameters are ignored.
-    * *   Specify the scaling group ID by using the ScalingGroupId parameter and specify the lifecycle hook name by using the LifecycleHookName parameter.
-    *
-    * @param request ModifyLifecycleHookRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyLifecycleHookResponse
+   * @summary Modifies a lifecycle hook.
+   *
+   * @description You can use one of the following methods to specify the lifecycle hook that you want to modify:
+   * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. When you use this method, the ScalingGroupId and LifecycleHookName parameters are ignored.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter.
+   *
+   * @param request ModifyLifecycleHookRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyLifecycleHookResponse
    */
   async modifyLifecycleHookWithOptions(request: ModifyLifecycleHookRequest, runtime: $Util.RuntimeOptions): Promise<ModifyLifecycleHookResponse> {
     Util.validateModel(request);
@@ -20700,18 +21650,27 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can use one of the following methods to specify the lifecycle hook that you want to modify:
-    * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. When you use this method, the ScalingGroupId and LifecycleHookName parameters are ignored.
-    * *   Specify the scaling group ID by using the ScalingGroupId parameter and specify the lifecycle hook name by using the LifecycleHookName parameter.
-    *
-    * @param request ModifyLifecycleHookRequest
-    * @return ModifyLifecycleHookResponse
+   * @summary Modifies a lifecycle hook.
+   *
+   * @description You can use one of the following methods to specify the lifecycle hook that you want to modify:
+   * *   Specify the lifecycle hook ID by using the LifecycleHookId parameter. When you use this method, the ScalingGroupId and LifecycleHookName parameters are ignored.
+   * *   Specify the scaling group ID by using the ScalingGroupId parameter and the lifecycle hook name by using the LifecycleHookName parameter.
+   *
+   * @param request ModifyLifecycleHookRequest
+   * @return ModifyLifecycleHookResponse
    */
   async modifyLifecycleHook(request: ModifyLifecycleHookRequest): Promise<ModifyLifecycleHookResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyLifecycleHookWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Modifies a notification.
+   *
+   * @param request ModifyNotificationConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyNotificationConfigurationResponse
+   */
   async modifyNotificationConfigurationWithOptions(request: ModifyNotificationConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<ModifyNotificationConfigurationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -20756,17 +21715,25 @@ export default class Client extends OpenApi {
     return $tea.cast<ModifyNotificationConfigurationResponse>(await this.callApi(params, req, runtime), new ModifyNotificationConfigurationResponse({}));
   }
 
+  /**
+   * @summary Modifies a notification.
+   *
+   * @param request ModifyNotificationConfigurationRequest
+   * @return ModifyNotificationConfigurationResponse
+   */
   async modifyNotificationConfiguration(request: ModifyNotificationConfigurationRequest): Promise<ModifyNotificationConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyNotificationConfigurationWithOptions(request, runtime);
   }
 
   /**
-    * You can change the name of a scaling configuration in a scaling group. The name must be unique within the scaling group.
-    *
-    * @param tmpReq ModifyScalingConfigurationRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyScalingConfigurationResponse
+   * @summary Modifies a scaling configuration.
+   *
+   * @description You can change the name of a scaling configuration in a scaling group. The name must be unique within the scaling group.
+   *
+   * @param tmpReq ModifyScalingConfigurationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyScalingConfigurationResponse
    */
   async modifyScalingConfigurationWithOptions(tmpReq: ModifyScalingConfigurationRequest, runtime: $Util.RuntimeOptions): Promise<ModifyScalingConfigurationResponse> {
     Util.validateModel(tmpReq);
@@ -21007,10 +21974,12 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can change the name of a scaling configuration in a scaling group. The name must be unique within the scaling group.
-    *
-    * @param request ModifyScalingConfigurationRequest
-    * @return ModifyScalingConfigurationResponse
+   * @summary Modifies a scaling configuration.
+   *
+   * @description You can change the name of a scaling configuration in a scaling group. The name must be unique within the scaling group.
+   *
+   * @param request ModifyScalingConfigurationRequest
+   * @return ModifyScalingConfigurationResponse
    */
   async modifyScalingConfiguration(request: ModifyScalingConfigurationRequest): Promise<ModifyScalingConfigurationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -21018,21 +21987,23 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   You cannot call this operation to modify the settings of the following parameters:
-    *     *   RegionId
-    *     *   LoadBalancerId
-    *     > If you want to change the CLB instances that are associated with your scaling group, call the AttachLoadBalancers and DetachLoadBalancers operations.
-    *     *   DBInstanceId
-    *     > If you want to change the ApsaraDB RDS instances that are associated with your scaling group, call the AttachDBInstances and DetachDBInstances operations.
-    * *   You can modify only scaling groups that are in the Active or Inactive state.
-    * *   If you enable a new scaling configuration, Elastic Compute Service (ECS) instances that are created based on the previous scaling configuration still run as expected in the scaling group.
-    * *   If the total number of instances in the scaling group is greater than the allowed maximum number after you change the value of the MaxSize parameter, Auto Scaling automatically removes instances from the scaling group to ensure that the number of instances is within the new range.
-    * *   If the total number of instances in the scaling group is less than the allowed minimum number after you change the value of the MinSize parameter, Auto Scaling automatically adds instances to the scaling group to ensure that the number of instances is within the new range.
-    * *   If the total number of instances in the scaling group does not match the expected number of instances after you change the value of the DesiredCapacity parameter, Auto Scaling automatically adds instances to or removes instances from the scaling group to ensure that the number of instances matches the value of the DesiredCapacity parameter.
-    *
-    * @param request ModifyScalingGroupRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyScalingGroupResponse
+   * @summary Modifies a scaling group.
+   *
+   * @description *   You cannot call this operation to modify the settings of the following parameters:
+   *     *   RegionId
+   *     *   LoadBalancerId
+   *     > If you want to change the CLB instances that are associated with your scaling group, call the AttachLoadBalancers and DetachLoadBalancers operations.
+   *     *   DBInstanceId
+   *     > If you want to change the ApsaraDB RDS instances that are associated with your scaling group, call the AttachDBInstances and DetachDBInstances operations.
+   * *   You can modify only scaling groups that are in the Active or Inactive state.
+   * *   If you enable a new scaling configuration, Elastic Compute Service (ECS) instances that are created based on the previous scaling configuration still run as expected in the scaling group.
+   * *   If the total number of instances in the scaling group is greater than the allowed maximum number after you change the value of the MaxSize parameter, Auto Scaling automatically removes instances from the scaling group to ensure that the number of instances is within the new range.
+   * *   If the total number of instances in the scaling group is less than the allowed minimum number after you change the value of the MinSize parameter, Auto Scaling automatically adds instances to the scaling group to ensure that the number of instances is within the new range.
+   * *   If the total number of instances in the scaling group does not match the expected number of instances after you change the value of the DesiredCapacity parameter, Auto Scaling automatically adds instances to or removes instances from the scaling group to ensure that the number of instances matches the value of the DesiredCapacity parameter.
+   *
+   * @param request ModifyScalingGroupRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyScalingGroupResponse
    */
   async modifyScalingGroupWithOptions(request: ModifyScalingGroupRequest, runtime: $Util.RuntimeOptions): Promise<ModifyScalingGroupResponse> {
     Util.validateModel(request);
@@ -21183,26 +22154,35 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   You cannot call this operation to modify the settings of the following parameters:
-    *     *   RegionId
-    *     *   LoadBalancerId
-    *     > If you want to change the CLB instances that are associated with your scaling group, call the AttachLoadBalancers and DetachLoadBalancers operations.
-    *     *   DBInstanceId
-    *     > If you want to change the ApsaraDB RDS instances that are associated with your scaling group, call the AttachDBInstances and DetachDBInstances operations.
-    * *   You can modify only scaling groups that are in the Active or Inactive state.
-    * *   If you enable a new scaling configuration, Elastic Compute Service (ECS) instances that are created based on the previous scaling configuration still run as expected in the scaling group.
-    * *   If the total number of instances in the scaling group is greater than the allowed maximum number after you change the value of the MaxSize parameter, Auto Scaling automatically removes instances from the scaling group to ensure that the number of instances is within the new range.
-    * *   If the total number of instances in the scaling group is less than the allowed minimum number after you change the value of the MinSize parameter, Auto Scaling automatically adds instances to the scaling group to ensure that the number of instances is within the new range.
-    * *   If the total number of instances in the scaling group does not match the expected number of instances after you change the value of the DesiredCapacity parameter, Auto Scaling automatically adds instances to or removes instances from the scaling group to ensure that the number of instances matches the value of the DesiredCapacity parameter.
-    *
-    * @param request ModifyScalingGroupRequest
-    * @return ModifyScalingGroupResponse
+   * @summary Modifies a scaling group.
+   *
+   * @description *   You cannot call this operation to modify the settings of the following parameters:
+   *     *   RegionId
+   *     *   LoadBalancerId
+   *     > If you want to change the CLB instances that are associated with your scaling group, call the AttachLoadBalancers and DetachLoadBalancers operations.
+   *     *   DBInstanceId
+   *     > If you want to change the ApsaraDB RDS instances that are associated with your scaling group, call the AttachDBInstances and DetachDBInstances operations.
+   * *   You can modify only scaling groups that are in the Active or Inactive state.
+   * *   If you enable a new scaling configuration, Elastic Compute Service (ECS) instances that are created based on the previous scaling configuration still run as expected in the scaling group.
+   * *   If the total number of instances in the scaling group is greater than the allowed maximum number after you change the value of the MaxSize parameter, Auto Scaling automatically removes instances from the scaling group to ensure that the number of instances is within the new range.
+   * *   If the total number of instances in the scaling group is less than the allowed minimum number after you change the value of the MinSize parameter, Auto Scaling automatically adds instances to the scaling group to ensure that the number of instances is within the new range.
+   * *   If the total number of instances in the scaling group does not match the expected number of instances after you change the value of the DesiredCapacity parameter, Auto Scaling automatically adds instances to or removes instances from the scaling group to ensure that the number of instances matches the value of the DesiredCapacity parameter.
+   *
+   * @param request ModifyScalingGroupRequest
+   * @return ModifyScalingGroupResponse
    */
   async modifyScalingGroup(request: ModifyScalingGroupRequest): Promise<ModifyScalingGroupResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyScalingGroupWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Modifies a scaling rule.
+   *
+   * @param request ModifyScalingRuleRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyScalingRuleResponse
+   */
   async modifyScalingRuleWithOptions(request: ModifyScalingRuleRequest, runtime: $Util.RuntimeOptions): Promise<ModifyScalingRuleResponse> {
     Util.validateModel(request);
     let query = { };
@@ -21315,20 +22295,28 @@ export default class Client extends OpenApi {
     return $tea.cast<ModifyScalingRuleResponse>(await this.callApi(params, req, runtime), new ModifyScalingRuleResponse({}));
   }
 
+  /**
+   * @summary Modifies a scaling rule.
+   *
+   * @param request ModifyScalingRuleRequest
+   * @return ModifyScalingRuleResponse
+   */
   async modifyScalingRule(request: ModifyScalingRuleRequest): Promise<ModifyScalingRuleResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyScalingRuleWithOptions(request, runtime);
   }
 
   /**
-    * You can use the following parameters to specify the scaling method of a scheduled task:
-    * *   If you use the `ScheduledAction` parameter, you must select an existing scaling rule for the scheduled task.
-    * *   If you use the `ScalingGroupId` parameter, you must specify the minimum number, maximum number, or expected number of instances in the scheduled task.
-    * > You cannot specify the `ScheduledAction` and `ScalingGroupId` parameters at the same time.
-    *
-    * @param request ModifyScheduledTaskRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ModifyScheduledTaskResponse
+   * @summary Modifies a scheduled task.
+   *
+   * @description You can use the following parameters to specify the scaling method of a scheduled task:
+   * *   If you use the `ScheduledAction` parameter, you must select an existing scaling rule for the scheduled task.
+   * *   If you use the `ScalingGroupId` parameter, you must specify the minimum number, maximum number, or expected number of instances in the scheduled task.
+   * > You cannot specify the `ScheduledAction` and `ScalingGroupId` parameters at the same time.
+   *
+   * @param request ModifyScheduledTaskRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ModifyScheduledTaskResponse
    */
   async modifyScheduledTaskWithOptions(request: ModifyScheduledTaskRequest, runtime: $Util.RuntimeOptions): Promise<ModifyScheduledTaskResponse> {
     Util.validateModel(request);
@@ -21423,19 +22411,36 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can use the following parameters to specify the scaling method of a scheduled task:
-    * *   If you use the `ScheduledAction` parameter, you must select an existing scaling rule for the scheduled task.
-    * *   If you use the `ScalingGroupId` parameter, you must specify the minimum number, maximum number, or expected number of instances in the scheduled task.
-    * > You cannot specify the `ScheduledAction` and `ScalingGroupId` parameters at the same time.
-    *
-    * @param request ModifyScheduledTaskRequest
-    * @return ModifyScheduledTaskResponse
+   * @summary Modifies a scheduled task.
+   *
+   * @description You can use the following parameters to specify the scaling method of a scheduled task:
+   * *   If you use the `ScheduledAction` parameter, you must select an existing scaling rule for the scheduled task.
+   * *   If you use the `ScalingGroupId` parameter, you must specify the minimum number, maximum number, or expected number of instances in the scheduled task.
+   * > You cannot specify the `ScheduledAction` and `ScalingGroupId` parameters at the same time.
+   *
+   * @param request ModifyScheduledTaskRequest
+   * @return ModifyScheduledTaskResponse
    */
   async modifyScheduledTask(request: ModifyScheduledTaskRequest): Promise<ModifyScheduledTaskResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.modifyScheduledTaskWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Rebalances the distribution of Elastic Compute Service (ECS) instances across zones. If ECS instances are unevenly distributed across multiple zones, you can call the RebalanceInstances operation to rebalance the distribution of the ECS instances across the zones.
+   *
+   * @description ## [](#)Usage notes
+   * Auto Scaling creates new ECS instances to replace the existing ECS instances to fulfill the rebalancing purpose. Auto Scaling starts the new ECS instances before stopping the existing ECS instances. The rebalancing operation does not affect the performance or service availability of your application.
+   * *   This operation is supported by only multi-zone scaling groups whose `MultiAZPolicy` is set to `BALANCE`.
+   * *   A rebalancing operation is required only when the distribution of the instances of a multi-zone scaling group is significantly unbalanced. In a rebalancing activity, Auto Scaling replaces up to 20 ECS instances to rectify the unbalanced distribution.
+   * *   During the execution of a rebalancing operation, if the number of instances in the scaling group approaches or hits the value of MaxSize but the rebalancing operation needs to continue, Auto Scaling allows the total number of ECS instances to momentarily exceed the value of MaxSize by 10%. This temporary surplus condition persists for a duration until equilibrium in the distribution of ECS instances is achieved. Typically, it takes 1 to 6 minutes.
+   *     **
+   *     **Note** If the 10% increment of the maximum number of instances in a scaling group yield a non-integer value, the decimal portion is always rounded up to ensure an additional instance is accounted for. For example, you have a scaling group that holds a maximum of 15 ECS instances. During a rebalancing operation, Auto Scaling would permit the total number of instances to momentarily surpass this limit by 2, instead of the calculated 10% (which is 1.5).
+   *
+   * @param request RebalanceInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return RebalanceInstancesResponse
+   */
   async rebalanceInstancesWithOptions(request: RebalanceInstancesRequest, runtime: $Util.RuntimeOptions): Promise<RebalanceInstancesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -21480,17 +22485,33 @@ export default class Client extends OpenApi {
     return $tea.cast<RebalanceInstancesResponse>(await this.callApi(params, req, runtime), new RebalanceInstancesResponse({}));
   }
 
+  /**
+   * @summary Rebalances the distribution of Elastic Compute Service (ECS) instances across zones. If ECS instances are unevenly distributed across multiple zones, you can call the RebalanceInstances operation to rebalance the distribution of the ECS instances across the zones.
+   *
+   * @description ## [](#)Usage notes
+   * Auto Scaling creates new ECS instances to replace the existing ECS instances to fulfill the rebalancing purpose. Auto Scaling starts the new ECS instances before stopping the existing ECS instances. The rebalancing operation does not affect the performance or service availability of your application.
+   * *   This operation is supported by only multi-zone scaling groups whose `MultiAZPolicy` is set to `BALANCE`.
+   * *   A rebalancing operation is required only when the distribution of the instances of a multi-zone scaling group is significantly unbalanced. In a rebalancing activity, Auto Scaling replaces up to 20 ECS instances to rectify the unbalanced distribution.
+   * *   During the execution of a rebalancing operation, if the number of instances in the scaling group approaches or hits the value of MaxSize but the rebalancing operation needs to continue, Auto Scaling allows the total number of ECS instances to momentarily exceed the value of MaxSize by 10%. This temporary surplus condition persists for a duration until equilibrium in the distribution of ECS instances is achieved. Typically, it takes 1 to 6 minutes.
+   *     **
+   *     **Note** If the 10% increment of the maximum number of instances in a scaling group yield a non-integer value, the decimal portion is always rounded up to ensure an additional instance is accounted for. For example, you have a scaling group that holds a maximum of 15 ECS instances. During a rebalancing operation, Auto Scaling would permit the total number of instances to momentarily surpass this limit by 2, instead of the calculated 10% (which is 1.5).
+   *
+   * @param request RebalanceInstancesRequest
+   * @return RebalanceInstancesResponse
+   */
   async rebalanceInstances(request: RebalanceInstancesRequest): Promise<RebalanceInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.rebalanceInstancesWithOptions(request, runtime);
   }
 
   /**
-    * You can call this operation to prolong the length of a lifecycle hook up to 20 times. Take note that the total length of a lifecycle hook cannot exceed 6 hours.
-    *
-    * @param request RecordLifecycleActionHeartbeatRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return RecordLifecycleActionHeartbeatResponse
+   * @summary Prolongs a lifecycle hook for Elastic Compute Service (ECS) instances.
+   *
+   * @description You can call this operation to prolong the length of a lifecycle hook up to 20 times. Take note that the total length of a lifecycle hook cannot exceed 6 hours.
+   *
+   * @param request RecordLifecycleActionHeartbeatRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return RecordLifecycleActionHeartbeatResponse
    */
   async recordLifecycleActionHeartbeatWithOptions(request: RecordLifecycleActionHeartbeatRequest, runtime: $Util.RuntimeOptions): Promise<RecordLifecycleActionHeartbeatResponse> {
     Util.validateModel(request);
@@ -21541,10 +22562,12 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * You can call this operation to prolong the length of a lifecycle hook up to 20 times. Take note that the total length of a lifecycle hook cannot exceed 6 hours.
-    *
-    * @param request RecordLifecycleActionHeartbeatRequest
-    * @return RecordLifecycleActionHeartbeatResponse
+   * @summary Prolongs a lifecycle hook for Elastic Compute Service (ECS) instances.
+   *
+   * @description You can call this operation to prolong the length of a lifecycle hook up to 20 times. Take note that the total length of a lifecycle hook cannot exceed 6 hours.
+   *
+   * @param request RecordLifecycleActionHeartbeatRequest
+   * @return RecordLifecycleActionHeartbeatResponse
    */
   async recordLifecycleActionHeartbeat(request: RecordLifecycleActionHeartbeatRequest): Promise<RecordLifecycleActionHeartbeatResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -21552,18 +22575,20 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   Before you call this operation, make sure that the following requirements are met:
-    *     *   The scaling group is in the Active state.
-    *     *   No scaling activity is in progress within the scaling group.
-    * > If no scaling activity is in progress within the scaling group, you can call the operation even within the cooldown period.
-    * *   If an ECS instance is automatically created by Auto Scaling, or if an ECS instance is manually added to a scaling group and managed by the scaling group, the ECS instance is stopped in economical mode or is released after the instance is removed from the scaling group.
-    * *   If an ECS instance is manually added to a scaling group and is not managed by the scaling group, the ECS instance is not stopped or released after the instance is removed from the scaling group.
-    * *   If the difference between the number of existing ECS instances specified by the TotalCapacity parameter and the number of ECS instances that you call this operation to remove is less than the value of the MinSize parameter, the call fails.
-    * A successful call only means that Auto Scaling accepts the request. The scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
-    *
-    * @param request RemoveInstancesRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return RemoveInstancesResponse
+   * @summary Removes one or more Elastic Compute Service (ECS) instances or elastic container instances from a scaling group.
+   *
+   * @description *   Before you call this operation, make sure that the following requirements are met:
+   *     *   The scaling group is in the Active state.
+   *     *   No scaling activity is in progress within the scaling group.
+   * > If no scaling activity is in progress within the scaling group, you can call the operation even within the cooldown period.
+   * *   If an ECS instance is automatically created by Auto Scaling, or if an ECS instance is manually added to a scaling group and managed by the scaling group, the ECS instance is stopped in economical mode or is released after the instance is removed from the scaling group.
+   * *   If an ECS instance is manually added to a scaling group and is not managed by the scaling group, the ECS instance is not stopped or released after the instance is removed from the scaling group.
+   * *   If the difference between the number of existing ECS instances specified by the TotalCapacity parameter and the number of ECS instances that you call this operation to remove is less than the value of the MinSize parameter, the call fails.
+   * A successful call only means that Auto Scaling accepts the request. The scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
+   *
+   * @param request RemoveInstancesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return RemoveInstancesResponse
    */
   async removeInstancesWithOptions(request: RemoveInstancesRequest, runtime: $Util.RuntimeOptions): Promise<RemoveInstancesResponse> {
     Util.validateModel(request);
@@ -21576,6 +22601,10 @@ export default class Client extends OpenApi {
       query["DecreaseDesiredCapacity"] = request.decreaseDesiredCapacity;
     }
 
+    if (!Util.isUnset(request.ignoreInvalidInstance)) {
+      query["IgnoreInvalidInstance"] = request.ignoreInvalidInstance;
+    }
+
     if (!Util.isUnset(request.instanceIds)) {
       query["InstanceIds"] = request.instanceIds;
     }
@@ -21626,23 +22655,32 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * *   Before you call this operation, make sure that the following requirements are met:
-    *     *   The scaling group is in the Active state.
-    *     *   No scaling activity is in progress within the scaling group.
-    * > If no scaling activity is in progress within the scaling group, you can call the operation even within the cooldown period.
-    * *   If an ECS instance is automatically created by Auto Scaling, or if an ECS instance is manually added to a scaling group and managed by the scaling group, the ECS instance is stopped in economical mode or is released after the instance is removed from the scaling group.
-    * *   If an ECS instance is manually added to a scaling group and is not managed by the scaling group, the ECS instance is not stopped or released after the instance is removed from the scaling group.
-    * *   If the difference between the number of existing ECS instances specified by the TotalCapacity parameter and the number of ECS instances that you call this operation to remove is less than the value of the MinSize parameter, the call fails.
-    * A successful call only means that Auto Scaling accepts the request. The scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
-    *
-    * @param request RemoveInstancesRequest
-    * @return RemoveInstancesResponse
+   * @summary Removes one or more Elastic Compute Service (ECS) instances or elastic container instances from a scaling group.
+   *
+   * @description *   Before you call this operation, make sure that the following requirements are met:
+   *     *   The scaling group is in the Active state.
+   *     *   No scaling activity is in progress within the scaling group.
+   * > If no scaling activity is in progress within the scaling group, you can call the operation even within the cooldown period.
+   * *   If an ECS instance is automatically created by Auto Scaling, or if an ECS instance is manually added to a scaling group and managed by the scaling group, the ECS instance is stopped in economical mode or is released after the instance is removed from the scaling group.
+   * *   If an ECS instance is manually added to a scaling group and is not managed by the scaling group, the ECS instance is not stopped or released after the instance is removed from the scaling group.
+   * *   If the difference between the number of existing ECS instances specified by the TotalCapacity parameter and the number of ECS instances that you call this operation to remove is less than the value of the MinSize parameter, the call fails.
+   * A successful call only means that Auto Scaling accepts the request. The scaling activity may still fail. You can obtain the status of a scaling activity based on the value of the ScalingActivityId parameter in the response.
+   *
+   * @param request RemoveInstancesRequest
+   * @return RemoveInstancesResponse
    */
   async removeInstances(request: RemoveInstancesRequest): Promise<RemoveInstancesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.removeInstancesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Resumes suspended processes in a scaling group.
+   *
+   * @param request ResumeProcessesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ResumeProcessesResponse
+   */
   async resumeProcessesWithOptions(request: ResumeProcessesRequest, runtime: $Util.RuntimeOptions): Promise<ResumeProcessesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -21687,24 +22725,32 @@ export default class Client extends OpenApi {
     return $tea.cast<ResumeProcessesResponse>(await this.callApi(params, req, runtime), new ResumeProcessesResponse({}));
   }
 
+  /**
+   * @summary Resumes suspended processes in a scaling group.
+   *
+   * @param request ResumeProcessesRequest
+   * @return ResumeProcessesResponse
+   */
   async resumeProcesses(request: ResumeProcessesRequest): Promise<ResumeProcessesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.resumeProcessesWithOptions(request, runtime);
   }
 
   /**
-    * Compared with the ExecuteScalingRule operation, the ScaleWithAdjustment operation does not require a scaling rule to be created in advance. Before you call the ScaleWithAdjustment operation, take note of the following items:
-    * *   The following conditions must be met:
-    *     *   The scaling group is in the Active state.
-    *     *   No scaling activities in the scaling group are in progress.
-    * *   If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * *   If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
-    * *   If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the `ScalingActivityId` parameter in the response.
-    *
-    * @param tmpReq ScaleWithAdjustmentRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return ScaleWithAdjustmentResponse
+   * @summary Scales instances in a scaling group based on the specified scaling policy.
+   *
+   * @description Compared with the ExecuteScalingRule operation, the ScaleWithAdjustment operation does not require a scaling rule to be created in advance. Before you call the ScaleWithAdjustment operation, take note of the following items:
+   * *   The following conditions must be met:
+   *     *   The scaling group is in the Active state.
+   *     *   No scaling activities in the scaling group are in progress.
+   * *   If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * *   If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
+   * *   If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the `ScalingActivityId` parameter in the response.
+   *
+   * @param tmpReq ScaleWithAdjustmentRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return ScaleWithAdjustmentResponse
    */
   async scaleWithAdjustmentWithOptions(tmpReq: ScaleWithAdjustmentRequest, runtime: $Util.RuntimeOptions): Promise<ScaleWithAdjustmentResponse> {
     Util.validateModel(tmpReq);
@@ -21781,23 +22827,32 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Compared with the ExecuteScalingRule operation, the ScaleWithAdjustment operation does not require a scaling rule to be created in advance. Before you call the ScaleWithAdjustment operation, take note of the following items:
-    * *   The following conditions must be met:
-    *     *   The scaling group is in the Active state.
-    *     *   No scaling activities in the scaling group are in progress.
-    * *   If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
-    * *   If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
-    * *   If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
-    * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the `ScalingActivityId` parameter in the response.
-    *
-    * @param request ScaleWithAdjustmentRequest
-    * @return ScaleWithAdjustmentResponse
+   * @summary Scales instances in a scaling group based on the specified scaling policy.
+   *
+   * @description Compared with the ExecuteScalingRule operation, the ScaleWithAdjustment operation does not require a scaling rule to be created in advance. Before you call the ScaleWithAdjustment operation, take note of the following items:
+   * *   The following conditions must be met:
+   *     *   The scaling group is in the Active state.
+   *     *   No scaling activities in the scaling group are in progress.
+   * *   If no scaling activities in the scaling group are in progress, the operation can trigger scaling activities even before the cooldown time expires.
+   * *   If the addition of a specified number of Elastic Compute Service (ECS) instances to a scaling group causes the total number of ECS instances in the scaling group to exceed the maximum number of instances allowed, Auto Scaling adds only a specific number of ECS instances to ensure that the total number of instances is equal to the maximum number of instances.
+   * *   If the removal of a specified number of ECS instances from a scaling group causes the total number of ECS instances in the scaling group to drop below the minimum number of instances allowed, Auto Scaling removes only a specific number of ECS instances to ensure that the total number of instances is equal to the minimum number of instances.
+   * A successful call indicates that Auto Scaling accepts the request. However, the scaling activity may still fail. You can obtain the status of a scaling activity by using the value of the `ScalingActivityId` parameter in the response.
+   *
+   * @param request ScaleWithAdjustmentRequest
+   * @return ScaleWithAdjustmentResponse
    */
   async scaleWithAdjustment(request: ScaleWithAdjustmentRequest): Promise<ScaleWithAdjustmentResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.scaleWithAdjustmentWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Sets deletion protection for a scaling group. If you enable deletion protection for a scaling group, you cannot delete the scaling group. If you disable deletion protection for a scaling group, you can directly delete the scaling group. You can call the SetGroupDeletionProtection operation to enable or disable deletion protection.
+   *
+   * @param request SetGroupDeletionProtectionRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return SetGroupDeletionProtectionResponse
+   */
   async setGroupDeletionProtectionWithOptions(request: SetGroupDeletionProtectionRequest, runtime: $Util.RuntimeOptions): Promise<SetGroupDeletionProtectionResponse> {
     Util.validateModel(request);
     let query = { };
@@ -21838,17 +22893,25 @@ export default class Client extends OpenApi {
     return $tea.cast<SetGroupDeletionProtectionResponse>(await this.callApi(params, req, runtime), new SetGroupDeletionProtectionResponse({}));
   }
 
+  /**
+   * @summary Sets deletion protection for a scaling group. If you enable deletion protection for a scaling group, you cannot delete the scaling group. If you disable deletion protection for a scaling group, you can directly delete the scaling group. You can call the SetGroupDeletionProtection operation to enable or disable deletion protection.
+   *
+   * @param request SetGroupDeletionProtectionRequest
+   * @return SetGroupDeletionProtectionResponse
+   */
   async setGroupDeletionProtection(request: SetGroupDeletionProtectionRequest): Promise<SetGroupDeletionProtectionResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.setGroupDeletionProtectionWithOptions(request, runtime);
   }
 
   /**
-    * Configures the health check feature for Elastic Compute Service (ECS) instances.
-    *
-    * @param request SetInstanceHealthRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return SetInstanceHealthResponse
+   * @summary Sets instance health. At times, the automatic health check system might not sufficiently determine the precise health status of your Elastic Compute Service (ECS) instances or elastic container instances. To overcome this, you can call the SetInstanceHealth operation to swiftly pinpoint problematic instances and resolve issues. This operation is designed to more precisely align with real-world business requirements and tackle O\\&M hurdles efficiently.
+   *
+   * @description Auto Scaling detects and removes unhealthy ECS instances or elastic container instances from the corresponding scaling groups. If you want to retain a specific instance in the corresponding scaling group, you can put the instance into the Standby or Protected state. For more information, see [EnterStandby](~~EnterStandby~~) and [SetInstancesProtection](~~SetInstancesProtection~~).
+   *
+   * @param request SetInstanceHealthRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return SetInstanceHealthResponse
    */
   async setInstanceHealthWithOptions(request: SetInstanceHealthRequest, runtime: $Util.RuntimeOptions): Promise<SetInstanceHealthResponse> {
     Util.validateModel(request);
@@ -21887,10 +22950,12 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Configures the health check feature for Elastic Compute Service (ECS) instances.
-    *
-    * @param request SetInstanceHealthRequest
-    * @return SetInstanceHealthResponse
+   * @summary Sets instance health. At times, the automatic health check system might not sufficiently determine the precise health status of your Elastic Compute Service (ECS) instances or elastic container instances. To overcome this, you can call the SetInstanceHealth operation to swiftly pinpoint problematic instances and resolve issues. This operation is designed to more precisely align with real-world business requirements and tackle O\\&M hurdles efficiently.
+   *
+   * @description Auto Scaling detects and removes unhealthy ECS instances or elastic container instances from the corresponding scaling groups. If you want to retain a specific instance in the corresponding scaling group, you can put the instance into the Standby or Protected state. For more information, see [EnterStandby](~~EnterStandby~~) and [SetInstancesProtection](~~SetInstancesProtection~~).
+   *
+   * @param request SetInstanceHealthRequest
+   * @return SetInstanceHealthResponse
    */
   async setInstanceHealth(request: SetInstanceHealthRequest): Promise<SetInstanceHealthResponse> {
     let runtime = new $Util.RuntimeOptions({ });
@@ -21898,11 +22963,16 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Puts one or more Elastic Compute Service (ECS) instances into the Protected state.
-    *
-    * @param request SetInstancesProtectionRequest
-    * @param runtime runtime options for this request RuntimeOptions
-    * @return SetInstancesProtectionResponse
+   * @summary Puts Elastic Compute Service (ECS) instances into the Protected state. When ECS instances are put into the Protected state, they become immune to manual deletion attempts by using the Auto Scaling console or API operations. This operation serves as a robust safeguard, efficiently preventing any inadvertent instance release that could lead to irreversible consequences.
+   *
+   * @description Once ECS instances enter the Protected state, they become subject to the following restrictions:
+   * *   ECS instances will persist in the Protected state, unless you deliberately remove them from this state.
+   * *   Even in scenarios where automatic scale-in actions are initiated due to fluctuations in the number of ECS instances or the execution of event-triggered tasks, Auto Scaling does not remove ECS instances that are in the Protected state from their respective scaling groups. Only after being manually removed from their respective scaling groups can ECS instances that are in the Protected state be released. For more information, see [Remove an ECS instance](https://help.aliyun.com/document_detail/25955.html).
+   * *   ECS instances in the Protected state maintain their existing health status even when they undergo stopping or restarting processes.
+   *
+   * @param request SetInstancesProtectionRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return SetInstancesProtectionResponse
    */
   async setInstancesProtectionWithOptions(request: SetInstancesProtectionRequest, runtime: $Util.RuntimeOptions): Promise<SetInstancesProtectionResponse> {
     Util.validateModel(request);
@@ -21945,16 +23015,28 @@ export default class Client extends OpenApi {
   }
 
   /**
-    * Puts one or more Elastic Compute Service (ECS) instances into the Protected state.
-    *
-    * @param request SetInstancesProtectionRequest
-    * @return SetInstancesProtectionResponse
+   * @summary Puts Elastic Compute Service (ECS) instances into the Protected state. When ECS instances are put into the Protected state, they become immune to manual deletion attempts by using the Auto Scaling console or API operations. This operation serves as a robust safeguard, efficiently preventing any inadvertent instance release that could lead to irreversible consequences.
+   *
+   * @description Once ECS instances enter the Protected state, they become subject to the following restrictions:
+   * *   ECS instances will persist in the Protected state, unless you deliberately remove them from this state.
+   * *   Even in scenarios where automatic scale-in actions are initiated due to fluctuations in the number of ECS instances or the execution of event-triggered tasks, Auto Scaling does not remove ECS instances that are in the Protected state from their respective scaling groups. Only after being manually removed from their respective scaling groups can ECS instances that are in the Protected state be released. For more information, see [Remove an ECS instance](https://help.aliyun.com/document_detail/25955.html).
+   * *   ECS instances in the Protected state maintain their existing health status even when they undergo stopping or restarting processes.
+   *
+   * @param request SetInstancesProtectionRequest
+   * @return SetInstancesProtectionResponse
    */
   async setInstancesProtection(request: SetInstancesProtectionRequest): Promise<SetInstancesProtectionResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.setInstancesProtectionWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Suspends scaling processes. This operation empowers you to selectively pause distinct scaling processes within a particular scaling group, enabling you to carry out alternative tasks and achieve more granular management over your scaling operations.
+   *
+   * @param request SuspendProcessesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return SuspendProcessesResponse
+   */
   async suspendProcessesWithOptions(request: SuspendProcessesRequest, runtime: $Util.RuntimeOptions): Promise<SuspendProcessesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -21999,11 +23081,24 @@ export default class Client extends OpenApi {
     return $tea.cast<SuspendProcessesResponse>(await this.callApi(params, req, runtime), new SuspendProcessesResponse({}));
   }
 
+  /**
+   * @summary Suspends scaling processes. This operation empowers you to selectively pause distinct scaling processes within a particular scaling group, enabling you to carry out alternative tasks and achieve more granular management over your scaling operations.
+   *
+   * @param request SuspendProcessesRequest
+   * @return SuspendProcessesResponse
+   */
   async suspendProcesses(request: SuspendProcessesRequest): Promise<SuspendProcessesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.suspendProcessesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Adds tags to specified Auto Scaling resources.
+   *
+   * @param request TagResourcesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return TagResourcesResponse
+   */
   async tagResourcesWithOptions(request: TagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<TagResourcesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -22048,11 +23143,24 @@ export default class Client extends OpenApi {
     return $tea.cast<TagResourcesResponse>(await this.callApi(params, req, runtime), new TagResourcesResponse({}));
   }
 
+  /**
+   * @summary Adds tags to specified Auto Scaling resources.
+   *
+   * @param request TagResourcesRequest
+   * @return TagResourcesResponse
+   */
   async tagResources(request: TagResourcesRequest): Promise<TagResourcesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.tagResourcesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Removes tags from Auto Scaling resources simultaneously. This operation streamlines resource management activities, enhances system efficiency, and mitigates potential security vulnerabilities. Once a tag is removed from a particular resource, and if it is not re-added to any other resource, the system will automatically delete the unused tag.
+   *
+   * @param request UntagResourcesRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return UntagResourcesResponse
+   */
   async untagResourcesWithOptions(request: UntagResourcesRequest, runtime: $Util.RuntimeOptions): Promise<UntagResourcesResponse> {
     Util.validateModel(request);
     let query = { };
@@ -22101,11 +23209,24 @@ export default class Client extends OpenApi {
     return $tea.cast<UntagResourcesResponse>(await this.callApi(params, req, runtime), new UntagResourcesResponse({}));
   }
 
+  /**
+   * @summary Removes tags from Auto Scaling resources simultaneously. This operation streamlines resource management activities, enhances system efficiency, and mitigates potential security vulnerabilities. Once a tag is removed from a particular resource, and if it is not re-added to any other resource, the system will automatically delete the unused tag.
+   *
+   * @param request UntagResourcesRequest
+   * @return UntagResourcesResponse
+   */
   async untagResources(request: UntagResourcesRequest): Promise<UntagResourcesResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.untagResourcesWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Checks whether Auto Scaling is authorized to access Elastic Compute Service (ECS) and Elastic Container Instance resources.
+   *
+   * @param request VerifyAuthenticationRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return VerifyAuthenticationResponse
+   */
   async verifyAuthenticationWithOptions(request: VerifyAuthenticationRequest, runtime: $Util.RuntimeOptions): Promise<VerifyAuthenticationResponse> {
     Util.validateModel(request);
     let query = { };
@@ -22146,11 +23267,24 @@ export default class Client extends OpenApi {
     return $tea.cast<VerifyAuthenticationResponse>(await this.callApi(params, req, runtime), new VerifyAuthenticationResponse({}));
   }
 
+  /**
+   * @summary Checks whether Auto Scaling is authorized to access Elastic Compute Service (ECS) and Elastic Container Instance resources.
+   *
+   * @param request VerifyAuthenticationRequest
+   * @return VerifyAuthenticationResponse
+   */
   async verifyAuthentication(request: VerifyAuthenticationRequest): Promise<VerifyAuthenticationResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.verifyAuthenticationWithOptions(request, runtime);
   }
 
+  /**
+   * @summary Verifies whether Auto Scaling is activated. This operation guarantees that in response to shifts in business workloads or variations in incoming traffic, the system will automatically adjust resource provisioning. This auto-scaling capability enhances the overall system performance, ensuring high availability and improved flexibility to accommodate dynamic demands.
+   *
+   * @param request VerifyUserRequest
+   * @param runtime runtime options for this request RuntimeOptions
+   * @return VerifyUserResponse
+   */
   async verifyUserWithOptions(request: VerifyUserRequest, runtime: $Util.RuntimeOptions): Promise<VerifyUserResponse> {
     Util.validateModel(request);
     let query = { };
@@ -22187,6 +23321,12 @@ export default class Client extends OpenApi {
     return $tea.cast<VerifyUserResponse>(await this.callApi(params, req, runtime), new VerifyUserResponse({}));
   }
 
+  /**
+   * @summary Verifies whether Auto Scaling is activated. This operation guarantees that in response to shifts in business workloads or variations in incoming traffic, the system will automatically adjust resource provisioning. This auto-scaling capability enhances the overall system performance, ensuring high availability and improved flexibility to accommodate dynamic demands.
+   *
+   * @param request VerifyUserRequest
+   * @return VerifyUserResponse
+   */
   async verifyUser(request: VerifyUserRequest): Promise<VerifyUserResponse> {
     let runtime = new $Util.RuntimeOptions({ });
     return await this.verifyUserWithOptions(request, runtime);