pulumi-gcp 8.7.0a1730183903__py3-none-any.whl → 8.8.0__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -688,6 +688,7 @@ __all__ = [
     'GetInstanceGroupManagerVersionTargetSizeResult',
     'GetInstanceGroupNamedPortResult',
     'GetInstanceGuestAcceleratorResult',
+    'GetInstanceGuestAttributesQueryValueResult',
     'GetInstanceNetworkInterfaceResult',
     'GetInstanceNetworkInterfaceAccessConfigResult',
     'GetInstanceNetworkInterfaceAliasIpRangeResult',
@@ -4354,6 +4355,8 @@ class ExternalVpnGatewayInterface(dict):
         suggest = None
         if key == "ipAddress":
             suggest = "ip_address"
+        elif key == "ipv6Address":
+            suggest = "ipv6_address"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ExternalVpnGatewayInterface. Access the value via the '{suggest}' property getter instead.")
@@ -4368,7 +4371,8 @@ class ExternalVpnGatewayInterface(dict):
 
     def __init__(__self__, *,
                  id: Optional[int] = None,
-                 ip_address: Optional[str] = None):
+                 ip_address: Optional[str] = None,
+                 ipv6_address: Optional[str] = None):
         """
         :param int id: The numeric ID for this interface. Allowed values are based on the redundancy type
                of this external VPN gateway
@@ -4379,11 +4383,19 @@ class ExternalVpnGatewayInterface(dict):
                Only IPv4 is supported. This IP address can be either from
                your on-premise gateway or another Cloud provider's VPN gateway,
                it cannot be an IP address from Google Compute Engine.
+        :param str ipv6_address: IPv6 address of the interface in the external VPN gateway. This IPv6
+               address can be either from your on-premise gateway or another Cloud
+               provider's VPN gateway, it cannot be an IP address from Google Compute
+               Engine. Must specify an IPv6 address (not IPV4-mapped) using any format
+               described in RFC 4291 (e.g. 2001:db8:0:0:2d9:51:0:0). The output format
+               is RFC 5952 format (e.g. 2001:db8::2d9:51:0:0).
         """
         if id is not None:
             pulumi.set(__self__, "id", id)
         if ip_address is not None:
             pulumi.set(__self__, "ip_address", ip_address)
+        if ipv6_address is not None:
+            pulumi.set(__self__, "ipv6_address", ipv6_address)
 
     @property
     @pulumi.getter
@@ -4408,6 +4420,19 @@ class ExternalVpnGatewayInterface(dict):
         """
         return pulumi.get(self, "ip_address")
 
+    @property
+    @pulumi.getter(name="ipv6Address")
+    def ipv6_address(self) -> Optional[str]:
+        """
+        IPv6 address of the interface in the external VPN gateway. This IPv6
+        address can be either from your on-premise gateway or another Cloud
+        provider's VPN gateway, it cannot be an IP address from Google Compute
+        Engine. Must specify an IPv6 address (not IPV4-mapped) using any format
+        described in RFC 4291 (e.g. 2001:db8:0:0:2d9:51:0:0). The output format
+        is RFC 5952 format (e.g. 2001:db8::2d9:51:0:0).
+        """
+        return pulumi.get(self, "ipv6_address")
+
 
 @pulumi.output_type
 class FirewallAllow(dict):
@@ -7151,6 +7176,8 @@ class InstanceAdvancedMachineFeatures(dict):
             suggest = "enable_nested_virtualization"
         elif key == "threadsPerCore":
             suggest = "threads_per_core"
+        elif key == "turboMode":
+            suggest = "turbo_mode"
         elif key == "visibleCoreCount":
             suggest = "visible_core_count"
 
@@ -7168,16 +7195,20 @@ class InstanceAdvancedMachineFeatures(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: Optional[bool] = None,
                  threads_per_core: Optional[int] = None,
+                 turbo_mode: Optional[str] = None,
                  visible_core_count: Optional[int] = None):
         """
         :param bool enable_nested_virtualization: Defines whether the instance should have nested virtualization  enabled. Defaults to false.
-        :param int threads_per_core: he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
+        :param int threads_per_core: The number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
         :param int visible_core_count: The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
         """
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         if threads_per_core is not None:
             pulumi.set(__self__, "threads_per_core", threads_per_core)
+        if turbo_mode is not None:
+            pulumi.set(__self__, "turbo_mode", turbo_mode)
         if visible_core_count is not None:
             pulumi.set(__self__, "visible_core_count", visible_core_count)
 
@@ -7193,10 +7224,18 @@ class InstanceAdvancedMachineFeatures(dict):
     @pulumi.getter(name="threadsPerCore")
     def threads_per_core(self) -> Optional[int]:
         """
-        he number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
+        The number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> Optional[str]:
+        """
+        Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> Optional[int]:
@@ -7766,6 +7805,8 @@ class InstanceFromMachineImageAdvancedMachineFeatures(dict):
             suggest = "enable_nested_virtualization"
         elif key == "threadsPerCore":
             suggest = "threads_per_core"
+        elif key == "turboMode":
+            suggest = "turbo_mode"
         elif key == "visibleCoreCount":
             suggest = "visible_core_count"
 
@@ -7783,16 +7824,20 @@ class InstanceFromMachineImageAdvancedMachineFeatures(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: Optional[bool] = None,
                  threads_per_core: Optional[int] = None,
+                 turbo_mode: Optional[str] = None,
                  visible_core_count: Optional[int] = None):
         """
         :param bool enable_nested_virtualization: Whether to enable nested virtualization or not.
         :param int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
         :param int visible_core_count: The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance\\'s nominal CPU count and the underlying platform\\'s SMT width.
         """
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         if threads_per_core is not None:
             pulumi.set(__self__, "threads_per_core", threads_per_core)
+        if turbo_mode is not None:
+            pulumi.set(__self__, "turbo_mode", turbo_mode)
         if visible_core_count is not None:
             pulumi.set(__self__, "visible_core_count", visible_core_count)
 
@@ -7812,6 +7857,14 @@ class InstanceFromMachineImageAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> Optional[str]:
+        """
+        Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> Optional[int]:
@@ -9414,6 +9467,8 @@ class InstanceFromTemplateAdvancedMachineFeatures(dict):
             suggest = "enable_nested_virtualization"
         elif key == "threadsPerCore":
             suggest = "threads_per_core"
