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

pulumi_alicloud/vpc/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__ = [
     'DhcpOptionsSetAssociateVpc',
+    'NatGatewayAccessMode',
     'NetworkAclAttachmentResource',
     'NetworkAclEgressAclEntry',
     'NetworkAclEntriesEgress',
@@ -32,6 +38,11 @@ __all__ = [
     'GetEnhancedNatAvailableZonesZoneResult',
     'GetForwardEntriesEntryResult',
     'GetHavipsHavipResult',
+    'GetIpamIpamPoolAllocationsAllocationResult',
+    'GetIpamIpamPoolCidrsCidrResult',
+    'GetIpamIpamPoolsPoolResult',
+    'GetIpamIpamScopesScopeResult',
+    'GetIpamIpamsIpamResult',
     'GetIpsecServersServerResult',
     'GetIpsecServersServerIkeConfigResult',
     'GetIpsecServersServerIpsecConfigResult',
@@ -117,6 +128,56 @@ class DhcpOptionsSetAssociateVpc(dict):
         return pulumi.get(self, "associate_status")
 
 
+@pulumi.output_type
+class NatGatewayAccessMode(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "modeValue":
+            suggest = "mode_value"
+        elif key == "tunnelType":
+            suggest = "tunnel_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NatGatewayAccessMode. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NatGatewayAccessMode.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NatGatewayAccessMode.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 mode_value: Optional[str] = None,
+                 tunnel_type: Optional[str] = None):
+        """
+        :param str mode_value: The mode of Access. Valid values:
+        :param str tunnel_type: The type of Tunnel. Valid values: `geneve`. **NOTE:** `tunnel_type` takes effect only if `mode_value` is set to `tunnel`.
+        """
+        if mode_value is not None:
+            pulumi.set(__self__, "mode_value", mode_value)
+        if tunnel_type is not None:
+            pulumi.set(__self__, "tunnel_type", tunnel_type)
+
+    @property
+    @pulumi.getter(name="modeValue")
+    def mode_value(self) -> Optional[str]:
+        """
+        The mode of Access. Valid values:
+        """
+        return pulumi.get(self, "mode_value")
+
+    @property
+    @pulumi.getter(name="tunnelType")
+    def tunnel_type(self) -> Optional[str]:
+        """
+        The type of Tunnel. Valid values: `geneve`. **NOTE:** `tunnel_type` takes effect only if `mode_value` is set to `tunnel`.
+        """
+        return pulumi.get(self, "tunnel_type")
+
+
 @pulumi.output_type
 class NetworkAclAttachmentResource(dict):
     @staticmethod
@@ -172,6 +233,10 @@ class NetworkAclEgressAclEntry(dict):
         suggest = None
         if key == "destinationCidrIp":
             suggest = "destination_cidr_ip"
+        elif key == "entryType":
+            suggest = "entry_type"
+        elif key == "ipVersion":
+            suggest = "ip_version"
         elif key == "networkAclEntryName":
             suggest = "network_acl_entry_name"
 
@@ -189,18 +254,22 @@ class NetworkAclEgressAclEntry(dict):
     def __init__(__self__, *,
                  description: Optional[str] = None,
                  destination_cidr_ip: Optional[str] = None,
+                 entry_type: Optional[str] = None,
+                 ip_version: Optional[str] = None,
                  network_acl_entry_name: Optional[str] = None,
                  policy: Optional[str] = None,
                  port: Optional[str] = None,
                  protocol: Optional[str] = None):
         """
-        :param str description: The description of the outbound rule.The description must be 1 to 256 characters in length and cannot start with http:// or https.
+        :param str description: The description of the outbound rule.  The description must be 1 to 256 characters in length and cannot start with http:// or https.
         :param str destination_cidr_ip: The network of the destination address.
-        :param str network_acl_entry_name: Name of the outbound rule entry.The name must be 1 to 128 characters in length and cannot start with http:// or https.
+        :param str entry_type: The route entry type. The value can be `custom`, indicating custom.
+        :param str ip_version: The IP protocol version of the route entry. Valid values: "IPV4" and "IPV4'.
+        :param str network_acl_entry_name: Name of the outbound rule entry.  The name must be 1 to 128 characters in length and cannot start with http:// or https.
         :param str policy: Authorization policy. Value:
                - accept: Allow.
                - drop: Refused.
-        :param str port: The destination port range of the outbound rule.When the Protocol type of the outbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted.When the Protocol type of the outbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
+        :param str port: The destination port range of the outbound rule.  When the Protocol type of the outbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted. When the Protocol type of the outbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
         :param str protocol: The protocol type. Value:
                - icmp: Network Control Message Protocol.
                - gre: Generic Routing Encapsulation Protocol.
@@ -212,6 +281,10 @@ class NetworkAclEgressAclEntry(dict):
             pulumi.set(__self__, "description", description)
         if destination_cidr_ip is not None:
             pulumi.set(__self__, "destination_cidr_ip", destination_cidr_ip)
+        if entry_type is not None:
+            pulumi.set(__self__, "entry_type", entry_type)
+        if ip_version is not None:
+            pulumi.set(__self__, "ip_version", ip_version)
         if network_acl_entry_name is not None:
             pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
         if policy is not None:
@@ -225,7 +298,7 @@ class NetworkAclEgressAclEntry(dict):
     @pulumi.getter
     def description(self) -> Optional[str]:
         """
-        The description of the outbound rule.The description must be 1 to 256 characters in length and cannot start with http:// or https.
+        The description of the outbound rule.  The description must be 1 to 256 characters in length and cannot start with http:// or https.
         """
         return pulumi.get(self, "description")
 
@@ -237,11 +310,27 @@ class NetworkAclEgressAclEntry(dict):
         """
         return pulumi.get(self, "destination_cidr_ip")
 
+    @property
+    @pulumi.getter(name="entryType")
+    def entry_type(self) -> Optional[str]:
+        """
+        The route entry type. The value can be `custom`, indicating custom.
+        """
+        return pulumi.get(self, "entry_type")
+
+    @property
+    @pulumi.getter(name="ipVersion")
+    def ip_version(self) -> Optional[str]:
+        """
+        The IP protocol version of the route entry. Valid values: "IPV4" and "IPV4'.
+        """
+        return pulumi.get(self, "ip_version")
+
     @property
     @pulumi.getter(name="networkAclEntryName")
     def network_acl_entry_name(self) -> Optional[str]:
         """
-        Name of the outbound rule entry.The name must be 1 to 128 characters in length and cannot start with http:// or https.
+        Name of the outbound rule entry.  The name must be 1 to 128 characters in length and cannot start with http:// or https.
         """
         return pulumi.get(self, "network_acl_entry_name")
 
@@ -259,7 +348,7 @@ class NetworkAclEgressAclEntry(dict):
     @pulumi.getter
     def port(self) -> Optional[str]:
         """
-        The destination port range of the outbound rule.When the Protocol type of the outbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted.When the Protocol type of the outbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
+        The destination port range of the outbound rule.  When the Protocol type of the outbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted. When the Protocol type of the outbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
         """
         return pulumi.get(self, "port")
 
@@ -307,13 +396,7 @@ class NetworkAclEntriesEgress(dict):
                  port: Optional[str] = None,
                  protocol: Optional[str] = None):
         """
-        :param str description: The description of the egress entry.
         :param str destination_cidr_ip: The destination ip of the egress entry.
-        :param str entry_type: The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
-        :param str name: The name of the egress entry.
-        :param str policy: The policy of the egress entry. It must be `accept` or `drop`.
-        :param str port: The port of the egress entry.
-        :param str protocol: The protocol of the egress entry.
         """
         if description is not None:
             pulumi.set(__self__, "description", description)
@@ -333,9 +416,6 @@ class NetworkAclEntriesEgress(dict):
     @property
     @pulumi.getter
     def description(self) -> Optional[str]:
-        """
-        The description of the egress entry.
-        """
         return pulumi.get(self, "description")
 
     @property
@@ -349,41 +429,26 @@ class NetworkAclEntriesEgress(dict):
     @property
     @pulumi.getter(name="entryType")
     def entry_type(self) -> Optional[str]:
-        """
-        The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
-        """
         return pulumi.get(self, "entry_type")
 
     @property
     @pulumi.getter
     def name(self) -> Optional[str]:
-        """
-        The name of the egress entry.
-        """
         return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
     def policy(self) -> Optional[str]:
-        """
-        The policy of the egress entry. It must be `accept` or `drop`.
-        """
         return pulumi.get(self, "policy")
 
     @property
     @pulumi.getter
     def port(self) -> Optional[str]:
-        """
-        The port of the egress entry.
-        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def protocol(self) -> Optional[str]:
-        """
-        The protocol of the egress entry.
-        """
         return pulumi.get(self, "protocol")
 
 
@@ -417,12 +482,6 @@ class NetworkAclEntriesIngress(dict):
                  protocol: Optional[str] = None,
                  source_cidr_ip: Optional[str] = None):
         """
-        :param str description: The description of the egress entry.
-        :param str entry_type: The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
-        :param str name: The name of the egress entry.
-        :param str policy: The policy of the egress entry. It must be `accept` or `drop`.
-        :param str port: The port of the egress entry.
-        :param str protocol: The protocol of the egress entry.
         :param str source_cidr_ip: The source ip of the ingress entry.
         """
         if description is not None:
@@ -443,49 +502,31 @@ class NetworkAclEntriesIngress(dict):
     @property
     @pulumi.getter
     def description(self) -> Optional[str]:
-        """
-        The description of the egress entry.
-        """
         return pulumi.get(self, "description")
 
     @property
     @pulumi.getter(name="entryType")
     def entry_type(self) -> Optional[str]:
-        """
-        The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
-        """
         return pulumi.get(self, "entry_type")
 
     @property
     @pulumi.getter
     def name(self) -> Optional[str]:
-        """
-        The name of the egress entry.
-        """
         return pulumi.get(self, "name")
 
     @property
     @pulumi.getter
     def policy(self) -> Optional[str]:
-        """
-        The policy of the egress entry. It must be `accept` or `drop`.
-        """
         return pulumi.get(self, "policy")
 
     @property
     @pulumi.getter
     def port(self) -> Optional[str]:
-        """
-        The port of the egress entry.
-        """
         return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
     def protocol(self) -> Optional[str]:
-        """
-        The protocol of the egress entry.
-        """
         return pulumi.get(self, "protocol")
 
     @property
@@ -502,7 +543,11 @@ class NetworkAclIngressAclEntry(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "networkAclEntryName":
+        if key == "entryType":
+            suggest = "entry_type"
+        elif key == "ipVersion":
+            suggest = "ip_version"
+        elif key == "networkAclEntryName":
             suggest = "network_acl_entry_name"
         elif key == "sourceCidrIp":
             suggest = "source_cidr_ip"
@@ -520,18 +565,22 @@ class NetworkAclIngressAclEntry(dict):
 
     def __init__(__self__, *,
                  description: Optional[str] = None,
+                 entry_type: Optional[str] = None,
+                 ip_version: Optional[str] = None,
                  network_acl_entry_name: Optional[str] = None,
                  policy: Optional[str] = None,
                  port: Optional[str] = None,
                  protocol: Optional[str] = None,
                  source_cidr_ip: Optional[str] = None):
         """
-        :param str description: Description of the inbound rule.The description must be 1 to 256 characters in length and cannot start with http:// or https.
-        :param str network_acl_entry_name: The name of the inbound rule entry.The name must be 1 to 128 characters in length and cannot start with http:// or https.
+        :param str description: Description of the inbound rule.  The description must be 1 to 256 characters in length and cannot start with http:// or https.
+        :param str entry_type: The route entry type. The value can be `custom`, indicating custom.
+        :param str ip_version: The IP protocol version of the route entry. Valid values: "IPV4" and "IPV6'.
+        :param str network_acl_entry_name: The name of the inbound rule entry.  The name must be 1 to 128 characters in length and cannot start with http:// or https.
         :param str policy: Authorization policy. Value:
                - accept: Allow.
                - drop: Refused.
-        :param str port: The source port range of the inbound rule.When the Protocol type of the inbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted.When the Protocol type of the inbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
+        :param str port: The source port range of the inbound rule.  When the Protocol type of the inbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted. When the Protocol type of the inbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
         :param str protocol: The protocol type. Value:
                - icmp: Network Control Message Protocol.
                - gre: Generic Routing Encapsulation Protocol.
@@ -542,6 +591,10 @@ class NetworkAclIngressAclEntry(dict):
         """
         if description is not None:
             pulumi.set(__self__, "description", description)
+        if entry_type is not None:
+            pulumi.set(__self__, "entry_type", entry_type)
+        if ip_version is not None:
+            pulumi.set(__self__, "ip_version", ip_version)
         if network_acl_entry_name is not None:
             pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
         if policy is not None:
@@ -557,15 +610,31 @@ class NetworkAclIngressAclEntry(dict):
     @pulumi.getter
     def description(self) -> Optional[str]:
         """
-        Description of the inbound rule.The description must be 1 to 256 characters in length and cannot start with http:// or https.
+        Description of the inbound rule.  The description must be 1 to 256 characters in length and cannot start with http:// or https.
         """
         return pulumi.get(self, "description")
 
+    @property
+    @pulumi.getter(name="entryType")
+    def entry_type(self) -> Optional[str]:
+        """
+        The route entry type. The value can be `custom`, indicating custom.
+        """
+        return pulumi.get(self, "entry_type")
+
+    @property
+    @pulumi.getter(name="ipVersion")
+    def ip_version(self) -> Optional[str]:
+        """
+        The IP protocol version of the route entry. Valid values: "IPV4" and "IPV6'.
+        """
+        return pulumi.get(self, "ip_version")
+
     @property
     @pulumi.getter(name="networkAclEntryName")
     def network_acl_entry_name(self) -> Optional[str]:
         """
-        The name of the inbound rule entry.The name must be 1 to 128 characters in length and cannot start with http:// or https.
+        The name of the inbound rule entry.  The name must be 1 to 128 characters in length and cannot start with http:// or https.
         """
         return pulumi.get(self, "network_acl_entry_name")
 
@@ -583,7 +652,7 @@ class NetworkAclIngressAclEntry(dict):
     @pulumi.getter
     def port(self) -> Optional[str]:
         """
-        The source port range of the inbound rule.When the Protocol type of the inbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted.When the Protocol type of the inbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
+        The source port range of the inbound rule.  When the Protocol type of the inbound rule is all, icmp, or gre, the port range is - 1/-1, indicating that the port is not restricted. When the Protocol type of the inbound rule is tcp or udp, the port range is 1 to 65535, and the format is 1/200 or 80/80, indicating port 1 to port 200 or port 80.
         """
         return pulumi.get(self, "port")
 
@@ -637,7 +706,7 @@ class NetworkAclResource(dict):
         """
         :param str resource_id: The ID of the associated resource.
         :param str resource_type: The type of the associated resource.
-        :param str status: The status of the associated resource.
+        :param str status: The state of the network ACL.
         """
         pulumi.set(__self__, "resource_id", resource_id)
         pulumi.set(__self__, "resource_type", resource_type)
@@ -664,7 +733,7 @@ class NetworkAclResource(dict):
     @pulumi.getter
     def status(self) -> Optional[str]:
         """
-        The status of the associated resource.
+        The state of the network ACL.
         """
         return pulumi.get(self, "status")
 
@@ -694,13 +763,16 @@ class NetworkIpv6CidrBlock(dict):
                  ipv6_cidr_block: Optional[str] = None,
                  ipv6_isp: Optional[str] = None):
         """
-        :param str ipv6_cidr_block: The IPv6 CIDR block of the VPC.
+        :param str ipv6_cidr_block: The IPv6 CIDR block of the default VPC.
+               
+               > **NOTE:**  When `EnableIpv6` is set to `true`, this parameter is required.
         :param str ipv6_isp: The IPv6 address segment type of the VPC. Value:
-               - **BGP** (default): Alibaba Cloud BGP IPv6.
-               - **ChinaMobile**: China Mobile (single line).
-               - **ChinaUnicom**: China Unicom (single line).
-               - **ChinaTelecom**: China Telecom (single line).
-               > **NOTE:**  If a single-line bandwidth whitelist is enabled, this field can be set to **ChinaTelecom** (China Telecom), **ChinaUnicom** (China Unicom), or **ChinaMobile** (China Mobile).
+               - `BGP` (default): Alibaba Cloud BGP IPv6.
+               - `ChinaMobile`: China Mobile (single line).
+               - `ChinaUnicom`: China Unicom (single line).
+               - `ChinaTelecom`: China Telecom (single line).
+               
+               > **NOTE:**  If a single-line bandwidth whitelist is enabled, this field can be set to `ChinaTelecom` (China Telecom), `ChinaUnicom` (China Unicom), or `ChinaMobile` (China Mobile).
         """
         if ipv6_cidr_block is not None:
             pulumi.set(__self__, "ipv6_cidr_block", ipv6_cidr_block)
@@ -711,7 +783,9 @@ class NetworkIpv6CidrBlock(dict):
     @pulumi.getter(name="ipv6CidrBlock")
     def ipv6_cidr_block(self) -> Optional[str]:
         """
-        The IPv6 CIDR block of the VPC.
+        The IPv6 CIDR block of the default VPC.
+
+        > **NOTE:**  When `EnableIpv6` is set to `true`, this parameter is required.
         """
         return pulumi.get(self, "ipv6_cidr_block")
 
@@ -720,11 +794,12 @@ class NetworkIpv6CidrBlock(dict):
     def ipv6_isp(self) -> Optional[str]:
         """
         The IPv6 address segment type of the VPC. Value:
-        - **BGP** (default): Alibaba Cloud BGP IPv6.
-        - **ChinaMobile**: China Mobile (single line).
-        - **ChinaUnicom**: China Unicom (single line).
-        - **ChinaTelecom**: China Telecom (single line).
-        > **NOTE:**  If a single-line bandwidth whitelist is enabled, this field can be set to **ChinaTelecom** (China Telecom), **ChinaUnicom** (China Unicom), or **ChinaMobile** (China Mobile).
+        - `BGP` (default): Alibaba Cloud BGP IPv6.
+        - `ChinaMobile`: China Mobile (single line).
+        - `ChinaUnicom`: China Unicom (single line).
+        - `ChinaTelecom`: China Telecom (single line).
+
+        > **NOTE:**  If a single-line bandwidth whitelist is enabled, this field can be set to `ChinaTelecom` (China Telecom), `ChinaUnicom` (China Unicom), or `ChinaMobile` (China Mobile).
         """
         return pulumi.get(self, "ipv6_isp")
 
@@ -926,23 +1001,6 @@ class TrafficMirrorFilterEgressRule(dict):
                  source_cidr_block: Optional[str] = None,
                  source_port_range: Optional[str] = None,
                  traffic_mirror_filter_rule_status: Optional[str] = None):
-        """
-        :param str action: Collection strategy for outbound rules. Value:
-               - accept: collects network traffic.
-               - drop: No network traffic is collected.
-        :param str protocol: The type of protocol used by the outbound network traffic to be mirrored. Value:
-               - ALL: ALL agreements.
-               - ICMP: Network Control Message Protocol.
-               - TCP: Transmission Control Protocol.
-               - UDP: User Datagram Protocol.
-        :param str destination_cidr_block: DestinationCidrBlock.
-        :param str destination_port_range: The destination port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-               > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        :param int priority: Priority.
-        :param str source_cidr_block: The source address of the outbound rule network traffic.
-        :param str source_port_range: The source port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-               > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         pulumi.set(__self__, "action", action)
         pulumi.set(__self__, "protocol", protocol)
         if destination_cidr_block is not None:
@@ -961,65 +1019,36 @@ class TrafficMirrorFilterEgressRule(dict):
     @property
     @pulumi.getter
     def action(self) -> str:
-        """
-        Collection strategy for outbound rules. Value:
-        - accept: collects network traffic.
-        - drop: No network traffic is collected.
-        """
         return pulumi.get(self, "action")
 
     @property
     @pulumi.getter
     def protocol(self) -> str:
-        """
-        The type of protocol used by the outbound network traffic to be mirrored. Value:
-        - ALL: ALL agreements.
-        - ICMP: Network Control Message Protocol.
-        - TCP: Transmission Control Protocol.
-        - UDP: User Datagram Protocol.
-        """
         return pulumi.get(self, "protocol")
 
     @property
     @pulumi.getter(name="destinationCidrBlock")
     def destination_cidr_block(self) -> Optional[str]:
-        """
-        DestinationCidrBlock.
-        """
         return pulumi.get(self, "destination_cidr_block")
 
     @property
     @pulumi.getter(name="destinationPortRange")
     def destination_port_range(self) -> Optional[str]:
-        """
-        The destination port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-        > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         return pulumi.get(self, "destination_port_range")
 
     @property
     @pulumi.getter
     def priority(self) -> Optional[int]:
-        """
-        Priority.
-        """
         return pulumi.get(self, "priority")
 
     @property
     @pulumi.getter(name="sourceCidrBlock")
     def source_cidr_block(self) -> Optional[str]:
-        """
-        The source address of the outbound rule network traffic.
-        """
         return pulumi.get(self, "source_cidr_block")
 
     @property
     @pulumi.getter(name="sourcePortRange")
     def source_port_range(self) -> Optional[str]:
-        """
-        The source port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-        > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         return pulumi.get(self, "source_port_range")
 
     @property
@@ -1064,23 +1093,6 @@ class TrafficMirrorFilterIngressRule(dict):
                  source_cidr_block: Optional[str] = None,
                  source_port_range: Optional[str] = None,
                  traffic_mirror_filter_rule_status: Optional[str] = None):
