pulumi-alicloud 3.51.0a1710157550__py3-none-any.whl → 3.73.0a1736832142__py3-none-any.whl

pulumi_alicloud/ecs/outputs.py

@@ -4,14 +4,20 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
 
 __all__ = [
     'AutoProvisioningGroupLaunchTemplateConfig',
+    'AutoSnapshotPolicyCopyEncryptionConfiguration',
     'DedicatedHostNetworkAttribute',
     'EcsInstanceSetDataDisk',
     'EcsInstanceSetExcludeInstanceFilter',
@@ -21,14 +27,17 @@ __all__ = [
     'EcsLaunchTemplateSystemDisk',
     'EcsPrefixListEntry',
     'ImageDiskDeviceMapping',
+    'ImageFeatures',
     'ImageImportDiskDeviceMapping',
     'InstanceDataDisk',
+    'InstanceImageOptions',
     'InstanceMaintenanceTime',
     'InstanceNetworkInterfaces',
     'LaunchTemplateDataDisk',
     'LaunchTemplateNetworkInterfaces',
     'LaunchTemplateSystemDisk',
     'ReservedInstanceOperationLock',
+    'SnapshotPolicyCopyEncryptionConfiguration',
     'GetActivationsActivationResult',
     'GetAutoSnapshotPoliciesPolicyResult',
     'GetCapacityReservationsReservationResult',
@@ -184,6 +193,54 @@ class AutoProvisioningGroupLaunchTemplateConfig(dict):
         return pulumi.get(self, "priority")
 
 
+@pulumi.output_type
+class AutoSnapshotPolicyCopyEncryptionConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kmsKeyId":
+            suggest = "kms_key_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AutoSnapshotPolicyCopyEncryptionConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AutoSnapshotPolicyCopyEncryptionConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AutoSnapshotPolicyCopyEncryptionConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 encrypted: Optional[bool] = None,
+                 kms_key_id: Optional[str] = None):
+        """
+        :param bool encrypted: Whether to enable encryption for cross-region snapshot replication. Default value: `false`. Valid values: `true`, `false`.
+        :param str kms_key_id: The ID of the Key Management Service (KMS) key used to encrypt snapshots in cross-region snapshot replication.
+        """
+        if encrypted is not None:
+            pulumi.set(__self__, "encrypted", encrypted)
+        if kms_key_id is not None:
+            pulumi.set(__self__, "kms_key_id", kms_key_id)
+
+    @property
+    @pulumi.getter
+    def encrypted(self) -> Optional[bool]:
+        """
+        Whether to enable encryption for cross-region snapshot replication. Default value: `false`. Valid values: `true`, `false`.
+        """
+        return pulumi.get(self, "encrypted")
+
+    @property
+    @pulumi.getter(name="kmsKeyId")
+    def kms_key_id(self) -> Optional[str]:
+        """
+        The ID of the Key Management Service (KMS) key used to encrypt snapshots in cross-region snapshot replication.
+        """
+        return pulumi.get(self, "kms_key_id")
+
+
 @pulumi.output_type
 class DedicatedHostNetworkAttribute(dict):
     @staticmethod
@@ -532,6 +589,7 @@ class EcsLaunchTemplateDataDisk(dict):
                  category: Optional[str] = None,
                  delete_with_instance: Optional[bool] = None,
                  description: Optional[str] = None,
+                 device: Optional[str] = None,
                  encrypted: Optional[bool] = None,
                  name: Optional[str] = None,
                  performance_level: Optional[str] = None,
@@ -541,6 +599,7 @@ class EcsLaunchTemplateDataDisk(dict):
         :param str category: The category of the disk.
         :param bool delete_with_instance: Indicates whether the data disk is released with the instance.
         :param str description: The description of the data disk.
+        :param str device: The mount point of the data disk.
         :param bool encrypted: Encrypted the data in this disk.
         :param str name: The name of the data disk.
         :param str performance_level: The performance level of the ESSD used as the data disk.
@@ -553,6 +612,8 @@ class EcsLaunchTemplateDataDisk(dict):
             pulumi.set(__self__, "delete_with_instance", delete_with_instance)
         if description is not None:
             pulumi.set(__self__, "description", description)
+        if device is not None:
+            pulumi.set(__self__, "device", device)
         if encrypted is not None:
             pulumi.set(__self__, "encrypted", encrypted)
         if name is not None:
@@ -588,6 +649,14 @@ class EcsLaunchTemplateDataDisk(dict):
         """
         return pulumi.get(self, "description")
 
+    @property
+    @pulumi.getter
+    def device(self) -> Optional[str]:
+        """
+        The mount point of the data disk.
+        """
+        return pulumi.get(self, "device")
+
     @property
     @pulumi.getter
     def encrypted(self) -> Optional[bool]:
@@ -889,6 +958,12 @@ class ImageDiskDeviceMapping(dict):
         suggest = None
         if key == "diskType":
             suggest = "disk_type"
+        elif key == "importOssBucket":
+            suggest = "import_oss_bucket"
+        elif key == "importOssObject":
+            suggest = "import_oss_object"
+        elif key == "remainTime":
+            suggest = "remain_time"
         elif key == "snapshotId":
             suggest = "snapshot_id"
 
@@ -906,18 +981,46 @@ class ImageDiskDeviceMapping(dict):
     def __init__(__self__, *,
                  device: Optional[str] = None,
                  disk_type: Optional[str] = None,
+                 format: Optional[str] = None,
+                 import_oss_bucket: Optional[str] = None,
+                 import_oss_object: Optional[str] = None,
+                 progress: Optional[str] = None,
+                 remain_time: Optional[int] = None,
                  size: Optional[int] = None,
                  snapshot_id: Optional[str] = None):
         """
-        :param str device: Specifies the name of a disk in the combined custom image. Value range: /dev/xvda to /dev/xvdz.
-        :param str disk_type: Specifies the type of a disk in the combined custom image. If you specify this parameter, you can use a data disk snapshot as the data source of a system disk for creating an image. If it is not specified, the disk type is determined by the corresponding snapshot. Valid values: `system`, `data`,
-        :param int size: Specifies the size of a disk in the combined custom image, in GiB. Value range: 5 to 2000.
-        :param str snapshot_id: Specifies a snapshot that is used to create a combined custom image.
+        :param str device: The device name of disk N in the custom image. Valid values:
+               - For disks other than basic disks, such as standard SSDs, ultra disks, and enhanced SSDs (ESSDs), the valid values range from /dev/vda to /dev/vdz in alphabetical order.
+               - For basic disks, the valid values range from /dev/xvda to /dev/xvdz in alphabetical order.
+        :param str disk_type: The type of disk N in the custom image. You can specify this parameter to create the system disk of the custom image from a data disk snapshot. If you do not specify this parameter, the disk type is determined by the corresponding snapshot. Valid values:
+               - system: system disk. You can specify only one snapshot to use to create the system disk in the custom image.
+               - data: data disk. You can specify up to 16 snapshots to use to create data disks in the custom image.
+        :param str format: Image format.
+        :param str import_oss_bucket: Import the bucket of the OSS to which the image belongs.
+        :param str import_oss_object: Import the object of the OSS to which the image file belongs.
+        :param str progress: Copy the progress of the task.
+        :param int remain_time: For an image being replicated, return the remaining time of the replication task, in seconds.
+        :param int size: The size of disk N in the custom image. Unit: GiB. The valid values and default value of DiskDeviceMapping.N.Size vary based on the value of DiskDeviceMapping.N.SnapshotId.
+               - If no corresponding snapshot IDs are specified in the value of DiskDeviceMapping.N.SnapshotId, DiskDeviceMapping.N.Size has the following valid values and default values:
+               *   For basic disks, the valid values range from 5 to 2000, and the default value is 5.
+               *   For other disks, the valid values range from 20 to 32768, and the default value is 20.
+               - If a corresponding snapshot ID is specified in the value of DiskDeviceMapping.N.SnapshotId, the value of DiskDeviceMapping.N.Size must be greater than or equal to the size of the specified snapshot. The default value of DiskDeviceMapping.N.Size is the size of the specified snapshot.
+        :param str snapshot_id: The ID of snapshot N to use to create the custom image. .
         """
         if device is not None:
             pulumi.set(__self__, "device", device)
         if disk_type is not None:
             pulumi.set(__self__, "disk_type", disk_type)
+        if format is not None:
+            pulumi.set(__self__, "format", format)
+        if import_oss_bucket is not None:
+            pulumi.set(__self__, "import_oss_bucket", import_oss_bucket)
+        if import_oss_object is not None:
+            pulumi.set(__self__, "import_oss_object", import_oss_object)
+        if progress is not None:
+            pulumi.set(__self__, "progress", progress)
+        if remain_time is not None:
+            pulumi.set(__self__, "remain_time", remain_time)
         if size is not None:
             pulumi.set(__self__, "size", size)
         if snapshot_id is not None:
@@ -927,7 +1030,9 @@ class ImageDiskDeviceMapping(dict):
     @pulumi.getter
     def device(self) -> Optional[str]:
         """
-        Specifies the name of a disk in the combined custom image. Value range: /dev/xvda to /dev/xvdz.
+        The device name of disk N in the custom image. Valid values:
+        - For disks other than basic disks, such as standard SSDs, ultra disks, and enhanced SSDs (ESSDs), the valid values range from /dev/vda to /dev/vdz in alphabetical order.
+        - For basic disks, the valid values range from /dev/xvda to /dev/xvdz in alphabetical order.
         """
         return pulumi.get(self, "device")
 
@@ -935,15 +1040,61 @@ class ImageDiskDeviceMapping(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> Optional[str]:
         """
-        Specifies the type of a disk in the combined custom image. If you specify this parameter, you can use a data disk snapshot as the data source of a system disk for creating an image. If it is not specified, the disk type is determined by the corresponding snapshot. Valid values: `system`, `data`,
+        The type of disk N in the custom image. You can specify this parameter to create the system disk of the custom image from a data disk snapshot. If you do not specify this parameter, the disk type is determined by the corresponding snapshot. Valid values:
+        - system: system disk. You can specify only one snapshot to use to create the system disk in the custom image.
+        - data: data disk. You can specify up to 16 snapshots to use to create data disks in the custom image.
         """
         return pulumi.get(self, "disk_type")
 
+    @property
+    @pulumi.getter
+    def format(self) -> Optional[str]:
+        """
+        Image format.
+        """
+        return pulumi.get(self, "format")
+
+    @property
+    @pulumi.getter(name="importOssBucket")
+    def import_oss_bucket(self) -> Optional[str]:
+        """
+        Import the bucket of the OSS to which the image belongs.
+        """
+        return pulumi.get(self, "import_oss_bucket")
+
+    @property
+    @pulumi.getter(name="importOssObject")
+    def import_oss_object(self) -> Optional[str]:
+        """
+        Import the object of the OSS to which the image file belongs.
+        """
+        return pulumi.get(self, "import_oss_object")
+
+    @property
+    @pulumi.getter
+    def progress(self) -> Optional[str]:
+        """
+        Copy the progress of the task.
+        """
+        return pulumi.get(self, "progress")
+
+    @property
+    @pulumi.getter(name="remainTime")
+    def remain_time(self) -> Optional[int]:
+        """
+        For an image being replicated, return the remaining time of the replication task, in seconds.
+        """
+        return pulumi.get(self, "remain_time")
+
     @property
     @pulumi.getter
     def size(self) -> Optional[int]:
         """
-        Specifies the size of a disk in the combined custom image, in GiB. Value range: 5 to 2000.
+        The size of disk N in the custom image. Unit: GiB. The valid values and default value of DiskDeviceMapping.N.Size vary based on the value of DiskDeviceMapping.N.SnapshotId.
+        - If no corresponding snapshot IDs are specified in the value of DiskDeviceMapping.N.SnapshotId, DiskDeviceMapping.N.Size has the following valid values and default values:
+        *   For basic disks, the valid values range from 5 to 2000, and the default value is 5.
+        *   For other disks, the valid values range from 20 to 32768, and the default value is 20.
+        - If a corresponding snapshot ID is specified in the value of DiskDeviceMapping.N.SnapshotId, the value of DiskDeviceMapping.N.Size must be greater than or equal to the size of the specified snapshot. The default value of DiskDeviceMapping.N.Size is the size of the specified snapshot.
         """
         return pulumi.get(self, "size")
 
@@ -951,11 +1102,51 @@ class ImageDiskDeviceMapping(dict):
     @pulumi.getter(name="snapshotId")
     def snapshot_id(self) -> Optional[str]:
         """
-        Specifies a snapshot that is used to create a combined custom image.
+        The ID of snapshot N to use to create the custom image. .
         """
         return pulumi.get(self, "snapshot_id")
 
 
+@pulumi.output_type
+class ImageFeatures(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "nvmeSupport":
+            suggest = "nvme_support"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ImageFeatures. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ImageFeatures.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ImageFeatures.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 nvme_support: Optional[str] = None):
+        """
+        :param str nvme_support: Specifies whether to support the Non-Volatile Memory Express (NVMe) protocol. Valid values:
+               - supported: The image supports NVMe. Instances created from this image also support NVMe.
+               - unsupported: The image does not support NVMe. Instances created from this image do not support NVMe.
+        """
+        if nvme_support is not None:
+            pulumi.set(__self__, "nvme_support", nvme_support)
+
+    @property
+    @pulumi.getter(name="nvmeSupport")
+    def nvme_support(self) -> Optional[str]:
+        """
+        Specifies whether to support the Non-Volatile Memory Express (NVMe) protocol. Valid values:
+        - supported: The image supports NVMe. Instances created from this image also support NVMe.
+        - unsupported: The image does not support NVMe. Instances created from this image do not support NVMe.
+        """
+        return pulumi.get(self, "nvme_support")
+
+
 @pulumi.output_type
 class ImageImportDiskDeviceMapping(dict):
     @staticmethod
@@ -986,13 +1177,11 @@ class ImageImportDiskDeviceMapping(dict):
                  oss_bucket: Optional[str] = None,
                  oss_object: Optional[str] = None):
         """
-        :param str device: The name of disk N in the custom image.
-        :param int disk_image_size: Resolution size. You must ensure that the system disk space ≥ file system space. Ranges: When n = 1, the system disk: 5 ~ 500GiB, When n = 2 ~ 17, that is, data disk: 5 ~ 1000GiB, When temporary is introduced, the system automatically detects the size, which is subject to the detection result.
-        :param str format: Image format. Value range: When the `RAW`, `VHD`, `qcow2` is imported into the image, the system automatically detects the image format, whichever comes first.
-        :param str oss_bucket: Save the exported OSS bucket.
-        :param str oss_object: The file name of your OSS Object.
-               
-               > **NOTE:** The disk_device_mapping is a list and it's first item will be used to system disk and other items are used to data disks.
+        :param str device: The device name of the disk.
+        :param int disk_image_size: The size of the disk. Default value: `5`.
+        :param str format: The format of the image. Valid values: `RAW`, `VHD`, `qcow2`.
+        :param str oss_bucket: The OSS bucket where the image file is stored.
+        :param str oss_object: The name (key) of the object that the uploaded image is stored as in the OSS bucket.
         """
         if device is not None:
             pulumi.set(__self__, "device", device)
@@ -1009,7 +1198,7 @@ class ImageImportDiskDeviceMapping(dict):
     @pulumi.getter
     def device(self) -> Optional[str]:
         """
-        The name of disk N in the custom image.
+        The device name of the disk.
         """
         return pulumi.get(self, "device")
 
@@ -1017,7 +1206,7 @@ class ImageImportDiskDeviceMapping(dict):
     @pulumi.getter(name="diskImageSize")
     def disk_image_size(self) -> Optional[int]:
         """
-        Resolution size. You must ensure that the system disk space ≥ file system space. Ranges: When n = 1, the system disk: 5 ~ 500GiB, When n = 2 ~ 17, that is, data disk: 5 ~ 1000GiB, When temporary is introduced, the system automatically detects the size, which is subject to the detection result.
+        The size of the disk. Default value: `5`.
         """
         return pulumi.get(self, "disk_image_size")
 
@@ -1025,7 +1214,7 @@ class ImageImportDiskDeviceMapping(dict):
     @pulumi.getter
     def format(self) -> Optional[str]:
         """
-        Image format. Value range: When the `RAW`, `VHD`, `qcow2` is imported into the image, the system automatically detects the image format, whichever comes first.
+        The format of the image. Valid values: `RAW`, `VHD`, `qcow2`.
         """
         return pulumi.get(self, "format")
 
@@ -1033,7 +1222,7 @@ class ImageImportDiskDeviceMapping(dict):
     @pulumi.getter(name="ossBucket")
     def oss_bucket(self) -> Optional[str]:
         """
-        Save the exported OSS bucket.
+        The OSS bucket where the image file is stored.
         """
         return pulumi.get(self, "oss_bucket")
 
@@ -1041,9 +1230,7 @@ class ImageImportDiskDeviceMapping(dict):
     @pulumi.getter(name="ossObject")
     def oss_object(self) -> Optional[str]:
         """
-        The file name of your OSS Object.
-
-        > **NOTE:** The disk_device_mapping is a list and it's first item will be used to system disk and other items are used to data disks.
+        The name (key) of the object that the uploaded image is stored as in the OSS bucket.
         """
         return pulumi.get(self, "oss_object")
 
@@ -1103,6 +1290,11 @@ class InstanceDataDisk(dict):
         :param str kms_key_id: The KMS key ID corresponding to the Nth data disk.
         :param str name: The name of the data disk.
         :param str performance_level: The performance level of the ESSD used as data disk:
+               - `PL0`: A single ESSD can deliver up to 10,000 random read/write IOPS.
+               - `PL1`: A single ESSD can deliver up to 50,000 random read/write IOPS.
+               - `PL2`: A single ESSD can deliver up to 100,000 random read/write IOPS.
+               - `PL3`: A single ESSD can deliver up to 1,000,000 random read/write IOPS.
+               Default to `PL1`.
         :param str snapshot_id: The snapshot ID used to initialize the data disk. If the size specified by snapshot is greater that the size of the disk, use the size specified by snapshot as the size of the data disk.
         """
         pulumi.set(__self__, "size", size)
@@ -1209,6 +1401,11 @@ class InstanceDataDisk(dict):
     def performance_level(self) -> Optional[str]:
         """
         The performance level of the ESSD used as data disk:
+        - `PL0`: A single ESSD can deliver up to 10,000 random read/write IOPS.
+        - `PL1`: A single ESSD can deliver up to 50,000 random read/write IOPS.
+        - `PL2`: A single ESSD can deliver up to 100,000 random read/write IOPS.
+        - `PL3`: A single ESSD can deliver up to 1,000,000 random read/write IOPS.
+        Default to `PL1`.
         """
         return pulumi.get(self, "performance_level")
 
@@ -1221,6 +1418,42 @@ class InstanceDataDisk(dict):
         return pulumi.get(self, "snapshot_id")
 
 
+@pulumi.output_type
+class InstanceImageOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "loginAsNonRoot":
+            suggest = "login_as_non_root"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceImageOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceImageOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceImageOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 login_as_non_root: Optional[bool] = None):
+        """
+        :param bool login_as_non_root: Whether to allow the instance logging in with the ecs-user user.
+        """
+        if login_as_non_root is not None:
+            pulumi.set(__self__, "login_as_non_root", login_as_non_root)
+
+    @property
+    @pulumi.getter(name="loginAsNonRoot")
+    def login_as_non_root(self) -> Optional[bool]:
+        """
+        Whether to allow the instance logging in with the ecs-user user.
+        """
+        return pulumi.get(self, "login_as_non_root")
+
+
 @pulumi.output_type
 class InstanceMaintenanceTime(dict):
     @staticmethod