+        elif key == "turboMode":
+            suggest = "turbo_mode"
         elif key == "visibleCoreCount":
             suggest = "visible_core_count"
 
@@ -9431,16 +9486,20 @@ class InstanceFromTemplateAdvancedMachineFeatures(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: Optional[bool] = None,
                  threads_per_core: Optional[int] = None,
+                 turbo_mode: Optional[str] = None,
                  visible_core_count: Optional[int] = None):
         """
         :param bool enable_nested_virtualization: Whether to enable nested virtualization or not.
         :param int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
         :param int visible_core_count: The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance\\'s nominal CPU count and the underlying platform\\'s SMT width.
         """
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         if threads_per_core is not None:
             pulumi.set(__self__, "threads_per_core", threads_per_core)
+        if turbo_mode is not None:
+            pulumi.set(__self__, "turbo_mode", turbo_mode)
         if visible_core_count is not None:
             pulumi.set(__self__, "visible_core_count", visible_core_count)
 
@@ -9460,6 +9519,14 @@ class InstanceFromTemplateAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> Optional[str]:
+        """
+        Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> Optional[int]:
@@ -13356,6 +13423,8 @@ class InstanceTemplateAdvancedMachineFeatures(dict):
             suggest = "enable_nested_virtualization"
         elif key == "threadsPerCore":
             suggest = "threads_per_core"
+        elif key == "turboMode":
+            suggest = "turbo_mode"
         elif key == "visibleCoreCount":
             suggest = "visible_core_count"
 
@@ -13373,16 +13442,20 @@ class InstanceTemplateAdvancedMachineFeatures(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: Optional[bool] = None,
                  threads_per_core: Optional[int] = None,
+                 turbo_mode: Optional[str] = None,
                  visible_core_count: Optional[int] = None):
         """
         :param bool enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
         :param int threads_per_core: The number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
         :param int visible_core_count: The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
         """
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         if threads_per_core is not None:
             pulumi.set(__self__, "threads_per_core", threads_per_core)
+        if turbo_mode is not None:
+            pulumi.set(__self__, "turbo_mode", turbo_mode)
         if visible_core_count is not None:
             pulumi.set(__self__, "visible_core_count", visible_core_count)
 
@@ -13402,6 +13475,14 @@ class InstanceTemplateAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> Optional[str]:
+        """
+        Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> Optional[int]:
@@ -13480,6 +13561,8 @@ class InstanceTemplateDisk(dict):
             suggest = "disk_type"
         elif key == "provisionedIops":
             suggest = "provisioned_iops"
+        elif key == "provisionedThroughput":
+            suggest = "provisioned_throughput"
         elif key == "resourceManagerTags":
             suggest = "resource_manager_tags"
         elif key == "resourcePolicies":
@@ -13516,6 +13599,7 @@ class InstanceTemplateDisk(dict):
                  labels: Optional[Mapping[str, str]] = None,
                  mode: Optional[str] = None,
                  provisioned_iops: Optional[int] = None,
+                 provisioned_throughput: Optional[int] = None,
                  resource_manager_tags: Optional[Mapping[str, str]] = None,
                  resource_policies: Optional[str] = None,
                  source: Optional[str] = None,
@@ -13560,6 +13644,7 @@ class InstanceTemplateDisk(dict):
                sets the number of I/O operations per second that the disk can handle.
                Values must be between 10,000 and 120,000. For more details, see the
                [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         :param Mapping[str, str] resource_manager_tags: A set of key/value resource manager tag pairs to bind to this disk. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456.
         :param str resource_policies: - A list (short name or id) of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
         :param str source: The name (**not self_link**)
@@ -13610,6 +13695,8 @@ class InstanceTemplateDisk(dict):
             pulumi.set(__self__, "mode", mode)
         if provisioned_iops is not None:
             pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        if provisioned_throughput is not None:
+            pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
         if resource_manager_tags is not None:
             pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
         if resource_policies is not None:
@@ -13739,6 +13826,14 @@ class InstanceTemplateDisk(dict):
         """
         return pulumi.get(self, "provisioned_iops")
 
+    @property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> Optional[int]:
+        """
+        Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Optional[Mapping[str, str]]:
@@ -15935,19 +16030,22 @@ class NetworkFirewallPolicyRuleMatch(dict):
                  src_threat_intelligences: Optional[Sequence[str]] = None):
         """
         :param Sequence['NetworkFirewallPolicyRuleMatchLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match.
-        :param Sequence[str] dest_address_groups: Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10. Destination address groups is only supported in Egress rules.
-        :param Sequence[str] dest_fqdns: Domain names that will be used to match against the resolved domain name of destination of traffic. Can only be specified if DIRECTION is egress.
+               Structure is documented below.
+        :param Sequence[str] dest_address_groups: Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10.
+        :param Sequence[str] dest_fqdns: Fully Qualified Domain Name (FQDN) which should be matched against traffic destination. Maximum number of destination fqdn allowed is 100.
         :param Sequence[str] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 5000.
-        :param Sequence[str] dest_region_codes: The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is egress.
-        :param Sequence[str] dest_threat_intelligences: Name of the Google Cloud Threat Intelligence list.
-        :param Sequence[str] src_address_groups: Address groups which should be matched against the traffic source. Maximum number of source address groups is 10. Source address groups is only supported in Ingress rules.
-        :param Sequence[str] src_fqdns: Domain names that will be used to match against the resolved domain name of source of traffic. Can only be specified if DIRECTION is ingress.
+        :param Sequence[str] dest_region_codes: Region codes whose IP addresses will be used to match for destination of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of dest region codes allowed is 5000.
+        :param Sequence[str] dest_threat_intelligences: Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic destination.
+        :param Sequence[str] src_address_groups: Address groups which should be matched against the traffic source. Maximum number of source address groups is 10.
+        :param Sequence[str] src_fqdns: Fully Qualified Domain Name (FQDN) which should be matched against traffic source. Maximum number of source fqdn allowed is 100.
         :param Sequence[str] src_ip_ranges: CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 5000.
-        :param Sequence[str] src_region_codes: The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is ingress.
-        :param Sequence['NetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
-        :param Sequence[str] src_threat_intelligences: Name of the Google Cloud Threat Intelligence list.
+        :param Sequence[str] src_region_codes: Region codes whose IP addresses will be used to match for source of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of source region codes allowed is 5000.
+        :param Sequence['NetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the srcSecureTag are INEFFECTIVE, and there is no srcIpRange, this rule will be ignored. Maximum number of source tag values allowed is 256.
+               Structure is documented below.
+        :param Sequence[str] src_threat_intelligences: Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic source.
                
-               The `layer4_configs` block supports:
+               
+               <a name="nested_layer4_configs"></a>The `layer4_configs` block supports:
         """
         pulumi.set(__self__, "layer4_configs", layer4_configs)
         if dest_address_groups is not None:
@@ -15978,6 +16076,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     def layer4_configs(self) -> Sequence['outputs.NetworkFirewallPolicyRuleMatchLayer4Config']:
         """
         Pairs of IP protocols and ports that the rule should match.
+        Structure is documented below.
         """
         return pulumi.get(self, "layer4_configs")
 
@@ -15985,7 +16084,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destAddressGroups")
     def dest_address_groups(self) -> Optional[Sequence[str]]:
         """
-        Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10. Destination address groups is only supported in Egress rules.
+        Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10.
         """
         return pulumi.get(self, "dest_address_groups")
 
@@ -15993,7 +16092,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destFqdns")
     def dest_fqdns(self) -> Optional[Sequence[str]]:
         """
-        Domain names that will be used to match against the resolved domain name of destination of traffic. Can only be specified if DIRECTION is egress.
+        Fully Qualified Domain Name (FQDN) which should be matched against traffic destination. Maximum number of destination fqdn allowed is 100.
         """
         return pulumi.get(self, "dest_fqdns")
 
@@ -16009,7 +16108,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destRegionCodes")
     def dest_region_codes(self) -> Optional[Sequence[str]]:
         """
-        The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is egress.
+        Region codes whose IP addresses will be used to match for destination of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of dest region codes allowed is 5000.
         """
         return pulumi.get(self, "dest_region_codes")
 
@@ -16017,7 +16116,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destThreatIntelligences")
     def dest_threat_intelligences(self) -> Optional[Sequence[str]]:
         """
-        Name of the Google Cloud Threat Intelligence list.
+        Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic destination.
         """
         return pulumi.get(self, "dest_threat_intelligences")
 
@@ -16025,7 +16124,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcAddressGroups")
     def src_address_groups(self) -> Optional[Sequence[str]]:
         """
-        Address groups which should be matched against the traffic source. Maximum number of source address groups is 10. Source address groups is only supported in Ingress rules.
+        Address groups which should be matched against the traffic source. Maximum number of source address groups is 10.
         """
         return pulumi.get(self, "src_address_groups")
 
@@ -16033,7 +16132,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcFqdns")
     def src_fqdns(self) -> Optional[Sequence[str]]:
         """
-        Domain names that will be used to match against the resolved domain name of source of traffic. Can only be specified if DIRECTION is ingress.
+        Fully Qualified Domain Name (FQDN) which should be matched against traffic source. Maximum number of source fqdn allowed is 100.
         """
         return pulumi.get(self, "src_fqdns")
 
@@ -16049,7 +16148,7 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcRegionCodes")
     def src_region_codes(self) -> Optional[Sequence[str]]:
         """
-        The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is ingress.
+        Region codes whose IP addresses will be used to match for source of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of source region codes allowed is 5000.
         """
         return pulumi.get(self, "src_region_codes")
 
@@ -16057,7 +16156,8 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcSecureTags")
     def src_secure_tags(self) -> Optional[Sequence['outputs.NetworkFirewallPolicyRuleMatchSrcSecureTag']]:
         """
-        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
+        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the srcSecureTag are INEFFECTIVE, and there is no srcIpRange, this rule will be ignored. Maximum number of source tag values allowed is 256.
+        Structure is documented below.
         """
         return pulumi.get(self, "src_secure_tags")
 
@@ -16065,9 +16165,10 @@ class NetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcThreatIntelligences")
     def src_threat_intelligences(self) -> Optional[Sequence[str]]:
         """
-        Name of the Google Cloud Threat Intelligence list.
+        Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic source.
 
-        The `layer4_configs` block supports:
+
+        <a name="nested_layer4_configs"></a>The `layer4_configs` block supports:
         """
         return pulumi.get(self, "src_threat_intelligences")
 
@@ -16095,8 +16196,10 @@ class NetworkFirewallPolicyRuleMatchLayer4Config(dict):
                  ip_protocol: str,
                  ports: Optional[Sequence[str]] = None):
         """
-        :param str ip_protocol: The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
-        :param Sequence[str] ports: An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
+        :param str ip_protocol: The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule.
+               This value can either be one of the following well known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp), or the IP protocol number.
+        :param Sequence[str] ports: An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port.
+               Example inputs include: ["22"], ["80","443"], and ["12345-12349"].
         """
         pulumi.set(__self__, "ip_protocol", ip_protocol)
         if ports is not None:
@@ -16106,7 +16209,8 @@ class NetworkFirewallPolicyRuleMatchLayer4Config(dict):
     @pulumi.getter(name="ipProtocol")
     def ip_protocol(self) -> str:
         """
-        The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
+        The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule.
+        This value can either be one of the following well known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp), or the IP protocol number.
         """
         return pulumi.get(self, "ip_protocol")
 