-        """
-        :param str action: Collection strategy for outbound rules. Value:
-               - accept: collects network traffic.
-               - drop: No network traffic is collected.
-        :param str protocol: The type of protocol used by the outbound network traffic to be mirrored. Value:
-               - ALL: ALL agreements.
-               - ICMP: Network Control Message Protocol.
-               - TCP: Transmission Control Protocol.
-               - UDP: User Datagram Protocol.
-        :param str destination_cidr_block: DestinationCidrBlock.
-        :param str destination_port_range: The destination port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-               > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        :param int priority: Priority.
-        :param str source_cidr_block: The source address of the outbound rule network traffic.
-        :param str source_port_range: The source port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-               > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         pulumi.set(__self__, "action", action)
         pulumi.set(__self__, "protocol", protocol)
         if destination_cidr_block is not None:
@@ -1099,65 +1111,36 @@ class TrafficMirrorFilterIngressRule(dict):
     @property
     @pulumi.getter
     def action(self) -> str:
-        """
-        Collection strategy for outbound rules. Value:
-        - accept: collects network traffic.
-        - drop: No network traffic is collected.
-        """
         return pulumi.get(self, "action")
 
     @property
     @pulumi.getter
     def protocol(self) -> str:
-        """
-        The type of protocol used by the outbound network traffic to be mirrored. Value:
-        - ALL: ALL agreements.
-        - ICMP: Network Control Message Protocol.
-        - TCP: Transmission Control Protocol.
-        - UDP: User Datagram Protocol.
-        """
         return pulumi.get(self, "protocol")
 
     @property
     @pulumi.getter(name="destinationCidrBlock")
     def destination_cidr_block(self) -> Optional[str]:
-        """
-        DestinationCidrBlock.
-        """
         return pulumi.get(self, "destination_cidr_block")
 
     @property
     @pulumi.getter(name="destinationPortRange")
     def destination_port_range(self) -> Optional[str]:
-        """
-        The destination port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-        > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         return pulumi.get(self, "destination_port_range")
 
     @property
     @pulumi.getter
     def priority(self) -> Optional[int]:
-        """
-        Priority.
-        """
         return pulumi.get(self, "priority")
 
     @property
     @pulumi.getter(name="sourceCidrBlock")
     def source_cidr_block(self) -> Optional[str]:
-        """
-        The source address of the outbound rule network traffic.
-        """
         return pulumi.get(self, "source_cidr_block")
 
     @property
     @pulumi.getter(name="sourcePortRange")
     def source_port_range(self) -> Optional[str]:
-        """
-        The source port range of the outbound rule network traffic. The port range is 1 to 65535. Use a forward slash (/) to separate the start port and the end Port. The format is 1/200 and 80/80. Among them, - 1/-1 cannot be set separately, which means that the port is not limited.
-        > **NOTE:**  When egresrules. N.Protocol is set to ALL or ICMP, this parameter does not need to be configured, indicating that the port is not restricted.
-        """
         return pulumi.get(self, "source_port_range")
 
     @property
@@ -1982,254 +1965,993 @@ class GetEnhancedNatAvailableZonesZoneResult(dict):
         return pulumi.get(self, "local_name")
 
     @property
-    @pulumi.getter(name="zoneId")
-    def zone_id(self) -> str:
-        return pulumi.get(self, "zone_id")
+    @pulumi.getter(name="zoneId")
+    def zone_id(self) -> str:
+        return pulumi.get(self, "zone_id")
+
+
+@pulumi.output_type
+class GetForwardEntriesEntryResult(dict):
+    def __init__(__self__, *,
+                 external_ip: str,
+                 external_port: str,
+                 forward_entry_id: str,
+                 forward_entry_name: str,
+                 id: str,
+                 internal_ip: str,
+                 internal_port: str,
+                 ip_protocol: str,
+                 name: str,
+                 status: str):
+        """
+        :param str external_ip: The public IP address.
+        :param str external_port: The public port.
+        :param str forward_entry_id: The forward entry ID.
+        :param str forward_entry_name: The name of forward entry.
+        :param str id: The ID of the Forward Entry.
+        :param str internal_ip: The private IP address.
+        :param str internal_port: The internal port.
+        :param str ip_protocol: The ip protocol. Valid values: `any`,`tcp` and `udp`.
+        :param str name: The forward entry name.
+        :param str status: The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
+        """
+        pulumi.set(__self__, "external_ip", external_ip)
+        pulumi.set(__self__, "external_port", external_port)
+        pulumi.set(__self__, "forward_entry_id", forward_entry_id)
+        pulumi.set(__self__, "forward_entry_name", forward_entry_name)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "internal_ip", internal_ip)
+        pulumi.set(__self__, "internal_port", internal_port)
+        pulumi.set(__self__, "ip_protocol", ip_protocol)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="externalIp")
+    def external_ip(self) -> str:
+        """
+        The public IP address.
+        """
+        return pulumi.get(self, "external_ip")
+
+    @property
+    @pulumi.getter(name="externalPort")
+    def external_port(self) -> str:
+        """
+        The public port.
+        """
+        return pulumi.get(self, "external_port")
+
+    @property
+    @pulumi.getter(name="forwardEntryId")
+    def forward_entry_id(self) -> str:
+        """
+        The forward entry ID.
+        """
+        return pulumi.get(self, "forward_entry_id")
+
+    @property
+    @pulumi.getter(name="forwardEntryName")
+    def forward_entry_name(self) -> str:
+        """
+        The name of forward entry.
+        """
+        return pulumi.get(self, "forward_entry_name")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the Forward Entry.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="internalIp")
+    def internal_ip(self) -> str:
+        """
+        The private IP address.
+        """
+        return pulumi.get(self, "internal_ip")
+
+    @property
+    @pulumi.getter(name="internalPort")
+    def internal_port(self) -> str:
+        """
+        The internal port.
+        """
+        return pulumi.get(self, "internal_port")
+
+    @property
+    @pulumi.getter(name="ipProtocol")
+    def ip_protocol(self) -> str:
+        """
+        The ip protocol. Valid values: `any`,`tcp` and `udp`.
+        """
+        return pulumi.get(self, "ip_protocol")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The forward entry name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class GetHavipsHavipResult(dict):
+    def __init__(__self__, *,
+                 associated_eip_addresses: Sequence[str],
+                 associated_instances: Sequence[str],
+                 description: str,
+                 havip_id: str,
+                 havip_name: str,
+                 id: str,
+                 ip_address: str,
+                 master_instance_id: str,
+                 status: str,
+                 vpc_id: str,
+                 vswitch_id: str):
+        """
+        :param Sequence[str] associated_eip_addresses: EIP bound to HaVip.
+        :param Sequence[str] associated_instances: An ECS instance that is bound to HaVip.
+        :param str description: Dependence of a HaVip instance.
+        :param str havip_id: The  ID of the resource.
+        :param str havip_name: The name of the HaVip instance.
+        :param str id: The ID of the Ha Vip.
+        :param str ip_address: IP address of private network.
+        :param str master_instance_id: The primary instance ID bound to HaVip.
+        :param str status: The status.
+        :param str vpc_id: The VPC ID to which the HaVip instance belongs.
+        :param str vswitch_id: The vswitch id.
+        """
+        pulumi.set(__self__, "associated_eip_addresses", associated_eip_addresses)
+        pulumi.set(__self__, "associated_instances", associated_instances)
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "havip_id", havip_id)
+        pulumi.set(__self__, "havip_name", havip_name)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "ip_address", ip_address)
+        pulumi.set(__self__, "master_instance_id", master_instance_id)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "vpc_id", vpc_id)
+        pulumi.set(__self__, "vswitch_id", vswitch_id)
+
+    @property
+    @pulumi.getter(name="associatedEipAddresses")
+    def associated_eip_addresses(self) -> Sequence[str]:
+        """
+        EIP bound to HaVip.
+        """
+        return pulumi.get(self, "associated_eip_addresses")
+
+    @property
+    @pulumi.getter(name="associatedInstances")
+    def associated_instances(self) -> Sequence[str]:
+        """
+        An ECS instance that is bound to HaVip.
+        """
+        return pulumi.get(self, "associated_instances")
+
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        Dependence of a HaVip instance.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="havipId")
+    def havip_id(self) -> str:
+        """
+        The  ID of the resource.
+        """
+        return pulumi.get(self, "havip_id")
+
+    @property
+    @pulumi.getter(name="havipName")
+    def havip_name(self) -> str:
+        """
+        The name of the HaVip instance.
+        """
+        return pulumi.get(self, "havip_name")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the Ha Vip.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> str:
+        """
+        IP address of private network.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter(name="masterInstanceId")
+    def master_instance_id(self) -> str:
+        """
+        The primary instance ID bound to HaVip.
+        """
+        return pulumi.get(self, "master_instance_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> str:
+        """
+        The VPC ID to which the HaVip instance belongs.
+        """
+        return pulumi.get(self, "vpc_id")
+
+    @property
+    @pulumi.getter(name="vswitchId")
+    def vswitch_id(self) -> str:
+        """
+        The vswitch id.
+        """
+        return pulumi.get(self, "vswitch_id")
+
+
+@pulumi.output_type
+class GetIpamIpamPoolAllocationsAllocationResult(dict):
+    def __init__(__self__, *,
+                 cidr: str,
+                 create_time: str,
+                 id: str,
+                 ipam_pool_allocation_description: str,
+                 ipam_pool_allocation_id: str,
+                 ipam_pool_allocation_name: str,
+                 ipam_pool_id: str,
+                 region_id: str,
+                 resource_id: str,
+                 resource_owner_id: int,
+                 resource_region_id: str,
+                 resource_type: str,
+                 source_cidr: str,
+                 status: str,
+                 total_count: int):
+        """
+        :param str cidr: The allocated address segment.
+        :param str create_time: Instance creation time.
+        :param str id: The ID of the resource supplied above.
+        :param str ipam_pool_allocation_description: The description of the ipam pool alloctaion.It must be 1 to 256 characters in length and must start with an English letter or Chinese character, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
+        :param str ipam_pool_allocation_id: The instance ID of the ipam pool allocation.
+        :param str ipam_pool_allocation_name: The name of the ipam pool allocation.It must be 1 to 128 characters in length and cannot start with 'http:// 'or 'https.
+        :param str ipam_pool_id: The ID of the IPAM Pool.
+        :param str region_id: When the IPAM Pool to which CIDR is allocated has the region attribute, this attribute is the IPAM Pool region.When the IPAM Pool to which CIDR is allocated does not have the region attribute, this attribute is the IPAM region.
+        :param str resource_id: The ID of the resource.
+        :param int resource_owner_id: The ID of the Alibaba Cloud account (primary account) to which the resource belongs.
+        :param str resource_region_id: The region of the resource.
+        :param str resource_type: The type of resource. Value:-**VPC**: indicates that the resource type is VPC.-**IpamPool**: indicates that the resource type is a child address pool.-**Custom**: indicates that the resource type is a Custom reserved CIDR block.
+        :param str source_cidr: The source address segment.
+        :param str status: The status of the instance. Value:-**Created**: indicates that the creation is complete.
+        :param int total_count: Total number of records.
+        """
+        pulumi.set(__self__, "cidr", cidr)
+        pulumi.set(__self__, "create_time", create_time)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "ipam_pool_allocation_description", ipam_pool_allocation_description)
+        pulumi.set(__self__, "ipam_pool_allocation_id", ipam_pool_allocation_id)
+        pulumi.set(__self__, "ipam_pool_allocation_name", ipam_pool_allocation_name)
+        pulumi.set(__self__, "ipam_pool_id", ipam_pool_id)
+        pulumi.set(__self__, "region_id", region_id)
+        pulumi.set(__self__, "resource_id", resource_id)
+        pulumi.set(__self__, "resource_owner_id", resource_owner_id)
+        pulumi.set(__self__, "resource_region_id", resource_region_id)
+        pulumi.set(__self__, "resource_type", resource_type)
+        pulumi.set(__self__, "source_cidr", source_cidr)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "total_count", total_count)
+
+    @property
+    @pulumi.getter
+    def cidr(self) -> str:
+        """
+        The allocated address segment.
+        """
+        return pulumi.get(self, "cidr")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        Instance creation time.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the resource supplied above.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="ipamPoolAllocationDescription")
+    def ipam_pool_allocation_description(self) -> str:
+        """
+        The description of the ipam pool alloctaion.It must be 1 to 256 characters in length and must start with an English letter or Chinese character, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
+        """
+        return pulumi.get(self, "ipam_pool_allocation_description")
+
+    @property
+    @pulumi.getter(name="ipamPoolAllocationId")
+    def ipam_pool_allocation_id(self) -> str:
+        """
+        The instance ID of the ipam pool allocation.
+        """
+        return pulumi.get(self, "ipam_pool_allocation_id")
+
+    @property
+    @pulumi.getter(name="ipamPoolAllocationName")
+    def ipam_pool_allocation_name(self) -> str:
+        """
+        The name of the ipam pool allocation.It must be 1 to 128 characters in length and cannot start with 'http:// 'or 'https.
+        """
+        return pulumi.get(self, "ipam_pool_allocation_name")
+
+    @property
+    @pulumi.getter(name="ipamPoolId")
+    def ipam_pool_id(self) -> str:
+        """
+        The ID of the IPAM Pool.
+        """
+        return pulumi.get(self, "ipam_pool_id")
+
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> str:
+        """
+        When the IPAM Pool to which CIDR is allocated has the region attribute, this attribute is the IPAM Pool region.When the IPAM Pool to which CIDR is allocated does not have the region attribute, this attribute is the IPAM region.
+        """
+        return pulumi.get(self, "region_id")
+
+    @property
+    @pulumi.getter(name="resourceId")
+    def resource_id(self) -> str:
+        """
+        The ID of the resource.
+        """
+        return pulumi.get(self, "resource_id")
+
+    @property
+    @pulumi.getter(name="resourceOwnerId")
+    def resource_owner_id(self) -> int:
+        """
+        The ID of the Alibaba Cloud account (primary account) to which the resource belongs.
+        """
+        return pulumi.get(self, "resource_owner_id")
+
+    @property
+    @pulumi.getter(name="resourceRegionId")
+    def resource_region_id(self) -> str:
+        """
+        The region of the resource.
+        """
+        return pulumi.get(self, "resource_region_id")
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> str:
+        """
+        The type of resource. Value:-**VPC**: indicates that the resource type is VPC.-**IpamPool**: indicates that the resource type is a child address pool.-**Custom**: indicates that the resource type is a Custom reserved CIDR block.
+        """
+        return pulumi.get(self, "resource_type")
+
+    @property
+    @pulumi.getter(name="sourceCidr")
+    def source_cidr(self) -> str:
+        """
+        The source address segment.
+        """
+        return pulumi.get(self, "source_cidr")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the instance. Value:-**Created**: indicates that the creation is complete.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="totalCount")
+    def total_count(self) -> int:
+        """
+        Total number of records.
+        """
+        return pulumi.get(self, "total_count")
+
+
+@pulumi.output_type
+class GetIpamIpamPoolCidrsCidrResult(dict):
+    def __init__(__self__, *,
+                 cidr: str,
+                 id: str,
+                 ipam_pool_id: str,
+                 status: str):
+        """
+        :param str cidr: The CIDR address segment to be preset.> currently, only IPv4 address segments are supported.
+        :param str id: The ID of the resource supplied above.
+        :param str ipam_pool_id: The ID of the IPAM pool instance.
+        :param str status: The status of the resource
+        """
+        pulumi.set(__self__, "cidr", cidr)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "ipam_pool_id", ipam_pool_id)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def cidr(self) -> str:
+        """
+        The CIDR address segment to be preset.> currently, only IPv4 address segments are supported.
+        """
+        return pulumi.get(self, "cidr")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the resource supplied above.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="ipamPoolId")
+    def ipam_pool_id(self) -> str:
+        """
+        The ID of the IPAM pool instance.
+        """
+        return pulumi.get(self, "ipam_pool_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the resource
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class GetIpamIpamPoolsPoolResult(dict):
+    def __init__(__self__, *,
+                 allocation_default_cidr_mask: int,
+                 allocation_max_cidr_mask: int,
+                 allocation_min_cidr_mask: int,
+                 auto_import: bool,
+                 create_time: str,
+                 has_sub_pool: bool,
+                 id: str,
+                 ip_version: str,
+                 ipam_id: str,
+                 ipam_pool_description: str,
+                 ipam_pool_id: str,
+                 ipam_pool_name: str,
+                 ipam_scope_id: str,
+                 pool_depth: int,
+                 pool_region_id: str,
+                 region_id: str,
+                 resource_group_id: str,
+                 source_ipam_pool_id: str,
+                 status: str,
+                 tags: Mapping[str, str]):
+        """
+        :param int allocation_default_cidr_mask: The default network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        :param int allocation_max_cidr_mask: The maximum network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        :param int allocation_min_cidr_mask: The minimum Network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        :param bool auto_import: Whether the automatic import function is enabled for the address pool.
+        :param str create_time: The creation time of the resource.
+        :param bool has_sub_pool: Whether it is a child address pool. Value:-**true**: Yes.-**false**: No.
+        :param str id: The ID of the resource supplied above.
+        :param str ip_version: The IP protocol version. Currently, only **IPv4** is supported * *.
+        :param str ipam_id: Ipam id.
+        :param str ipam_pool_description: The description of the IPAM address pool.It must be 2 to 256 characters in length and must start with an English letter or a Chinese character, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
+        :param str ipam_pool_id: The first ID of the resource.
+        :param str ipam_pool_name: The name of the resource.
+        :param str ipam_scope_id: Ipam scope id.
+        :param int pool_depth: The depth of the IPAM address pool. Value range: **0 to 10 * *.
+        :param str pool_region_id: The effective region of the IPAM address pool.
+        :param str region_id: The region ID of the resource.
+        :param str resource_group_id: The ID of the resource group.
+        :param str source_ipam_pool_id: The instance ID of the source IPAM address pool.> If this parameter is not entered, the created address pool is the parent address pool.
+        :param str status: The status of the resource.
+        :param Mapping[str, str] tags: The tag of the resource.
+        """
+        pulumi.set(__self__, "allocation_default_cidr_mask", allocation_default_cidr_mask)
+        pulumi.set(__self__, "allocation_max_cidr_mask", allocation_max_cidr_mask)
+        pulumi.set(__self__, "allocation_min_cidr_mask", allocation_min_cidr_mask)
+        pulumi.set(__self__, "auto_import", auto_import)
+        pulumi.set(__self__, "create_time", create_time)
+        pulumi.set(__self__, "has_sub_pool", has_sub_pool)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "ip_version", ip_version)
+        pulumi.set(__self__, "ipam_id", ipam_id)
+        pulumi.set(__self__, "ipam_pool_description", ipam_pool_description)
+        pulumi.set(__self__, "ipam_pool_id", ipam_pool_id)
+        pulumi.set(__self__, "ipam_pool_name", ipam_pool_name)
+        pulumi.set(__self__, "ipam_scope_id", ipam_scope_id)
+        pulumi.set(__self__, "pool_depth", pool_depth)
+        pulumi.set(__self__, "pool_region_id", pool_region_id)
+        pulumi.set(__self__, "region_id", region_id)
+        pulumi.set(__self__, "resource_group_id", resource_group_id)
+        pulumi.set(__self__, "source_ipam_pool_id", source_ipam_pool_id)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "tags", tags)
+
+    @property
+    @pulumi.getter(name="allocationDefaultCidrMask")
+    def allocation_default_cidr_mask(self) -> int:
+        """
+        The default network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        """
+        return pulumi.get(self, "allocation_default_cidr_mask")
+
+    @property
+    @pulumi.getter(name="allocationMaxCidrMask")
+    def allocation_max_cidr_mask(self) -> int:
+        """
+        The maximum network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        """
+        return pulumi.get(self, "allocation_max_cidr_mask")
+
+    @property
+    @pulumi.getter(name="allocationMinCidrMask")
+    def allocation_min_cidr_mask(self) -> int:
+        """
+        The minimum Network mask assigned by the IPAM address pool.IPv4 network mask value range: **0 to 32** bits.
+        """
+        return pulumi.get(self, "allocation_min_cidr_mask")
+
+    @property
+    @pulumi.getter(name="autoImport")
+    def auto_import(self) -> bool:
+        """
+        Whether the automatic import function is enabled for the address pool.
+        """
+        return pulumi.get(self, "auto_import")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        The creation time of the resource.
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter(name="hasSubPool")
+    def has_sub_pool(self) -> bool:
+        """
+        Whether it is a child address pool. Value:-**true**: Yes.-**false**: No.
+        """
+        return pulumi.get(self, "has_sub_pool")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The ID of the resource supplied above.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="ipVersion")
+    def ip_version(self) -> str:
+        """
+        The IP protocol version. Currently, only **IPv4** is supported * *.
+        """
+        return pulumi.get(self, "ip_version")
+
+    @property
+    @pulumi.getter(name="ipamId")
+    def ipam_id(self) -> str:
+        """
+        Ipam id.
+        """
+        return pulumi.get(self, "ipam_id")
+
+    @property
+    @pulumi.getter(name="ipamPoolDescription")
+    def ipam_pool_description(self) -> str:
+        """
+        The description of the IPAM address pool.It must be 2 to 256 characters in length and must start with an English letter or a Chinese character, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
+        """
+        return pulumi.get(self, "ipam_pool_description")
+
+    @property
+    @pulumi.getter(name="ipamPoolId")
+    def ipam_pool_id(self) -> str:
+        """
+        The first ID of the resource.
+        """
+        return pulumi.get(self, "ipam_pool_id")
+
+    @property
+    @pulumi.getter(name="ipamPoolName")
+    def ipam_pool_name(self) -> str:
+        """
+        The name of the resource.
+        """
+        return pulumi.get(self, "ipam_pool_name")
+
+    @property
+    @pulumi.getter(name="ipamScopeId")
+    def ipam_scope_id(self) -> str:
+        """
+        Ipam scope id.
+        """
+        return pulumi.get(self, "ipam_scope_id")
+
+    @property
+    @pulumi.getter(name="poolDepth")
+    def pool_depth(self) -> int:
+        """
+        The depth of the IPAM address pool. Value range: **0 to 10 * *.
+        """
+        return pulumi.get(self, "pool_depth")
+
+    @property
+    @pulumi.getter(name="poolRegionId")
+    def pool_region_id(self) -> str:
+        """
+        The effective region of the IPAM address pool.
+        """
+        return pulumi.get(self, "pool_region_id")
+
+    @property
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> str:
+        """
+        The region ID of the resource.
+        """
+        return pulumi.get(self, "region_id")
+
+    @property
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> str:
+        """
+        The ID of the resource group.
+        """
+        return pulumi.get(self, "resource_group_id")
+
+    @property
+    @pulumi.getter(name="sourceIpamPoolId")
+    def source_ipam_pool_id(self) -> str:
+        """
+        The instance ID of the source IPAM address pool.> If this parameter is not entered, the created address pool is the parent address pool.
+        """
+        return pulumi.get(self, "source_ipam_pool_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the resource.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Mapping[str, str]:
+        """
+        The tag of the resource.
+        """
+        return pulumi.get(self, "tags")
 
 
 @pulumi.output_type
-class GetForwardEntriesEntryResult(dict):
+class GetIpamIpamScopesScopeResult(dict):
     def __init__(__self__, *,
-                 external_ip: str,
-                 external_port: str,
-                 forward_entry_id: str,
-                 forward_entry_name: str,
+                 create_time: str,
                  id: str,
-                 internal_ip: str,
-                 internal_port: str,
-                 ip_protocol: str,
-                 name: str,
-                 status: str):
+                 ipam_id: str,
+                 ipam_scope_description: str,
+                 ipam_scope_id: str,
+                 ipam_scope_name: str,
+                 ipam_scope_type: str,
+                 region_id: str,
+                 resource_group_id: str,
+                 status: str,
+                 tags: Mapping[str, str]):
         """