@@ -1276,8 +1509,18 @@ class InstanceNetworkInterfaces(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "networkInterfaceId":
+        if key == "networkCardIndex":
+            suggest = "network_card_index"
+        elif key == "networkInterfaceId":
             suggest = "network_interface_id"
+        elif key == "networkInterfaceTrafficMode":
+            suggest = "network_interface_traffic_mode"
+        elif key == "queuePairNumber":
+            suggest = "queue_pair_number"
+        elif key == "securityGroupIds":
+            suggest = "security_group_ids"
+        elif key == "vswitchId":
+            suggest = "vswitch_id"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkInterfaces. Access the value via the '{suggest}' property getter instead.")
@@ -1291,21 +1534,85 @@ class InstanceNetworkInterfaces(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 network_interface_id: Optional[str] = None):
-        """
-        :param str network_interface_id: The ID of the secondary ENI.
+                 network_card_index: Optional[int] = None,
+                 network_interface_id: Optional[str] = None,
+                 network_interface_traffic_mode: Optional[str] = None,
+                 queue_pair_number: Optional[int] = None,
+                 security_group_ids: Optional[Sequence[str]] = None,
+                 vswitch_id: Optional[str] = None):
         """
+        :param int network_card_index: The index of the network card for Secondary ENI.
+        :param str network_interface_id: The ID of the Secondary ENI.
+        :param str network_interface_traffic_mode: The communication mode of the Secondary ENI. Default value: `Standard`. Valid values:
+               - `Standard`: Uses the TCP communication mode.
+               - `HighPerformance`: Uses the remote direct memory access (RDMA) communication mode with Elastic RDMA Interface (ERI) enabled.
+        :param int queue_pair_number: The number of queues supported by the ERI.
+        :param Sequence[str] security_group_ids: The ID of security group N to which to assign Secondary ENI N.
+        :param str vswitch_id: The ID of the vSwitch to which to connect Secondary ENI N.
+        """
+        if network_card_index is not None:
+            pulumi.set(__self__, "network_card_index", network_card_index)
         if network_interface_id is not None:
             pulumi.set(__self__, "network_interface_id", network_interface_id)
+        if network_interface_traffic_mode is not None:
+            pulumi.set(__self__, "network_interface_traffic_mode", network_interface_traffic_mode)
+        if queue_pair_number is not None:
+            pulumi.set(__self__, "queue_pair_number", queue_pair_number)
+        if security_group_ids is not None:
+            pulumi.set(__self__, "security_group_ids", security_group_ids)
+        if vswitch_id is not None:
+            pulumi.set(__self__, "vswitch_id", vswitch_id)
+
+    @property
+    @pulumi.getter(name="networkCardIndex")
+    def network_card_index(self) -> Optional[int]:
+        """
+        The index of the network card for Secondary ENI.
+        """
+        return pulumi.get(self, "network_card_index")
 
     @property
     @pulumi.getter(name="networkInterfaceId")
     def network_interface_id(self) -> Optional[str]:
         """
-        The ID of the secondary ENI.
+        The ID of the Secondary ENI.
         """
         return pulumi.get(self, "network_interface_id")
 
+    @property
+    @pulumi.getter(name="networkInterfaceTrafficMode")
+    def network_interface_traffic_mode(self) -> Optional[str]:
+        """
+        The communication mode of the Secondary ENI. Default value: `Standard`. Valid values:
+        - `Standard`: Uses the TCP communication mode.
+        - `HighPerformance`: Uses the remote direct memory access (RDMA) communication mode with Elastic RDMA Interface (ERI) enabled.
+        """
+        return pulumi.get(self, "network_interface_traffic_mode")
+
+    @property
+    @pulumi.getter(name="queuePairNumber")
+    def queue_pair_number(self) -> Optional[int]:
+        """
+        The number of queues supported by the ERI.
+        """
+        return pulumi.get(self, "queue_pair_number")
+
+    @property
+    @pulumi.getter(name="securityGroupIds")
+    def security_group_ids(self) -> Optional[Sequence[str]]:
+        """
+        The ID of security group N to which to assign Secondary ENI N.
+        """
+        return pulumi.get(self, "security_group_ids")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> Optional[str]:
+        """
+        The ID of the vSwitch to which to connect Secondary ENI N.
+        """
+        return pulumi.get(self, "vswitch_id")
+
 
 @pulumi.output_type
 class LaunchTemplateDataDisk(dict):
@@ -1334,6 +1641,7 @@ class LaunchTemplateDataDisk(dict):
                  category: Optional[str] = None,
                  delete_with_instance: Optional[bool] = None,
                  description: Optional[str] = None,
+                 device: Optional[str] = None,
                  encrypted: Optional[bool] = None,
                  name: Optional[str] = None,
                  performance_level: Optional[str] = None,
@@ -1370,6 +1678,8 @@ class LaunchTemplateDataDisk(dict):
             pulumi.set(__self__, "delete_with_instance", delete_with_instance)
         if description is not None:
             pulumi.set(__self__, "description", description)
+        if device is not None:
+            pulumi.set(__self__, "device", device)
         if encrypted is not None:
             pulumi.set(__self__, "encrypted", encrypted)
         if name is not None:
@@ -1414,6 +1724,11 @@ class LaunchTemplateDataDisk(dict):
         """
         return pulumi.get(self, "description")
 
+    @property
+    @pulumi.getter
+    def device(self) -> Optional[str]:
+        return pulumi.get(self, "device")
+
     @property
     @pulumi.getter
     def encrypted(self) -> Optional[bool]:
@@ -1489,8 +1804,8 @@ class LaunchTemplateNetworkInterfaces(dict):
                  security_group_id: Optional[str] = None,
                  vswitch_id: Optional[str] = None):
         """
-        :param str description: The description of the data disk.
-        :param str name: The name of the data disk.
+        :param str description: The ENI description.
+        :param str name: ENI name.
         :param str primary_ip: The primary private IP address of the ENI.
         :param str security_group_id: The security group ID must be one in the same VPC.
         :param str vswitch_id: The VSwitch ID for ENI. The instance must be in the same zone of the same VPC network as the ENI, but they may belong to different VSwitches.
@@ -1510,7 +1825,7 @@ class LaunchTemplateNetworkInterfaces(dict):
     @pulumi.getter
     def description(self) -> Optional[str]:
         """