@@ -16114,7 +16218,8 @@ class NetworkFirewallPolicyRuleMatchLayer4Config(dict):
     @pulumi.getter
     def ports(self) -> Optional[Sequence[str]]:
         """
-        An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
+        An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port.
+        Example inputs include: ["22"], ["80","443"], and ["12345-12349"].
         """
         return pulumi.get(self, "ports")
 
@@ -16122,21 +16227,25 @@ class NetworkFirewallPolicyRuleMatchLayer4Config(dict):
 @pulumi.output_type
 class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
     def __init__(__self__, *,
-                 name: str,
+                 name: Optional[str] = None,
                  state: Optional[str] = None):
         """
-        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
-        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        :param str name: Name of the secure tag, created with TagManager's TagValue API.
+        :param str state: (Output)
+               State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
+               
+               - - -
         """
-        pulumi.set(__self__, "name", name)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
-        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
+        Name of the secure tag, created with TagManager's TagValue API.
         """
         return pulumi.get(self, "name")
 
@@ -16144,7 +16253,10 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
     @pulumi.getter
     def state(self) -> Optional[str]:
         """
-        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        (Output)
+        State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
+
+        - - -
         """
         return pulumi.get(self, "state")
 
@@ -16152,21 +16264,23 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
 @pulumi.output_type
 class NetworkFirewallPolicyRuleTargetSecureTag(dict):
     def __init__(__self__, *,
-                 name: str,
+                 name: Optional[str] = None,
                  state: Optional[str] = None):
         """
-        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
-        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        :param str name: Name of the secure tag, created with TagManager's TagValue API.
+        :param str state: (Output)
+               State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
         """
-        pulumi.set(__self__, "name", name)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
-        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
+        Name of the secure tag, created with TagManager's TagValue API.
         """
         return pulumi.get(self, "name")
 
@@ -16174,7 +16288,8 @@ class NetworkFirewallPolicyRuleTargetSecureTag(dict):
     @pulumi.getter
     def state(self) -> Optional[str]:
         """
-        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        (Output)
+        State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
         """
         return pulumi.get(self, "state")
 
@@ -23283,6 +23398,8 @@ class RegionInstanceTemplateAdvancedMachineFeatures(dict):
             suggest = "enable_nested_virtualization"
         elif key == "threadsPerCore":
             suggest = "threads_per_core"
+        elif key == "turboMode":
+            suggest = "turbo_mode"
         elif key == "visibleCoreCount":
             suggest = "visible_core_count"
 
@@ -23300,16 +23417,20 @@ class RegionInstanceTemplateAdvancedMachineFeatures(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: Optional[bool] = None,
                  threads_per_core: Optional[int] = None,
+                 turbo_mode: Optional[str] = None,
                  visible_core_count: Optional[int] = None):
         """
         :param bool enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
         :param int threads_per_core: The number of threads per physical core. To disable [simultaneous multithreading (SMT)](https://cloud.google.com/compute/docs/instances/disabling-smt) set this to 1.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
         :param int visible_core_count: The number of physical cores to expose to an instance. [visible cores info (VC)](https://cloud.google.com/compute/docs/instances/customize-visible-cores).
         """
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         if threads_per_core is not None:
             pulumi.set(__self__, "threads_per_core", threads_per_core)
+        if turbo_mode is not None:
+            pulumi.set(__self__, "turbo_mode", turbo_mode)
         if visible_core_count is not None:
             pulumi.set(__self__, "visible_core_count", visible_core_count)
 
@@ -23329,6 +23450,14 @@ class RegionInstanceTemplateAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> Optional[str]:
+        """
+        Turbo frequency mode to use for the instance. Supported modes are currently either `ALL_CORE_MAX` or unset (default).
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> Optional[int]:
@@ -23407,6 +23536,8 @@ class RegionInstanceTemplateDisk(dict):
             suggest = "disk_type"
         elif key == "provisionedIops":
             suggest = "provisioned_iops"
+        elif key == "provisionedThroughput":
+            suggest = "provisioned_throughput"
         elif key == "resourceManagerTags":
             suggest = "resource_manager_tags"
         elif key == "resourcePolicies":
@@ -23443,6 +23574,7 @@ class RegionInstanceTemplateDisk(dict):
                  labels: Optional[Mapping[str, str]] = None,
                  mode: Optional[str] = None,
                  provisioned_iops: Optional[int] = None,
+                 provisioned_throughput: Optional[int] = None,
                  resource_manager_tags: Optional[Mapping[str, str]] = None,
                  resource_policies: Optional[str] = None,
                  source: Optional[str] = None,
@@ -23487,6 +23619,7 @@ class RegionInstanceTemplateDisk(dict):
                sets the number of I/O operations per second that the disk can handle.
                Values must be between 10,000 and 120,000. For more details, see the
                [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         :param Mapping[str, str] resource_manager_tags: A set of key/value resource manager tag pairs to bind to this disk. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456.
         :param str resource_policies: - A list (short name or id) of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
         :param str source: The name (**not self_link**)
@@ -23537,6 +23670,8 @@ class RegionInstanceTemplateDisk(dict):
             pulumi.set(__self__, "mode", mode)
         if provisioned_iops is not None:
             pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        if provisioned_throughput is not None:
+            pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
         if resource_manager_tags is not None:
             pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
         if resource_policies is not None:
@@ -23666,6 +23801,14 @@ class RegionInstanceTemplateDisk(dict):
         """
         return pulumi.get(self, "provisioned_iops")
 
+    @property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> Optional[int]:
+        """
+        Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Optional[Mapping[str, str]]:
@@ -25336,19 +25479,22 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
                  src_threat_intelligences: Optional[Sequence[str]] = None):
         """
         :param Sequence['RegionNetworkFirewallPolicyRuleMatchLayer4ConfigArgs'] layer4_configs: Pairs of IP protocols and ports that the rule should match.