-        :param str external_ip: The public IP address.
-        :param str external_port: The public port.
-        :param str forward_entry_id: The forward entry ID.
-        :param str forward_entry_name: The name of forward entry.
-        :param str id: The ID of the Forward Entry.
-        :param str internal_ip: The private IP address.
-        :param str internal_port: The internal port.
-        :param str ip_protocol: The ip protocol. Valid values: `any`,`tcp` and `udp`.
-        :param str name: The forward entry name.
-        :param str status: The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
+        :param str create_time: The creation time of the resource.
+        :param str id: The ID of the resource supplied above.
+        :param str ipam_id: The id of the Ipam instance.
+        :param str ipam_scope_description: The description of the IPAM's scope of action.It must be 2 to 256 characters in length and must start with a lowercase letter, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
+        :param str ipam_scope_id: The first ID of the resource.
+        :param str ipam_scope_name: The name of the resource.
+        :param str ipam_scope_type: IPAM scope of action type:**private**.> Currently, only the role scope of the private network is supported.
+        :param str region_id: The region ID of the resource.
+        :param str resource_group_id: The ID of the resource group.
+        :param str status: The status of the resource.
+        :param Mapping[str, str] tags: The tag of the resource.
         """
-        pulumi.set(__self__, "external_ip", external_ip)
-        pulumi.set(__self__, "external_port", external_port)
-        pulumi.set(__self__, "forward_entry_id", forward_entry_id)
-        pulumi.set(__self__, "forward_entry_name", forward_entry_name)
+        pulumi.set(__self__, "create_time", create_time)
         pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "internal_ip", internal_ip)
-        pulumi.set(__self__, "internal_port", internal_port)
-        pulumi.set(__self__, "ip_protocol", ip_protocol)
-        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "ipam_id", ipam_id)
+        pulumi.set(__self__, "ipam_scope_description", ipam_scope_description)
+        pulumi.set(__self__, "ipam_scope_id", ipam_scope_id)
+        pulumi.set(__self__, "ipam_scope_name", ipam_scope_name)
+        pulumi.set(__self__, "ipam_scope_type", ipam_scope_type)
+        pulumi.set(__self__, "region_id", region_id)
+        pulumi.set(__self__, "resource_group_id", resource_group_id)
         pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "tags", tags)
 
     @property
-    @pulumi.getter(name="externalIp")
-    def external_ip(self) -> str:
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
         """
-        The public IP address.
+        The creation time of the resource.
         """
-        return pulumi.get(self, "external_ip")
+        return pulumi.get(self, "create_time")
 
     @property
-    @pulumi.getter(name="externalPort")
-    def external_port(self) -> str:
+    @pulumi.getter
+    def id(self) -> str:
         """
-        The public port.
+        The ID of the resource supplied above.
         """
-        return pulumi.get(self, "external_port")
+        return pulumi.get(self, "id")
 
     @property
-    @pulumi.getter(name="forwardEntryId")
-    def forward_entry_id(self) -> str:
+    @pulumi.getter(name="ipamId")
+    def ipam_id(self) -> str:
         """
-        The forward entry ID.
+        The id of the Ipam instance.
         """
-        return pulumi.get(self, "forward_entry_id")
+        return pulumi.get(self, "ipam_id")
 
     @property
-    @pulumi.getter(name="forwardEntryName")
-    def forward_entry_name(self) -> str:
+    @pulumi.getter(name="ipamScopeDescription")
+    def ipam_scope_description(self) -> str:
         """
-        The name of forward entry.
+        The description of the IPAM's scope of action.It must be 2 to 256 characters in length and must start with a lowercase letter, but cannot start with 'http:// 'or 'https. If it is not filled in, it is empty. The default value is empty.
         """
-        return pulumi.get(self, "forward_entry_name")
+        return pulumi.get(self, "ipam_scope_description")
 
     @property
-    @pulumi.getter
-    def id(self) -> str:
+    @pulumi.getter(name="ipamScopeId")
+    def ipam_scope_id(self) -> str:
         """