-        The description of the data disk.
+        The ENI description.
         """
         return pulumi.get(self, "description")
 
@@ -1518,7 +1833,7 @@ class LaunchTemplateNetworkInterfaces(dict):
     @pulumi.getter
     def name(self) -> Optional[str]:
         """
-        The name of the data disk.
+        ENI name.
         """
         return pulumi.get(self, "name")
 
@@ -1589,11 +1904,11 @@ class LaunchTemplateSystemDisk(dict):
         :param bool delete_with_instance: Delete this data disk when the instance is destroyed. It only works on cloud, cloud_efficiency, cloud_ssd and cloud_essd disk. If the category of this data disk was ephemeral_ssd, please don't set this param.
                
                Default to true
-        :param str description: The description of the data disk.
+        :param str description: Description of instance launch template version 1. It can be [2, 256] characters in length. It cannot start with "http://" or "https://". The default value is null.
         :param bool encrypted: Encrypted the data in this disk.
                
                Default to false
-        :param str name: The name of the data disk.
+        :param str name: Instance launch template name. Can contain [2, 128] characters in length. It must start with an English letter or Chinese, can contain numbers, periods (.), colons (:), underscores (_), and hyphens (-). It cannot start with "http://" or "https://".
         :param int size: The size of the data disk.
                - cloud：[5, 2000]
                - cloud_efficiency：[20, 32768]
@@ -1647,7 +1962,7 @@ class LaunchTemplateSystemDisk(dict):
     @pulumi.getter
     def description(self) -> Optional[str]:
         """
-        The description of the data disk.
+        Description of instance launch template version 1. It can be [2, 256] characters in length. It cannot start with "http://" or "https://". The default value is null.
         """
         return pulumi.get(self, "description")
 
@@ -1670,7 +1985,7 @@ class LaunchTemplateSystemDisk(dict):
     @pulumi.getter
     def name(self) -> Optional[str]:
         """
-        The name of the data disk.
+        Instance launch template name. Can contain [2, 128] characters in length. It must start with an English letter or Chinese, can contain numbers, periods (.), colons (:), underscores (_), and hyphens (-). It cannot start with "http://" or "https://".
         """
         return pulumi.get(self, "name")
 
@@ -1729,6 +2044,44 @@ class ReservedInstanceOperationLock(dict):
         return pulumi.get(self, "lock_reason")
 
 
+@pulumi.output_type
+class SnapshotPolicyCopyEncryptionConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kmsKeyId":
+            suggest = "kms_key_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SnapshotPolicyCopyEncryptionConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SnapshotPolicyCopyEncryptionConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SnapshotPolicyCopyEncryptionConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 encrypted: Optional[bool] = None,
+                 kms_key_id: Optional[str] = None):
+        if encrypted is not None:
+            pulumi.set(__self__, "encrypted", encrypted)
+        if kms_key_id is not None:
+            pulumi.set(__self__, "kms_key_id", kms_key_id)
+
+    @property
+    @pulumi.getter
+    def encrypted(self) -> Optional[bool]:
+        return pulumi.get(self, "encrypted")
+
+    @property
+    @pulumi.getter(name="kmsKeyId")
+    def kms_key_id(self) -> Optional[str]:
+        return pulumi.get(self, "kms_key_id")
+
+
 @pulumi.output_type
 class GetActivationsActivationResult(dict):
     def __init__(__self__, *,
@@ -1869,7 +2222,7 @@ class GetAutoSnapshotPoliciesPolicyResult(dict):
                  repeat_weekdays: Sequence[str],
                  retention_days: int,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  target_copy_regions: Sequence[str],
                  time_points: Sequence[str],
                  volume_nums: int):
@@ -1883,7 +2236,7 @@ class GetAutoSnapshotPoliciesPolicyResult(dict):
         :param Sequence[str] repeat_weekdays: The automatic snapshot repetition dates.
         :param int retention_days: The snapshot retention time, and the unit of measurement is day.
         :param str status: The status of Auto Snapshot Policy.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         :param Sequence[str] target_copy_regions: The destination region to which the snapshot is copied.
         :param Sequence[str] time_points: The automatic snapshot creation schedule, and the unit of measurement is hour.
         :param int volume_nums: The number of extended volumes on which this policy is enabled.
@@ -1976,7 +2329,7 @@ class GetAutoSnapshotPoliciesPolicyResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -2027,7 +2380,7 @@ class GetCapacityReservationsReservationResult(dict):
                  status: str,
                  time_slot: str,
                  zone_ids: Sequence[str],
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param str capacity_reservation_id: Capacity Reservation id
         :param str capacity_reservation_name: Capacity reservation service name.
@@ -2046,7 +2399,7 @@ class GetCapacityReservationsReservationResult(dict):
         :param str status: The status of the capacity reservation. value range `All`, `Pending`, `Preparing`, `Prepared`, `Active`, `Released`.
         :param str time_slot: This parameter is under test and is not yet open for use.
         :param Sequence[str] zone_ids: The ID of the zone in the region to which the capacity reservation service belongs. Currently, it is only supported to create a capacity reservation service in one zone.
-        :param Mapping[str, Any] tags: The tag of the resource.
+        :param Mapping[str, str] tags: The tag of the resource.
         """
         pulumi.set(__self__, "capacity_reservation_id", capacity_reservation_id)
         pulumi.set(__self__, "capacity_reservation_name", capacity_reservation_name)
@@ -2206,7 +2559,7 @@ class GetCapacityReservationsReservationResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         The tag of the resource.
         """
@@ -2358,7 +2711,7 @@ class GetDedicatedHostsHostResult(dict):
                  supported_custom_instance_type_families: Sequence[str],
                  supported_instance_type_families: Sequence[str],
                  supported_instance_types_lists: Sequence[str],
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  zone_id: str):
         """
         :param str action_on_maintenance: The policy used to migrate the instances from the dedicated host when the dedicated host fails or needs to be repaired online.
@@ -2386,7 +2739,7 @@ class GetDedicatedHostsHostResult(dict):
         :param Sequence[str] supported_custom_instance_type_families: (Available in 1.123.1+) A custom instance type family supported by a dedicated host.
         :param Sequence[str] supported_instance_type_families: (Available in 1.123.1+) ECS instance type family supported by the dedicated host.
         :param Sequence[str] supported_instance_types_lists: The list of ECS instance
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         :param str zone_id: The zone ID of the ECS Dedicated Host.
         """
         pulumi.set(__self__, "action_on_maintenance", action_on_maintenance)
@@ -2619,7 +2972,7 @@ class GetDedicatedHostsHostResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -2825,6 +3178,7 @@ class GetDisksDiskResult(dict):
                  enable_auto_snapshot: bool,
                  enable_automated_snapshot_policy: bool,
                  encrypted: str,
+                 expiration_time: str,
                  expired_time: str,
                  id: str,
                  image_id: str,
@@ -2846,7 +3200,7 @@ class GetDisksDiskResult(dict):
                  size: int,
                  snapshot_id: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  zone_id: str):
         """
@@ -2857,6 +3211,7 @@ class GetDisksDiskResult(dict):
         :param str description: Disk description.
         :param str detached_time: Disk detachment time.
         :param str encrypted: Indicate whether the disk is encrypted or not. Possible values: `on` and `off`.
+        :param str expiration_time: Disk expiration time.
         :param str id: ID of the disk.
         :param str image_id: ID of the image from which the disk is created. It is null unless the disk is created using an image.
         :param str instance_id: Filter the results by the specified ECS instance ID.
@@ -2866,8 +3221,7 @@ class GetDisksDiskResult(dict):
         :param int size: Disk size in GiB.
         :param str snapshot_id: Snapshot used to create the disk. It is null if no snapshot is used to create the disk.
         :param str status: Current status. Possible values: `In_use`, `Available`, `Attaching`, `Detaching`, `Creating` and `ReIniting`.
-        :param Mapping[str, Any] tags: A map of tags assigned to the disks. It must be in the format:
-               <!--Start PulumiCodeChooser -->
+        :param Mapping[str, str] tags: A map of tags assigned to the disks. It must be in the format:
                ```python
                import pulumi
                import pulumi_alicloud as alicloud
@@ -2877,7 +3231,6 @@ class GetDisksDiskResult(dict):
                    "tagKey2": "tagValue2",
                })
                ```
-               <!--End PulumiCodeChooser -->
         :param str type: Disk type. Possible values: `system` and `data`.
         """
         pulumi.set(__self__, "attached_time", attached_time)
@@ -2896,6 +3249,7 @@ class GetDisksDiskResult(dict):
         pulumi.set(__self__, "enable_auto_snapshot", enable_auto_snapshot)
         pulumi.set(__self__, "enable_automated_snapshot_policy", enable_automated_snapshot_policy)
         pulumi.set(__self__, "encrypted", encrypted)
+        pulumi.set(__self__, "expiration_time", expiration_time)
         pulumi.set(__self__, "expired_time", expired_time)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "image_id", image_id)
@@ -3022,6 +3376,14 @@ class GetDisksDiskResult(dict):
         """
         return pulumi.get(self, "encrypted")
 
+    @property
+    @pulumi.getter(name="expirationTime")
+    def expiration_time(self) -> str:
+        """
+        Disk expiration time.
+        """
+        return pulumi.get(self, "expiration_time")
+
     @property
     @pulumi.getter(name="expiredTime")
     def expired_time(self) -> str:
@@ -3156,10 +3518,9 @@ class GetDisksDiskResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A map of tags assigned to the disks. It must be in the format:
-        <!--Start PulumiCodeChooser -->
         ```python
         import pulumi
         import pulumi_alicloud as alicloud
@@ -3169,7 +3530,6 @@ class GetDisksDiskResult(dict):
             "tagKey2": "tagValue2",
         })
         ```
-        <!--End PulumiCodeChooser -->
         """
         return pulumi.get(self, "tags")
 
@@ -3258,7 +3618,7 @@ class GetEcsDedicatedHostClustersClusterResult(dict):
                  description: str,
                  id: str,
                  resource_group_id: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  zone_id: str):
         """
         :param Sequence['GetEcsDedicatedHostClustersClusterDedicatedHostClusterCapacityArgs'] dedicated_host_cluster_capacities: The capacity of the dedicated host cluster.
@@ -3268,7 +3628,7 @@ class GetEcsDedicatedHostClustersClusterResult(dict):
         :param str description: The description of the dedicated host cluster.
         :param str id: The ID of the Dedicated Host Cluster.
         :param str resource_group_id: The ID of the resource group to which the dedicated host cluster belongs.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         :param str zone_id: The zone ID of the dedicated host cluster.
         """
         pulumi.set(__self__, "dedicated_host_cluster_capacities", dedicated_host_cluster_capacities)
@@ -3339,7 +3699,7 @@ class GetEcsDedicatedHostClustersClusterResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -3592,6 +3952,7 @@ class GetEcsDisksDiskResult(dict):
                  enable_auto_snapshot: bool,
                  enable_automated_snapshot_policy: bool,
                  encrypted: str,
+                 expiration_time: str,
                  expired_time: str,
                  id: str,
                  image_id: str,
@@ -3613,14 +3974,14 @@ class GetEcsDisksDiskResult(dict):
                  size: int,
                  snapshot_id: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  zone_id: str):
         """
         :param str attached_time: A mount of time.
         :param str auto_snapshot_policy_id: Query cloud disks based on the automatic snapshot policy ID.
-        :param str availability_zone: Availability zone of the disk.
-        :param str category: Disk category.
+        :param str availability_zone: Field `availability_zone` has been deprecated from provider version 1.122.0. New field `zone_id` instead.
+        :param str category: Disk category. Valid values: `cloud`, `cloud_efficiency`, `cloud_essd`, `cloud_ssd`, `ephemeral_ssd`, `cloud_auto`, `cloud_essd_entry`.
         :param str creation_time: Disk creation time.
         :param bool delete_auto_snapshot: Indicates whether the automatic snapshot is deleted when the disk is released.
         :param bool delete_with_instance: Indicates whether the disk is released together with the instance.
@@ -3629,29 +3990,35 @@ class GetEcsDisksDiskResult(dict):
         :param str device: The mount point of the disk.
         :param str disk_id: ID of the disk.
         :param str disk_name: The disk name.
-        :param str disk_type: The disk type.
-        :param bool enable_auto_snapshot: Whether the disk implements an automatic snapshot policy.
-        :param bool enable_automated_snapshot_policy: Whether the disk implements an automatic snapshot policy.
-        :param str encrypted: Indicate whether the disk is encrypted or not.
+        :param str disk_type: The disk type. Valid values: `system`, `data`, `all`.
+        :param bool enable_auto_snapshot: Indicates whether the automatic snapshot is deleted when the disk is released.
+        :param bool enable_automated_snapshot_policy: Whether the cloud disk has an automatic snapshot policy
+        :param str encrypted: Indicate whether the disk is encrypted or not. Valid values: `on` and `off`.
+        :param str expiration_time: The time when the subscription disk expires.
+        :param str expired_time: The time when the subscription disk expires.
         :param str id: ID of the disk.
         :param str image_id: ID of the image from which the disk is created. It is null unless the disk is created using an image.
-        :param str instance_id: The instance ID of the disk mount.
+        :param str instance_id: Filter the results by the specified ECS instance ID.
+        :param int iops: The maximum number of read and write operations per second.
+        :param int iops_read: The maximum number of read operations per second.
+        :param int iops_write: The maximum number of write operations per second.
         :param str kms_key_id: The kms key id.
         :param int mount_instance_num: Number of instances mounted on shared storage.
         :param Sequence['GetEcsDisksDiskMountInstanceArgs'] mount_instances: Disk mount instances.
         :param str name: Disk name.
-        :param str payment_type: Payment method for disk.
+        :param Sequence['GetEcsDisksDiskOperationLockArgs'] operation_locks: The reasons why the disk was locked. See `operation_locks` below for details.
+        :param str payment_type: Payment method for disk. Valid Values: `PayAsYouGo`, `Subscription`.
         :param str performance_level: Performance levels of ESSD cloud disk.
-        :param bool portable: Whether the disk is unmountable.
+        :param bool portable: Whether the cloud disk or local disk supports uninstallation.
         :param str product_code: The product logo of the cloud market.
         :param str region_id: Region ID the disk belongs to.
-        :param str resource_group_id: The Id of resource group.
+        :param str resource_group_id: The Id of resource group which the disk belongs.
         :param int size: Disk size in GiB.
-        :param str snapshot_id: Snapshot used to create the disk. It is null if no snapshot is used to create the disk.
-        :param str status: Current status.
-        :param Mapping[str, Any] tags: A map of tags assigned to the disk.
-        :param str type: Disk type.
-        :param str zone_id: The zone id.
+        :param str snapshot_id: The source snapshot id.
+        :param str status: The status of disk. Valid Values: `Attaching`, `Available`, `Creating`, `Detaching`, `In_use`, `Migrating`, `ReIniting`, `Transferring`.
+        :param Mapping[str, str] tags: A map of tags assigned to the disks.
+        :param str type: Field `type` has been deprecated from provider version 1.122.0. New field `disk_type` instead.
+        :param str zone_id: ID of the free zone to which the disk belongs.
         """
         pulumi.set(__self__, "attached_time", attached_time)
         pulumi.set(__self__, "auto_snapshot_policy_id", auto_snapshot_policy_id)
@@ -3669,6 +4036,7 @@ class GetEcsDisksDiskResult(dict):
         pulumi.set(__self__, "enable_auto_snapshot", enable_auto_snapshot)
         pulumi.set(__self__, "enable_automated_snapshot_policy", enable_automated_snapshot_policy)
         pulumi.set(__self__, "encrypted", encrypted)
+        pulumi.set(__self__, "expiration_time", expiration_time)
         pulumi.set(__self__, "expired_time", expired_time)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "image_id", image_id)
@@ -3714,7 +4082,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="availabilityZone")
     def availability_zone(self) -> str:
         """
-        Availability zone of the disk.
+        Field `availability_zone` has been deprecated from provider version 1.122.0. New field `zone_id` instead.
         """
         return pulumi.get(self, "availability_zone")
 
@@ -3722,7 +4090,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter
     def category(self) -> str:
         """
-        Disk category.
+        Disk category. Valid values: `cloud`, `cloud_efficiency`, `cloud_essd`, `cloud_ssd`, `ephemeral_ssd`, `cloud_auto`, `cloud_essd_entry`.
         """
         return pulumi.get(self, "category")
 
@@ -3794,7 +4162,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> str:
         """
-        The disk type.
+        The disk type. Valid values: `system`, `data`, `all`.
         """
         return pulumi.get(self, "disk_type")
 
@@ -3802,7 +4170,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="enableAutoSnapshot")
     def enable_auto_snapshot(self) -> bool:
         """
-        Whether the disk implements an automatic snapshot policy.
+        Indicates whether the automatic snapshot is deleted when the disk is released.
         """
         return pulumi.get(self, "enable_auto_snapshot")
 
@@ -3810,7 +4178,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="enableAutomatedSnapshotPolicy")
     def enable_automated_snapshot_policy(self) -> bool:
         """
-        Whether the disk implements an automatic snapshot policy.
+        Whether the cloud disk has an automatic snapshot policy
         """
         return pulumi.get(self, "enable_automated_snapshot_policy")
 
@@ -3818,13 +4186,24 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter
     def encrypted(self) -> str:
         """
-        Indicate whether the disk is encrypted or not.
+        Indicate whether the disk is encrypted or not. Valid values: `on` and `off`.
         """
         return pulumi.get(self, "encrypted")
 
+    @property
+    @pulumi.getter(name="expirationTime")
+    def expiration_time(self) -> str:
+        """
+        The time when the subscription disk expires.
+        """
+        return pulumi.get(self, "expiration_time")
+
     @property
     @pulumi.getter(name="expiredTime")
     def expired_time(self) -> str:
+        """
+        The time when the subscription disk expires.
+        """
         return pulumi.get(self, "expired_time")
 
     @property
@@ -3847,23 +4226,32 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="instanceId")
     def instance_id(self) -> str:
         """
-        The instance ID of the disk mount.
+        Filter the results by the specified ECS instance ID.
         """
         return pulumi.get(self, "instance_id")
 
     @property
     @pulumi.getter
     def iops(self) -> int:
+        """
+        The maximum number of read and write operations per second.
+        """
         return pulumi.get(self, "iops")
 
     @property
     @pulumi.getter(name="iopsRead")
     def iops_read(self) -> int:
+        """
+        The maximum number of read operations per second.
+        """
         return pulumi.get(self, "iops_read")
 
     @property
     @pulumi.getter(name="iopsWrite")
     def iops_write(self) -> int:
+        """
+        The maximum number of write operations per second.
+        """
         return pulumi.get(self, "iops_write")
 
     @property
@@ -3901,13 +4289,16 @@ class GetEcsDisksDiskResult(dict):
     @property
     @pulumi.getter(name="operationLocks")
     def operation_locks(self) -> Sequence['outputs.GetEcsDisksDiskOperationLockResult']:
+        """
+        The reasons why the disk was locked. See `operation_locks` below for details.
+        """
         return pulumi.get(self, "operation_locks")
 
     @property
     @pulumi.getter(name="paymentType")
     def payment_type(self) -> str:
         """
-        Payment method for disk.
+        Payment method for disk. Valid Values: `PayAsYouGo`, `Subscription`.
         """
         return pulumi.get(self, "payment_type")
 
@@ -3923,7 +4314,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter
     def portable(self) -> bool:
         """
-        Whether the disk is unmountable.
+        Whether the cloud disk or local disk supports uninstallation.
         """
         return pulumi.get(self, "portable")
 
@@ -3947,7 +4338,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="resourceGroupId")
     def resource_group_id(self) -> str:
         """
-        The Id of resource group.
+        The Id of resource group which the disk belongs.
         """
         return pulumi.get(self, "resource_group_id")
 
@@ -3963,7 +4354,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="snapshotId")
     def snapshot_id(self) -> str:
         """
-        Snapshot used to create the disk. It is null if no snapshot is used to create the disk.
+        The source snapshot id.
         """
         return pulumi.get(self, "snapshot_id")
 
@@ -3971,15 +4362,15 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        Current status.
+        The status of disk. Valid Values: `Attaching`, `Available`, `Creating`, `Detaching`, `In_use`, `Migrating`, `ReIniting`, `Transferring`.
         """
         return pulumi.get(self, "status")
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
-        A map of tags assigned to the disk.
+        A map of tags assigned to the disks.
         """
         return pulumi.get(self, "tags")
 
@@ -3987,7 +4378,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter
     def type(self) -> str:
         """
-        Disk type.
+        Field `type` has been deprecated from provider version 1.122.0. New field `disk_type` instead.
         """
         return pulumi.get(self, "type")
 
@@ -3995,7 +4386,7 @@ class GetEcsDisksDiskResult(dict):
     @pulumi.getter(name="zoneId")
     def zone_id(self) -> str:
         """
-        The zone id.
+        ID of the free zone to which the disk belongs.
         """
         return pulumi.get(self, "zone_id")
 
@@ -4009,7 +4400,7 @@ class GetEcsDisksDiskMountInstanceResult(dict):
         """
         :param str attached_time: A mount of time.
         :param str device: The mount point of the disk.
-        :param str instance_id: The instance ID of the disk mount.
+        :param str instance_id: Filter the results by the specified ECS instance ID.
         """
         pulumi.set(__self__, "attached_time", attached_time)
         pulumi.set(__self__, "device", device)
@@ -4035,7 +4426,7 @@ class GetEcsDisksDiskMountInstanceResult(dict):
     @pulumi.getter(name="instanceId")
     def instance_id(self) -> str:
         """
-        The instance ID of the disk mount.
+        Filter the results by the specified ECS instance ID.
         """
         return pulumi.get(self, "instance_id")
 
@@ -4044,11 +4435,17 @@ class GetEcsDisksDiskMountInstanceResult(dict):
 class GetEcsDisksDiskOperationLockResult(dict):
     def __init__(__self__, *,
                  lock_reason: str):
+        """
+        :param str lock_reason: The reason why the disk was locked.
+        """
         pulumi.set(__self__, "lock_reason", lock_reason)
 
     @property
     @pulumi.getter(name="lockReason")
     def lock_reason(self) -> str:
+        """
+        The reason why the disk was locked.
+        """
         return pulumi.get(self, "lock_reason")
 
 
@@ -4056,12 +4453,18 @@ class GetEcsDisksDiskOperationLockResult(dict):
 class GetEcsDisksOperationLockResult(dict):
     def __init__(__self__, *,
                  lock_reason: Optional[str] = None):
+        """
+        :param str lock_reason: The reason why the disk was locked.
+        """
         if lock_reason is not None:
             pulumi.set(__self__, "lock_reason", lock_reason)
 
     @property
     @pulumi.getter(name="lockReason")
     def lock_reason(self) -> Optional[str]:
+        """
+        The reason why the disk was locked.
+        """
         return pulumi.get(self, "lock_reason")
 
 
@@ -4078,7 +4481,7 @@ class GetEcsImageComponentsComponentResult(dict):
                  owner: str,
                  resource_group_id: str,
                  system_type: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str component_type: The type of the image component.
         :param str content: The content of the image component.
@@ -4090,7 +4493,7 @@ class GetEcsImageComponentsComponentResult(dict):
         :param str owner: The type of the image component.
         :param str resource_group_id: The ID of the resource group.
         :param str system_type: The operating system type supported by the image component.
-        :param Mapping[str, Any] tags: List of label key-value pairs.
+        :param Mapping[str, str] tags: List of label key-value pairs.
         """
         pulumi.set(__self__, "component_type", component_type)
         pulumi.set(__self__, "content", content)
@@ -4186,7 +4589,7 @@ class GetEcsImageComponentsComponentResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         List of label key-value pairs.
         """
@@ -4213,7 +4616,7 @@ class GetEcsImagePipelinePipelineResult(dict):
                  system_disk_size: int,
                  to_region_ids: Sequence[str],
                  vswitch_id: str,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param Sequence[str] add_accounts: The IDs of Alibaba Cloud accounts to which the image was shared.
         :param str base_image: The source image.
@@ -4232,7 +4635,7 @@ class GetEcsImagePipelinePipelineResult(dict):
         :param int system_disk_size: The system disk size of the intermediate instance. Unit: `GiB`.
         :param Sequence[str] to_region_ids: The IDs of regions to which to distribute the created image.
         :param str vswitch_id: The vswitch id.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "add_accounts", add_accounts)
         pulumi.set(__self__, "base_image", base_image)
@@ -4392,7 +4795,7 @@ class GetEcsImagePipelinePipelineResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -4426,14 +4829,12 @@ class GetEcsInvocationsInvocationResult(dict):
         :param str frequency: The schedule on which the recurring execution of the command takes place. For information about the value specifications, see [Cron expression](https://www.alibabacloud.com/help/en/elastic-compute-service/latest/cron-expression).
         :param str id: The ID of the Invocation.
         :param str invocation_id: The ID of the Invocation.
-        :param str invocation_status: The execution state on a single instance. Valid values: `Pending`, `Scheduled`, `Running`, `Success`, `Failed`, `Stopping`, `Stopped`, `PartialFailed`.
+        :param str invocation_status: The overall execution state of the command. The value of this parameter depends on the execution states on all the involved instances.
         :param Sequence['GetEcsInvocationsInvocationInvokeInstanceArgs'] invoke_instances: Execute target instance set type.
         :param str invoke_status: The overall execution state of the command. **Note:** We recommend that you ignore this parameter and check the value of the `invocation_status` response parameter for the overall execution state.
         :param str parameters: The custom parameters in the command.
         :param str repeat_mode: Indicates the execution mode of the command.
         :param bool timed: Indicates whether the commands are to be automatically run.
-               * `error_code	` - The code that indicates why the command failed to be sent or run.
-               * `instance_invoke_status	` - **Note:** We recommend that you ignore this parameter and check the value of the `invocation_status` response parameter for the overall execution state.
         :param str username: The username that was used to run the command on the instance.
         """
         pulumi.set(__self__, "command_content", command_content)
@@ -4520,7 +4921,7 @@ class GetEcsInvocationsInvocationResult(dict):
     @pulumi.getter(name="invocationStatus")
     def invocation_status(self) -> str:
         """
-        The execution state on a single instance. Valid values: `Pending`, `Scheduled`, `Running`, `Success`, `Failed`, `Stopping`, `Stopped`, `PartialFailed`.
+        The overall execution state of the command. The value of this parameter depends on the execution states on all the involved instances.
         """
         return pulumi.get(self, "invocation_status")
 
@@ -4561,8 +4962,6 @@ class GetEcsInvocationsInvocationResult(dict):
     def timed(self) -> bool:
         """
         Indicates whether the commands are to be automatically run.
-        * `error_code	` - The code that indicates why the command failed to be sent or run.
-        * `instance_invoke_status	` - **Note:** We recommend that you ignore this parameter and check the value of the `invocation_status` response parameter for the overall execution state.
         """
         return pulumi.get(self, "timed")
 
@@ -4752,14 +5151,14 @@ class GetEcsKeyPairsKeyPairResult(dict):
                  key_name: str,
                  key_pair_name: str,
                  resource_group_id: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str finger_print: The finger print of the key pair.
         :param str id: The ID of the Key Pair.
         :param Sequence['GetEcsKeyPairsKeyPairInstanceArgs'] instances: A list of ECS instances that has been bound this key pair.
         :param str key_name: The Key Pair Name.
-        :param str resource_group_id: The Resource Group Id.
-        :param Mapping[str, Any] tags: The tags.
+        :param str resource_group_id: The resource group Id.
+        :param Mapping[str, str] tags: The tags.
         """
         pulumi.set(__self__, "finger_print", finger_print)
         pulumi.set(__self__, "id", id)
@@ -4810,13 +5209,13 @@ class GetEcsKeyPairsKeyPairResult(dict):
     @pulumi.getter(name="resourceGroupId")
     def resource_group_id(self) -> str:
         """
-        The Resource Group Id.
+        The resource group Id.
         """
         return pulumi.get(self, "resource_group_id")
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         The tags.
         """
@@ -4845,7 +5244,7 @@ class GetEcsKeyPairsKeyPairInstanceResult(dict):
         :param str key_name: The Key Pair Name.
         :param str private_ip: The private IP address of the ECS instance.
         :param str public_ip: The public IP address or EIP of the ECS instance.
-        :param str vswitch_id: The ID of the VSwitch attached to the ECS instance.
+        :param str vswitch_id: The ID of the vSwitch attached to the ECS instance.
         """
         pulumi.set(__self__, "availability_zone", availability_zone)
         pulumi.set(__self__, "description", description)
@@ -4937,7 +5336,7 @@ class GetEcsKeyPairsKeyPairInstanceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        The ID of the VSwitch attached to the ECS instance.
+        The ID of the vSwitch attached to the ECS instance.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -4951,14 +5350,14 @@ class GetEcsKeyPairsPairResult(dict):
                  key_name: str,
                  key_pair_name: str,
                  resource_group_id: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str finger_print: The finger print of the key pair.
         :param str id: The ID of the Key Pair.
         :param Sequence['GetEcsKeyPairsPairInstanceArgs'] instances: A list of ECS instances that has been bound this key pair.
         :param str key_name: The Key Pair Name.
         :param str resource_group_id: The Resource Group Id.
-        :param Mapping[str, Any] tags: The tags.
+        :param Mapping[str, str] tags: The tags.
         """
         pulumi.set(__self__, "finger_print", finger_print)
         pulumi.set(__self__, "id", id)
@@ -5015,7 +5414,7 @@ class GetEcsKeyPairsPairResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         The tags.
         """
@@ -5044,7 +5443,7 @@ class GetEcsKeyPairsPairInstanceResult(dict):
         :param str key_name: The Key Pair Name.
         :param str private_ip: The private IP address of the ECS instance.
         :param str public_ip: The public IP address or EIP of the ECS instance.
-        :param str vswitch_id: The ID of the VSwitch attached to the ECS instance.
+        :param str vswitch_id: The ID of the vSwitch attached to the ECS instance.
         """
         pulumi.set(__self__, "availability_zone", availability_zone)
         pulumi.set(__self__, "description", description)