-        :param Sequence[str] dest_address_groups: Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10. Destination address groups is only supported in Egress rules.
-        :param Sequence[str] dest_fqdns: Domain names that will be used to match against the resolved domain name of destination of traffic. Can only be specified if DIRECTION is egress.
+               Structure is documented below.
+        :param Sequence[str] dest_address_groups: Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10.
+        :param Sequence[str] dest_fqdns: Fully Qualified Domain Name (FQDN) which should be matched against traffic destination. Maximum number of destination fqdn allowed is 100.
         :param Sequence[str] dest_ip_ranges: CIDR IP address range. Maximum number of destination CIDR IP ranges allowed is 5000.
-        :param Sequence[str] dest_region_codes: The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is egress.
-        :param Sequence[str] dest_threat_intelligences: Name of the Google Cloud Threat Intelligence list.
-        :param Sequence[str] src_address_groups: Address groups which should be matched against the traffic source. Maximum number of source address groups is 10. Source address groups is only supported in Ingress rules.
-        :param Sequence[str] src_fqdns: Domain names that will be used to match against the resolved domain name of source of traffic. Can only be specified if DIRECTION is ingress.
+        :param Sequence[str] dest_region_codes: Region codes whose IP addresses will be used to match for destination of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of dest region codes allowed is 5000.
+        :param Sequence[str] dest_threat_intelligences: Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic destination.
+        :param Sequence[str] src_address_groups: Address groups which should be matched against the traffic source. Maximum number of source address groups is 10.
+        :param Sequence[str] src_fqdns: Fully Qualified Domain Name (FQDN) which should be matched against traffic source. Maximum number of source fqdn allowed is 100.
         :param Sequence[str] src_ip_ranges: CIDR IP address range. Maximum number of source CIDR IP ranges allowed is 5000.
-        :param Sequence[str] src_region_codes: The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is ingress.
-        :param Sequence['RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
-        :param Sequence[str] src_threat_intelligences: Name of the Google Cloud Threat Intelligence list.
+        :param Sequence[str] src_region_codes: Region codes whose IP addresses will be used to match for source of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of source region codes allowed is 5000.
+        :param Sequence['RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgs'] src_secure_tags: List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the srcSecureTag are INEFFECTIVE, and there is no srcIpRange, this rule will be ignored. Maximum number of source tag values allowed is 256.
+               Structure is documented below.
+        :param Sequence[str] src_threat_intelligences: Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic source.
                
-               The `layer4_configs` block supports:
+               
+               <a name="nested_layer4_configs"></a>The `layer4_configs` block supports:
         """
         pulumi.set(__self__, "layer4_configs", layer4_configs)
         if dest_address_groups is not None:
@@ -25379,6 +25525,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     def layer4_configs(self) -> Sequence['outputs.RegionNetworkFirewallPolicyRuleMatchLayer4Config']:
         """
         Pairs of IP protocols and ports that the rule should match.
+        Structure is documented below.
         """
         return pulumi.get(self, "layer4_configs")
 
@@ -25386,7 +25533,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destAddressGroups")
     def dest_address_groups(self) -> Optional[Sequence[str]]:
         """
-        Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10. Destination address groups is only supported in Egress rules.
+        Address groups which should be matched against the traffic destination. Maximum number of destination address groups is 10.
         """
         return pulumi.get(self, "dest_address_groups")
 
@@ -25394,7 +25541,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destFqdns")
     def dest_fqdns(self) -> Optional[Sequence[str]]:
         """
-        Domain names that will be used to match against the resolved domain name of destination of traffic. Can only be specified if DIRECTION is egress.
+        Fully Qualified Domain Name (FQDN) which should be matched against traffic destination. Maximum number of destination fqdn allowed is 100.
         """
         return pulumi.get(self, "dest_fqdns")
 
@@ -25410,7 +25557,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destRegionCodes")
     def dest_region_codes(self) -> Optional[Sequence[str]]:
         """
-        The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is egress.
+        Region codes whose IP addresses will be used to match for destination of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of dest region codes allowed is 5000.
         """
         return pulumi.get(self, "dest_region_codes")
 
@@ -25418,7 +25565,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="destThreatIntelligences")
     def dest_threat_intelligences(self) -> Optional[Sequence[str]]:
         """
-        Name of the Google Cloud Threat Intelligence list.
+        Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic destination.
         """
         return pulumi.get(self, "dest_threat_intelligences")
 
@@ -25426,7 +25573,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcAddressGroups")
     def src_address_groups(self) -> Optional[Sequence[str]]:
         """
-        Address groups which should be matched against the traffic source. Maximum number of source address groups is 10. Source address groups is only supported in Ingress rules.
+        Address groups which should be matched against the traffic source. Maximum number of source address groups is 10.
         """
         return pulumi.get(self, "src_address_groups")
 
@@ -25434,7 +25581,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcFqdns")
     def src_fqdns(self) -> Optional[Sequence[str]]:
         """
-        Domain names that will be used to match against the resolved domain name of source of traffic. Can only be specified if DIRECTION is ingress.
+        Fully Qualified Domain Name (FQDN) which should be matched against traffic source. Maximum number of source fqdn allowed is 100.
         """
         return pulumi.get(self, "src_fqdns")
 
@@ -25450,7 +25597,7 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcRegionCodes")
     def src_region_codes(self) -> Optional[Sequence[str]]:
         """
-        The Unicode country codes whose IP addresses will be used to match against the source of traffic. Can only be specified if DIRECTION is ingress.
+        Region codes whose IP addresses will be used to match for source of traffic. Should be specified as 2 letter country code defined as per ISO 3166 alpha-2 country codes. ex."US" Maximum number of source region codes allowed is 5000.
         """
         return pulumi.get(self, "src_region_codes")
 
@@ -25458,7 +25605,8 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcSecureTags")
     def src_secure_tags(self) -> Optional[Sequence['outputs.RegionNetworkFirewallPolicyRuleMatchSrcSecureTag']]:
         """
-        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the <code>srcSecureTag</code> are INEFFECTIVE, and there is no <code>srcIpRange</code>, this rule will be ignored. Maximum number of source tag values allowed is 256.
+        List of secure tag values, which should be matched at the source of the traffic. For INGRESS rule, if all the srcSecureTag are INEFFECTIVE, and there is no srcIpRange, this rule will be ignored. Maximum number of source tag values allowed is 256.
+        Structure is documented below.
         """
         return pulumi.get(self, "src_secure_tags")
 
@@ -25466,9 +25614,10 @@ class RegionNetworkFirewallPolicyRuleMatch(dict):
     @pulumi.getter(name="srcThreatIntelligences")
     def src_threat_intelligences(self) -> Optional[Sequence[str]]:
         """
-        Name of the Google Cloud Threat Intelligence list.
+        Names of Network Threat Intelligence lists. The IPs in these lists will be matched against traffic source.
 
-        The `layer4_configs` block supports:
+
+        <a name="nested_layer4_configs"></a>The `layer4_configs` block supports:
         """
         return pulumi.get(self, "src_threat_intelligences")
 
@@ -25496,8 +25645,10 @@ class RegionNetworkFirewallPolicyRuleMatchLayer4Config(dict):
                  ip_protocol: str,
                  ports: Optional[Sequence[str]] = None):
         """
-        :param str ip_protocol: The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
-        :param Sequence[str] ports: An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
+        :param str ip_protocol: The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule.
+               This value can either be one of the following well known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp), or the IP protocol number.
+        :param Sequence[str] ports: An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port.
+               Example inputs include: ["22"], ["80","443"], and ["12345-12349"].
         """
         pulumi.set(__self__, "ip_protocol", ip_protocol)
         if ports is not None:
@@ -25507,7 +25658,8 @@ class RegionNetworkFirewallPolicyRuleMatchLayer4Config(dict):
     @pulumi.getter(name="ipProtocol")
     def ip_protocol(self) -> str:
         """