-        The ID of the Forward Entry.
+        The first ID of the resource.
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "ipam_scope_id")
 
     @property
-    @pulumi.getter(name="internalIp")
-    def internal_ip(self) -> str:
+    @pulumi.getter(name="ipamScopeName")
+    def ipam_scope_name(self) -> str:
         """
-        The private IP address.
+        The name of the resource.
         """
-        return pulumi.get(self, "internal_ip")
+        return pulumi.get(self, "ipam_scope_name")
 
     @property
-    @pulumi.getter(name="internalPort")
-    def internal_port(self) -> str:
+    @pulumi.getter(name="ipamScopeType")
+    def ipam_scope_type(self) -> str:
         """
-        The internal port.
+        IPAM scope of action type:**private**.> Currently, only the role scope of the private network is supported.
         """
-        return pulumi.get(self, "internal_port")
+        return pulumi.get(self, "ipam_scope_type")
 
     @property
-    @pulumi.getter(name="ipProtocol")
-    def ip_protocol(self) -> str:
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> str:
         """
-        The ip protocol. Valid values: `any`,`tcp` and `udp`.
+        The region ID of the resource.
         """
-        return pulumi.get(self, "ip_protocol")
+        return pulumi.get(self, "region_id")
 
     @property
-    @pulumi.getter
-    def name(self) -> str:
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> str:
         """
-        The forward entry name.
+        The ID of the resource group.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "resource_group_id")
 
     @property
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
+        The status of the resource.
         """
         return pulumi.get(self, "status")
 
+    @property
+    @pulumi.getter
+    def tags(self) -> Mapping[str, str]:
+        """
+        The tag of the resource.
+        """
+        return pulumi.get(self, "tags")
+
 
 @pulumi.output_type
-class GetHavipsHavipResult(dict):
+class GetIpamIpamsIpamResult(dict):
     def __init__(__self__, *,
-                 associated_eip_addresses: Sequence[str],
-                 associated_instances: Sequence[str],
-                 description: str,
-                 havip_id: str,
-                 havip_name: str,
+                 create_time: str,
+                 default_resource_discovery_association_id: str,
+                 default_resource_discovery_id: str,
                  id: str,
-                 ip_address: str,
-                 master_instance_id: str,
+                 ipam_description: str,
+                 ipam_id: str,
+                 ipam_name: str,
+                 private_default_scope_id: str,
+                 public_default_scope_id: str,
+                 region_id: str,
+                 resource_discovery_association_count: int,
+                 resource_group_id: str,
                  status: str,
-                 vpc_id: str,
-                 vswitch_id: str):
+                 tags: Mapping[str, str]):
         """
-        :param Sequence[str] associated_eip_addresses: EIP bound to HaVip.
-        :param Sequence[str] associated_instances: An ECS instance that is bound to HaVip.
-        :param str description: Dependence of a HaVip instance.
-        :param str havip_id: The  ID of the resource.
-        :param str havip_name: The name of the HaVip instance.
-        :param str id: The ID of the Ha Vip.
-        :param str ip_address: IP address of private network.
-        :param str master_instance_id: The primary instance ID bound to HaVip.
-        :param str status: The status.
-        :param str vpc_id: The VPC ID to which the HaVip instance belongs.
-        :param str vswitch_id: The vswitch id.
+        :param str create_time: The creation time of the resource.
+        :param str default_resource_discovery_association_id: After an IPAM is created, the association between the resource discovery created by the system by default and the IPAM.
+        :param str default_resource_discovery_id: After IPAM is created, the system creates resource discovery by default.
+        :param str id: The ID of the resource supplied above.
+        :param str ipam_description: The description of IPAM.It must be 2 to 256 characters in length and must start with an uppercase letter or a Chinese character, but cannot start with 'http: // 'or 'https. If the description is not filled in, it is blank. The default value is blank.
+        :param str ipam_id: The first ID of the resource.
+        :param str ipam_name: The name of the resource.
+        :param str private_default_scope_id: After an IPAM is created, the scope of the private network IPAM created by the system by default.
+        :param str public_default_scope_id: After an IPAM is created, the public network IPAM is created by default.
+        :param str region_id: The region ID of the resource.
+        :param int resource_discovery_association_count: The number of resource discovery objects associated with IPAM.
+        :param str resource_group_id: The ID of the resource group.
+        :param str status: The status of the resource.
+        :param Mapping[str, str] tags: The tag of the resource.
         """
-        pulumi.set(__self__, "associated_eip_addresses", associated_eip_addresses)
-        pulumi.set(__self__, "associated_instances", associated_instances)
-        pulumi.set(__self__, "description", description)
-        pulumi.set(__self__, "havip_id", havip_id)
-        pulumi.set(__self__, "havip_name", havip_name)
+        pulumi.set(__self__, "create_time", create_time)
+        pulumi.set(__self__, "default_resource_discovery_association_id", default_resource_discovery_association_id)
+        pulumi.set(__self__, "default_resource_discovery_id", default_resource_discovery_id)
         pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "ip_address", ip_address)
-        pulumi.set(__self__, "master_instance_id", master_instance_id)
+        pulumi.set(__self__, "ipam_description", ipam_description)
+        pulumi.set(__self__, "ipam_id", ipam_id)
+        pulumi.set(__self__, "ipam_name", ipam_name)
+        pulumi.set(__self__, "private_default_scope_id", private_default_scope_id)
+        pulumi.set(__self__, "public_default_scope_id", public_default_scope_id)
+        pulumi.set(__self__, "region_id", region_id)
+        pulumi.set(__self__, "resource_discovery_association_count", resource_discovery_association_count)
+        pulumi.set(__self__, "resource_group_id", resource_group_id)
         pulumi.set(__self__, "status", status)
-        pulumi.set(__self__, "vpc_id", vpc_id)
-        pulumi.set(__self__, "vswitch_id", vswitch_id)
+        pulumi.set(__self__, "tags", tags)
 
     @property
-    @pulumi.getter(name="associatedEipAddresses")
-    def associated_eip_addresses(self) -> Sequence[str]:
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
         """
-        EIP bound to HaVip.
+        The creation time of the resource.
         """
-        return pulumi.get(self, "associated_eip_addresses")
+        return pulumi.get(self, "create_time")
 
     @property
-    @pulumi.getter(name="associatedInstances")
-    def associated_instances(self) -> Sequence[str]:
+    @pulumi.getter(name="defaultResourceDiscoveryAssociationId")
+    def default_resource_discovery_association_id(self) -> str:
         """
-        An ECS instance that is bound to HaVip.
+        After an IPAM is created, the association between the resource discovery created by the system by default and the IPAM.
         """
-        return pulumi.get(self, "associated_instances")
+        return pulumi.get(self, "default_resource_discovery_association_id")
+
+    @property
+    @pulumi.getter(name="defaultResourceDiscoveryId")
+    def default_resource_discovery_id(self) -> str:
+        """
+        After IPAM is created, the system creates resource discovery by default.
+        """
+        return pulumi.get(self, "default_resource_discovery_id")
 
     @property
     @pulumi.getter
-    def description(self) -> str:
+    def id(self) -> str:
         """
-        Dependence of a HaVip instance.
+        The ID of the resource supplied above.
         """
-        return pulumi.get(self, "description")
+        return pulumi.get(self, "id")
 
     @property
-    @pulumi.getter(name="havipId")
-    def havip_id(self) -> str:
+    @pulumi.getter(name="ipamDescription")
+    def ipam_description(self) -> str:
         """
-        The  ID of the resource.
+        The description of IPAM.It must be 2 to 256 characters in length and must start with an uppercase letter or a Chinese character, but cannot start with 'http: // 'or 'https. If the description is not filled in, it is blank. The default value is blank.
         """
-        return pulumi.get(self, "havip_id")
+        return pulumi.get(self, "ipam_description")
 
     @property
-    @pulumi.getter(name="havipName")
-    def havip_name(self) -> str:
+    @pulumi.getter(name="ipamId")
+    def ipam_id(self) -> str:
         """
-        The name of the HaVip instance.
+        The first ID of the resource.
         """
-        return pulumi.get(self, "havip_name")
+        return pulumi.get(self, "ipam_id")
 
     @property
-    @pulumi.getter
-    def id(self) -> str:
+    @pulumi.getter(name="ipamName")
+    def ipam_name(self) -> str:
         """
-        The ID of the Ha Vip.
+        The name of the resource.
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "ipam_name")
 
     @property
-    @pulumi.getter(name="ipAddress")
-    def ip_address(self) -> str:
+    @pulumi.getter(name="privateDefaultScopeId")
+    def private_default_scope_id(self) -> str:
         """
-        IP address of private network.
+        After an IPAM is created, the scope of the private network IPAM created by the system by default.
         """
-        return pulumi.get(self, "ip_address")
+        return pulumi.get(self, "private_default_scope_id")
 
     @property
-    @pulumi.getter(name="masterInstanceId")
-    def master_instance_id(self) -> str:
+    @pulumi.getter(name="publicDefaultScopeId")
+    def public_default_scope_id(self) -> str:
         """
-        The primary instance ID bound to HaVip.
+        After an IPAM is created, the public network IPAM is created by default.
         """
-        return pulumi.get(self, "master_instance_id")
+        return pulumi.get(self, "public_default_scope_id")
 
     @property
-    @pulumi.getter
-    def status(self) -> str:
+    @pulumi.getter(name="regionId")
+    def region_id(self) -> str:
         """
-        The status.
+        The region ID of the resource.
         """
-        return pulumi.get(self, "status")
+        return pulumi.get(self, "region_id")
 
     @property
-    @pulumi.getter(name="vpcId")
-    def vpc_id(self) -> str:
+    @pulumi.getter(name="resourceDiscoveryAssociationCount")
+    def resource_discovery_association_count(self) -> int:
         """
-        The VPC ID to which the HaVip instance belongs.
+        The number of resource discovery objects associated with IPAM.
         """
-        return pulumi.get(self, "vpc_id")
+        return pulumi.get(self, "resource_discovery_association_count")
 
     @property
-    @pulumi.getter(name="vswitchId")
-    def vswitch_id(self) -> str:
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> str:
         """
-        The vswitch id.
+        The ID of the resource group.
         """
-        return pulumi.get(self, "vswitch_id")
+        return pulumi.get(self, "resource_group_id")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the resource.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def tags(self) -> Mapping[str, str]:
+        """
+        The tag of the resource.
+        """
+        return pulumi.get(self, "tags")
 
 
 @pulumi.output_type
@@ -3158,7 +3880,7 @@ class GetNatGatewaysGatewayResult(dict):
                  spec: str,
                  specification: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  vpc_id: str,
                  vswitch_id: str):
         """
@@ -3182,7 +3904,7 @@ class GetNatGatewaysGatewayResult(dict):
         :param str spec: The specification of the NAT gateway.
         :param str specification: The specification of NAT gateway. Valid values `Middle`, `Large`, `Small` and `XLarge.1`. Default value is `Small`.
         :param str status: The status of NAT gateway. Valid values `Available`, `Converting`, `Creating`, `Deleting` and `Modifying`.
-        :param Mapping[str, Any] tags: The tags of NAT gateway.
+        :param Mapping[str, str] tags: The tags of NAT gateway.
         :param str vpc_id: The ID of the VPC.
         :param str vswitch_id: The ID of the vSwitch to which the NAT gateway belongs.
         """
@@ -3372,7 +4094,7 @@ class GetNatGatewaysGatewayResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         The tags of NAT gateway.
         """
@@ -3620,7 +4342,7 @@ class GetNetworkAclsAclResult(dict):
                  status: str,
                  vpc_id: str):
         """
-        :param str description: Description of the entry direction rule.
+        :param str description: Description of network ACL information.
         :param Sequence['GetNetworkAclsAclEgressAclEntryArgs'] egress_acl_entries: Output direction rule information.
         :param str id: The ID of the Network Acl.
         :param Sequence['GetNetworkAclsAclIngressAclEntryArgs'] ingress_acl_entries: Entry direction rule information.
@@ -3644,7 +4366,7 @@ class GetNetworkAclsAclResult(dict):
     @pulumi.getter
     def description(self) -> str:
         """
-        Description of the entry direction rule.
+        Description of network ACL information.
         """
         return pulumi.get(self, "description")
 
@@ -3723,12 +4445,12 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
                  port: str,
                  protocol: str):
         """
-        :param str description: Description of the entry direction rule.
+        :param str description: Give the description information of the direction rule.
         :param str destination_cidr_ip: The destination address segment.
-        :param str network_acl_entry_name: The name of the entry direction rule entry.
-        :param str policy: The authorization policy.
-        :param str port: Source port range.
-        :param str protocol: Transport layer protocol.
+        :param str network_acl_entry_name: The name of the entry for the direction rule.
+        :param str policy: The  authorization policy.
+        :param str port: Destination port range.
+        :param str protocol: Transport  layer protocol.
         """
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "destination_cidr_ip", destination_cidr_ip)
@@ -3741,7 +4463,7 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
     @pulumi.getter
     def description(self) -> str:
         """
-        Description of the entry direction rule.
+        Give the description information of the direction rule.
         """
         return pulumi.get(self, "description")
 
@@ -3757,7 +4479,7 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
     @pulumi.getter(name="networkAclEntryName")
     def network_acl_entry_name(self) -> str:
         """
-        The name of the entry direction rule entry.
+        The name of the entry for the direction rule.
         """
         return pulumi.get(self, "network_acl_entry_name")
 
@@ -3765,7 +4487,7 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
     @pulumi.getter
     def policy(self) -> str:
         """
-        The authorization policy.
+        The  authorization policy.
         """
         return pulumi.get(self, "policy")
 
@@ -3773,7 +4495,7 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
     @pulumi.getter
     def port(self) -> str:
         """
-        Source port range.
+        Destination port range.
         """
         return pulumi.get(self, "port")
 
@@ -3781,7 +4503,7 @@ class GetNetworkAclsAclEgressAclEntryResult(dict):
     @pulumi.getter
     def protocol(self) -> str:
         """
-        Transport layer protocol.
+        Transport  layer protocol.
         """
         return pulumi.get(self, "protocol")
 
@@ -3868,7 +4590,7 @@ class GetNetworkAclsAclResourceResult(dict):
         """
         :param str resource_id: The ID of the associated resource.
         :param str resource_type: The type of the associated resource.
-        :param str status: The state of the network ACL.
+        :param str status: The state of the associated resource.
         """
         pulumi.set(__self__, "resource_id", resource_id)
         pulumi.set(__self__, "resource_type", resource_type)
@@ -3894,7 +4616,7 @@ class GetNetworkAclsAclResourceResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The state of the network ACL.
+        The state of the associated resource.
         """
         return pulumi.get(self, "status")
 
@@ -3905,6 +4627,9 @@ class GetNetworksVpcResult(dict):
                  cidr_block: str,
                  creation_time: str,
                  description: str,
+                 dhcp_options_set_id: str,
+                 dhcp_options_set_status: str,
+                 dns_hostname_status: str,
                  id: str,
                  ipv6_cidr_block: str,
                  is_default: bool,
@@ -3914,7 +4639,7 @@ class GetNetworksVpcResult(dict):
                  router_id: str,
                  secondary_cidr_blocks: Sequence[str],
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  user_cidrs: Sequence[str],
                  vpc_id: str,
                  vpc_name: str,
@@ -3924,6 +4649,9 @@ class GetNetworksVpcResult(dict):
         :param str cidr_block: Filter results by a specific CIDR block. For example: "172.16.0.0/12".
         :param str creation_time: Time of creation.
         :param str description: Description of the VPC
+        :param str dhcp_options_set_id: The ID of dhcp options set.
+        :param str dhcp_options_set_status: The status of the DHCP options set. Valid values: `Available`, `InUse`, `Deleted`, `Pending`.
+        :param str dns_hostname_status: Indicates whether the Domain Name System (DNS) feature is enabled.
         :param str id: ID of the VPC.
         :param str ipv6_cidr_block: The IPv6 CIDR block of the VPC.
         :param bool is_default: Indicate whether the VPC is the default one in the specified region.
@@ -3933,16 +4661,19 @@ class GetNetworksVpcResult(dict):
         :param str router_id: The ID of the VRouter.
         :param Sequence[str] secondary_cidr_blocks: A list of secondary IPv4 CIDR blocks of the VPC.
         :param str status: Filter results by a specific status. Valid value are `Pending` 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.
         :param Sequence[str] user_cidrs: A list of user CIDRs.
         :param str vpc_id: ID of the VPC.
         :param str vpc_name: The name of the VPC.
         :param str vrouter_id: ID of the VRouter.
-        :param Sequence[str] vswitch_ids: List of VSwitch IDs in the specified VPC
+        :param Sequence[str] vswitch_ids: List of vSwitch IDs in the specified VPC
         """
         pulumi.set(__self__, "cidr_block", cidr_block)
         pulumi.set(__self__, "creation_time", creation_time)
         pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "dhcp_options_set_id", dhcp_options_set_id)
+        pulumi.set(__self__, "dhcp_options_set_status", dhcp_options_set_status)
+        pulumi.set(__self__, "dns_hostname_status", dns_hostname_status)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "ipv6_cidr_block", ipv6_cidr_block)
         pulumi.set(__self__, "is_default", is_default)
@@ -3983,6 +4714,30 @@ class GetNetworksVpcResult(dict):
         """
         return pulumi.get(self, "description")
 
+    @property
+    @pulumi.getter(name="dhcpOptionsSetId")
+    def dhcp_options_set_id(self) -> str:
+        """
+        The ID of dhcp options set.
+        """
+        return pulumi.get(self, "dhcp_options_set_id")
+
+    @property
+    @pulumi.getter(name="dhcpOptionsSetStatus")
+    def dhcp_options_set_status(self) -> str:
+        """
+        The status of the DHCP options set. Valid values: `Available`, `InUse`, `Deleted`, `Pending`.
+        """
+        return pulumi.get(self, "dhcp_options_set_status")
+
+    @property
+    @pulumi.getter(name="dnsHostnameStatus")
+    def dns_hostname_status(self) -> str:
+        """
+        Indicates whether the Domain Name System (DNS) feature is enabled.
+        """
+        return pulumi.get(self, "dns_hostname_status")
+
     @property
     @pulumi.getter
     def id(self) -> str:
@@ -4057,7 +4812,7 @@ class GetNetworksVpcResult(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.
         """
@@ -4099,7 +4854,7 @@ class GetNetworksVpcResult(dict):
     @pulumi.getter(name="vswitchIds")
     def vswitch_ids(self) -> Sequence[str]:
         """
-        List of VSwitch IDs in the specified VPC
+        List of vSwitch IDs in the specified VPC
         """
         return pulumi.get(self, "vswitch_ids")
 
@@ -4223,7 +4978,7 @@ class GetPeerConnectionsConnectionResult(dict):
         :param str id: The ID of the PeerConnection.
         :param str peer_connection_id: The first ID of the resource.
         :param str peer_connection_name: The name of the resource.
-        :param str status: The status of the resource.
+        :param str status: The status of the resource. Valid values: `Accepting`, `Activated`, `Creating`, `Deleted`, `Deleting`, `Expired`, `Rejected`, `Updating`.
         :param str vpc_id: The ID of the requester VPC.
         """
         pulumi.set(__self__, "accepting_ali_uid", accepting_ali_uid)
@@ -4314,7 +5069,7 @@ class GetPeerConnectionsConnectionResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of the resource.
+        The status of the resource. Valid values: `Accepting`, `Activated`, `Creating`, `Deleted`, `Deleting`, `Expired`, `Rejected`, `Updating`.
         """
         return pulumi.get(self, "status")
 
@@ -4771,7 +5526,7 @@ class GetRouteTablesTableResult(dict):
                  router_id: str,
                  router_type: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  vpc_id: str,
                  vswitch_ids: Sequence[str]):
         """
@@ -4781,11 +5536,11 @@ class GetRouteTablesTableResult(dict):
         :param str resource_group_id: The Id of resource group which route tables belongs.
         :param str route_table_id: The route table id.
         :param str route_table_name: The route table name.
-        :param str route_table_type: The type of route table.
+        :param str route_table_type: The route table type.
         :param str router_id: The router ID.
         :param str router_type: The route type of route table. Valid values: `VRouter` and `VBR`.
         :param str status: The status of resource. Valid values: `Available` and `Pending`.
-        :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 vpc_id: Vpc id of the route table.
         :param Sequence[str] vswitch_ids: A list of vswitch id.
         """
@@ -4855,7 +5610,7 @@ class GetRouteTablesTableResult(dict):
     @pulumi.getter(name="routeTableType")
     def route_table_type(self) -> str:
         """
-        The type of route table.
+        The route table type.
         """
         return pulumi.get(self, "route_table_type")
 
@@ -4885,7 +5640,7 @@ class GetRouteTablesTableResult(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.
         """
@@ -5436,28 +6191,28 @@ class GetSwitchesVswitchResult(dict):
                  resource_group_id: str,
                  route_table_id: str,
                  status: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  vpc_id: str,
                  vswitch_id: str,
                  vswitch_name: str,
                  zone_id: str):
         """
-        :param int available_ip_address_count: The available ip address count of the VSwitch.
+        :param int available_ip_address_count: The available ip address count of the vSwitch.
         :param str cidr_block: Filter results by a specific CIDR block. For example: "172.16.0.0/12".
         :param str creation_time: Time of creation.
-        :param str description: Description of the VSwitch.
-        :param str id: ID of the VSwitch.
+        :param str description: Description of the vSwitch.
+        :param str id: ID of the vSwitch.
         :param str ipv6_cidr_block: The IPv6 CIDR block of the switch.
-        :param bool is_default: Indicate whether the VSwitch is created by the system.
-        :param str name: Name of the VSwitch.
+        :param bool is_default: Indicate whether the vSwitch is created by the system.
+        :param str name: Name of the vSwitch.
         :param str resource_group_id: The Id of resource group which VSWitch belongs.
-        :param str route_table_id: The route table ID of the VSwitch.
-        :param str status: The status of the VSwitch. Valid values: `Available` and `Pending`.
-        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
-        :param str vpc_id: ID of the VPC that owns the VSwitch.
-        :param str vswitch_id: ID of the VSwitch.
-        :param str vswitch_name: The name of the VSwitch.
-        :param str zone_id: The availability zone of the VSwitch.
+        :param str route_table_id: The route table ID of the vSwitch.
+        :param str status: The status of the vSwitch. Valid values: `Available` and `Pending`.
+        :param Mapping[str, str] tags: A mapping of tags to assign to the resource.
+        :param str vpc_id: ID of the VPC that owns the vSwitch.
+        :param str vswitch_id: ID of the vSwitch.
+        :param str vswitch_name: The name of the vSwitch.
+        :param str zone_id: The availability zone of the vSwitch.
         """
         pulumi.set(__self__, "available_ip_address_count", available_ip_address_count)
         pulumi.set(__self__, "cidr_block", cidr_block)
@@ -5480,7 +6235,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="availableIpAddressCount")
     def available_ip_address_count(self) -> int:
         """
-        The available ip address count of the VSwitch.
+        The available ip address count of the vSwitch.
         """
         return pulumi.get(self, "available_ip_address_count")
 
@@ -5504,7 +6259,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter
     def description(self) -> str:
         """
-        Description of the VSwitch.
+        Description of the vSwitch.
         """
         return pulumi.get(self, "description")
 
@@ -5512,7 +6267,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter
     def id(self) -> str:
         """
-        ID of the VSwitch.
+        ID of the vSwitch.
         """
         return pulumi.get(self, "id")
 
@@ -5528,7 +6283,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="isDefault")
     def is_default(self) -> bool:
         """
-        Indicate whether the VSwitch is created by the system.
+        Indicate whether the vSwitch is created by the system.
         """
         return pulumi.get(self, "is_default")
 
@@ -5536,7 +6291,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter
     def name(self) -> str:
         """
-        Name of the VSwitch.
+        Name of the vSwitch.
         """
         return pulumi.get(self, "name")
 
@@ -5552,7 +6307,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="routeTableId")
     def route_table_id(self) -> str:
         """
-        The route table ID of the VSwitch.
+        The route table ID of the vSwitch.
         """
         return pulumi.get(self, "route_table_id")
 
@@ -5560,13 +6315,13 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter
     def status(self) -> str:
         """
-        The status of the VSwitch. Valid values: `Available` and `Pending`.
+        The status of the vSwitch. Valid values: `Available` and `Pending`.
         """
         return pulumi.get(self, "status")
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         """
         A mapping of tags to assign to the resource.
         """
@@ -5576,7 +6331,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="vpcId")
     def vpc_id(self) -> str:
         """
-        ID of the VPC that owns the VSwitch.
+        ID of the VPC that owns the vSwitch.
         """
         return pulumi.get(self, "vpc_id")
 
@@ -5584,7 +6339,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        ID of the VSwitch.
+        ID of the vSwitch.
         """
         return pulumi.get(self, "vswitch_id")
 
@@ -5592,7 +6347,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="vswitchName")
     def vswitch_name(self) -> str:
         """
-        The name of the VSwitch.
+        The name of the vSwitch.
         """
         return pulumi.get(self, "vswitch_name")
 
@@ -5600,7 +6355,7 @@ class GetSwitchesVswitchResult(dict):
     @pulumi.getter(name="zoneId")
     def zone_id(self) -> str:
         """
-        The availability zone of the VSwitch.
+        The availability zone of the vSwitch.
         """
         return pulumi.get(self, "zone_id")