pulumi-gcp 8.32.1__py3-none-any.whl → 8.33.0__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
 import builtins
@@ -44,6 +44,8 @@ __all__ = [
     'BackendServiceConsistentHashHttpCookie',
     'BackendServiceConsistentHashHttpCookieTtl',
     'BackendServiceCustomMetric',
+    'BackendServiceDynamicForwarding',
+    'BackendServiceDynamicForwardingIpPortSelection',
     'BackendServiceIamBindingCondition',
     'BackendServiceIamMemberCondition',
     'BackendServiceIap',
@@ -52,6 +54,8 @@ __all__ = [
     'BackendServiceLocalityLbPolicyPolicy',
     'BackendServiceLogConfig',
     'BackendServiceMaxStreamDuration',
+    'BackendServiceNetworkPassThroughLbTrafficPolicy',
+    'BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity',
     'BackendServiceOutlierDetection',
     'BackendServiceOutlierDetectionBaseEjectionTime',
     'BackendServiceOutlierDetectionInterval',
@@ -83,6 +87,29 @@ __all__ = [
     'FirewallPolicyWithRulesRuleMatch',
     'FirewallPolicyWithRulesRuleMatchLayer4Config',
     'ForwardingRuleServiceDirectoryRegistrations',
+    'FutureReservationAutoCreatedReservationsDuration',
+    'FutureReservationCommitmentInfo',
+    'FutureReservationShareSettings',
+    'FutureReservationShareSettingsProjectMap',
+    'FutureReservationSpecificSkuProperties',
+    'FutureReservationSpecificSkuPropertiesInstanceProperties',
+    'FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator',
+    'FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd',
+    'FutureReservationStatus',
+    'FutureReservationStatusLastKnownGoodState',
+    'FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecs',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow',
+    'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowDuration',
+    'FutureReservationStatusSpecificSkuProperties',
+    'FutureReservationTimeWindow',
+    'FutureReservationTimeWindowDuration',
     'GlobalForwardingRuleMetadataFilter',
     'GlobalForwardingRuleMetadataFilterFilterLabel',
     'GlobalForwardingRuleServiceDirectoryRegistrations',
@@ -311,6 +338,8 @@ __all__ = [
     'RegionBackendServiceConsistentHashHttpCookie',
     'RegionBackendServiceConsistentHashHttpCookieTtl',
     'RegionBackendServiceCustomMetric',
+    'RegionBackendServiceDynamicForwarding',
+    'RegionBackendServiceDynamicForwardingIpPortSelection',
     'RegionBackendServiceFailoverPolicy',
     'RegionBackendServiceIamBindingCondition',
     'RegionBackendServiceIamMemberCondition',
@@ -551,6 +580,7 @@ __all__ = [
     'RouterBgpAdvertisedIpRange',
     'RouterMd5AuthenticationKeys',
     'RouterNatLogConfig',
+    'RouterNatNat64Subnetwork',
     'RouterNatRule',
     'RouterNatRuleAction',
     'RouterNatSubnetwork',
@@ -687,6 +717,8 @@ __all__ = [
     'URLMapPathMatcherRouteRuleHeaderAction',
     'URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAdd',
     'URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd',
+    'URLMapPathMatcherRouteRuleHttpFilterConfig',
+    'URLMapPathMatcherRouteRuleHttpFilterMetadata',
     'URLMapPathMatcherRouteRuleMatchRule',
     'URLMapPathMatcherRouteRuleMatchRuleHeaderMatch',
     'URLMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatch',
@@ -728,12 +760,16 @@ __all__ = [
     'GetBackendServiceConsistentHashHttpCookyResult',
     'GetBackendServiceConsistentHashHttpCookyTtlResult',
     'GetBackendServiceCustomMetricResult',
+    'GetBackendServiceDynamicForwardingResult',
+    'GetBackendServiceDynamicForwardingIpPortSelectionResult',
     'GetBackendServiceIapResult',
     'GetBackendServiceLocalityLbPolicyResult',
     'GetBackendServiceLocalityLbPolicyCustomPolicyResult',
     'GetBackendServiceLocalityLbPolicyPolicyResult',
     'GetBackendServiceLogConfigResult',
     'GetBackendServiceMaxStreamDurationResult',
+    'GetBackendServiceNetworkPassThroughLbTrafficPolicyResult',
+    'GetBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityResult',
     'GetBackendServiceOutlierDetectionResult',
     'GetBackendServiceOutlierDetectionBaseEjectionTimeResult',
     'GetBackendServiceOutlierDetectionIntervalResult',
@@ -850,6 +886,8 @@ __all__ = [
     'GetRegionBackendServiceConsistentHashHttpCookyResult',
     'GetRegionBackendServiceConsistentHashHttpCookyTtlResult',
     'GetRegionBackendServiceCustomMetricResult',
+    'GetRegionBackendServiceDynamicForwardingResult',
+    'GetRegionBackendServiceDynamicForwardingIpPortSelectionResult',
     'GetRegionBackendServiceFailoverPolicyResult',
     'GetRegionBackendServiceIapResult',
     'GetRegionBackendServiceLogConfigResult',
@@ -936,6 +974,7 @@ __all__ = [
     'GetRouterBgpAdvertisedIpRangeResult',
     'GetRouterMd5AuthenticationKeyResult',
     'GetRouterNatLogConfigResult',
+    'GetRouterNatNat64SubnetworkResult',
     'GetRouterNatRuleResult',
     'GetRouterNatRuleActionResult',
     'GetRouterNatSubnetworkResult',
@@ -3347,6 +3386,63 @@ class BackendServiceCustomMetric(dict):
         return pulumi.get(self, "name")
 
 
+@pulumi.output_type
+class BackendServiceDynamicForwarding(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ipPortSelection":
+            suggest = "ip_port_selection"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackendServiceDynamicForwarding. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackendServiceDynamicForwarding.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackendServiceDynamicForwarding.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ip_port_selection: Optional['outputs.BackendServiceDynamicForwardingIpPortSelection'] = None):
+        """
+        :param 'BackendServiceDynamicForwardingIpPortSelectionArgs' ip_port_selection: IP:PORT based dynamic forwarding configuration.
+               Structure is documented below.
+        """
+        if ip_port_selection is not None:
+            pulumi.set(__self__, "ip_port_selection", ip_port_selection)
+
+    @property
+    @pulumi.getter(name="ipPortSelection")
+    def ip_port_selection(self) -> Optional['outputs.BackendServiceDynamicForwardingIpPortSelection']:
+        """
+        IP:PORT based dynamic forwarding configuration.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ip_port_selection")
+
+
+@pulumi.output_type
+class BackendServiceDynamicForwardingIpPortSelection(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[builtins.bool] = None):
+        """
+        :param builtins.bool enabled: A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[builtins.bool]:
+        """
+        A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class BackendServiceIamBindingCondition(dict):
     def __init__(__self__, *,
@@ -3703,6 +3799,7 @@ class BackendServiceLogConfig(dict):
         :param Sequence[builtins.str] optional_fields: This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
                was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
                For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+               For example: orca_load_report, tls.protocol
         :param builtins.str optional_mode: Specifies the optional logging mode for the load balancer traffic.
                Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
                Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
@@ -3735,6 +3832,7 @@ class BackendServiceLogConfig(dict):
         This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
         was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
         For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        For example: orca_load_report, tls.protocol
         """
         return pulumi.get(self, "optional_fields")
 
@@ -3794,6 +3892,104 @@ class BackendServiceMaxStreamDuration(dict):
         return pulumi.get(self, "nanos")
 
 
+@pulumi.output_type
+class BackendServiceNetworkPassThroughLbTrafficPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "zonalAffinity":
+            suggest = "zonal_affinity"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackendServiceNetworkPassThroughLbTrafficPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackendServiceNetworkPassThroughLbTrafficPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackendServiceNetworkPassThroughLbTrafficPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 zonal_affinity: Optional['outputs.BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity'] = None):
+        """
+        :param 'BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityArgs' zonal_affinity: When configured, new connections are load balanced across healthy backend endpoints in the local zone.
+               Structure is documented below.
+        """
+        if zonal_affinity is not None:
+            pulumi.set(__self__, "zonal_affinity", zonal_affinity)
+
+    @property
+    @pulumi.getter(name="zonalAffinity")
+    def zonal_affinity(self) -> Optional['outputs.BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity']:
+        """
+        When configured, new connections are load balanced across healthy backend endpoints in the local zone.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "zonal_affinity")
+
+
+@pulumi.output_type
+class BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "spilloverRatio":
+            suggest = "spillover_ratio"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinity.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 spillover: Optional[builtins.str] = None,
+                 spillover_ratio: Optional[builtins.float] = None):
+        """
+        :param builtins.str spillover: This field indicates whether zonal affinity is enabled or not.
+               Default value is `ZONAL_AFFINITY_DISABLED`.
+               Possible values are: `ZONAL_AFFINITY_DISABLED`, `ZONAL_AFFINITY_SPILL_CROSS_ZONE`, `ZONAL_AFFINITY_STAY_WITHIN_ZONE`.
+        :param builtins.float spillover_ratio: The value of the field must be in [0, 1]. When the ratio of the count of healthy backend endpoints in a zone
+               to the count of backend endpoints in that same zone is equal to or above this threshold, the load balancer
+               distributes new connections to all healthy endpoints in the local zone only. When the ratio of the count
+               of healthy backend endpoints in a zone to the count of backend endpoints in that same zone is below this
+               threshold, the load balancer distributes all new connections to all healthy endpoints across all zones.
+        """
+        if spillover is not None:
+            pulumi.set(__self__, "spillover", spillover)
+        if spillover_ratio is not None:
+            pulumi.set(__self__, "spillover_ratio", spillover_ratio)
+
+    @property
+    @pulumi.getter
+    def spillover(self) -> Optional[builtins.str]:
+        """
+        This field indicates whether zonal affinity is enabled or not.
+        Default value is `ZONAL_AFFINITY_DISABLED`.
+        Possible values are: `ZONAL_AFFINITY_DISABLED`, `ZONAL_AFFINITY_SPILL_CROSS_ZONE`, `ZONAL_AFFINITY_STAY_WITHIN_ZONE`.
+        """
+        return pulumi.get(self, "spillover")
+
+    @property
+    @pulumi.getter(name="spilloverRatio")
+    def spillover_ratio(self) -> Optional[builtins.float]:
+        """
+        The value of the field must be in [0, 1]. When the ratio of the count of healthy backend endpoints in a zone
+        to the count of backend endpoints in that same zone is equal to or above this threshold, the load balancer
+        distributes new connections to all healthy endpoints in the local zone only. When the ratio of the count
+        of healthy backend endpoints in a zone to the count of backend endpoints in that same zone is below this
+        threshold, the load balancer distributes all new connections to all healthy endpoints across all zones.
+        """
+        return pulumi.get(self, "spillover_ratio")
+
+
 @pulumi.output_type
 class BackendServiceOutlierDetection(dict):
     @staticmethod
@@ -6272,237 +6468,1735 @@ class FirewallPolicyWithRulesRuleMatch(dict):
         if src_threat_intelligences is not None:
             pulumi.set(__self__, "src_threat_intelligences", src_threat_intelligences)
 
-    @property
-    @pulumi.getter(name="layer4Configs")
-    def layer4_configs(self) -> Sequence['outputs.FirewallPolicyWithRulesRuleMatchLayer4Config']:
-        """
-        Pairs of IP protocols and ports that the rule should match.
-        Structure is documented below.
+    @property
+    @pulumi.getter(name="layer4Configs")
+    def layer4_configs(self) -> Sequence['outputs.FirewallPolicyWithRulesRuleMatchLayer4Config']:
+        """
+        Pairs of IP protocols and ports that the rule should match.
+        Structure is documented below.
+
+
+        <a name="nested_rule_rule_match_layer4_config"></a>The `layer4_config` block supports:
+        """
+        return pulumi.get(self, "layer4_configs")
+
+    @property
+    @pulumi.getter(name="destAddressGroups")
+    def dest_address_groups(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="destFqdns")
+    def dest_fqdns(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="destIpRanges")
+    def dest_ip_ranges(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Destination IP address range in CIDR format. Required for
+        EGRESS rules.
+        """
+        return pulumi.get(self, "dest_ip_ranges")
+
+    @property
+    @pulumi.getter(name="destNetworkScope")
+    def dest_network_scope(self) -> Optional[builtins.str]:
+        """
+        Network scope of the traffic destination.
+        Possible values are: `INTERNET`, `INTRA_VPC`, `NON_INTERNET`, `VPC_NETWORKS`.
+        """
+        return pulumi.get(self, "dest_network_scope")
+
+    @property
+    @pulumi.getter(name="destRegionCodes")
+    def dest_region_codes(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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 destination region codes allowed is 5000.
+        """
+        return pulumi.get(self, "dest_region_codes")
+
+    @property
+    @pulumi.getter(name="destThreatIntelligences")
+    def dest_threat_intelligences(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Names of Network Threat Intelligence lists.
+        The IPs in these lists will be matched against traffic destination.
+        """
+        return pulumi.get(self, "dest_threat_intelligences")
+
+    @property
+    @pulumi.getter(name="srcAddressGroups")
+    def src_address_groups(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="srcFqdns")
+    def src_fqdns(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="srcIpRanges")
+    def src_ip_ranges(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Source IP address range in CIDR format. Required for
+        INGRESS rules.
+        """
+        return pulumi.get(self, "src_ip_ranges")
+
+    @property
+    @pulumi.getter(name="srcNetworkScope")
+    def src_network_scope(self) -> Optional[builtins.str]:
+        """
+        Network scope of the traffic source.
+        Possible values are: `INTERNET`, `INTRA_VPC`, `NON_INTERNET`, `VPC_NETWORKS`.
+        """
+        return pulumi.get(self, "src_network_scope")
+
+    @property
+    @pulumi.getter(name="srcNetworks")
+    def src_networks(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Networks of the traffic source. It can be either a full or partial url.
+        """
+        return pulumi.get(self, "src_networks")
+
+    @property
+    @pulumi.getter(name="srcRegionCodes")
+    def src_region_codes(self) -> Optional[Sequence[builtins.str]]:
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="srcThreatIntelligences")
+    def src_threat_intelligences(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Names of Network Threat Intelligence lists.
+        The IPs in these lists will be matched against traffic source.
+        """
+        return pulumi.get(self, "src_threat_intelligences")
+
+
+@pulumi.output_type
+class FirewallPolicyWithRulesRuleMatchLayer4Config(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ipProtocol":
+            suggest = "ip_protocol"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FirewallPolicyWithRulesRuleMatchLayer4Config. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FirewallPolicyWithRulesRuleMatchLayer4Config.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FirewallPolicyWithRulesRuleMatchLayer4Config.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ip_protocol: builtins.str,
+                 ports: Optional[Sequence[builtins.str]] = None):
+        """
+        :param builtins.str ip_protocol: (Output)
+               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[builtins.str] ports: (Output)
+               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:
+            pulumi.set(__self__, "ports", ports)
+
+    @property
+    @pulumi.getter(name="ipProtocol")
+    def ip_protocol(self) -> builtins.str:
+        """
+        (Output)
+        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")
+
+    @property
+    @pulumi.getter
+    def ports(self) -> Optional[Sequence[builtins.str]]:
+        """
+        (Output)
+        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")
+
+
+@pulumi.output_type
+class ForwardingRuleServiceDirectoryRegistrations(dict):
+    def __init__(__self__, *,
+                 namespace: Optional[builtins.str] = None,
+                 service: Optional[builtins.str] = None):
+        """
+        :param builtins.str namespace: Service Directory namespace to register the forwarding rule under.
+        :param builtins.str service: Service Directory service to register the forwarding rule under.
+        """
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+        if service is not None:
+            pulumi.set(__self__, "service", service)
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> Optional[builtins.str]:
+        """
+        Service Directory namespace to register the forwarding rule under.
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter
+    def service(self) -> Optional[builtins.str]:
+        """
+        Service Directory service to register the forwarding rule under.
+        """
+        return pulumi.get(self, "service")
+
+
+@pulumi.output_type
+class FutureReservationAutoCreatedReservationsDuration(dict):
+    def __init__(__self__, *,
+                 nanos: Optional[builtins.int] = None,
+                 seconds: Optional[builtins.str] = None):
+        """
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
+        :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        """
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+        if seconds is not None:
+            pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[builtins.int]:
+        """
+        Span of time that's a fraction of a second at nanosecond resolution. Durations less than one second are represented with a 0 seconds field and a positive nanos field. Must be from 0 to 999,999,999 inclusive.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> Optional[builtins.str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class FutureReservationCommitmentInfo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "commitmentName":
+            suggest = "commitment_name"
+        elif key == "commitmentPlan":
+            suggest = "commitment_plan"
+        elif key == "previousCommitmentTerms":
+            suggest = "previous_commitment_terms"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationCommitmentInfo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationCommitmentInfo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationCommitmentInfo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 commitment_name: Optional[builtins.str] = None,
+                 commitment_plan: Optional[builtins.str] = None,
+                 previous_commitment_terms: Optional[builtins.str] = None):
+        """
+        :param builtins.str commitment_name: name of the commitment where capacity is being delivered to.
+        :param builtins.str commitment_plan: Indicates if a Commitment needs to be created as part of FR delivery. If this field is not present, then no commitment needs to be created.
+               Possible values are: `INVALID`, `THIRTY_SIX_MONTH`, `TWELVE_MONTH`.
+        :param builtins.str previous_commitment_terms: Only applicable if FR is delivering to the same reservation. If set, all parent commitments will be extended to match the end date of the plan for this commitment.
+               Possible values are: `EXTEND`.
+        """
+        if commitment_name is not None:
+            pulumi.set(__self__, "commitment_name", commitment_name)
+        if commitment_plan is not None:
+            pulumi.set(__self__, "commitment_plan", commitment_plan)
+        if previous_commitment_terms is not None:
+            pulumi.set(__self__, "previous_commitment_terms", previous_commitment_terms)
+
+    @property
+    @pulumi.getter(name="commitmentName")
+    def commitment_name(self) -> Optional[builtins.str]:
+        """
+        name of the commitment where capacity is being delivered to.
+        """
+        return pulumi.get(self, "commitment_name")
+
+    @property
+    @pulumi.getter(name="commitmentPlan")
+    def commitment_plan(self) -> Optional[builtins.str]:
+        """
+        Indicates if a Commitment needs to be created as part of FR delivery. If this field is not present, then no commitment needs to be created.
+        Possible values are: `INVALID`, `THIRTY_SIX_MONTH`, `TWELVE_MONTH`.
+        """
+        return pulumi.get(self, "commitment_plan")
+
+    @property
+    @pulumi.getter(name="previousCommitmentTerms")
+    def previous_commitment_terms(self) -> Optional[builtins.str]:
+        """
+        Only applicable if FR is delivering to the same reservation. If set, all parent commitments will be extended to match the end date of the plan for this commitment.
+        Possible values are: `EXTEND`.
+        """
+        return pulumi.get(self, "previous_commitment_terms")
+
+
+@pulumi.output_type
+class FutureReservationShareSettings(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "projectMaps":
+            suggest = "project_maps"
+        elif key == "shareType":
+            suggest = "share_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationShareSettings. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationShareSettings.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationShareSettings.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 project_maps: Optional[Sequence['outputs.FutureReservationShareSettingsProjectMap']] = None,
+                 projects: Optional[Sequence[builtins.str]] = None,
+                 share_type: Optional[builtins.str] = None):
+        """
+        :param Sequence['FutureReservationShareSettingsProjectMapArgs'] project_maps: A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+               Structure is documented below.
+        :param Sequence[builtins.str] projects: list of Project names to specify consumer projects for this shared-reservation. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        :param builtins.str share_type: Type of sharing for this future reservation.
+               Possible values are: `LOCAL`, `SPECIFIC_PROJECTS`.
+        """
+        if project_maps is not None:
+            pulumi.set(__self__, "project_maps", project_maps)
+        if projects is not None:
+            pulumi.set(__self__, "projects", projects)
+        if share_type is not None:
+            pulumi.set(__self__, "share_type", share_type)
+
+    @property
+    @pulumi.getter(name="projectMaps")
+    def project_maps(self) -> Optional[Sequence['outputs.FutureReservationShareSettingsProjectMap']]:
+        """
+        A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "project_maps")
+
+    @property
+    @pulumi.getter
+    def projects(self) -> Optional[Sequence[builtins.str]]:
+        """
+        list of Project names to specify consumer projects for this shared-reservation. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        """
+        return pulumi.get(self, "projects")
+
+    @property
+    @pulumi.getter(name="shareType")
+    def share_type(self) -> Optional[builtins.str]:
+        """
+        Type of sharing for this future reservation.
+        Possible values are: `LOCAL`, `SPECIFIC_PROJECTS`.
+        """
+        return pulumi.get(self, "share_type")
+
+
+@pulumi.output_type
+class FutureReservationShareSettingsProjectMap(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "projectId":
+            suggest = "project_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationShareSettingsProjectMap. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationShareSettingsProjectMap.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationShareSettingsProjectMap.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 id: builtins.str,
+                 project_id: Optional[builtins.str] = None):
+        """
+        :param builtins.str id: The identifier for this object. Format specified above.
+        :param builtins.str project_id: The project ID, should be same as the key of this project config in the parent map.
+        """
+        pulumi.set(__self__, "id", id)
+        if project_id is not None:
+            pulumi.set(__self__, "project_id", project_id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        The identifier for this object. Format specified above.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> Optional[builtins.str]:
+        """
+        The project ID, should be same as the key of this project config in the parent map.
+        """
+        return pulumi.get(self, "project_id")
+
+
+@pulumi.output_type
+class FutureReservationSpecificSkuProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "instanceProperties":
+            suggest = "instance_properties"
+        elif key == "sourceInstanceTemplate":
+            suggest = "source_instance_template"
+        elif key == "totalCount":
+            suggest = "total_count"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationSpecificSkuProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationSpecificSkuProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationSpecificSkuProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 instance_properties: Optional['outputs.FutureReservationSpecificSkuPropertiesInstanceProperties'] = None,
+                 source_instance_template: Optional[builtins.str] = None,
+                 total_count: Optional[builtins.str] = None):
+        """
+        :param 'FutureReservationSpecificSkuPropertiesInstancePropertiesArgs' instance_properties: Properties of the SKU instances being reserved.
+               Structure is documented below.
+        :param builtins.str source_instance_template: The instance template that will be used to populate the ReservedInstanceProperties of the future reservation
+        :param builtins.str total_count: Total number of instances for which capacity assurance is requested at a future time period.
+        """
+        if instance_properties is not None:
+            pulumi.set(__self__, "instance_properties", instance_properties)
+        if source_instance_template is not None:
+            pulumi.set(__self__, "source_instance_template", source_instance_template)
+        if total_count is not None:
+            pulumi.set(__self__, "total_count", total_count)
+
+    @property
+    @pulumi.getter(name="instanceProperties")
+    def instance_properties(self) -> Optional['outputs.FutureReservationSpecificSkuPropertiesInstanceProperties']:
+        """
+        Properties of the SKU instances being reserved.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "instance_properties")
+
+    @property
+    @pulumi.getter(name="sourceInstanceTemplate")
+    def source_instance_template(self) -> Optional[builtins.str]:
+        """
+        The instance template that will be used to populate the ReservedInstanceProperties of the future reservation
+        """
+        return pulumi.get(self, "source_instance_template")
+
+    @property
+    @pulumi.getter(name="totalCount")
+    def total_count(self) -> Optional[builtins.str]:
+        """
+        Total number of instances for which capacity assurance is requested at a future time period.
+        """
+        return pulumi.get(self, "total_count")
+
+
+@pulumi.output_type
+class FutureReservationSpecificSkuPropertiesInstanceProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "guestAccelerators":
+            suggest = "guest_accelerators"
+        elif key == "localSsds":
+            suggest = "local_ssds"
+        elif key == "locationHint":
+            suggest = "location_hint"
+        elif key == "machineType":
+            suggest = "machine_type"
+        elif key == "maintenanceFreezeDurationHours":
+            suggest = "maintenance_freeze_duration_hours"
+        elif key == "maintenanceInterval":
+            suggest = "maintenance_interval"
+        elif key == "minCpuPlatform":
+            suggest = "min_cpu_platform"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationSpecificSkuPropertiesInstanceProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationSpecificSkuPropertiesInstanceProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationSpecificSkuPropertiesInstanceProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 guest_accelerators: Optional[Sequence['outputs.FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator']] = None,
+                 local_ssds: Optional[Sequence['outputs.FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd']] = None,
+                 location_hint: Optional[builtins.str] = None,
+                 machine_type: Optional[builtins.str] = None,
+                 maintenance_freeze_duration_hours: Optional[builtins.int] = None,
+                 maintenance_interval: Optional[builtins.str] = None,
+                 min_cpu_platform: Optional[builtins.str] = None):
+        """
+        :param Sequence['FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAcceleratorArgs'] guest_accelerators: Specifies accelerator type and count.
+               Structure is documented below.
+        :param Sequence['FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsdArgs'] local_ssds: Specifies amount of local ssd to reserve with each instance. The type of disk is local-ssd.
+               Structure is documented below.
+        :param builtins.str location_hint: An opaque location hint used to place the allocation close to other resources. This field is for use by internal tools that use the public API.
+        :param builtins.str machine_type: Specifies type of machine (name only) which has fixed number of vCPUs and fixed amount of memory. This also includes specifying custom machine type following custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY pattern.
+        :param builtins.int maintenance_freeze_duration_hours: Specifies the number of hours after reservation creation where instances using the reservation won't be scheduled for maintenance.
+        :param builtins.str maintenance_interval: Specifies the frequency of planned maintenance events. The accepted values are: PERIODIC
+               Possible values are: `PERIODIC`.
+        :param builtins.str min_cpu_platform: Minimum cpu platform the reservation.
+        """
+        if guest_accelerators is not None:
+            pulumi.set(__self__, "guest_accelerators", guest_accelerators)
+        if local_ssds is not None:
+            pulumi.set(__self__, "local_ssds", local_ssds)
+        if location_hint is not None:
+            pulumi.set(__self__, "location_hint", location_hint)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+        if maintenance_freeze_duration_hours is not None:
+            pulumi.set(__self__, "maintenance_freeze_duration_hours", maintenance_freeze_duration_hours)
+        if maintenance_interval is not None:
+            pulumi.set(__self__, "maintenance_interval", maintenance_interval)
+        if min_cpu_platform is not None:
+            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
+
+    @property
+    @pulumi.getter(name="guestAccelerators")
+    def guest_accelerators(self) -> Optional[Sequence['outputs.FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator']]:
+        """
+        Specifies accelerator type and count.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "guest_accelerators")
+
+    @property
+    @pulumi.getter(name="localSsds")
+    def local_ssds(self) -> Optional[Sequence['outputs.FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd']]:
+        """
+        Specifies amount of local ssd to reserve with each instance. The type of disk is local-ssd.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "local_ssds")
+
+    @property
+    @pulumi.getter(name="locationHint")
+    def location_hint(self) -> Optional[builtins.str]:
+        """
+        An opaque location hint used to place the allocation close to other resources. This field is for use by internal tools that use the public API.
+        """
+        return pulumi.get(self, "location_hint")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[builtins.str]:
+        """
+        Specifies type of machine (name only) which has fixed number of vCPUs and fixed amount of memory. This also includes specifying custom machine type following custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY pattern.
+        """
+        return pulumi.get(self, "machine_type")
+
+    @property
+    @pulumi.getter(name="maintenanceFreezeDurationHours")
+    def maintenance_freeze_duration_hours(self) -> Optional[builtins.int]:
+        """
+        Specifies the number of hours after reservation creation where instances using the reservation won't be scheduled for maintenance.
+        """
+        return pulumi.get(self, "maintenance_freeze_duration_hours")
+
+    @property
+    @pulumi.getter(name="maintenanceInterval")
+    def maintenance_interval(self) -> Optional[builtins.str]:
+        """
+        Specifies the frequency of planned maintenance events. The accepted values are: PERIODIC
+        Possible values are: `PERIODIC`.
+        """
+        return pulumi.get(self, "maintenance_interval")
+
+    @property
+    @pulumi.getter(name="minCpuPlatform")
+    def min_cpu_platform(self) -> Optional[builtins.str]:
+        """
+        Minimum cpu platform the reservation.
+        """
+        return pulumi.get(self, "min_cpu_platform")
+
+
+@pulumi.output_type
+class FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "acceleratorCount":
+            suggest = "accelerator_count"
+        elif key == "acceleratorType":
+            suggest = "accelerator_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationSpecificSkuPropertiesInstancePropertiesGuestAccelerator.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 accelerator_count: Optional[builtins.int] = None,
+                 accelerator_type: Optional[builtins.str] = None):
+        """
+        :param builtins.int accelerator_count: The number of the guest accelerator cards exposed to this instance.
+        :param builtins.str accelerator_type: Full or partial URL of the accelerator type resource to attach to this instance.
+        """
+        if accelerator_count is not None:
+            pulumi.set(__self__, "accelerator_count", accelerator_count)
+        if accelerator_type is not None:
+            pulumi.set(__self__, "accelerator_type", accelerator_type)
+
+    @property
+    @pulumi.getter(name="acceleratorCount")
+    def accelerator_count(self) -> Optional[builtins.int]:
+        """
+        The number of the guest accelerator cards exposed to this instance.
+        """
+        return pulumi.get(self, "accelerator_count")
+
+    @property
+    @pulumi.getter(name="acceleratorType")
+    def accelerator_type(self) -> Optional[builtins.str]:
+        """
+        Full or partial URL of the accelerator type resource to attach to this instance.
+        """
+        return pulumi.get(self, "accelerator_type")
+
+
+@pulumi.output_type
+class FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskSizeGb":
+            suggest = "disk_size_gb"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationSpecificSkuPropertiesInstancePropertiesLocalSsd.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_size_gb: Optional[builtins.str] = None,
+                 interface: Optional[builtins.str] = None):
+        """
+        :param builtins.str disk_size_gb: Specifies the size of the disk in base-2 GB.
+        :param builtins.str interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI.
+               Possible values are: `SCSI`, `NVME`.
+        """
+        if disk_size_gb is not None:
+            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
+        if interface is not None:
+            pulumi.set(__self__, "interface", interface)
+
+    @property
+    @pulumi.getter(name="diskSizeGb")
+    def disk_size_gb(self) -> Optional[builtins.str]:
+        """
+        Specifies the size of the disk in base-2 GB.
+        """
+        return pulumi.get(self, "disk_size_gb")
+
+    @property
+    @pulumi.getter
+    def interface(self) -> Optional[builtins.str]:
+        """
+        Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI.
+        Possible values are: `SCSI`, `NVME`.
+        """
+        return pulumi.get(self, "interface")
+
+
+@pulumi.output_type
+class FutureReservationStatus(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "amendmentStatus":
+            suggest = "amendment_status"
+        elif key == "autoCreatedReservations":
+            suggest = "auto_created_reservations"
+        elif key == "fulfilledCount":
+            suggest = "fulfilled_count"
+        elif key == "lastKnownGoodState":
+            suggest = "last_known_good_state"
+        elif key == "lockTime":
+            suggest = "lock_time"
+        elif key == "procurementStatus":
+            suggest = "procurement_status"
+        elif key == "specificSkuProperties":
+            suggest = "specific_sku_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 amendment_status: Optional[builtins.str] = None,
+                 auto_created_reservations: Optional[Sequence[builtins.str]] = None,
+                 fulfilled_count: Optional[builtins.str] = None,
+                 last_known_good_state: Optional['outputs.FutureReservationStatusLastKnownGoodState'] = None,
+                 lock_time: Optional[builtins.str] = None,
+                 procurement_status: Optional[builtins.str] = None,
+                 specific_sku_properties: Optional['outputs.FutureReservationStatusSpecificSkuProperties'] = None):
+        """
+        :param builtins.str amendment_status: The current status of the requested amendment.
+               Possible values are: .
+        :param Sequence[builtins.str] auto_created_reservations: Fully qualified urls of the automatically created reservations at startTime.
+        :param builtins.str fulfilled_count: This count indicates the fulfilled capacity so far. This is set during "PROVISIONING" state. This count also includes capacity delivered as part of existing matching reservations.
+        :param 'FutureReservationStatusLastKnownGoodStateArgs' last_known_good_state: This field represents the future reservation before an amendment was requested. If the amendment is declined, the Future Reservation will be reverted to the last known good state. The last known good state is not set when updating a future reservation whose Procurement Status is DRAFTING.
+               Structure is documented below.
+        :param builtins.str lock_time: The lock time of the FutureReservation before an amendment was requested.
+        :param builtins.str procurement_status: The status of the last known good state for the Future Reservation
+               Possible values are: .
+        :param 'FutureReservationStatusSpecificSkuPropertiesArgs' specific_sku_properties: The previous instance related properties of the Future Reservation.
+               Structure is documented below.
+        """
+        if amendment_status is not None:
+            pulumi.set(__self__, "amendment_status", amendment_status)
+        if auto_created_reservations is not None:
+            pulumi.set(__self__, "auto_created_reservations", auto_created_reservations)
+        if fulfilled_count is not None:
+            pulumi.set(__self__, "fulfilled_count", fulfilled_count)
+        if last_known_good_state is not None:
+            pulumi.set(__self__, "last_known_good_state", last_known_good_state)
+        if lock_time is not None:
+            pulumi.set(__self__, "lock_time", lock_time)
+        if procurement_status is not None:
+            pulumi.set(__self__, "procurement_status", procurement_status)
+        if specific_sku_properties is not None:
+            pulumi.set(__self__, "specific_sku_properties", specific_sku_properties)
+
+    @property
+    @pulumi.getter(name="amendmentStatus")
+    def amendment_status(self) -> Optional[builtins.str]:
+        """
+        The current status of the requested amendment.
+        Possible values are: .
+        """
+        return pulumi.get(self, "amendment_status")
+
+    @property
+    @pulumi.getter(name="autoCreatedReservations")
+    def auto_created_reservations(self) -> Optional[Sequence[builtins.str]]:
+        """
+        Fully qualified urls of the automatically created reservations at startTime.
+        """
+        return pulumi.get(self, "auto_created_reservations")
+
+    @property
+    @pulumi.getter(name="fulfilledCount")
+    def fulfilled_count(self) -> Optional[builtins.str]:
+        """
+        This count indicates the fulfilled capacity so far. This is set during "PROVISIONING" state. This count also includes capacity delivered as part of existing matching reservations.
+        """
+        return pulumi.get(self, "fulfilled_count")
+
+    @property
+    @pulumi.getter(name="lastKnownGoodState")
+    def last_known_good_state(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodState']:
+        """
+        This field represents the future reservation before an amendment was requested. If the amendment is declined, the Future Reservation will be reverted to the last known good state. The last known good state is not set when updating a future reservation whose Procurement Status is DRAFTING.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "last_known_good_state")
+
+    @property
+    @pulumi.getter(name="lockTime")
+    def lock_time(self) -> Optional[builtins.str]:
+        """
+        The lock time of the FutureReservation before an amendment was requested.
+        """
+        return pulumi.get(self, "lock_time")
+
+    @property
+    @pulumi.getter(name="procurementStatus")
+    def procurement_status(self) -> Optional[builtins.str]:
+        """
+        The status of the last known good state for the Future Reservation
+        Possible values are: .
+        """
+        return pulumi.get(self, "procurement_status")
+
+    @property
+    @pulumi.getter(name="specificSkuProperties")
+    def specific_sku_properties(self) -> Optional['outputs.FutureReservationStatusSpecificSkuProperties']:
+        """
+        The previous instance related properties of the Future Reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "specific_sku_properties")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodState(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "existingMatchingUsageInfo":
+            suggest = "existing_matching_usage_info"
+        elif key == "futureReservationSpecs":
+            suggest = "future_reservation_specs"
+        elif key == "lockTime":
+            suggest = "lock_time"
+        elif key == "namePrefix":
+            suggest = "name_prefix"
+        elif key == "procurementStatus":
+            suggest = "procurement_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodState. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodState.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodState.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 description: Optional[builtins.str] = None,
+                 existing_matching_usage_info: Optional['outputs.FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo'] = None,
+                 future_reservation_specs: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecs'] = None,
+                 lock_time: Optional[builtins.str] = None,
+                 name_prefix: Optional[builtins.str] = None,
+                 procurement_status: Optional[builtins.str] = None):
+        """
+        :param builtins.str description: The description of the FutureReservation before an amendment was requested.
+        :param 'FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfoArgs' existing_matching_usage_info: Represents the matching usage for the future reservation before an amendment was requested.
+               Structure is documented below.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs' future_reservation_specs: The previous instance-related properties of the Future Reservation.
+               Structure is documented below.
+        :param builtins.str lock_time: The lock time of the FutureReservation before an amendment was requested.
+        :param builtins.str name_prefix: The name prefix of the Future Reservation before an amendment was requested.
+        :param builtins.str procurement_status: The status of the last known good state for the Future Reservation
+               Possible values are: .
+        """
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if existing_matching_usage_info is not None:
+            pulumi.set(__self__, "existing_matching_usage_info", existing_matching_usage_info)
+        if future_reservation_specs is not None:
+            pulumi.set(__self__, "future_reservation_specs", future_reservation_specs)
+        if lock_time is not None:
+            pulumi.set(__self__, "lock_time", lock_time)
+        if name_prefix is not None:
+            pulumi.set(__self__, "name_prefix", name_prefix)
+        if procurement_status is not None:
+            pulumi.set(__self__, "procurement_status", procurement_status)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        """
+        The description of the FutureReservation before an amendment was requested.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter(name="existingMatchingUsageInfo")
+    def existing_matching_usage_info(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo']:
+        """
+        Represents the matching usage for the future reservation before an amendment was requested.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "existing_matching_usage_info")
+
+    @property
+    @pulumi.getter(name="futureReservationSpecs")
+    def future_reservation_specs(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecs']:
+        """
+        The previous instance-related properties of the Future Reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "future_reservation_specs")
+
+    @property
+    @pulumi.getter(name="lockTime")
+    def lock_time(self) -> Optional[builtins.str]:
+        """
+        The lock time of the FutureReservation before an amendment was requested.
+        """
+        return pulumi.get(self, "lock_time")
+
+    @property
+    @pulumi.getter(name="namePrefix")
+    def name_prefix(self) -> Optional[builtins.str]:
+        """
+        The name prefix of the Future Reservation before an amendment was requested.
+        """
+        return pulumi.get(self, "name_prefix")
+
+    @property
+    @pulumi.getter(name="procurementStatus")
+    def procurement_status(self) -> Optional[builtins.str]:
+        """
+        The status of the last known good state for the Future Reservation
+        Possible values are: .
+        """
+        return pulumi.get(self, "procurement_status")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "timeStamp":
+            suggest = "time_stamp"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfo.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 count: Optional[builtins.str] = None,
+                 time_stamp: Optional[builtins.str] = None):
+        """
+        :param builtins.str count: Count representing minimum(FR totalCount, matching_reserved_capacity+matching_unreserved_instances).
+        :param builtins.str time_stamp: Timestamp when the matching usage was calculated.
+        """
+        if count is not None:
+            pulumi.set(__self__, "count", count)
+        if time_stamp is not None:
+            pulumi.set(__self__, "time_stamp", time_stamp)
+
+    @property
+    @pulumi.getter
+    def count(self) -> Optional[builtins.str]:
+        """
+        Count representing minimum(FR totalCount, matching_reserved_capacity+matching_unreserved_instances).
+        """
+        return pulumi.get(self, "count")
+
+    @property
+    @pulumi.getter(name="timeStamp")
+    def time_stamp(self) -> Optional[builtins.str]:
+        """
+        Timestamp when the matching usage was calculated.
+        """
+        return pulumi.get(self, "time_stamp")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecs(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "shareSettings":
+            suggest = "share_settings"
+        elif key == "specificSkuProperties":
+            suggest = "specific_sku_properties"
+        elif key == "timeWindow":
+            suggest = "time_window"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecs. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecs.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecs.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 share_settings: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings'] = None,
+                 specific_sku_properties: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties'] = None,
+                 time_window: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow'] = None):
+        """
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs' share_settings: The previous share settings of the Future Reservation.
+               Structure is documented below.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs' specific_sku_properties: The previous instance related properties of the Future Reservation.
+               Structure is documented below.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowArgs' time_window: Time window for this Future Reservation.
+               Structure is documented below.
+        """
+        if share_settings is not None:
+            pulumi.set(__self__, "share_settings", share_settings)
+        if specific_sku_properties is not None:
+            pulumi.set(__self__, "specific_sku_properties", specific_sku_properties)
+        if time_window is not None:
+            pulumi.set(__self__, "time_window", time_window)
+
+    @property
+    @pulumi.getter(name="shareSettings")
+    def share_settings(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings']:
+        """
+        The previous share settings of the Future Reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "share_settings")
+
+    @property
+    @pulumi.getter(name="specificSkuProperties")
+    def specific_sku_properties(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties']:
+        """
+        The previous instance related properties of the Future Reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "specific_sku_properties")
+
+    @property
+    @pulumi.getter(name="timeWindow")
+    def time_window(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow']:
+        """
+        Time window for this Future Reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "time_window")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "projectMaps":
+            suggest = "project_maps"
+        elif key == "shareType":
+            suggest = "share_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 project_maps: Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap']] = None,
+                 projects: Optional[Sequence[builtins.str]] = None,
+                 share_type: Optional[builtins.str] = None):
+        """
+        :param Sequence['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMapArgs'] project_maps: A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+               Structure is documented below.
+        :param Sequence[builtins.str] projects: list of Project names to specify consumer projects for this shared-reservation. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        :param builtins.str share_type: Type of sharing for this future reservation.
+               Possible values are: `LOCAL`, `SPECIFIC_PROJECTS`.
+        """
+        if project_maps is not None:
+            pulumi.set(__self__, "project_maps", project_maps)
+        if projects is not None:
+            pulumi.set(__self__, "projects", projects)
+        if share_type is not None:
+            pulumi.set(__self__, "share_type", share_type)
+
+    @property
+    @pulumi.getter(name="projectMaps")
+    def project_maps(self) -> Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap']]:
+        """
+        A map of project id and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "project_maps")
+
+    @property
+    @pulumi.getter
+    def projects(self) -> Optional[Sequence[builtins.str]]:
+        """
+        list of Project names to specify consumer projects for this shared-reservation. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        """
+        return pulumi.get(self, "projects")
+
+    @property
+    @pulumi.getter(name="shareType")
+    def share_type(self) -> Optional[builtins.str]:
+        """
+        Type of sharing for this future reservation.
+        Possible values are: `LOCAL`, `SPECIFIC_PROJECTS`.
+        """
+        return pulumi.get(self, "share_type")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "projectId":
+            suggest = "project_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMap.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 project: builtins.str,
+                 project_id: Optional[builtins.str] = None):
+        """
+        :param builtins.str project: (Required) The identifier for this object. Format specified above.
+        :param builtins.str project_id: The project ID, should be same as the key of this project config in the parent map.
+        """
+        pulumi.set(__self__, "project", project)
+        if project_id is not None:
+            pulumi.set(__self__, "project_id", project_id)
+
+    @property
+    @pulumi.getter
+    def project(self) -> builtins.str:
+        """
+        (Required) The identifier for this object. Format specified above.
+        """
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter(name="projectId")
+    def project_id(self) -> Optional[builtins.str]:
+        """
+        The project ID, should be same as the key of this project config in the parent map.
+        """
+        return pulumi.get(self, "project_id")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "instanceProperties":
+            suggest = "instance_properties"
+        elif key == "sourceInstanceTemplate":
+            suggest = "source_instance_template"
+        elif key == "totalCount":
+            suggest = "total_count"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 instance_properties: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties'] = None,
+                 source_instance_template: Optional[builtins.str] = None,
+                 total_count: Optional[builtins.str] = None):
+        """
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesArgs' instance_properties: Properties of the SKU instances being reserved.
+               Structure is documented below.
+        :param builtins.str source_instance_template: The instance template that will be used to populate the ReservedInstanceProperties of the future reservation
+        :param builtins.str total_count: Total number of instances for which capacity assurance is requested at a future time period.
+        """
+        if instance_properties is not None:
+            pulumi.set(__self__, "instance_properties", instance_properties)
+        if source_instance_template is not None:
+            pulumi.set(__self__, "source_instance_template", source_instance_template)
+        if total_count is not None:
+            pulumi.set(__self__, "total_count", total_count)
+
+    @property
+    @pulumi.getter(name="instanceProperties")
+    def instance_properties(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties']:
+        """
+        Properties of the SKU instances being reserved.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "instance_properties")
+
+    @property
+    @pulumi.getter(name="sourceInstanceTemplate")
+    def source_instance_template(self) -> Optional[builtins.str]:
+        """
+        The instance template that will be used to populate the ReservedInstanceProperties of the future reservation
+        """
+        return pulumi.get(self, "source_instance_template")
+
+    @property
+    @pulumi.getter(name="totalCount")
+    def total_count(self) -> Optional[builtins.str]:
+        """
+        Total number of instances for which capacity assurance is requested at a future time period.
+        """
+        return pulumi.get(self, "total_count")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "guestAccelerators":
+            suggest = "guest_accelerators"
+        elif key == "localSsds":
+            suggest = "local_ssds"
+        elif key == "locationHint":
+            suggest = "location_hint"
+        elif key == "machineType":
+            suggest = "machine_type"
+        elif key == "maintenanceFreezeDurationHours":
+            suggest = "maintenance_freeze_duration_hours"
+        elif key == "maintenanceInterval":
+            suggest = "maintenance_interval"
+        elif key == "minCpuPlatform":
+            suggest = "min_cpu_platform"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstanceProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 guest_accelerators: Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator']] = None,
+                 local_ssds: Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd']] = None,
+                 location_hint: Optional[builtins.str] = None,
+                 machine_type: Optional[builtins.str] = None,
+                 maintenance_freeze_duration_hours: Optional[builtins.int] = None,
+                 maintenance_interval: Optional[builtins.str] = None,
+                 min_cpu_platform: Optional[builtins.str] = None):
+        """
+        :param Sequence['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAcceleratorArgs'] guest_accelerators: Specifies accelerator type and count.
+               Structure is documented below.
+        :param Sequence['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsdArgs'] local_ssds: Specifies amount of local ssd to reserve with each instance. The type of disk is local-ssd.
+               Structure is documented below.
+        :param builtins.str location_hint: An opaque location hint used to place the allocation close to other resources. This field is for use by internal tools that use the public API.
+        :param builtins.str machine_type: Specifies type of machine (name only) which has fixed number of vCPUs and fixed amount of memory. This also includes specifying custom machine type following custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY pattern.
+        :param builtins.int maintenance_freeze_duration_hours: Specifies the number of hours after reservation creation where instances using the reservation won't be scheduled for maintenance.
+        :param builtins.str maintenance_interval: Specifies the frequency of planned maintenance events. The accepted values are: PERIODIC
+               Possible values are: `PERIODIC`.
+        :param builtins.str min_cpu_platform: Minimum cpu platform the reservation.
+        """
+        if guest_accelerators is not None:
+            pulumi.set(__self__, "guest_accelerators", guest_accelerators)
+        if local_ssds is not None:
+            pulumi.set(__self__, "local_ssds", local_ssds)
+        if location_hint is not None:
+            pulumi.set(__self__, "location_hint", location_hint)
+        if machine_type is not None:
+            pulumi.set(__self__, "machine_type", machine_type)
+        if maintenance_freeze_duration_hours is not None:
+            pulumi.set(__self__, "maintenance_freeze_duration_hours", maintenance_freeze_duration_hours)
+        if maintenance_interval is not None:
+            pulumi.set(__self__, "maintenance_interval", maintenance_interval)
+        if min_cpu_platform is not None:
+            pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
+
+    @property
+    @pulumi.getter(name="guestAccelerators")
+    def guest_accelerators(self) -> Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator']]:
+        """
+        Specifies accelerator type and count.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "guest_accelerators")
+
+    @property
+    @pulumi.getter(name="localSsds")
+    def local_ssds(self) -> Optional[Sequence['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd']]:
+        """
+        Specifies amount of local ssd to reserve with each instance. The type of disk is local-ssd.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "local_ssds")
+
+    @property
+    @pulumi.getter(name="locationHint")
+    def location_hint(self) -> Optional[builtins.str]:
+        """
+        An opaque location hint used to place the allocation close to other resources. This field is for use by internal tools that use the public API.
+        """
+        return pulumi.get(self, "location_hint")
+
+    @property
+    @pulumi.getter(name="machineType")
+    def machine_type(self) -> Optional[builtins.str]:
+        """
+        Specifies type of machine (name only) which has fixed number of vCPUs and fixed amount of memory. This also includes specifying custom machine type following custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY pattern.
+        """
+        return pulumi.get(self, "machine_type")
+
+    @property
+    @pulumi.getter(name="maintenanceFreezeDurationHours")
+    def maintenance_freeze_duration_hours(self) -> Optional[builtins.int]:
+        """
+        Specifies the number of hours after reservation creation where instances using the reservation won't be scheduled for maintenance.
+        """
+        return pulumi.get(self, "maintenance_freeze_duration_hours")
+
+    @property
+    @pulumi.getter(name="maintenanceInterval")
+    def maintenance_interval(self) -> Optional[builtins.str]:
+        """
+        Specifies the frequency of planned maintenance events. The accepted values are: PERIODIC
+        Possible values are: `PERIODIC`.
+        """
+        return pulumi.get(self, "maintenance_interval")
+
+    @property
+    @pulumi.getter(name="minCpuPlatform")
+    def min_cpu_platform(self) -> Optional[builtins.str]:
+        """
+        Minimum cpu platform the reservation.
+        """
+        return pulumi.get(self, "min_cpu_platform")
+
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "acceleratorCount":
+            suggest = "accelerator_count"
+        elif key == "acceleratorType":
+            suggest = "accelerator_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator.__key_warning(key)
+        return super().__getitem__(key)
 
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesGuestAccelerator.__key_warning(key)
+        return super().get(key, default)
 
-        <a name="nested_rule_rule_match_layer4_config"></a>The `layer4_config` block supports:
+    def __init__(__self__, *,
+                 accelerator_count: Optional[builtins.int] = None,
+                 accelerator_type: Optional[builtins.str] = None):
         """
-        return pulumi.get(self, "layer4_configs")
+        :param builtins.int accelerator_count: The number of the guest accelerator cards exposed to this instance.
+        :param builtins.str accelerator_type: Full or partial URL of the accelerator type resource to attach to this instance.
+        """
+        if accelerator_count is not None:
+            pulumi.set(__self__, "accelerator_count", accelerator_count)
+        if accelerator_type is not None:
+            pulumi.set(__self__, "accelerator_type", accelerator_type)
 
     @property
-    @pulumi.getter(name="destAddressGroups")
-    def dest_address_groups(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="acceleratorCount")
+    def accelerator_count(self) -> Optional[builtins.int]:
         """
-        Address groups which should be matched against the traffic destination.
-        Maximum number of destination address groups is 10.
+        The number of the guest accelerator cards exposed to this instance.
         """
-        return pulumi.get(self, "dest_address_groups")
+        return pulumi.get(self, "accelerator_count")
 
     @property
-    @pulumi.getter(name="destFqdns")
-    def dest_fqdns(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="acceleratorType")
+    def accelerator_type(self) -> Optional[builtins.str]:
         """
-        Fully Qualified Domain Name (FQDN) which should be matched against
-        traffic destination. Maximum number of destination fqdn allowed is 100.
+        Full or partial URL of the accelerator type resource to attach to this instance.
         """
-        return pulumi.get(self, "dest_fqdns")
+        return pulumi.get(self, "accelerator_type")
 
-    @property
-    @pulumi.getter(name="destIpRanges")
-    def dest_ip_ranges(self) -> Optional[Sequence[builtins.str]]:
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskSizeGb":
+            suggest = "disk_size_gb"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesInstancePropertiesLocalSsd.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_size_gb: Optional[builtins.str] = None,
+                 interface: Optional[builtins.str] = None):
         """
-        Destination IP address range in CIDR format. Required for
-        EGRESS rules.
+        :param builtins.str disk_size_gb: Specifies the size of the disk in base-2 GB.
+        :param builtins.str interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI.
+               Possible values are: `SCSI`, `NVME`.
         """
-        return pulumi.get(self, "dest_ip_ranges")
+        if disk_size_gb is not None:
+            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
+        if interface is not None:
+            pulumi.set(__self__, "interface", interface)
 
     @property
-    @pulumi.getter(name="destNetworkScope")
-    def dest_network_scope(self) -> Optional[builtins.str]:
+    @pulumi.getter(name="diskSizeGb")
+    def disk_size_gb(self) -> Optional[builtins.str]:
         """
-        Network scope of the traffic destination.
-        Possible values are: `INTERNET`, `INTRA_VPC`, `NON_INTERNET`, `VPC_NETWORKS`.
+        Specifies the size of the disk in base-2 GB.
         """
-        return pulumi.get(self, "dest_network_scope")
+        return pulumi.get(self, "disk_size_gb")
 
     @property
-    @pulumi.getter(name="destRegionCodes")
-    def dest_region_codes(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter
+    def interface(self) -> Optional[builtins.str]:
         """
-        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 destination region codes allowed is 5000.
+        Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME. The default is SCSI.
+        Possible values are: `SCSI`, `NVME`.
         """
-        return pulumi.get(self, "dest_region_codes")
+        return pulumi.get(self, "interface")
 
-    @property
-    @pulumi.getter(name="destThreatIntelligences")
-    def dest_threat_intelligences(self) -> Optional[Sequence[builtins.str]]:
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "endTime":
+            suggest = "end_time"
+        elif key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 duration: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowDuration'] = None,
+                 end_time: Optional[builtins.str] = None,
+                 start_time: Optional[builtins.str] = None):
         """
-        Names of Network Threat Intelligence lists.
-        The IPs in these lists will be matched against traffic destination.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowDurationArgs' duration: Duration of the future reservation
+               Structure is documented below.
+        :param builtins.str end_time: End time of the future reservation in RFC3339 format.
+        :param builtins.str start_time: Start time of the future reservation in RFC3339 format.
         """
-        return pulumi.get(self, "dest_threat_intelligences")
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
 
     @property
-    @pulumi.getter(name="srcAddressGroups")
-    def src_address_groups(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter
+    def duration(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowDuration']:
         """
-        Address groups which should be matched against the traffic source.
-        Maximum number of source address groups is 10.
+        Duration of the future reservation
+        Structure is documented below.
         """
-        return pulumi.get(self, "src_address_groups")
+        return pulumi.get(self, "duration")
 
     @property
-    @pulumi.getter(name="srcFqdns")
-    def src_fqdns(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[builtins.str]:
         """
-        Fully Qualified Domain Name (FQDN) which should be matched against
-        traffic source. Maximum number of source fqdn allowed is 100.
+        End time of the future reservation in RFC3339 format.
         """
-        return pulumi.get(self, "src_fqdns")
+        return pulumi.get(self, "end_time")
 
     @property
-    @pulumi.getter(name="srcIpRanges")
-    def src_ip_ranges(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[builtins.str]:
         """
-        Source IP address range in CIDR format. Required for
-        INGRESS rules.
+        Start time of the future reservation in RFC3339 format.
         """
-        return pulumi.get(self, "src_ip_ranges")
+        return pulumi.get(self, "start_time")
 
-    @property
-    @pulumi.getter(name="srcNetworkScope")
-    def src_network_scope(self) -> Optional[builtins.str]:
+
+@pulumi.output_type
+class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowDuration(dict):
+    def __init__(__self__, *,
+                 nanos: Optional[builtins.int] = None,
+                 seconds: Optional[builtins.str] = None):
         """
-        Network scope of the traffic source.
-        Possible values are: `INTERNET`, `INTRA_VPC`, `NON_INTERNET`, `VPC_NETWORKS`.
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
+               
+               - - -
+        :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
-        return pulumi.get(self, "src_network_scope")
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+        if seconds is not None:
+            pulumi.set(__self__, "seconds", seconds)
 
     @property
-    @pulumi.getter(name="srcNetworks")
-    def src_networks(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter
+    def nanos(self) -> Optional[builtins.int]:
         """
-        Networks of the traffic source. It can be either a full or partial url.
+        Span of time that's a fraction of a second at nanosecond resolution.
+
+        - - -
         """
-        return pulumi.get(self, "src_networks")
+        return pulumi.get(self, "nanos")
 
     @property
-    @pulumi.getter(name="srcRegionCodes")
-    def src_region_codes(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter
+    def seconds(self) -> Optional[builtins.str]:
         """
-        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.
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
-        return pulumi.get(self, "src_region_codes")
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class FutureReservationStatusSpecificSkuProperties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceInstanceTemplateId":
+            suggest = "source_instance_template_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationStatusSpecificSkuProperties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationStatusSpecificSkuProperties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationStatusSpecificSkuProperties.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_instance_template_id: Optional[builtins.str] = None):
+        """
+        :param builtins.str source_instance_template_id: ID of the instance template used to populate the Future Reservation properties.
+        """
+        if source_instance_template_id is not None:
+            pulumi.set(__self__, "source_instance_template_id", source_instance_template_id)
 
     @property
-    @pulumi.getter(name="srcThreatIntelligences")
-    def src_threat_intelligences(self) -> Optional[Sequence[builtins.str]]:
+    @pulumi.getter(name="sourceInstanceTemplateId")
+    def source_instance_template_id(self) -> Optional[builtins.str]:
         """
-        Names of Network Threat Intelligence lists.
-        The IPs in these lists will be matched against traffic source.
+        ID of the instance template used to populate the Future Reservation properties.
         """
-        return pulumi.get(self, "src_threat_intelligences")
+        return pulumi.get(self, "source_instance_template_id")
 
 
 @pulumi.output_type
-class FirewallPolicyWithRulesRuleMatchLayer4Config(dict):
+class FutureReservationTimeWindow(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "ipProtocol":
-            suggest = "ip_protocol"
+        if key == "startTime":
+            suggest = "start_time"
+        elif key == "endTime":
+            suggest = "end_time"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in FirewallPolicyWithRulesRuleMatchLayer4Config. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationTimeWindow. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        FirewallPolicyWithRulesRuleMatchLayer4Config.__key_warning(key)
+        FutureReservationTimeWindow.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        FirewallPolicyWithRulesRuleMatchLayer4Config.__key_warning(key)
+        FutureReservationTimeWindow.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 ip_protocol: builtins.str,
-                 ports: Optional[Sequence[builtins.str]] = None):
+                 start_time: builtins.str,
+                 duration: Optional['outputs.FutureReservationTimeWindowDuration'] = None,
+                 end_time: Optional[builtins.str] = None):
         """
-        :param builtins.str ip_protocol: (Output)
-               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[builtins.str] ports: (Output)
-               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"].
+        :param builtins.str start_time: Start time of the future reservation in RFC3339 format.
+        :param 'FutureReservationTimeWindowDurationArgs' duration: Duration of the future reservation
+               Structure is documented below.
+        :param builtins.str end_time: End time of the future reservation in RFC3339 format.
         """
-        pulumi.set(__self__, "ip_protocol", ip_protocol)
-        if ports is not None:
-            pulumi.set(__self__, "ports", ports)
+        pulumi.set(__self__, "start_time", start_time)
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if end_time is not None:
+            pulumi.set(__self__, "end_time", end_time)
 
     @property
-    @pulumi.getter(name="ipProtocol")
-    def ip_protocol(self) -> builtins.str:
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> builtins.str:
         """
-        (Output)
-        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.
+        Start time of the future reservation in RFC3339 format.
         """
-        return pulumi.get(self, "ip_protocol")
+        return pulumi.get(self, "start_time")
 
     @property
     @pulumi.getter
-    def ports(self) -> Optional[Sequence[builtins.str]]:
+    def duration(self) -> Optional['outputs.FutureReservationTimeWindowDuration']:
         """
-        (Output)
-        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"].
+        Duration of the future reservation
+        Structure is documented below.
         """
-        return pulumi.get(self, "ports")
+        return pulumi.get(self, "duration")
+
+    @property
+    @pulumi.getter(name="endTime")
+    def end_time(self) -> Optional[builtins.str]:
+        """
+        End time of the future reservation in RFC3339 format.
+        """
+        return pulumi.get(self, "end_time")
 
 
 @pulumi.output_type
-class ForwardingRuleServiceDirectoryRegistrations(dict):
+class FutureReservationTimeWindowDuration(dict):
     def __init__(__self__, *,
-                 namespace: Optional[builtins.str] = None,
-                 service: Optional[builtins.str] = None):
+                 nanos: Optional[builtins.int] = None,
+                 seconds: Optional[builtins.str] = None):
         """
-        :param builtins.str namespace: Service Directory namespace to register the forwarding rule under.
-        :param builtins.str service: Service Directory service to register the forwarding rule under.
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
+               
+               - - -
+        :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
-        if namespace is not None:
-            pulumi.set(__self__, "namespace", namespace)
-        if service is not None:
-            pulumi.set(__self__, "service", service)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+        if seconds is not None:
+            pulumi.set(__self__, "seconds", seconds)
 
     @property
     @pulumi.getter
-    def namespace(self) -> Optional[builtins.str]:
+    def nanos(self) -> Optional[builtins.int]:
         """
-        Service Directory namespace to register the forwarding rule under.
+        Span of time that's a fraction of a second at nanosecond resolution.
+
+        - - -
         """
-        return pulumi.get(self, "namespace")
+        return pulumi.get(self, "nanos")
 
     @property
     @pulumi.getter
-    def service(self) -> Optional[builtins.str]:
+    def seconds(self) -> Optional[builtins.str]:
         """
-        Service Directory service to register the forwarding rule under.
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
-        return pulumi.get(self, "service")
+        return pulumi.get(self, "seconds")
 
 
 @pulumi.output_type
@@ -24602,6 +26296,63 @@ class RegionBackendServiceCustomMetric(dict):
         return pulumi.get(self, "name")
 
 
+@pulumi.output_type
+class RegionBackendServiceDynamicForwarding(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ipPortSelection":
+            suggest = "ip_port_selection"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceDynamicForwarding. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RegionBackendServiceDynamicForwarding.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RegionBackendServiceDynamicForwarding.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 ip_port_selection: Optional['outputs.RegionBackendServiceDynamicForwardingIpPortSelection'] = None):
+        """
+        :param 'RegionBackendServiceDynamicForwardingIpPortSelectionArgs' ip_port_selection: IP:PORT based dynamic forwarding configuration.
+               Structure is documented below.
+        """
+        if ip_port_selection is not None:
+            pulumi.set(__self__, "ip_port_selection", ip_port_selection)
+
+    @property
+    @pulumi.getter(name="ipPortSelection")
+    def ip_port_selection(self) -> Optional['outputs.RegionBackendServiceDynamicForwardingIpPortSelection']:
+        """
+        IP:PORT based dynamic forwarding configuration.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ip_port_selection")
+
+
+@pulumi.output_type
+class RegionBackendServiceDynamicForwardingIpPortSelection(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[builtins.bool] = None):
+        """
+        :param builtins.bool enabled: A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[builtins.bool]:
+        """
+        A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class RegionBackendServiceFailoverPolicy(dict):
     @staticmethod
@@ -25328,13 +27079,40 @@ class RegionBackendServiceStrongSessionAffinityCookieTtl(dict):
 
 @pulumi.output_type
 class RegionBackendServiceSubsetting(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "subsetSize":
+            suggest = "subset_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceSubsetting. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RegionBackendServiceSubsetting.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RegionBackendServiceSubsetting.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 policy: builtins.str):
+                 policy: builtins.str,
+                 subset_size: Optional[builtins.int] = None):
         """
         :param builtins.str policy: The algorithm used for subsetting.
                Possible values are: `CONSISTENT_HASH_SUBSETTING`.
+        :param builtins.int subset_size: The number of backends per backend group assigned to each proxy instance or each service mesh client.
+               An input parameter to the CONSISTENT_HASH_SUBSETTING algorithm. Can only be set if policy is set to
+               CONSISTENT_HASH_SUBSETTING. Can only be set if load balancing scheme is INTERNAL_MANAGED or INTERNAL_SELF_MANAGED.
+               subsetSize is optional for Internal HTTP(S) load balancing and required for Traffic Director.
+               If you do not provide this value, Cloud Load Balancing will calculate it dynamically to optimize the number
+               of proxies/clients visible to each backend and vice versa.
+               Must be greater than 0. If subsetSize is larger than the number of backends/endpoints, then subsetting is disabled.
         """
         pulumi.set(__self__, "policy", policy)
+        if subset_size is not None:
+            pulumi.set(__self__, "subset_size", subset_size)
 
     @property
     @pulumi.getter
@@ -25345,6 +27123,20 @@ class RegionBackendServiceSubsetting(dict):
         """
         return pulumi.get(self, "policy")
 
+    @property
+    @pulumi.getter(name="subsetSize")
+    def subset_size(self) -> Optional[builtins.int]:
+        """
+        The number of backends per backend group assigned to each proxy instance or each service mesh client.
+        An input parameter to the CONSISTENT_HASH_SUBSETTING algorithm. Can only be set if policy is set to
+        CONSISTENT_HASH_SUBSETTING. Can only be set if load balancing scheme is INTERNAL_MANAGED or INTERNAL_SELF_MANAGED.
+        subsetSize is optional for Internal HTTP(S) load balancing and required for Traffic Director.
+        If you do not provide this value, Cloud Load Balancing will calculate it dynamically to optimize the number
+        of proxies/clients visible to each backend and vice versa.
+        Must be greater than 0. If subsetSize is larger than the number of backends/endpoints, then subsetting is disabled.
+        """
+        return pulumi.get(self, "subset_size")
+
 
 @pulumi.output_type
 class RegionCommitmentLicenseResource(dict):
@@ -41984,6 +43776,26 @@ class RouterNatLogConfig(dict):
         return pulumi.get(self, "filter")
 
 
+@pulumi.output_type
+class RouterNatNat64Subnetwork(dict):
+    def __init__(__self__, *,
+                 name: builtins.str):
+        """
+        :param builtins.str name: Name of the NAT service. The name must be 1-63 characters long and
+               comply with RFC1035.
+        """
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of the NAT service. The name must be 1-63 characters long and
+        comply with RFC1035.
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class RouterNatRule(dict):
     @staticmethod
@@ -42192,7 +44004,7 @@ class RouterNatSubnetwork(dict):
                  source_ip_ranges_to_nats: Sequence[builtins.str],
                  secondary_ip_range_names: Optional[Sequence[builtins.str]] = None):
         """
-        :param builtins.str name: Self-link of subnetwork to NAT
+        :param builtins.str name: Self-link of the subnetwork resource that will use NAT64
         :param Sequence[builtins.str] source_ip_ranges_to_nats: List of options for which source IPs in the subnetwork
                should have NAT enabled. Supported values include:
                `ALL_IP_RANGES`, `LIST_OF_SECONDARY_IP_RANGES`,
@@ -42201,6 +44013,8 @@ class RouterNatSubnetwork(dict):
                to use NAT. This can be populated only if
                `LIST_OF_SECONDARY_IP_RANGES` is one of the values in
                sourceIpRangesToNat
+               
+               <a name="nested_nat64_subnetwork"></a>The `nat64_subnetwork` block supports:
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "source_ip_ranges_to_nats", source_ip_ranges_to_nats)
@@ -42211,7 +44025,7 @@ class RouterNatSubnetwork(dict):
     @pulumi.getter
     def name(self) -> builtins.str:
         """
-        Self-link of subnetwork to NAT
+        Self-link of the subnetwork resource that will use NAT64
         """
         return pulumi.get(self, "name")
 
@@ -42234,6 +44048,8 @@ class RouterNatSubnetwork(dict):
         to use NAT. This can be populated only if
         `LIST_OF_SECONDARY_IP_RANGES` is one of the values in
         sourceIpRangesToNat
+
+        <a name="nested_nat64_subnetwork"></a>The `nat64_subnetwork` block supports:
         """
         return pulumi.get(self, "secondary_ip_range_names")
 
@@ -47360,6 +49176,8 @@ class URLMapDefaultRouteActionRequestMirrorPolicy(dict):
         suggest = None
         if key == "backendService":
             suggest = "backend_service"
+        elif key == "mirrorPercent":
+            suggest = "mirror_percent"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in URLMapDefaultRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")
@@ -47373,11 +49191,16 @@ class URLMapDefaultRouteActionRequestMirrorPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 backend_service: builtins.str):
+                 backend_service: builtins.str,
+                 mirror_percent: Optional[builtins.float] = None):
         """
         :param builtins.str backend_service: The full or partial URL to the BackendService resource being mirrored to.
+        :param builtins.float mirror_percent: The percentage of requests to be mirrored to backendService.
+               The value must be between 0.0 and 100.0 inclusive.
         """
         pulumi.set(__self__, "backend_service", backend_service)
+        if mirror_percent is not None:
+            pulumi.set(__self__, "mirror_percent", mirror_percent)
 
     @property
     @pulumi.getter(name="backendService")
@@ -47387,6 +49210,15 @@ class URLMapDefaultRouteActionRequestMirrorPolicy(dict):
         """
         return pulumi.get(self, "backend_service")
 
+    @property
+    @pulumi.getter(name="mirrorPercent")
+    def mirror_percent(self) -> Optional[builtins.float]:
+        """
+        The percentage of requests to be mirrored to backendService.
+        The value must be between 0.0 and 100.0 inclusive.
+        """
+        return pulumi.get(self, "mirror_percent")
+
 
 @pulumi.output_type
 class URLMapDefaultRouteActionRetryPolicy(dict):
@@ -49231,6 +51063,8 @@ class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy(dict):
         suggest = None
         if key == "backendService":
             suggest = "backend_service"
+        elif key == "mirrorPercent":
+            suggest = "mirror_percent"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")
@@ -49244,11 +51078,16 @@ class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 backend_service: builtins.str):
+                 backend_service: builtins.str,
+                 mirror_percent: Optional[builtins.float] = None):
         """
         :param builtins.str backend_service: The full or partial URL to the BackendService resource being mirrored to.
+        :param builtins.float mirror_percent: The percentage of requests to be mirrored to backendService.
+               The value must be between 0.0 and 100.0 inclusive.
         """
         pulumi.set(__self__, "backend_service", backend_service)
+        if mirror_percent is not None:
+            pulumi.set(__self__, "mirror_percent", mirror_percent)
 
     @property
     @pulumi.getter(name="backendService")
@@ -49258,6 +51097,15 @@ class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy(dict):
         """
         return pulumi.get(self, "backend_service")
 
+    @property
+    @pulumi.getter(name="mirrorPercent")
+    def mirror_percent(self) -> Optional[builtins.float]:
+        """
+        The percentage of requests to be mirrored to backendService.
+        The value must be between 0.0 and 100.0 inclusive.
+        """
+        return pulumi.get(self, "mirror_percent")
+
 
 @pulumi.output_type
 class URLMapPathMatcherDefaultRouteActionRetryPolicy(dict):
@@ -50960,6 +52808,8 @@ class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
         suggest = None
         if key == "backendService":
             suggest = "backend_service"
+        elif key == "mirrorPercent":
+            suggest = "mirror_percent"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")
@@ -50973,11 +52823,16 @@ class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 backend_service: builtins.str):
+                 backend_service: builtins.str,
+                 mirror_percent: Optional[builtins.float] = None):
         """
         :param builtins.str backend_service: The full or partial URL to the BackendService resource being mirrored to.
+        :param builtins.float mirror_percent: The percentage of requests to be mirrored to backendService.
+               The value must be between 0.0 and 100.0 inclusive.
         """
         pulumi.set(__self__, "backend_service", backend_service)
+        if mirror_percent is not None:
+            pulumi.set(__self__, "mirror_percent", mirror_percent)
 
     @property
     @pulumi.getter(name="backendService")
@@ -50987,6 +52842,15 @@ class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
         """
         return pulumi.get(self, "backend_service")
 
+    @property
+    @pulumi.getter(name="mirrorPercent")
+    def mirror_percent(self) -> Optional[builtins.float]:
+        """
+        The percentage of requests to be mirrored to backendService.
+        The value must be between 0.0 and 100.0 inclusive.
+        """
+        return pulumi.get(self, "mirror_percent")
+
 
 @pulumi.output_type
 class URLMapPathMatcherPathRuleRouteActionRetryPolicy(dict):
@@ -51644,6 +53508,10 @@ class URLMapPathMatcherRouteRule(dict):
             suggest = "custom_error_response_policy"
         elif key == "headerAction":
             suggest = "header_action"
+        elif key == "httpFilterConfigs":
+            suggest = "http_filter_configs"
+        elif key == "httpFilterMetadatas":
+            suggest = "http_filter_metadatas"
         elif key == "matchRules":
             suggest = "match_rules"
         elif key == "routeAction":
@@ -51666,6 +53534,8 @@ class URLMapPathMatcherRouteRule(dict):
                  priority: builtins.int,
                  custom_error_response_policy: Optional['outputs.URLMapPathMatcherRouteRuleCustomErrorResponsePolicy'] = None,
                  header_action: Optional['outputs.URLMapPathMatcherRouteRuleHeaderAction'] = None,
+                 http_filter_configs: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHttpFilterConfig']] = None,
+                 http_filter_metadatas: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHttpFilterMetadata']] = None,
                  match_rules: Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRule']] = None,
                  route_action: Optional['outputs.URLMapPathMatcherRouteRuleRouteAction'] = None,
                  service: Optional[builtins.str] = None,
@@ -51691,6 +53561,16 @@ class URLMapPathMatcherRouteRule(dict):
                the matching pathMatchers[].headerAction and after pathMatchers[].routeRules[].r
                outeAction.weightedBackendService.backendServiceWeightAction[].headerAction
                Structure is documented below.
+        :param Sequence['URLMapPathMatcherRouteRuleHttpFilterConfigArgs'] http_filter_configs: Outbound route specific configuration for networkservices.HttpFilter resources enabled by Traffic Director.
+               httpFilterConfigs only applies for load balancers with loadBalancingScheme set to INTERNAL_SELF_MANAGED.
+               See ForwardingRule for more details.
+               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
+               Structure is documented below.
+        :param Sequence['URLMapPathMatcherRouteRuleHttpFilterMetadataArgs'] http_filter_metadatas: Outbound route specific metadata supplied to networkservices.HttpFilter resources enabled by Traffic Director.
+               httpFilterMetadata only applies for load balancers with loadBalancingScheme set to INTERNAL_SELF_MANAGED.
+               See ForwardingRule for more details.
+               Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
+               Structure is documented below.
         :param Sequence['URLMapPathMatcherRouteRuleMatchRuleArgs'] match_rules: The rules for determining a match.
                Structure is documented below.
         :param 'URLMapPathMatcherRouteRuleRouteActionArgs' route_action: In response to a matching matchRule, the load balancer performs advanced routing
@@ -51717,6 +53597,10 @@ class URLMapPathMatcherRouteRule(dict):
             pulumi.set(__self__, "custom_error_response_policy", custom_error_response_policy)
         if header_action is not None:
             pulumi.set(__self__, "header_action", header_action)
+        if http_filter_configs is not None:
+            pulumi.set(__self__, "http_filter_configs", http_filter_configs)
+        if http_filter_metadatas is not None:
+            pulumi.set(__self__, "http_filter_metadatas", http_filter_metadatas)
         if match_rules is not None:
             pulumi.set(__self__, "match_rules", match_rules)
         if route_action is not None:
@@ -51767,6 +53651,30 @@ class URLMapPathMatcherRouteRule(dict):
         """
         return pulumi.get(self, "header_action")
 
+    @property
+    @pulumi.getter(name="httpFilterConfigs")
+    def http_filter_configs(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHttpFilterConfig']]:
+        """
+        Outbound route specific configuration for networkservices.HttpFilter resources enabled by Traffic Director.
+        httpFilterConfigs only applies for load balancers with loadBalancingScheme set to INTERNAL_SELF_MANAGED.
+        See ForwardingRule for more details.
+        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_filter_configs")
+
+    @property
+    @pulumi.getter(name="httpFilterMetadatas")
+    def http_filter_metadatas(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleHttpFilterMetadata']]:
+        """
+        Outbound route specific metadata supplied to networkservices.HttpFilter resources enabled by Traffic Director.
+        httpFilterMetadata only applies for load balancers with loadBalancingScheme set to INTERNAL_SELF_MANAGED.
+        See ForwardingRule for more details.
+        Not supported when the URL map is bound to a target gRPC proxy that has validateForProxyless field set to true.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "http_filter_metadatas")
+
     @property
     @pulumi.getter(name="matchRules")
     def match_rules(self) -> Optional[Sequence['outputs.URLMapPathMatcherRouteRuleMatchRule']]:
@@ -52170,6 +54078,142 @@ class URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAdd(dict):
         return pulumi.get(self, "replace")
 
 
+@pulumi.output_type
+class URLMapPathMatcherRouteRuleHttpFilterConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "configTypeUrl":
+            suggest = "config_type_url"
+        elif key == "filterName":
+            suggest = "filter_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleHttpFilterConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        URLMapPathMatcherRouteRuleHttpFilterConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        URLMapPathMatcherRouteRuleHttpFilterConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 config: Optional[builtins.str] = None,
+                 config_type_url: Optional[builtins.str] = None,
+                 filter_name: Optional[builtins.str] = None):
+        """
+        :param builtins.str config: The configuration needed to enable the networkservices.HttpFilter resource.
+               The configuration must be YAML formatted and only contain fields defined in the protobuf identified in configTypeUrl
+        :param builtins.str config_type_url: The fully qualified versioned proto3 type url of the protobuf that the filter expects for its contextual settings,
+               for example: type.googleapis.com/google.protobuf.Struct
+        :param builtins.str filter_name: Name of the networkservices.HttpFilter resource this configuration belongs to.
+               This name must be known to the xDS client. Example: envoy.wasm
+        """
+        if config is not None:
+            pulumi.set(__self__, "config", config)
+        if config_type_url is not None:
+            pulumi.set(__self__, "config_type_url", config_type_url)
+        if filter_name is not None:
+            pulumi.set(__self__, "filter_name", filter_name)
+
+    @property
+    @pulumi.getter
+    def config(self) -> Optional[builtins.str]:
+        """
+        The configuration needed to enable the networkservices.HttpFilter resource.
+        The configuration must be YAML formatted and only contain fields defined in the protobuf identified in configTypeUrl
+        """
+        return pulumi.get(self, "config")
+
+    @property
+    @pulumi.getter(name="configTypeUrl")
+    def config_type_url(self) -> Optional[builtins.str]:
+        """
+        The fully qualified versioned proto3 type url of the protobuf that the filter expects for its contextual settings,
+        for example: type.googleapis.com/google.protobuf.Struct
+        """
+        return pulumi.get(self, "config_type_url")
+
+    @property
+    @pulumi.getter(name="filterName")
+    def filter_name(self) -> Optional[builtins.str]:
+        """
+        Name of the networkservices.HttpFilter resource this configuration belongs to.
+        This name must be known to the xDS client. Example: envoy.wasm
+        """
+        return pulumi.get(self, "filter_name")
+
+
+@pulumi.output_type
+class URLMapPathMatcherRouteRuleHttpFilterMetadata(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "configTypeUrl":
+            suggest = "config_type_url"
+        elif key == "filterName":
+            suggest = "filter_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleHttpFilterMetadata. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        URLMapPathMatcherRouteRuleHttpFilterMetadata.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        URLMapPathMatcherRouteRuleHttpFilterMetadata.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 config: Optional[builtins.str] = None,
+                 config_type_url: Optional[builtins.str] = None,
+                 filter_name: Optional[builtins.str] = None):
+        """
+        :param builtins.str config: The configuration needed to enable the networkservices.HttpFilter resource.
+               The configuration must be YAML formatted and only contain fields defined in the protobuf identified in configTypeUrl
+        :param builtins.str config_type_url: The fully qualified versioned proto3 type url of the protobuf that the filter expects for its contextual settings,
+               for example: type.googleapis.com/google.protobuf.Struct
+        :param builtins.str filter_name: Name of the networkservices.HttpFilter resource this configuration belongs to.
+               This name must be known to the xDS client. Example: envoy.wasm
+        """
+        if config is not None:
+            pulumi.set(__self__, "config", config)
+        if config_type_url is not None:
+            pulumi.set(__self__, "config_type_url", config_type_url)
+        if filter_name is not None:
+            pulumi.set(__self__, "filter_name", filter_name)
+
+    @property
+    @pulumi.getter
+    def config(self) -> Optional[builtins.str]:
+        """
+        The configuration needed to enable the networkservices.HttpFilter resource.
+        The configuration must be YAML formatted and only contain fields defined in the protobuf identified in configTypeUrl
+        """
+        return pulumi.get(self, "config")
+
+    @property
+    @pulumi.getter(name="configTypeUrl")
+    def config_type_url(self) -> Optional[builtins.str]:
+        """
+        The fully qualified versioned proto3 type url of the protobuf that the filter expects for its contextual settings,
+        for example: type.googleapis.com/google.protobuf.Struct
+        """
+        return pulumi.get(self, "config_type_url")
+
+    @property
+    @pulumi.getter(name="filterName")
+    def filter_name(self) -> Optional[builtins.str]:
+        """
+        Name of the networkservices.HttpFilter resource this configuration belongs to.
+        This name must be known to the xDS client. Example: envoy.wasm
+        """
+        return pulumi.get(self, "filter_name")
+
+
 @pulumi.output_type
 class URLMapPathMatcherRouteRuleMatchRule(dict):
     @staticmethod
@@ -53343,6 +55387,8 @@ class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
         suggest = None
         if key == "backendService":
             suggest = "backend_service"
+        elif key == "mirrorPercent":
+            suggest = "mirror_percent"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy. Access the value via the '{suggest}' property getter instead.")
@@ -53356,11 +55402,16 @@ class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 backend_service: builtins.str):
+                 backend_service: builtins.str,
+                 mirror_percent: Optional[builtins.float] = None):
         """
         :param builtins.str backend_service: The full or partial URL to the BackendService resource being mirrored to.
+        :param builtins.float mirror_percent: The percentage of requests to be mirrored to backendService.
+               The value must be between 0.0 and 100.0 inclusive.
         """
         pulumi.set(__self__, "backend_service", backend_service)
+        if mirror_percent is not None:
+            pulumi.set(__self__, "mirror_percent", mirror_percent)
 
     @property
     @pulumi.getter(name="backendService")
@@ -53370,6 +55421,15 @@ class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
         """
         return pulumi.get(self, "backend_service")
 
+    @property
+    @pulumi.getter(name="mirrorPercent")
+    def mirror_percent(self) -> Optional[builtins.float]:
+        """
+        The percentage of requests to be mirrored to backendService.
+        The value must be between 0.0 and 100.0 inclusive.
+        """
+        return pulumi.get(self, "mirror_percent")
+
 
 @pulumi.output_type
 class URLMapPathMatcherRouteRuleRouteActionRetryPolicy(dict):
@@ -55386,6 +57446,42 @@ class GetBackendServiceCustomMetricResult(dict):
         return pulumi.get(self, "name")
 
 
+@pulumi.output_type
+class GetBackendServiceDynamicForwardingResult(dict):
+    def __init__(__self__, *,
+                 ip_port_selections: Sequence['outputs.GetBackendServiceDynamicForwardingIpPortSelectionResult']):
+        """
+        :param Sequence['GetBackendServiceDynamicForwardingIpPortSelectionArgs'] ip_port_selections: IP:PORT based dynamic forwarding configuration.
+        """
+        pulumi.set(__self__, "ip_port_selections", ip_port_selections)
+
+    @property
+    @pulumi.getter(name="ipPortSelections")
+    def ip_port_selections(self) -> Sequence['outputs.GetBackendServiceDynamicForwardingIpPortSelectionResult']:
+        """
+        IP:PORT based dynamic forwarding configuration.
+        """
+        return pulumi.get(self, "ip_port_selections")
+
+
+@pulumi.output_type
+class GetBackendServiceDynamicForwardingIpPortSelectionResult(dict):
+    def __init__(__self__, *,
+                 enabled: builtins.bool):
+        """
+        :param builtins.bool enabled: A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> builtins.bool:
+        """
+        A boolean flag enabling IP:PORT based dynamic forwarding.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class GetBackendServiceIapResult(dict):
     def __init__(__self__, *,
@@ -55537,6 +57633,7 @@ class GetBackendServiceLogConfigResult(dict):
         :param Sequence[builtins.str] optional_fields: This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
                was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
                For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+               For example: orca_load_report, tls.protocol
         :param builtins.str optional_mode: Specifies the optional logging mode for the load balancer traffic.
                Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM. Possible values: ["INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM"]
         :param builtins.float sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
@@ -55564,6 +57661,7 @@ class GetBackendServiceLogConfigResult(dict):
         This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
         was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
         For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        For example: orca_load_report, tls.protocol
         """
         return pulumi.get(self, "optional_fields")
 
@@ -55621,6 +57719,61 @@ class GetBackendServiceMaxStreamDurationResult(dict):
         return pulumi.get(self, "seconds")
 
 
+@pulumi.output_type
+class GetBackendServiceNetworkPassThroughLbTrafficPolicyResult(dict):
+    def __init__(__self__, *,
+                 zonal_affinities: Sequence['outputs.GetBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityResult']):
+        """
+        :param Sequence['GetBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityArgs'] zonal_affinities: When configured, new connections are load balanced across healthy backend endpoints in the local zone.
+        """
+        pulumi.set(__self__, "zonal_affinities", zonal_affinities)
+
+    @property
+    @pulumi.getter(name="zonalAffinities")
+    def zonal_affinities(self) -> Sequence['outputs.GetBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityResult']:
+        """
+        When configured, new connections are load balanced across healthy backend endpoints in the local zone.
+        """
+        return pulumi.get(self, "zonal_affinities")
+
+
+@pulumi.output_type
+class GetBackendServiceNetworkPassThroughLbTrafficPolicyZonalAffinityResult(dict):
+    def __init__(__self__, *,
+                 spillover: builtins.str,
+                 spillover_ratio: builtins.float):
+        """
+        :param builtins.str spillover: This field indicates whether zonal affinity is enabled or not. Default value: "ZONAL_AFFINITY_DISABLED" Possible values: ["ZONAL_AFFINITY_DISABLED", "ZONAL_AFFINITY_SPILL_CROSS_ZONE", "ZONAL_AFFINITY_STAY_WITHIN_ZONE"]
+        :param builtins.float spillover_ratio: The value of the field must be in [0, 1]. When the ratio of the count of healthy backend endpoints in a zone
+               to the count of backend endpoints in that same zone is equal to or above this threshold, the load balancer
+               distributes new connections to all healthy endpoints in the local zone only. When the ratio of the count
+               of healthy backend endpoints in a zone to the count of backend endpoints in that same zone is below this
+               threshold, the load balancer distributes all new connections to all healthy endpoints across all zones.
+        """
+        pulumi.set(__self__, "spillover", spillover)
+        pulumi.set(__self__, "spillover_ratio", spillover_ratio)
+
+    @property
+    @pulumi.getter
+    def spillover(self) -> builtins.str:
+        """
+        This field indicates whether zonal affinity is enabled or not. Default value: "ZONAL_AFFINITY_DISABLED" Possible values: ["ZONAL_AFFINITY_DISABLED", "ZONAL_AFFINITY_SPILL_CROSS_ZONE", "ZONAL_AFFINITY_STAY_WITHIN_ZONE"]
+        """
+        return pulumi.get(self, "spillover")
+
+    @property
+    @pulumi.getter(name="spilloverRatio")
+    def spillover_ratio(self) -> builtins.float:
+        """
+        The value of the field must be in [0, 1]. When the ratio of the count of healthy backend endpoints in a zone
+        to the count of backend endpoints in that same zone is equal to or above this threshold, the load balancer
+        distributes new connections to all healthy endpoints in the local zone only. When the ratio of the count
+        of healthy backend endpoints in a zone to the count of backend endpoints in that same zone is below this
+        threshold, the load balancer distributes all new connections to all healthy endpoints across all zones.
+        """
+        return pulumi.get(self, "spillover_ratio")
+
+
 @pulumi.output_type
 class GetBackendServiceOutlierDetectionResult(dict):
     def __init__(__self__, *,
@@ -63126,178 +65279,260 @@ class GetRegionBackendServiceCircuitBreakerConnectTimeoutResult(dict):
 
 
 @pulumi.output_type
-class GetRegionBackendServiceConnectionTrackingPolicyResult(dict):
-    def __init__(__self__, *,
-                 connection_persistence_on_unhealthy_backends: builtins.str,
-                 enable_strong_affinity: builtins.bool,
-                 idle_timeout_sec: builtins.int,
-                 tracking_mode: builtins.str):
-        """
-        :param builtins.str connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy.
-               
-               If set to 'DEFAULT_FOR_PROTOCOL', the existing connections persist on
-               unhealthy backends only for connection-oriented protocols (TCP and SCTP)
-               and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
-               or the Session Affinity is configured for 5-tuple. They do not persist
-               for UDP.
-               
-               If set to 'NEVER_PERSIST', after a backend becomes unhealthy, the existing
-               connections on the unhealthy backend are never persisted on the unhealthy
-               backend. They are always diverted to newly selected healthy backends
-               (unless all backends are unhealthy).
-               
-               If set to 'ALWAYS_PERSIST', existing connections always persist on
-               unhealthy backends regardless of protocol and session affinity. It is
-               generally not recommended to use this mode overriding the default. Default value: "DEFAULT_FOR_PROTOCOL" Possible values: ["DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST"]
-        :param builtins.bool enable_strong_affinity: Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
-        :param builtins.int idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is
-               no matching traffic (in seconds).
-               
-               For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
-               
-               For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
-        :param builtins.str tracking_mode: Specifies the key used for connection tracking. There are two options:
-               'PER_CONNECTION': The Connection Tracking is performed as per the
-               Connection Key (default Hash Method) for the specific protocol.
-               
-               'PER_SESSION': The Connection Tracking is performed as per the
-               configured Session Affinity. It matches the configured Session Affinity. Default value: "PER_CONNECTION" Possible values: ["PER_CONNECTION", "PER_SESSION"]
-        """
-        pulumi.set(__self__, "connection_persistence_on_unhealthy_backends", connection_persistence_on_unhealthy_backends)
-        pulumi.set(__self__, "enable_strong_affinity", enable_strong_affinity)
-        pulumi.set(__self__, "idle_timeout_sec", idle_timeout_sec)
-        pulumi.set(__self__, "tracking_mode", tracking_mode)
-
-    @property
-    @pulumi.getter(name="connectionPersistenceOnUnhealthyBackends")
-    def connection_persistence_on_unhealthy_backends(self) -> builtins.str:
-        """
-        Specifies connection persistence when backends are unhealthy.
-
-        If set to 'DEFAULT_FOR_PROTOCOL', the existing connections persist on
-        unhealthy backends only for connection-oriented protocols (TCP and SCTP)
-        and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
-        or the Session Affinity is configured for 5-tuple. They do not persist
-        for UDP.
-
-        If set to 'NEVER_PERSIST', after a backend becomes unhealthy, the existing
-        connections on the unhealthy backend are never persisted on the unhealthy
-        backend. They are always diverted to newly selected healthy backends
-        (unless all backends are unhealthy).
-
-        If set to 'ALWAYS_PERSIST', existing connections always persist on
-        unhealthy backends regardless of protocol and session affinity. It is
-        generally not recommended to use this mode overriding the default. Default value: "DEFAULT_FOR_PROTOCOL" Possible values: ["DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST"]
-        """
-        return pulumi.get(self, "connection_persistence_on_unhealthy_backends")
-
-    @property
-    @pulumi.getter(name="enableStrongAffinity")
-    def enable_strong_affinity(self) -> builtins.bool:
-        """
-        Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
-        """
-        return pulumi.get(self, "enable_strong_affinity")
-
-    @property
-    @pulumi.getter(name="idleTimeoutSec")
-    def idle_timeout_sec(self) -> builtins.int:
-        """
-        Specifies how long to keep a Connection Tracking entry while there is
-        no matching traffic (in seconds).
-
-        For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
-
-        For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
-        """
-        return pulumi.get(self, "idle_timeout_sec")
-
-    @property
-    @pulumi.getter(name="trackingMode")
-    def tracking_mode(self) -> builtins.str:
-        """
-        Specifies the key used for connection tracking. There are two options:
-        'PER_CONNECTION': The Connection Tracking is performed as per the
-        Connection Key (default Hash Method) for the specific protocol.
-
-        'PER_SESSION': The Connection Tracking is performed as per the
-        configured Session Affinity. It matches the configured Session Affinity. Default value: "PER_CONNECTION" Possible values: ["PER_CONNECTION", "PER_SESSION"]
-        """
-        return pulumi.get(self, "tracking_mode")
-
-
-@pulumi.output_type
-class GetRegionBackendServiceConsistentHashResult(dict):
+class GetRegionBackendServiceConnectionTrackingPolicyResult(dict):
+    def __init__(__self__, *,
+                 connection_persistence_on_unhealthy_backends: builtins.str,
+                 enable_strong_affinity: builtins.bool,
+                 idle_timeout_sec: builtins.int,
+                 tracking_mode: builtins.str):
+        """
+        :param builtins.str connection_persistence_on_unhealthy_backends: Specifies connection persistence when backends are unhealthy.
+               
+               If set to 'DEFAULT_FOR_PROTOCOL', the existing connections persist on
+               unhealthy backends only for connection-oriented protocols (TCP and SCTP)
+               and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
+               or the Session Affinity is configured for 5-tuple. They do not persist
+               for UDP.
+               
+               If set to 'NEVER_PERSIST', after a backend becomes unhealthy, the existing
+               connections on the unhealthy backend are never persisted on the unhealthy
+               backend. They are always diverted to newly selected healthy backends
+               (unless all backends are unhealthy).
+               
+               If set to 'ALWAYS_PERSIST', existing connections always persist on
+               unhealthy backends regardless of protocol and session affinity. It is
+               generally not recommended to use this mode overriding the default. Default value: "DEFAULT_FOR_PROTOCOL" Possible values: ["DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST"]
+        :param builtins.bool enable_strong_affinity: Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
+        :param builtins.int idle_timeout_sec: Specifies how long to keep a Connection Tracking entry while there is
+               no matching traffic (in seconds).
+               
+               For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
+               
+               For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
+        :param builtins.str tracking_mode: Specifies the key used for connection tracking. There are two options:
+               'PER_CONNECTION': The Connection Tracking is performed as per the
+               Connection Key (default Hash Method) for the specific protocol.
+               
+               'PER_SESSION': The Connection Tracking is performed as per the
+               configured Session Affinity. It matches the configured Session Affinity. Default value: "PER_CONNECTION" Possible values: ["PER_CONNECTION", "PER_SESSION"]
+        """
+        pulumi.set(__self__, "connection_persistence_on_unhealthy_backends", connection_persistence_on_unhealthy_backends)
+        pulumi.set(__self__, "enable_strong_affinity", enable_strong_affinity)
+        pulumi.set(__self__, "idle_timeout_sec", idle_timeout_sec)
+        pulumi.set(__self__, "tracking_mode", tracking_mode)
+
+    @property
+    @pulumi.getter(name="connectionPersistenceOnUnhealthyBackends")
+    def connection_persistence_on_unhealthy_backends(self) -> builtins.str:
+        """
+        Specifies connection persistence when backends are unhealthy.
+
+        If set to 'DEFAULT_FOR_PROTOCOL', the existing connections persist on
+        unhealthy backends only for connection-oriented protocols (TCP and SCTP)
+        and only if the Tracking Mode is PER_CONNECTION (default tracking mode)
+        or the Session Affinity is configured for 5-tuple. They do not persist
+        for UDP.
+
+        If set to 'NEVER_PERSIST', after a backend becomes unhealthy, the existing
+        connections on the unhealthy backend are never persisted on the unhealthy
+        backend. They are always diverted to newly selected healthy backends
+        (unless all backends are unhealthy).
+
+        If set to 'ALWAYS_PERSIST', existing connections always persist on
+        unhealthy backends regardless of protocol and session affinity. It is
+        generally not recommended to use this mode overriding the default. Default value: "DEFAULT_FOR_PROTOCOL" Possible values: ["DEFAULT_FOR_PROTOCOL", "NEVER_PERSIST", "ALWAYS_PERSIST"]
+        """
+        return pulumi.get(self, "connection_persistence_on_unhealthy_backends")
+
+    @property
+    @pulumi.getter(name="enableStrongAffinity")
+    def enable_strong_affinity(self) -> builtins.bool:
+        """
+        Enable Strong Session Affinity for Network Load Balancing. This option is not available publicly.
+        """
+        return pulumi.get(self, "enable_strong_affinity")
+
+    @property
+    @pulumi.getter(name="idleTimeoutSec")
+    def idle_timeout_sec(self) -> builtins.int:
+        """
+        Specifies how long to keep a Connection Tracking entry while there is
+        no matching traffic (in seconds).
+
+        For L4 ILB the minimum(default) is 10 minutes and maximum is 16 hours.
+
+        For NLB the minimum(default) is 60 seconds and the maximum is 16 hours.
+        """
+        return pulumi.get(self, "idle_timeout_sec")
+
+    @property
+    @pulumi.getter(name="trackingMode")
+    def tracking_mode(self) -> builtins.str:
+        """
+        Specifies the key used for connection tracking. There are two options:
+        'PER_CONNECTION': The Connection Tracking is performed as per the
+        Connection Key (default Hash Method) for the specific protocol.
+
+        'PER_SESSION': The Connection Tracking is performed as per the
+        configured Session Affinity. It matches the configured Session Affinity. Default value: "PER_CONNECTION" Possible values: ["PER_CONNECTION", "PER_SESSION"]
+        """
+        return pulumi.get(self, "tracking_mode")
+
+
+@pulumi.output_type
+class GetRegionBackendServiceConsistentHashResult(dict):
+    def __init__(__self__, *,
+                 http_cookies: Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyResult'],
+                 http_header_name: builtins.str,
+                 minimum_ring_size: builtins.int):
+        """
+        :param Sequence['GetRegionBackendServiceConsistentHashHttpCookyArgs'] http_cookies: Hash is based on HTTP Cookie. This field describes a HTTP cookie
+               that will be used as the hash key for the consistent hash load
+               balancer. If the cookie is not present, it will be generated.
+               This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
+        :param builtins.str http_header_name: The hash based on the value of the specified header field.
+               This field is applicable if the sessionAffinity is set to HEADER_FIELD.
+        :param builtins.int minimum_ring_size: The minimum number of virtual nodes to use for the hash ring.
+               Larger ring sizes result in more granular load
+               distributions. If the number of hosts in the load balancing pool
+               is larger than the ring size, each host will be assigned a single
+               virtual node.
+               Defaults to 1024.
+        """
+        pulumi.set(__self__, "http_cookies", http_cookies)
+        pulumi.set(__self__, "http_header_name", http_header_name)
+        pulumi.set(__self__, "minimum_ring_size", minimum_ring_size)
+
+    @property
+    @pulumi.getter(name="httpCookies")
+    def http_cookies(self) -> Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyResult']:
+        """
+        Hash is based on HTTP Cookie. This field describes a HTTP cookie
+        that will be used as the hash key for the consistent hash load
+        balancer. If the cookie is not present, it will be generated.
+        This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
+        """
+        return pulumi.get(self, "http_cookies")
+
+    @property
+    @pulumi.getter(name="httpHeaderName")
+    def http_header_name(self) -> builtins.str:
+        """
+        The hash based on the value of the specified header field.
+        This field is applicable if the sessionAffinity is set to HEADER_FIELD.
+        """
+        return pulumi.get(self, "http_header_name")
+
+    @property
+    @pulumi.getter(name="minimumRingSize")
+    def minimum_ring_size(self) -> builtins.int:
+        """
+        The minimum number of virtual nodes to use for the hash ring.
+        Larger ring sizes result in more granular load
+        distributions. If the number of hosts in the load balancing pool
+        is larger than the ring size, each host will be assigned a single
+        virtual node.
+        Defaults to 1024.
+        """
+        return pulumi.get(self, "minimum_ring_size")
+
+
+@pulumi.output_type
+class GetRegionBackendServiceConsistentHashHttpCookyResult(dict):
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 path: builtins.str,
+                 ttls: Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyTtlResult']):
+        """
+        :param builtins.str name: The name of the regional backend service.
+        :param builtins.str path: Path to set for the cookie.
+        :param Sequence['GetRegionBackendServiceConsistentHashHttpCookyTtlArgs'] ttls: Lifetime of the cookie.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "ttls", ttls)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name of the regional backend service.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def path(self) -> builtins.str:
+        """
+        Path to set for the cookie.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def ttls(self) -> Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyTtlResult']:
+        """
+        Lifetime of the cookie.
+        """
+        return pulumi.get(self, "ttls")
+
+
+@pulumi.output_type
+class GetRegionBackendServiceConsistentHashHttpCookyTtlResult(dict):
+    def __init__(__self__, *,
+                 nanos: builtins.int,
+                 seconds: builtins.int):
+        """
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond
+               resolution. Durations less than one second are represented
+               with a 0 seconds field and a positive nanos field. Must
+               be from 0 to 999,999,999 inclusive.
+        :param builtins.int seconds: Span of time at a resolution of a second.
+               Must be from 0 to 315,576,000,000 inclusive.
+        """
+        pulumi.set(__self__, "nanos", nanos)
+        pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> builtins.int:
+        """
+        Span of time that's a fraction of a second at nanosecond
+        resolution. Durations less than one second are represented
+        with a 0 seconds field and a positive nanos field. Must
+        be from 0 to 999,999,999 inclusive.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> builtins.int:
+        """
+        Span of time at a resolution of a second.
+        Must be from 0 to 315,576,000,000 inclusive.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class GetRegionBackendServiceCustomMetricResult(dict):
     def __init__(__self__, *,
-                 http_cookies: Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyResult'],
-                 http_header_name: builtins.str,
-                 minimum_ring_size: builtins.int):
-        """
-        :param Sequence['GetRegionBackendServiceConsistentHashHttpCookyArgs'] http_cookies: Hash is based on HTTP Cookie. This field describes a HTTP cookie
-               that will be used as the hash key for the consistent hash load
-               balancer. If the cookie is not present, it will be generated.
-               This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
-        :param builtins.str http_header_name: The hash based on the value of the specified header field.
-               This field is applicable if the sessionAffinity is set to HEADER_FIELD.
-        :param builtins.int minimum_ring_size: The minimum number of virtual nodes to use for the hash ring.
-               Larger ring sizes result in more granular load
-               distributions. If the number of hosts in the load balancing pool
-               is larger than the ring size, each host will be assigned a single
-               virtual node.
-               Defaults to 1024.
-        """
-        pulumi.set(__self__, "http_cookies", http_cookies)
-        pulumi.set(__self__, "http_header_name", http_header_name)
-        pulumi.set(__self__, "minimum_ring_size", minimum_ring_size)
-
-    @property
-    @pulumi.getter(name="httpCookies")
-    def http_cookies(self) -> Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyResult']:
-        """
-        Hash is based on HTTP Cookie. This field describes a HTTP cookie
-        that will be used as the hash key for the consistent hash load
-        balancer. If the cookie is not present, it will be generated.
-        This field is applicable if the sessionAffinity is set to HTTP_COOKIE.
-        """
-        return pulumi.get(self, "http_cookies")
-
-    @property
-    @pulumi.getter(name="httpHeaderName")
-    def http_header_name(self) -> builtins.str:
+                 dry_run: builtins.bool,
+                 name: builtins.str):
         """
-        The hash based on the value of the specified header field.
-        This field is applicable if the sessionAffinity is set to HEADER_FIELD.
+        :param builtins.bool dry_run: If true, the metric data is not used for load balancing.
+        :param builtins.str name: The name of the regional backend service.
         """
-        return pulumi.get(self, "http_header_name")
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
 
     @property
-    @pulumi.getter(name="minimumRingSize")
-    def minimum_ring_size(self) -> builtins.int:
-        """
-        The minimum number of virtual nodes to use for the hash ring.
-        Larger ring sizes result in more granular load
-        distributions. If the number of hosts in the load balancing pool
-        is larger than the ring size, each host will be assigned a single
-        virtual node.
-        Defaults to 1024.
-        """
-        return pulumi.get(self, "minimum_ring_size")
-
-
-@pulumi.output_type
-class GetRegionBackendServiceConsistentHashHttpCookyResult(dict):
-    def __init__(__self__, *,
-                 name: builtins.str,
-                 path: builtins.str,
-                 ttls: Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyTtlResult']):
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> builtins.bool:
         """
-        :param builtins.str name: The name of the regional backend service.
-        :param builtins.str path: Path to set for the cookie.
-        :param Sequence['GetRegionBackendServiceConsistentHashHttpCookyTtlArgs'] ttls: Lifetime of the cookie.
+        If true, the metric data is not used for load balancing.
         """
-        pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "path", path)
-        pulumi.set(__self__, "ttls", ttls)
+        return pulumi.get(self, "dry_run")
 
     @property
     @pulumi.getter
@@ -63307,87 +65542,41 @@ class GetRegionBackendServiceConsistentHashHttpCookyResult(dict):
         """
         return pulumi.get(self, "name")
 
-    @property
-    @pulumi.getter
-    def path(self) -> builtins.str:
-        """
-        Path to set for the cookie.
-        """
-        return pulumi.get(self, "path")
-
-    @property
-    @pulumi.getter
-    def ttls(self) -> Sequence['outputs.GetRegionBackendServiceConsistentHashHttpCookyTtlResult']:
-        """
-        Lifetime of the cookie.
-        """
-        return pulumi.get(self, "ttls")
-
 
 @pulumi.output_type
-class GetRegionBackendServiceConsistentHashHttpCookyTtlResult(dict):
+class GetRegionBackendServiceDynamicForwardingResult(dict):
     def __init__(__self__, *,
-                 nanos: builtins.int,
-                 seconds: builtins.int):
-        """
-        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond
-               resolution. Durations less than one second are represented
-               with a 0 seconds field and a positive nanos field. Must
-               be from 0 to 999,999,999 inclusive.
-        :param builtins.int seconds: Span of time at a resolution of a second.
-               Must be from 0 to 315,576,000,000 inclusive.
+                 ip_port_selections: Sequence['outputs.GetRegionBackendServiceDynamicForwardingIpPortSelectionResult']):
         """
-        pulumi.set(__self__, "nanos", nanos)
-        pulumi.set(__self__, "seconds", seconds)
-
-    @property
-    @pulumi.getter
-    def nanos(self) -> builtins.int:
-        """
-        Span of time that's a fraction of a second at nanosecond
-        resolution. Durations less than one second are represented
-        with a 0 seconds field and a positive nanos field. Must
-        be from 0 to 999,999,999 inclusive.
+        :param Sequence['GetRegionBackendServiceDynamicForwardingIpPortSelectionArgs'] ip_port_selections: IP:PORT based dynamic forwarding configuration.
         """
-        return pulumi.get(self, "nanos")
+        pulumi.set(__self__, "ip_port_selections", ip_port_selections)
 
     @property
-    @pulumi.getter
-    def seconds(self) -> builtins.int:
+    @pulumi.getter(name="ipPortSelections")
+    def ip_port_selections(self) -> Sequence['outputs.GetRegionBackendServiceDynamicForwardingIpPortSelectionResult']:
         """
-        Span of time at a resolution of a second.
-        Must be from 0 to 315,576,000,000 inclusive.
+        IP:PORT based dynamic forwarding configuration.
         """
-        return pulumi.get(self, "seconds")
+        return pulumi.get(self, "ip_port_selections")
 
 
 @pulumi.output_type
-class GetRegionBackendServiceCustomMetricResult(dict):
+class GetRegionBackendServiceDynamicForwardingIpPortSelectionResult(dict):
     def __init__(__self__, *,
-                 dry_run: builtins.bool,
-                 name: builtins.str):
-        """
-        :param builtins.bool dry_run: If true, the metric data is not used for load balancing.
-        :param builtins.str name: The name of the regional backend service.
-        """
-        pulumi.set(__self__, "dry_run", dry_run)
-        pulumi.set(__self__, "name", name)
-
-    @property
-    @pulumi.getter(name="dryRun")
-    def dry_run(self) -> builtins.bool:
+                 enabled: builtins.bool):
         """
-        If true, the metric data is not used for load balancing.
+        :param builtins.bool enabled: A boolean flag enabling IP:PORT based dynamic forwarding.
         """
-        return pulumi.get(self, "dry_run")
+        pulumi.set(__self__, "enabled", enabled)
 
     @property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def enabled(self) -> builtins.bool:
         """
-        The name of the regional backend service.
+        A boolean flag enabling IP:PORT based dynamic forwarding.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "enabled")
 
 
 @pulumi.output_type
@@ -63904,11 +66093,20 @@ class GetRegionBackendServiceStrongSessionAffinityCookyTtlResult(dict):
 @pulumi.output_type
 class GetRegionBackendServiceSubsettingResult(dict):
     def __init__(__self__, *,
-                 policy: builtins.str):
+                 policy: builtins.str,
+                 subset_size: builtins.int):
         """
         :param builtins.str policy: The algorithm used for subsetting. Possible values: ["CONSISTENT_HASH_SUBSETTING"]
+        :param builtins.int subset_size: The number of backends per backend group assigned to each proxy instance or each service mesh client.
+               An input parameter to the CONSISTENT_HASH_SUBSETTING algorithm. Can only be set if policy is set to
+               CONSISTENT_HASH_SUBSETTING. Can only be set if load balancing scheme is INTERNAL_MANAGED or INTERNAL_SELF_MANAGED.
+               subsetSize is optional for Internal HTTP(S) load balancing and required for Traffic Director.
+               If you do not provide this value, Cloud Load Balancing will calculate it dynamically to optimize the number
+               of proxies/clients visible to each backend and vice versa.
+               Must be greater than 0. If subsetSize is larger than the number of backends/endpoints, then subsetting is disabled.
         """
         pulumi.set(__self__, "policy", policy)
+        pulumi.set(__self__, "subset_size", subset_size)
 
     @property
     @pulumi.getter
@@ -63918,6 +66116,20 @@ class GetRegionBackendServiceSubsettingResult(dict):
         """
         return pulumi.get(self, "policy")
 
+    @property
+    @pulumi.getter(name="subsetSize")
+    def subset_size(self) -> builtins.int:
+        """
+        The number of backends per backend group assigned to each proxy instance or each service mesh client.
+        An input parameter to the CONSISTENT_HASH_SUBSETTING algorithm. Can only be set if policy is set to
+        CONSISTENT_HASH_SUBSETTING. Can only be set if load balancing scheme is INTERNAL_MANAGED or INTERNAL_SELF_MANAGED.
+        subsetSize is optional for Internal HTTP(S) load balancing and required for Traffic Director.
+        If you do not provide this value, Cloud Load Balancing will calculate it dynamically to optimize the number
+        of proxies/clients visible to each backend and vice versa.
+        Must be greater than 0. If subsetSize is larger than the number of backends/endpoints, then subsetting is disabled.
+        """
+        return pulumi.get(self, "subset_size")
+
 
 @pulumi.output_type
 class GetRegionDiskAsyncPrimaryDiskResult(dict):
@@ -67472,6 +69684,26 @@ class GetRouterNatLogConfigResult(dict):
         return pulumi.get(self, "filter")
 
 
+@pulumi.output_type
+class GetRouterNatNat64SubnetworkResult(dict):
+    def __init__(__self__, *,
+                 name: builtins.str):
+        """
+        :param builtins.str name: Name of the NAT service. The name must be 1-63 characters long and
+               comply with RFC1035.
+        """
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of the NAT service. The name must be 1-63 characters long and
+        comply with RFC1035.
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class GetRouterNatRuleResult(dict):
     def __init__(__self__, *,