-        The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule. This value can either be one of the following well known protocol strings (`tcp`, `udp`, `icmp`, `esp`, `ah`, `ipip`, `sctp`), or the IP protocol number.
+        The IP protocol to which this rule applies. The protocol type is required when creating a firewall rule.
+        This value can either be one of the following well known protocol strings (tcp, udp, icmp, esp, ah, ipip, sctp), or the IP protocol number.
         """
         return pulumi.get(self, "ip_protocol")
 
@@ -25515,7 +25667,8 @@ class RegionNetworkFirewallPolicyRuleMatchLayer4Config(dict):
     @pulumi.getter
     def ports(self) -> Optional[Sequence[str]]:
         """
-        An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port. Example inputs include: ``.
+        An optional list of ports to which this rule applies. This field is only applicable for UDP or TCP protocol. Each entry must be either an integer or a range. If not specified, this rule applies to connections through any port.
+        Example inputs include: ["22"], ["80","443"], and ["12345-12349"].
         """
         return pulumi.get(self, "ports")
 
@@ -25523,21 +25676,25 @@ class RegionNetworkFirewallPolicyRuleMatchLayer4Config(dict):
 @pulumi.output_type
 class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
     def __init__(__self__, *,
-                 name: str,
+                 name: Optional[str] = None,
                  state: Optional[str] = None):
         """
-        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
-        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        :param str name: Name of the secure tag, created with TagManager's TagValue API.
+        :param str state: (Output)
+               State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
+               
+               - - -
         """
-        pulumi.set(__self__, "name", name)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
-        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
+        Name of the secure tag, created with TagManager's TagValue API.
         """
         return pulumi.get(self, "name")
 
@@ -25545,7 +25702,10 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
     @pulumi.getter
     def state(self) -> Optional[str]:
         """
-        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        (Output)
+        State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
+
+        - - -
         """
         return pulumi.get(self, "state")
 
@@ -25553,21 +25713,23 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
 @pulumi.output_type
 class RegionNetworkFirewallPolicyRuleTargetSecureTag(dict):
     def __init__(__self__, *,
-                 name: str,
+                 name: Optional[str] = None,
                  state: Optional[str] = None):
         """
-        :param str name: Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
-        :param str state: [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        :param str name: Name of the secure tag, created with TagManager's TagValue API.
+        :param str state: (Output)
+               State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
         """
-        pulumi.set(__self__, "name", name)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
         if state is not None:
             pulumi.set(__self__, "state", state)
 
     @property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> Optional[str]:
         """
-        Name of the secure tag, created with TagManager's TagValue API. @pattern tagValues/[0-9]+
+        Name of the secure tag, created with TagManager's TagValue API.
         """
         return pulumi.get(self, "name")
 
@@ -25575,7 +25737,8 @@ class RegionNetworkFirewallPolicyRuleTargetSecureTag(dict):
     @pulumi.getter
     def state(self) -> Optional[str]:
         """
-        [Output Only] State of the secure tag, either `EFFECTIVE` or `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted or its network is deleted.
+        (Output)
+        State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
         """
         return pulumi.get(self, "state")
 