@@ -5136,7 +5535,7 @@ class GetEcsKeyPairsPairInstanceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        The ID of the VSwitch attached to the ECS instance.
+        The ID of the vSwitch attached to the ECS instance.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -5152,6 +5551,9 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
                  description: str,
                  enable_vm_os_config: bool,
                  host_name: str,
+                 http_endpoint: str,
+                 http_put_response_hop_limit: int,
+                 http_tokens: str,
                  id: str,
                  image_id: str,
                  image_owner_alias: str,
@@ -5181,14 +5583,14 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
                  spot_price_limit: float,
                  spot_strategy: str,
                  system_disks: Sequence['outputs.GetEcsLaunchTemplatesTemplateSystemDiskResult'],
-                 template_tags: Mapping[str, Any],
+                 template_tags: Mapping[str, str],
                  user_data: str,
                  version_description: str,
                  vpc_id: str,
                  vswitch_id: str,
                  zone_id: str):
         """
-        :param str auto_release_time: Instance auto release time.
+        :param str auto_release_time: (Optional) Instance auto release time.
         :param str created_by: CreatedBy.
         :param Sequence['GetEcsLaunchTemplatesTemplateDataDiskArgs'] data_disks: The list of data disks created with instance.
         :param int default_version_number: The Default Version Number.
@@ -5196,6 +5598,9 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
         :param str description: System disk description.
         :param bool enable_vm_os_config: Whether to enable the instance operating system configuration.
         :param str host_name: Instance host name.
+        :param str http_endpoint: Whether to enable access to instance metadata.
+        :param int http_put_response_hop_limit: The HTTP PUT response hop limit required for instance metadata requests.
+        :param str http_tokens: Whether to use the hardened mode (IMDSv2) when accessing instance metadata.
         :param str id: The ID of the Launch Template.
         :param str image_id: The Image Id.
         :param str image_owner_alias: Mirror source.
@@ -5225,7 +5630,7 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
         :param float spot_price_limit: Sets the maximum hourly instance price.
         :param str spot_strategy: The spot strategy for a Pay-As-You-Go instance.
         :param Sequence['GetEcsLaunchTemplatesTemplateSystemDiskArgs'] system_disks: The System Disk.
-        :param Mapping[str, Any] template_tags: The template tags.
+        :param Mapping[str, str] template_tags: The template tags.
         :param str user_data: The User Data.
         :param str version_description: The Version Description.
         :param str vpc_id: VpcId.
@@ -5240,6 +5645,9 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "enable_vm_os_config", enable_vm_os_config)
         pulumi.set(__self__, "host_name", host_name)
+        pulumi.set(__self__, "http_endpoint", http_endpoint)
+        pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
+        pulumi.set(__self__, "http_tokens", http_tokens)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "image_id", image_id)
         pulumi.set(__self__, "image_owner_alias", image_owner_alias)
@@ -5280,7 +5688,7 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
     @pulumi.getter(name="autoReleaseTime")
     def auto_release_time(self) -> str:
         """
-        Instance auto release time.
+        (Optional) Instance auto release time.
         """
         return pulumi.get(self, "auto_release_time")
 
@@ -5340,6 +5748,30 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
         """
         return pulumi.get(self, "host_name")
 
+    @property
+    @pulumi.getter(name="httpEndpoint")
+    def http_endpoint(self) -> str:
+        """
+        Whether to enable access to instance metadata.
+        """
+        return pulumi.get(self, "http_endpoint")
+
+    @property
+    @pulumi.getter(name="httpPutResponseHopLimit")
+    def http_put_response_hop_limit(self) -> int:
+        """
+        The HTTP PUT response hop limit required for instance metadata requests.
+        """
+        return pulumi.get(self, "http_put_response_hop_limit")
+
+    @property
+    @pulumi.getter(name="httpTokens")
+    def http_tokens(self) -> str:
+        """
+        Whether to use the hardened mode (IMDSv2) when accessing instance metadata.
+        """
+        return pulumi.get(self, "http_tokens")
+
     @property
     @pulumi.getter
     def id(self) -> str:
@@ -5574,7 +6006,7 @@ class GetEcsLaunchTemplatesTemplateResult(dict):
 
     @property
     @pulumi.getter(name="templateTags")
-    def template_tags(self) -> Mapping[str, Any]:
+    def template_tags(self) -> Mapping[str, str]:
         """
         The template tags.
         """
@@ -5954,6 +6386,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
                  description: str,
                  id: str,
                  instance_id: str,
+                 ipv6_sets: Sequence[str],
                  mac: str,
                  name: str,
                  network_interface_id: str,
@@ -5971,7 +6404,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
                  service_id: int,
                  service_managed: bool,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  vpc_id: str,
                  vswitch_id: str,
@@ -5982,14 +6415,16 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
         :param str description: The description of the ENI.
         :param str id: The ID of the Network Interface.
         :param str instance_id: The instance id.
+        :param Sequence[str] ipv6_sets: A list of IPv6 addresses that is assigned to the ENI.  **NOTE:** Available since v1.228.0.
         :param str mac: The MAC address of the ENI.
-        :param str name: The network interface name.
+        :param str name: Field `name` has been deprecated from provider version 1.123.1. New field `network_interface_name` instead
         :param str network_interface_id: The network interface id.
         :param str network_interface_name: The network interface name.
         :param str network_interface_traffic_mode: The communication mode of the elastic network card.
         :param str owner_id: The ID of the account to which the ENIC belongs.
         :param str primary_ip_address: The primary private IP address of the ENI.
-        :param str private_ip: The primary private IP address of the ENI.
+        :param str private_ip: Field `private_ip` has been deprecated from provider version 1.123.1. New field `primary_ip_address` instead
+        :param Sequence[str] private_ip_addresses: A list of secondary private IP address that is assigned to the ENI.
         :param Sequence[str] private_ips: A list of secondary private IP address that is assigned to the ENI.
         :param int queue_number: Number of network card queues.
         :param str resource_group_id: The resource group id.
@@ -5997,10 +6432,10 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
         :param Sequence[str] security_groups: The security groups.
         :param int service_id: The service id.
         :param bool service_managed: Whether the user of the elastic network card is a cloud product or a virtual vendor.
-        :param str status: The status of the ENI.
-        :param Mapping[str, Any] tags: The tags.
-        :param str type: The type of the ENI.
-        :param str vpc_id: The Vpc Id.
+        :param str status: The status of ENI. Valid Values: `Attaching`, `Available`, `CreateFailed`, `Creating`, `Deleting`, `Detaching`, `InUse`, `Linked`, `Linking`, `Unlinking`.
+        :param Mapping[str, str] tags: A map of tags assigned to ENIs.
+        :param str type: The type of ENI. Valid Values: `Primary`, `Secondary`.
+        :param str vpc_id: The vpc id.
         :param str vswitch_id: The vswitch id.
         :param str zone_id: The zone id.
         """
@@ -6009,6 +6444,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "instance_id", instance_id)
+        pulumi.set(__self__, "ipv6_sets", ipv6_sets)
         pulumi.set(__self__, "mac", mac)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network_interface_id", network_interface_id)
@@ -6072,6 +6508,14 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
         """
         return pulumi.get(self, "instance_id")
 
+    @property
+    @pulumi.getter(name="ipv6Sets")
+    def ipv6_sets(self) -> Sequence[str]:
+        """
+        A list of IPv6 addresses that is assigned to the ENI.  **NOTE:** Available since v1.228.0.
+        """
+        return pulumi.get(self, "ipv6_sets")
+
     @property
     @pulumi.getter
     def mac(self) -> str:
@@ -6084,7 +6528,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter
     def name(self) -> str:
         """
-        The network interface name.
+        Field `name` has been deprecated from provider version 1.123.1. New field `network_interface_name` instead
         """
         return pulumi.get(self, "name")
 
@@ -6132,13 +6576,16 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter(name="privateIp")
     def private_ip(self) -> str:
         """
-        The primary private IP address of the ENI.
+        Field `private_ip` has been deprecated from provider version 1.123.1. New field `primary_ip_address` instead
         """
         return pulumi.get(self, "private_ip")
 
     @property
     @pulumi.getter(name="privateIpAddresses")
     def private_ip_addresses(self) -> Sequence[str]:
+        """
+        A list of secondary private IP address that is assigned to the ENI.
+        """
         return pulumi.get(self, "private_ip_addresses")
 
     @property
@@ -6201,15 +6648,15 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of the ENI.
+        The status of ENI. Valid Values: `Attaching`, `Available`, `CreateFailed`, `Creating`, `Deleting`, `Detaching`, `InUse`, `Linked`, `Linking`, `Unlinking`.
         """
         return pulumi.get(self, "status")
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
-        The tags.
+        A map of tags assigned to ENIs.
         """
         return pulumi.get(self, "tags")
 
@@ -6217,7 +6664,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter
     def type(self) -> str:
         """
-        The type of the ENI.
+        The type of ENI. Valid Values: `Primary`, `Secondary`.
         """
         return pulumi.get(self, "type")
 
@@ -6225,7 +6672,7 @@ class GetEcsNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter(name="vpcId")
     def vpc_id(self) -> str:
         """
-        The Vpc Id.
+        The vpc id.
         """
         return pulumi.get(self, "vpc_id")
 
@@ -6401,7 +6848,7 @@ class GetEcsSnapshotGroupsGroupResult(dict):
                  snapshot_group_id: str,
                  snapshot_group_name: str,
                  status: str,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param str description: The description of the snapshot-consistent group.
         :param str id: The ID of the Snapshot Group.
@@ -6410,7 +6857,7 @@ class GetEcsSnapshotGroupsGroupResult(dict):
         :param str snapshot_group_id: The first ID of the resource.
         :param str snapshot_group_name: The name of the snapshot-consistent group.
         :param str status: The status of the resource.
-        :param Mapping[str, Any] tags: List of label key-value pairs.
+        :param Mapping[str, str] tags: List of label key-value pairs.
         """
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "id", id)
@@ -6480,7 +6927,7 @@ class GetEcsSnapshotGroupsGroupResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         List of label key-value pairs.
         """
@@ -6513,7 +6960,7 @@ class GetEcsSnapshotsSnapshotResult(dict):
                  source_disk_type: str,
                  source_storage_type: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  usage: str):
         """
@@ -6537,7 +6984,7 @@ class GetEcsSnapshotsSnapshotResult(dict):
         :param str source_disk_type: Source disk attributes.
         :param str source_storage_type: Original disk type.
         :param str status: The status of the snapshot.
-        :param Mapping[str, Any] tags: The tags.
+        :param Mapping[str, str] tags: The tags.
         :param str usage: A resource type that has a reference relationship.
         """
         pulumi.set(__self__, "category", category)
@@ -6744,7 +7191,7 @@ class GetEcsSnapshotsSnapshotResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         The tags.
         """
@@ -6914,7 +7361,7 @@ class GetEipAddressesAddressResult(dict):
                  second_limited: bool,
                  segment_instance_id: str,
                  status: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str address_name: The name of the EIP.
         :param str allocation_id: The ID of the EIP.
@@ -6946,7 +7393,7 @@ class GetEipAddressesAddressResult(dict):
         :param bool second_limited: Indicates whether level-2 throttling is configured.
         :param str segment_instance_id: The IDs of the contiguous EIPs.
         :param str status: The status of the EIP.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "address_name", address_name)
         pulumi.set(__self__, "allocation_id", allocation_id)
@@ -7222,7 +7669,7 @@ class GetEipAddressesAddressResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -7248,8 +7695,8 @@ class GetEipAddressesEipResult(dict):
         :param str instance_id: The ID of the instance with which the EIP is associated.
         :param str instance_type: The type of the instance with which the EIP is associated.
         :param str internet_charge_type: The metering method of the EIP.
-        :param str ip_address: The IP address of the EIP.
-        :param str status: The status of the EIP.
+        :param str ip_address: The eip address.
+        :param str status: The status of the EIP. Valid values:  `Associating`: The EIP is being associated. `Unassociating`: The EIP is being disassociated. `InUse`: The EIP is allocated. `Available`:The EIP is available.
         """
         pulumi.set(__self__, "bandwidth", bandwidth)
         pulumi.set(__self__, "creation_time", creation_time)
@@ -7318,7 +7765,7 @@ class GetEipAddressesEipResult(dict):
     @pulumi.getter(name="ipAddress")
     def ip_address(self) -> str:
         """
-        The IP address of the EIP.
+        The eip address.
         """
         return pulumi.get(self, "ip_address")
 
@@ -7326,7 +7773,7 @@ class GetEipAddressesEipResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of the EIP.
+        The status of the EIP. Valid values:  `Associating`: The EIP is being associated. `Unassociating`: The EIP is being disassociated. `InUse`: The EIP is allocated. `Available`:The EIP is available.
         """
         return pulumi.get(self, "status")
 
@@ -7364,7 +7811,7 @@ class GetEipsAddressResult(dict):
                  second_limited: bool,
                  segment_instance_id: str,
                  status: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str bandwidth: EIP internet max bandwidth in Mbps.
         :param bool deletion_protection: (Optional, Available in v1.124.4+) Whether enable the deletion protection or not.
@@ -7375,7 +7822,7 @@ class GetEipsAddressResult(dict):
         :param str ip_address: Public IP Address of the the EIP.
         :param str resource_group_id: The Id of resource group which the eips belongs.
         :param str status: EIP status. Possible values are: `Associating`, `Unassociating`, `InUse` and `Available`.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "address_name", address_name)
         pulumi.set(__self__, "allocation_id", allocation_id)
@@ -7588,7 +8035,7 @@ class GetEipsAddressResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -7719,7 +8166,7 @@ class GetElasticityAssurancesAssuranceResult(dict):
                  status: str,
                  total_assurance_times: str,
                  used_assurance_times: int,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param Sequence['GetElasticityAssurancesAssuranceAllocatedResourceArgs'] allocated_resources: Details of resource allocation.
         :param str description: Description of flexible guarantee service.
@@ -7736,7 +8183,7 @@ class GetElasticityAssurancesAssuranceResult(dict):
         :param str status: The status of flexible guarantee services. Possible values: `All`, `Preparing`, `Prepared`, `Active`, `Released`.
         :param str total_assurance_times: The total number of flexible guarantee services.
         :param int used_assurance_times: This parameter is not yet available.
-        :param Mapping[str, Any] tags: The tag key-value pair information bound by the elastic guarantee service.
+        :param Mapping[str, str] tags: The tag key-value pair information bound by the elastic guarantee service.
         """
         pulumi.set(__self__, "allocated_resources", allocated_resources)
         pulumi.set(__self__, "description", description)
@@ -7878,7 +8325,7 @@ class GetElasticityAssurancesAssuranceResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         The tag key-value pair information bound by the elastic guarantee service.
         """
@@ -8013,7 +8460,7 @@ class GetImagesImageResult(dict):
                  state: str,
                  status: str,
                  usage: str,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param str architecture: The image architecture. Valid values: `i386` and `x86_64`.
         :param str creation_time: Time of creation.
@@ -8031,9 +8478,15 @@ class GetImagesImageResult(dict):
         :param str product_code: Product code of the image on the image market.
         :param str progress: Progress of image creation, presented in percentages.
         :param int size: Size of the created disk.
-        :param str status: The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values:
+        :param str status: The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values: 
+               * `Creating`: The image is being created.
+               * `Waiting`: The image is waiting to be processed.
+               * `Available`: The image is available.
+               * `UnAvailable`: The image is unavailable.
+               * `CreateFailed`: The image failed to be created.
+               * `Deprecated`: The image is discontinued.
         :param str usage: Specifies whether to check the validity of the request without actually making the request. Valid values:
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "creation_time", creation_time)
@@ -8218,7 +8671,13 @@ class GetImagesImageResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values:
+        The status of the image. The following values are available, Separate multiple parameter values by using commas (,). Default value: `Available`. Valid values: 
+        * `Creating`: The image is being created.
+        * `Waiting`: The image is waiting to be processed.
+        * `Available`: The image is available.
+        * `UnAvailable`: The image is unavailable.
+        * `CreateFailed`: The image failed to be created.
+        * `Deprecated`: The image is discontinued.
         """
         return pulumi.get(self, "status")
 
@@ -8232,7 +8691,7 @@ class GetImagesImageResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -8326,13 +8785,20 @@ class GetInstanceTypesInstanceTypeResult(dict):
                  burstable_instance: 'outputs.GetInstanceTypesInstanceTypeBurstableInstanceResult',
                  cpu_core_count: int,
                  eni_amount: int,
+                 eni_ipv6_address_quantity: int,
+                 eni_private_ip_address_quantity: int,
+                 eni_quantity: int,
                  family: str,
                  gpu: 'outputs.GetInstanceTypesInstanceTypeGpuResult',
                  id: str,
                  local_storage: 'outputs.GetInstanceTypesInstanceTypeLocalStorageResult',
+                 maximum_queue_number_per_eni: int,
                  memory_size: float,
                  nvme_support: str,
-                 price: str):
+                 price: str,
+                 primary_eni_queue_number: int,
+                 secondary_eni_queue_number: int,
+                 total_eni_queue_quantity: int):
         """
         :param Sequence[str] availability_zones: List of availability zones that support the instance type.
         :param 'GetInstanceTypesInstanceTypeBurstableInstanceArgs' burstable_instance: The burstable instance attribution:
@@ -8340,6 +8806,9 @@ class GetInstanceTypesInstanceTypeResult(dict):
                - baseline_credit:  The compute performance benchmark CPU credit of a burstable instance.
         :param int cpu_core_count: Filter the results to a specific number of cpu cores.
         :param int eni_amount: Filter the result whose network interface number is no more than `eni_amount`.
+        :param int eni_ipv6_address_quantity: (Available since v1.239.0) The maximum number of IPv6 addresses per ENI.
+        :param int eni_private_ip_address_quantity: (Available since v1.239.0) The maximum number of IPv4 addresses per ENI.
+        :param int eni_quantity: (Available since v1.239.0) The maximum number of ENIs per instance.
         :param str family: The instance type family.
         :param 'GetInstanceTypesInstanceTypeGpuArgs' gpu: The GPU attribution of an instance type:
                - amount: The amount of GPU of an instance type.
@@ -8349,22 +8818,34 @@ class GetInstanceTypesInstanceTypeResult(dict):
                - capacity: The capacity of a local storage in GB.
                - amount:  The number of local storage devices that an instance has been attached to.
                - category: The category of local storage that an instance has been attached to.
+        :param int maximum_queue_number_per_eni: (Available since v1.239.0) The maximum number of queues per ENI, including primary and secondary ENIs.
         :param float memory_size: Filter the results to a specific memory size in GB.
         :param str nvme_support: Indicates whether the cloud disk can be attached by using the nonvolatile memory express (NVMe) protocol. Valid values:
                - required: The cloud disk can be attached by using the NVMe protocol.
                - unsupported: The cloud disk cannot be attached by using the NVMe protocol.
+        :param str price: The price of instance type.
+        :param int primary_eni_queue_number: (Available since v1.239.0) The default number of queues per primary ENI.
+        :param int secondary_eni_queue_number: (Available since v1.239.0) The default number of queues per secondary ENI.
+        :param int total_eni_queue_quantity: (Available since v1.239.0) The maximum number of queues on ENIs that the instance type supports.
         """
         pulumi.set(__self__, "availability_zones", availability_zones)
         pulumi.set(__self__, "burstable_instance", burstable_instance)
         pulumi.set(__self__, "cpu_core_count", cpu_core_count)
         pulumi.set(__self__, "eni_amount", eni_amount)
+        pulumi.set(__self__, "eni_ipv6_address_quantity", eni_ipv6_address_quantity)
+        pulumi.set(__self__, "eni_private_ip_address_quantity", eni_private_ip_address_quantity)
+        pulumi.set(__self__, "eni_quantity", eni_quantity)
         pulumi.set(__self__, "family", family)
         pulumi.set(__self__, "gpu", gpu)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "local_storage", local_storage)
+        pulumi.set(__self__, "maximum_queue_number_per_eni", maximum_queue_number_per_eni)
         pulumi.set(__self__, "memory_size", memory_size)
         pulumi.set(__self__, "nvme_support", nvme_support)
         pulumi.set(__self__, "price", price)
+        pulumi.set(__self__, "primary_eni_queue_number", primary_eni_queue_number)
+        pulumi.set(__self__, "secondary_eni_queue_number", secondary_eni_queue_number)
+        pulumi.set(__self__, "total_eni_queue_quantity", total_eni_queue_quantity)
 
     @property
     @pulumi.getter(name="availabilityZones")
@@ -8400,6 +8881,30 @@ class GetInstanceTypesInstanceTypeResult(dict):
         """
         return pulumi.get(self, "eni_amount")
 
+    @property
+    @pulumi.getter(name="eniIpv6AddressQuantity")
+    def eni_ipv6_address_quantity(self) -> int:
+        """
+        (Available since v1.239.0) The maximum number of IPv6 addresses per ENI.
+        """
+        return pulumi.get(self, "eni_ipv6_address_quantity")
+
+    @property
+    @pulumi.getter(name="eniPrivateIpAddressQuantity")
+    def eni_private_ip_address_quantity(self) -> int:
+        """
+        (Available since v1.239.0) The maximum number of IPv4 addresses per ENI.
+        """
+        return pulumi.get(self, "eni_private_ip_address_quantity")
+
+    @property
+    @pulumi.getter(name="eniQuantity")
+    def eni_quantity(self) -> int:
+        """
+        (Available since v1.239.0) The maximum number of ENIs per instance.
+        """
+        return pulumi.get(self, "eni_quantity")
+
     @property
     @pulumi.getter
     def family(self) -> str:
@@ -8437,6 +8942,14 @@ class GetInstanceTypesInstanceTypeResult(dict):
         """
         return pulumi.get(self, "local_storage")
 
+    @property
+    @pulumi.getter(name="maximumQueueNumberPerEni")
+    def maximum_queue_number_per_eni(self) -> int:
+        """
+        (Available since v1.239.0) The maximum number of queues per ENI, including primary and secondary ENIs.
+        """
+        return pulumi.get(self, "maximum_queue_number_per_eni")
+
     @property
     @pulumi.getter(name="memorySize")
     def memory_size(self) -> float:
@@ -8458,8 +8971,35 @@ class GetInstanceTypesInstanceTypeResult(dict):
     @property
     @pulumi.getter
     def price(self) -> str:
+        """
+        The price of instance type.
+        """
         return pulumi.get(self, "price")
 
+    @property
+    @pulumi.getter(name="primaryEniQueueNumber")
+    def primary_eni_queue_number(self) -> int:
+        """
+        (Available since v1.239.0) The default number of queues per primary ENI.
+        """
+        return pulumi.get(self, "primary_eni_queue_number")
+
+    @property
+    @pulumi.getter(name="secondaryEniQueueNumber")
+    def secondary_eni_queue_number(self) -> int:
+        """
+        (Available since v1.239.0) The default number of queues per secondary ENI.
+        """
+        return pulumi.get(self, "secondary_eni_queue_number")
+
+    @property
+    @pulumi.getter(name="totalEniQueueQuantity")
+    def total_eni_queue_quantity(self) -> int:
+        """
+        (Available since v1.239.0) The maximum number of queues on ENIs that the instance type supports.
+        """
+        return pulumi.get(self, "total_eni_queue_quantity")
+
 
 @pulumi.output_type
 class GetInstanceTypesInstanceTypeBurstableInstanceResult(dict):
@@ -8551,7 +9091,7 @@ class GetInstancesInstanceResult(dict):
                  status: str,
                  vpc_id: str,
                  vswitch_id: str,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param str availability_zone: Availability zone where instances are located.
         :param str creation_time: Instance creation time.
@@ -8575,9 +9115,8 @@ class GetInstancesInstanceResult(dict):
         :param str spot_strategy: Spot strategy the instance is using.
         :param str status: Instance status. Valid values: "Creating", "Starting", "Running", "Stopping" and "Stopped". If undefined, all statuses are considered.
         :param str vpc_id: ID of the VPC linked to the instances.
-        :param str vswitch_id: ID of the VSwitch linked to the instances.
-        :param Mapping[str, Any] tags: A map of tags assigned to the ECS instances. It must be in the format:
-               <!--Start PulumiCodeChooser -->
+        :param str vswitch_id: ID of the vSwitch linked to the instances.
+        :param Mapping[str, str] tags: A map of tags assigned to the ECS instances. It must be in the format:
                ```python
                import pulumi
                import pulumi_alicloud as alicloud
@@ -8587,7 +9126,6 @@ class GetInstancesInstanceResult(dict):
                    "tagKey2": "tagValue2",
                })
                ```
-               <!--End PulumiCodeChooser -->
         """
         pulumi.set(__self__, "availability_zone", availability_zone)
         pulumi.set(__self__, "creation_time", creation_time)
@@ -8795,16 +9333,15 @@ class GetInstancesInstanceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        ID of the VSwitch linked to the instances.
+        ID of the vSwitch linked to the instances.
         """
         return pulumi.get(self, "vswitch_id")
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         A map of tags assigned to the ECS instances. It must be in the format:
-        <!--Start PulumiCodeChooser -->
         ```python
         import pulumi
         import pulumi_alicloud as alicloud
@@ -8814,7 +9351,6 @@ class GetInstancesInstanceResult(dict):
             "tagKey2": "tagValue2",
         })
         ```
-        <!--End PulumiCodeChooser -->
         """
         return pulumi.get(self, "tags")
 
@@ -8901,14 +9437,14 @@ class GetKeyPairsKeyPairResult(dict):
                  key_name: str,
                  key_pair_name: str,
                  resource_group_id: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str finger_print: A finger print used to retrieve specified key pair.
         :param str id: ID of the key pair.
         :param Sequence['GetKeyPairsKeyPairInstanceArgs'] instances: A list of ECS instances that has been bound this key pair.
         :param str key_name: Name of the key pair.
         :param str resource_group_id: The Id of resource group which the key pair belongs.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "finger_print", finger_print)
         pulumi.set(__self__, "id", id)
@@ -8965,7 +9501,7 @@ class GetKeyPairsKeyPairResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -8994,7 +9530,7 @@ class GetKeyPairsKeyPairInstanceResult(dict):
         :param str key_name: Name of the key pair.
         :param str private_ip: The private IP address of the ECS instance.
         :param str public_ip: The public IP address or EIP of the ECS instance.
-        :param str vswitch_id: The ID of the VSwitch attached to the ECS instance.
+        :param str vswitch_id: The ID of the vSwitch attached to the ECS instance.
         """
         pulumi.set(__self__, "availability_zone", availability_zone)
         pulumi.set(__self__, "description", description)
@@ -9086,7 +9622,7 @@ class GetKeyPairsKeyPairInstanceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        The ID of the VSwitch attached to the ECS instance.
+        The ID of the vSwitch attached to the ECS instance.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -9100,14 +9636,14 @@ class GetKeyPairsPairResult(dict):
                  key_name: str,
                  key_pair_name: str,
                  resource_group_id: str,
-                 tags: Mapping[str, Any]):
+                 tags: Mapping[str, str]):
         """
         :param str finger_print: A finger print used to retrieve specified key pair.
         :param str id: ID of the key pair.
         :param Sequence['GetKeyPairsPairInstanceArgs'] instances: A list of ECS instances that has been bound this key pair.
         :param str key_name: Name of the key pair.
         :param str resource_group_id: The Id of resource group which the key pair belongs.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
         """
         pulumi.set(__self__, "finger_print", finger_print)
         pulumi.set(__self__, "id", id)
@@ -9164,7 +9700,7 @@ class GetKeyPairsPairResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -9193,7 +9729,7 @@ class GetKeyPairsPairInstanceResult(dict):
         :param str key_name: Name of the key pair.
         :param str private_ip: The private IP address of the ECS instance.
         :param str public_ip: The public IP address or EIP of the ECS instance.
-        :param str vswitch_id: The ID of the VSwitch attached to the ECS instance.
+        :param str vswitch_id: The ID of the vSwitch attached to the ECS instance.
         """
         pulumi.set(__self__, "availability_zone", availability_zone)
         pulumi.set(__self__, "description", description)
@@ -9285,7 +9821,7 @@ class GetKeyPairsPairInstanceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        The ID of the VSwitch attached to the ECS instance.
+        The ID of the vSwitch attached to the ECS instance.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -9298,6 +9834,7 @@ class GetNetworkInterfacesInterfaceResult(dict):
                  description: str,
                  id: str,
                  instance_id: str,
+                 ipv6_sets: Sequence[str],
                  mac: str,
                  name: str,
                  network_interface_id: str,
@@ -9315,7 +9852,7 @@ class GetNetworkInterfacesInterfaceResult(dict):
                  service_id: int,
                  service_managed: bool,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  vpc_id: str,
                  vswitch_id: str,
@@ -9332,9 +9869,9 @@ class GetNetworkInterfacesInterfaceResult(dict):
         :param str resource_group_id: The Id of resource group.
         :param Sequence[str] security_groups: A list of security group that the ENI belongs to.
         :param str status: Current status of the ENI.
-        :param Mapping[str, Any] tags: A map of tags assigned to the ENI.
+        :param Mapping[str, str] tags: A map of tags assigned to the ENI.
         :param str vpc_id: ID of the VPC that the ENI belongs to.
-        :param str vswitch_id: ID of the VSwitch that the ENI is linked to.
+        :param str vswitch_id: ID of the vSwitch that the ENI is linked to.
         :param str zone_id: ID of the availability zone that the ENI belongs to.
         """
         pulumi.set(__self__, "associated_public_ips", associated_public_ips)
@@ -9342,6 +9879,7 @@ class GetNetworkInterfacesInterfaceResult(dict):
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "instance_id", instance_id)
+        pulumi.set(__self__, "ipv6_sets", ipv6_sets)
         pulumi.set(__self__, "mac", mac)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network_interface_id", network_interface_id)
@@ -9402,6 +9940,11 @@ class GetNetworkInterfacesInterfaceResult(dict):
         """
         return pulumi.get(self, "instance_id")
 
+    @property
+    @pulumi.getter(name="ipv6Sets")
+    def ipv6_sets(self) -> Sequence[str]:
+        return pulumi.get(self, "ipv6_sets")
+
     @property
     @pulumi.getter
     def mac(self) -> str:
@@ -9510,7 +10053,7 @@ class GetNetworkInterfacesInterfaceResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A map of tags assigned to the ENI.
         """
@@ -9533,7 +10076,7 @@ class GetNetworkInterfacesInterfaceResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        ID of the VSwitch that the ENI is linked to.
+        ID of the vSwitch that the ENI is linked to.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -9719,7 +10262,7 @@ class GetSecurityGroupsGroupResult(dict):
                  resource_group_id: str,
                  security_group_type: str,
                  vpc_id: str,
-                 tags: Optional[Mapping[str, Any]] = None):
+                 tags: Optional[Mapping[str, str]] = None):
         """
         :param str creation_time: Creation time of the security group.
         :param str description: The description of the security group.
@@ -9729,8 +10272,7 @@ class GetSecurityGroupsGroupResult(dict):
         :param str resource_group_id: The Id of resource group which the security_group belongs.
         :param str security_group_type: The type of the security group.
         :param str vpc_id: Used to retrieve security groups that belong to the specified VPC ID.
-        :param Mapping[str, Any] tags: A map of tags assigned to the ECS instances. It must be in the format:
-               <!--Start PulumiCodeChooser -->
+        :param Mapping[str, str] tags: A map of tags assigned to the ECS instances. It must be in the format:
                ```python
                import pulumi
                import pulumi_alicloud as alicloud
@@ -9740,7 +10282,6 @@ class GetSecurityGroupsGroupResult(dict):
                    "tagKey2": "tagValue2",
                })
                ```
-               <!--End PulumiCodeChooser -->
         """
         pulumi.set(__self__, "creation_time", creation_time)
         pulumi.set(__self__, "description", description)
@@ -9819,10 +10360,9 @@ class GetSecurityGroupsGroupResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Optional[Mapping[str, Any]]:
+    def tags(self) -> Optional[Mapping[str, str]]:
         """
         A map of tags assigned to the ECS instances. It must be in the format:
-        <!--Start PulumiCodeChooser -->
         ```python
         import pulumi
         import pulumi_alicloud as alicloud
@@ -9832,7 +10372,6 @@ class GetSecurityGroupsGroupResult(dict):
             "tagKey2": "tagValue2",
         })
         ```
-        <!--End PulumiCodeChooser -->
         """
         return pulumi.get(self, "tags")
 
@@ -9863,7 +10402,7 @@ class GetSnapshotsSnapshotResult(dict):
                  source_disk_type: str,
                  source_storage_type: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  type: str,
                  usage: str):
         """
@@ -9880,7 +10419,7 @@ class GetSnapshotsSnapshotResult(dict):
         :param str source_disk_size: Size of the source disk, measured in GB.
         :param str source_disk_type: Source disk attribute. Value range: `System`,`Data`.
         :param str status: The snapshot status. Value range: `progressing`, `accomplished` and `failed`.
-        :param Mapping[str, Any] tags: A map of tags assigned to the snapshot.
+        :param Mapping[str, str] tags: A map of tags assigned to the snapshot.
         :param str usage: Whether the snapshots are used to create resources or not. Value range: `image`, `disk`, `image_disk` and `none`.
         """
         pulumi.set(__self__, "category", category)
@@ -10066,7 +10605,7 @@ class GetSnapshotsSnapshotResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A map of tags assigned to the snapshot.
         """