@@ -37279,17 +37442,20 @@ class SecurityPolicyRuleHeaderAction(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 request_headers_to_adds: Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']):
+                 request_headers_to_adds: Optional[Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']] = None):
         """
-        :param Sequence['SecurityPolicyRuleHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: The list of request headers to add or overwrite if they're already present. Structure is documented below.
+        :param Sequence['SecurityPolicyRuleHeaderActionRequestHeadersToAddArgs'] request_headers_to_adds: The list of request headers to add or overwrite if they're already present.
+               Structure is documented below.
         """
-        pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
+        if request_headers_to_adds is not None:
+            pulumi.set(__self__, "request_headers_to_adds", request_headers_to_adds)
 
     @property
     @pulumi.getter(name="requestHeadersToAdds")
-    def request_headers_to_adds(self) -> Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']:
+    def request_headers_to_adds(self) -> Optional[Sequence['outputs.SecurityPolicyRuleHeaderActionRequestHeadersToAdd']]:
         """
-        The list of request headers to add or overwrite if they're already present. Structure is documented below.
+        The list of request headers to add or overwrite if they're already present.
+        Structure is documented below.
         """
         return pulumi.get(self, "request_headers_to_adds")
 
@@ -37316,19 +37482,20 @@ class SecurityPolicyRuleHeaderActionRequestHeadersToAdd(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 header_name: str,
+                 header_name: Optional[str] = None,
                  header_value: Optional[str] = None):
         """
         :param str header_name: The name of the header to set.
         :param str header_value: The value to set the named header to.
         """
-        pulumi.set(__self__, "header_name", header_name)
+        if header_name is not None:
+            pulumi.set(__self__, "header_name", header_name)
         if header_value is not None:
             pulumi.set(__self__, "header_value", header_value)
 
     @property
     @pulumi.getter(name="headerName")
-    def header_name(self) -> str:
+    def header_name(self) -> Optional[str]:
         """
         The name of the header to set.
         """
@@ -38286,37 +38453,32 @@ class SecurityPolicyRuleRateLimitOptionsRateLimitThreshold(dict):
 @pulumi.output_type
 class SecurityPolicyRuleRedirectOptions(dict):
     def __init__(__self__, *,
-                 type: str,
-                 target: Optional[str] = None):
+                 target: Optional[str] = None,
+                 type: Optional[str] = None):
         """
-        :param str type: Type of redirect action.
-               
-               * `EXTERNAL_302`: Redirect to an external address, configured in `target`.
-               * `GOOGLE_RECAPTCHA`: Redirect to Google reCAPTCHA.
-        :param str target: External redirection target when `EXTERNAL_302` is set in `type`.
+        :param str target: Target for the redirect action. This is required if the type is EXTERNAL_302 and cannot be specified for GOOGLE_RECAPTCHA.
+        :param str type: Type of the redirect action.
         """
-        pulumi.set(__self__, "type", type)
         if target is not None:
             pulumi.set(__self__, "target", target)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
 
     @property
     @pulumi.getter
-    def type(self) -> str:
+    def target(self) -> Optional[str]:
         """
-        Type of redirect action.
-
-        * `EXTERNAL_302`: Redirect to an external address, configured in `target`.
-        * `GOOGLE_RECAPTCHA`: Redirect to Google reCAPTCHA.
+        Target for the redirect action. This is required if the type is EXTERNAL_302 and cannot be specified for GOOGLE_RECAPTCHA.
         """
-        return pulumi.get(self, "type")
+        return pulumi.get(self, "target")
 
     @property
     @pulumi.getter
-    def target(self) -> Optional[str]:
+    def type(self) -> Optional[str]:
         """
-        External redirection target when `EXTERNAL_302` is set in `type`.
+        Type of the redirect action.
         """
-        return pulumi.get(self, "target")
+        return pulumi.get(self, "type")
 
 
 @pulumi.output_type
@@ -38554,7 +38716,7 @@ class ServiceAttachmentConnectedEndpoint(dict):
                The url of the consumer network.
         :param str endpoint: (Output)
                The URL of the consumer forwarding rule.
-        :param int propagated_connection_count: (Output, Beta)
+        :param int propagated_connection_count: (Output)
                The number of consumer Network Connectivity Center spokes that the connected Private Service Connect endpoint has propagated to.
         :param str psc_connection_id: (Output)
                The PSC connection id of the connected endpoint.
@@ -38595,7 +38757,7 @@ class ServiceAttachmentConnectedEndpoint(dict):
     @pulumi.getter(name="propagatedConnectionCount")
     def propagated_connection_count(self) -> Optional[int]:
         """
-        (Output, Beta)
+        (Output)
         The number of consumer Network Connectivity Center spokes that the connected Private Service Connect endpoint has propagated to.
         """
         return pulumi.get(self, "propagated_connection_count")
@@ -49972,14 +50134,17 @@ class GetInstanceAdvancedMachineFeatureResult(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: bool,
                  threads_per_core: int,
+                 turbo_mode: str,
                  visible_core_count: int):
         """
         :param bool enable_nested_virtualization: Whether to enable nested virtualization or not.
         :param int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
         :param int visible_core_count: The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance\\'s nominal CPU count and the underlying platform\\'s SMT width.
         """
         pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         pulumi.set(__self__, "threads_per_core", threads_per_core)
+        pulumi.set(__self__, "turbo_mode", turbo_mode)
         pulumi.set(__self__, "visible_core_count", visible_core_count)
 
     @property
@@ -49998,6 +50163,14 @@ class GetInstanceAdvancedMachineFeatureResult(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> str:
+        """
+        Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> int:
@@ -50025,7 +50198,7 @@ class GetInstanceAttachedDiskResult(dict):
                (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>) that protects this resource.
         :param str kms_key_self_link: The self_link of the encryption key that is stored in Google Cloud KMS to encrypt this disk. Only one of kms_key_self_link and disk_encryption_key_raw may be set.
         :param str mode: Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
-        :param str source: The name or self_link of the disk attached to this instance.
+        :param str source: The self_link of the disk attached to this instance.
         """
         pulumi.set(__self__, "device_name", device_name)
         pulumi.set(__self__, "disk_encryption_key_raw", disk_encryption_key_raw)
@@ -50081,7 +50254,7 @@ class GetInstanceAttachedDiskResult(dict):
     @pulumi.getter
     def source(self) -> str:
         """
-        The name or self_link of the disk attached to this instance.
+        The self_link of the disk attached to this instance.
         """
         return pulumi.get(self, "source")
 
@@ -50111,7 +50284,7 @@ class GetInstanceBootDiskResult(dict):
         :param str interface: The disk interface used for attaching this disk. One of `SCSI` or `NVME`.
         :param str kms_key_self_link: The self_link of the encryption key that is stored in Google Cloud KMS to encrypt this disk. Only one of kms_key_self_link and disk_encryption_key_raw may be set.
         :param str mode: Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
-        :param str source: The name or self_link of the disk attached to this instance.
+        :param str source: The self_link of the disk attached to this instance.
         """
         pulumi.set(__self__, "auto_delete", auto_delete)
         pulumi.set(__self__, "device_name", device_name)
@@ -50195,7 +50368,7 @@ class GetInstanceBootDiskResult(dict):
     @pulumi.getter
     def source(self) -> str:
         """
-        The name or self_link of the disk attached to this instance.
+        The self_link of the disk attached to this instance.
         """
         return pulumi.get(self, "source")
 
@@ -50976,6 +51149,46 @@ class GetInstanceGuestAcceleratorResult(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class GetInstanceGuestAttributesQueryValueResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 namespace: str,
+                 value: str):
+        """
+        :param str key: Key of the guest_attribute.
+        :param str namespace: Namespace of the guest_attribute.
+        :param str value: Value of the guest_attribute.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "namespace", namespace)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        Key of the guest_attribute.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> str:
+        """
+        Namespace of the guest_attribute.
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        Value of the guest_attribute.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class GetInstanceNetworkInterfaceResult(dict):
     def __init__(__self__, *,
@@ -51793,14 +52006,17 @@ class GetInstanceTemplateAdvancedMachineFeatureResult(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: bool,
                  threads_per_core: int,
+                 turbo_mode: str,
                  visible_core_count: int):
         """
         :param bool enable_nested_virtualization: Whether to enable nested virtualization or not.
         :param int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
         :param int visible_core_count: The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance\\'s nominal CPU count and the underlying platform\\'s SMT width.
         """
         pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         pulumi.set(__self__, "threads_per_core", threads_per_core)
+        pulumi.set(__self__, "turbo_mode", turbo_mode)
         pulumi.set(__self__, "visible_core_count", visible_core_count)
 
     @property
@@ -51819,6 +52035,14 @@ class GetInstanceTemplateAdvancedMachineFeatureResult(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> str:
+        """
+        Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> int:
@@ -51877,6 +52101,7 @@ class GetInstanceTemplateDiskResult(dict):
                  labels: Mapping[str, str],
                  mode: str,
                  provisioned_iops: int,
+                 provisioned_throughput: int,
                  resource_manager_tags: Mapping[str, str],
                  resource_policies: Sequence[str],
                  source: str,
@@ -51913,6 +52138,7 @@ class GetInstanceTemplateDiskResult(dict):
                sets the number of I/O operations per second that the disk can handle.
                Values must be between 10,000 and 120,000. For more details, see the
                [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         :param Mapping[str, str] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param Sequence[str] resource_policies: (Optional) -- A list of short names of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
         :param str source: The name (**not self_link**)
@@ -51951,6 +52177,7 @@ class GetInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "labels", labels)
         pulumi.set(__self__, "mode", mode)
         pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
         pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
         pulumi.set(__self__, "resource_policies", resource_policies)
         pulumi.set(__self__, "source", source)
@@ -52064,6 +52291,14 @@ class GetInstanceTemplateDiskResult(dict):
         """
         return pulumi.get(self, "provisioned_iops")
 
+    @property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> int:
+        """
+        Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Mapping[str, str]:
@@ -54049,14 +54284,17 @@ class GetRegionInstanceTemplateAdvancedMachineFeatureResult(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: bool,
                  threads_per_core: int,
+                 turbo_mode: str,
                  visible_core_count: int):
         """
         :param bool enable_nested_virtualization: Whether to enable nested virtualization or not.
         :param int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
+        :param str turbo_mode: Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
         :param int visible_core_count: The number of physical cores to expose to an instance. Multiply by the number of threads per core to compute the total number of virtual CPUs to expose to the instance. If unset, the number of cores is inferred from the instance\\'s nominal CPU count and the underlying platform\\'s SMT width.
         """
         pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
         pulumi.set(__self__, "threads_per_core", threads_per_core)
+        pulumi.set(__self__, "turbo_mode", turbo_mode)
         pulumi.set(__self__, "visible_core_count", visible_core_count)
 
     @property
@@ -54075,6 +54313,14 @@ class GetRegionInstanceTemplateAdvancedMachineFeatureResult(dict):
         """
         return pulumi.get(self, "threads_per_core")
 
+    @property
+    @pulumi.getter(name="turboMode")
+    def turbo_mode(self) -> str:
+        """
+        Turbo frequency mode to use for the instance. Currently supported modes is "ALL_CORE_MAX".
+        """
+        return pulumi.get(self, "turbo_mode")
+
     @property
     @pulumi.getter(name="visibleCoreCount")
     def visible_core_count(self) -> int:
@@ -54133,6 +54379,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
                  labels: Mapping[str, str],
                  mode: str,
                  provisioned_iops: int,
+                 provisioned_throughput: int,
                  resource_manager_tags: Mapping[str, str],
                  resource_policies: Sequence[str],
                  source: str,
@@ -54169,6 +54416,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
                sets the number of I/O operations per second that the disk can handle.
                Values must be between 10,000 and 120,000. For more details, see the
                [Extreme persistent disk documentation](https://cloud.google.com/compute/docs/disks/extreme-persistent-disk).
+        :param int provisioned_throughput: Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
         :param Mapping[str, str] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param Sequence[str] resource_policies: (Optional) -- A list of short names of resource policies to attach to this disk for automatic snapshot creations. Currently a max of 1 resource policy is supported.
         :param str source: The name (**not self_link**)
@@ -54207,6 +54455,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "labels", labels)
         pulumi.set(__self__, "mode", mode)
         pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
         pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
         pulumi.set(__self__, "resource_policies", resource_policies)
         pulumi.set(__self__, "source", source)
@@ -54320,6 +54569,14 @@ class GetRegionInstanceTemplateDiskResult(dict):
         """
         return pulumi.get(self, "provisioned_iops")
 
+    @property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> int:
+        """
+        Indicates how much throughput to provision for the disk, in MB/s. This sets the amount of data that can be read or written from the disk per second. Values must greater than or equal to 1. For more details, see the [Hyperdisk documentation](https://cloud.google.com/compute/docs/disks/hyperdisks).
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Mapping[str, str]: