pulumi-gcp 8.21.0a1741156431__py3-none-any.whl → 8.22.0__py3-none-any.whl

pulumi_gcp/compute/_inputs.py

@@ -47,6 +47,8 @@ __all__ = [
     'BackendBucketIamMemberConditionArgsDict',
     'BackendServiceBackendArgs',
     'BackendServiceBackendArgsDict',
+    'BackendServiceBackendCustomMetricArgs',
+    'BackendServiceBackendCustomMetricArgsDict',
     'BackendServiceCdnPolicyArgs',
     'BackendServiceCdnPolicyArgsDict',
     'BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgs',
@@ -65,6 +67,8 @@ __all__ = [
     'BackendServiceConsistentHashHttpCookieArgsDict',
     'BackendServiceConsistentHashHttpCookieTtlArgs',
     'BackendServiceConsistentHashHttpCookieTtlArgsDict',
+    'BackendServiceCustomMetricArgs',
+    'BackendServiceCustomMetricArgsDict',
     'BackendServiceIamBindingConditionArgs',
     'BackendServiceIamBindingConditionArgsDict',
     'BackendServiceIamMemberConditionArgs',
@@ -105,6 +109,8 @@ __all__ = [
     'DiskIamBindingConditionArgsDict',
     'DiskIamMemberConditionArgs',
     'DiskIamMemberConditionArgsDict',
+    'DiskParamsArgs',
+    'DiskParamsArgsDict',
     'DiskSourceImageEncryptionKeyArgs',
     'DiskSourceImageEncryptionKeyArgsDict',
     'DiskSourceSnapshotEncryptionKeyArgs',
@@ -403,6 +409,10 @@ __all__ = [
     'InstanceTemplateServiceAccountArgsDict',
     'InstanceTemplateShieldedInstanceConfigArgs',
     'InstanceTemplateShieldedInstanceConfigArgsDict',
+    'InstantSnapshotIamBindingConditionArgs',
+    'InstantSnapshotIamBindingConditionArgsDict',
+    'InstantSnapshotIamMemberConditionArgs',
+    'InstantSnapshotIamMemberConditionArgsDict',
     'InterconnectAttachmentPrivateInterconnectInfoArgs',
     'InterconnectAttachmentPrivateInterconnectInfoArgsDict',
     'InterconnectCircuitInfoArgs',
@@ -527,6 +537,8 @@ __all__ = [
     'RegionAutoscalerAutoscalingPolicyScalingScheduleArgsDict',
     'RegionBackendServiceBackendArgs',
     'RegionBackendServiceBackendArgsDict',
+    'RegionBackendServiceBackendCustomMetricArgs',
+    'RegionBackendServiceBackendCustomMetricArgsDict',
     'RegionBackendServiceCdnPolicyArgs',
     'RegionBackendServiceCdnPolicyArgsDict',
     'RegionBackendServiceCdnPolicyCacheKeyPolicyArgs',
@@ -545,6 +557,8 @@ __all__ = [
     'RegionBackendServiceConsistentHashHttpCookieArgsDict',
     'RegionBackendServiceConsistentHashHttpCookieTtlArgs',
     'RegionBackendServiceConsistentHashHttpCookieTtlArgsDict',
+    'RegionBackendServiceCustomMetricArgs',
+    'RegionBackendServiceCustomMetricArgsDict',
     'RegionBackendServiceFailoverPolicyArgs',
     'RegionBackendServiceFailoverPolicyArgsDict',
     'RegionBackendServiceIamBindingConditionArgs',
@@ -1007,6 +1021,12 @@ __all__ = [
     'ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeekArgsDict',
     'ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs',
     'ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgsDict',
+    'RouteAsPathArgs',
+    'RouteAsPathArgsDict',
+    'RouteWarningArgs',
+    'RouteWarningArgsDict',
+    'RouteWarningDataArgs',
+    'RouteWarningDataArgsDict',
     'RouterBgpArgs',
     'RouterBgpArgsDict',
     'RouterBgpAdvertisedIpRangeArgs',
@@ -1133,6 +1153,8 @@ __all__ = [
     'URLMapDefaultRouteActionFaultInjectionPolicyDelayArgsDict',
     'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
     'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgsDict',
+    'URLMapDefaultRouteActionMaxStreamDurationArgs',
+    'URLMapDefaultRouteActionMaxStreamDurationArgsDict',
     'URLMapDefaultRouteActionRequestMirrorPolicyArgs',
     'URLMapDefaultRouteActionRequestMirrorPolicyArgsDict',
     'URLMapDefaultRouteActionRetryPolicyArgs',
@@ -1179,6 +1201,8 @@ __all__ = [
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayArgsDict',
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgsDict',
+    'URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs',
+    'URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgsDict',
     'URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs',
     'URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgsDict',
     'URLMapPathMatcherDefaultRouteActionRetryPolicyArgs',
@@ -1223,6 +1247,8 @@ __all__ = [
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgsDict',
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgsDict',
+    'URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs',
+    'URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgsDict',
     'URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs',
     'URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgsDict',
     'URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs',
@@ -1275,6 +1301,8 @@ __all__ = [
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgsDict',
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs',
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgsDict',
+    'URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs',
+    'URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgsDict',
     'URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs',
     'URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgsDict',
     'URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs',
@@ -2890,12 +2918,12 @@ if not MYPY:
         """
         Specifies the balancing mode for this backend.
         For global HTTP(S) or TCP/SSL load balancing, the default is
-        UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S))
-        and CONNECTION (for TCP/SSL).
+        UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S)),
+        CUSTOM_METRICS (for HTTP(s)) and CONNECTION (for TCP/SSL).
         See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
         for an explanation of load balancing modes.
         Default value is `UTILIZATION`.
-        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         """
         capacity_scaler: NotRequired[pulumi.Input[float]]
         """
@@ -2906,6 +2934,11 @@ if not MYPY:
         setting of 0 means the group is completely drained, offering
         0% of its available Capacity. Valid range is [0.0,1.0].
         """
+        custom_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input['BackendServiceBackendCustomMetricArgsDict']]]]
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
         description: NotRequired[pulumi.Input[str]]
         """
         An optional description of this resource.
@@ -2973,6 +3006,7 @@ class BackendServiceBackendArgs:
                  group: pulumi.Input[str],
                  balancing_mode: Optional[pulumi.Input[str]] = None,
                  capacity_scaler: Optional[pulumi.Input[float]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceBackendCustomMetricArgs']]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  max_connections: Optional[pulumi.Input[int]] = None,
                  max_connections_per_endpoint: Optional[pulumi.Input[int]] = None,
@@ -2998,18 +3032,20 @@ class BackendServiceBackendArgs:
                partial URL.
         :param pulumi.Input[str] balancing_mode: Specifies the balancing mode for this backend.
                For global HTTP(S) or TCP/SSL load balancing, the default is
-               UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S))
-               and CONNECTION (for TCP/SSL).
+               UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S)),
+               CUSTOM_METRICS (for HTTP(s)) and CONNECTION (for TCP/SSL).
                See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
                for an explanation of load balancing modes.
                Default value is `UTILIZATION`.
-               Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+               Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         :param pulumi.Input[float] capacity_scaler: A multiplier applied to the group's maximum servicing capacity
                (based on UTILIZATION, RATE or CONNECTION).
                Default value is 1, which means the group will serve up to 100%
                of its configured capacity (depending on balancingMode). A
                setting of 0 means the group is completely drained, offering
                0% of its available Capacity. Valid range is [0.0,1.0].
+        :param pulumi.Input[Sequence[pulumi.Input['BackendServiceBackendCustomMetricArgs']]] custom_metrics: The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
                Provide this property when you create the resource.
         :param pulumi.Input[int] max_connections: The max number of simultaneous connections for the group. Can
@@ -3050,6 +3086,8 @@ class BackendServiceBackendArgs:
             pulumi.set(__self__, "balancing_mode", balancing_mode)
         if capacity_scaler is not None:
             pulumi.set(__self__, "capacity_scaler", capacity_scaler)
+        if custom_metrics is not None:
+            pulumi.set(__self__, "custom_metrics", custom_metrics)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if max_connections is not None:
@@ -3098,12 +3136,12 @@ class BackendServiceBackendArgs:
         """
         Specifies the balancing mode for this backend.
         For global HTTP(S) or TCP/SSL load balancing, the default is
-        UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S))
-        and CONNECTION (for TCP/SSL).
+        UTILIZATION. Valid values are UTILIZATION, RATE (for HTTP(S)),
+        CUSTOM_METRICS (for HTTP(s)) and CONNECTION (for TCP/SSL).
         See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
         for an explanation of load balancing modes.
         Default value is `UTILIZATION`.
-        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         """
         return pulumi.get(self, "balancing_mode")
 
@@ -3128,6 +3166,19 @@ class BackendServiceBackendArgs:
     def capacity_scaler(self, value: Optional[pulumi.Input[float]]):
         pulumi.set(self, "capacity_scaler", value)
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceBackendCustomMetricArgs']]]]:
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
+    @custom_metrics.setter
+    def custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceBackendCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -3251,6 +3302,103 @@ class BackendServiceBackendArgs:
         pulumi.set(self, "max_utilization", value)
 
 
+if not MYPY:
+    class BackendServiceBackendCustomMetricArgsDict(TypedDict):
+        dry_run: pulumi.Input[bool]
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        name: pulumi.Input[str]
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        max_utilization: NotRequired[pulumi.Input[float]]
+        """
+        Optional parameter to define a target utilization for the Custom Metrics
+        balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+elif False:
+    BackendServiceBackendCustomMetricArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class BackendServiceBackendCustomMetricArgs:
+    def __init__(__self__, *,
+                 dry_run: pulumi.Input[bool],
+                 name: pulumi.Input[str],
+                 max_utilization: Optional[pulumi.Input[float]] = None):
+        """
+        :param pulumi.Input[bool] dry_run: If true, the metric data is not used for load balancing.
+        :param pulumi.Input[str] name: Name of a custom utilization signal. The name must be 1-64 characters
+               long and match the regular expression a-z? which
+               means the first character must be a lowercase letter, and all following
+               characters must be a dash, period, underscore, lowercase letter, or
+               digit, except the last character, which cannot be a dash, period, or
+               underscore. For usage guidelines, see Custom Metrics balancing mode. This
+               field can only be used for a global or regional backend service with the
+               loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+               <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        :param pulumi.Input[float] max_utilization: Optional parameter to define a target utilization for the Custom Metrics
+               balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
+        if max_utilization is not None:
+            pulumi.set(__self__, "max_utilization", max_utilization)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> pulumi.Input[bool]:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @dry_run.setter
+    def dry_run(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "dry_run", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="maxUtilization")
+    def max_utilization(self) -> Optional[pulumi.Input[float]]:
+        """
+        Optional parameter to define a target utilization for the Custom Metrics
+        balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+        return pulumi.get(self, "max_utilization")
+
+    @max_utilization.setter
+    def max_utilization(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "max_utilization", value)
+
+
 if not MYPY:
     class BackendServiceCdnPolicyArgsDict(TypedDict):
         bypass_cache_on_request_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyBypassCacheOnRequestHeaderArgsDict']]]]
@@ -4253,6 +4401,80 @@ class BackendServiceConsistentHashHttpCookieTtlArgs:
         pulumi.set(self, "nanos", value)
 
 
+if not MYPY:
+    class BackendServiceCustomMetricArgsDict(TypedDict):
+        dry_run: pulumi.Input[bool]
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        name: pulumi.Input[str]
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+elif False:
+    BackendServiceCustomMetricArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class BackendServiceCustomMetricArgs:
+    def __init__(__self__, *,
+                 dry_run: pulumi.Input[bool],
+                 name: pulumi.Input[str]):
+        """
+        :param pulumi.Input[bool] dry_run: If true, the metric data is not used for load balancing.
+        :param pulumi.Input[str] name: Name of a custom utilization signal. The name must be 1-64 characters
+               long and match the regular expression a-z? which
+               means the first character must be a lowercase letter, and all following
+               characters must be a dash, period, underscore, lowercase letter, or
+               digit, except the last character, which cannot be a dash, period, or
+               underscore. For usage guidelines, see Custom Metrics balancing mode. This
+               field can only be used for a global or regional backend service with the
+               loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+               <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> pulumi.Input[bool]:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @dry_run.setter
+    def dry_run(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "dry_run", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+
 if not MYPY:
     class BackendServiceIamBindingConditionArgsDict(TypedDict):
         expression: pulumi.Input[str]
@@ -5914,6 +6136,44 @@ class DiskIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class DiskParamsArgsDict(TypedDict):
+        resource_manager_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Resource manager tags to be bound to the disk. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456.
+        """
+elif False:
+    DiskParamsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DiskParamsArgs:
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_manager_tags: Resource manager tags to be bound to the disk. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456.
+        """
+        if resource_manager_tags is not None:
+            pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        Resource manager tags to be bound to the disk. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+    @resource_manager_tags.setter
+    def resource_manager_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "resource_manager_tags", value)
+
+
 if not MYPY:
     class DiskSourceImageEncryptionKeyArgsDict(TypedDict):
         kms_key_self_link: NotRequired[pulumi.Input[str]]
@@ -12642,6 +12902,12 @@ if not MYPY:
         """
         Whether the instance is spot. If this is set as SPOT.
         """
+        termination_time: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the timestamp, when the instance will be terminated,
+        in RFC3339 text format. If specified, the instance termination action
+        will be performed at the termination time.
+        """
 elif False:
     InstanceFromMachineImageSchedulingArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -12661,7 +12927,8 @@ class InstanceFromMachineImageSchedulingArgs:
                  on_host_maintenance: Optional[pulumi.Input[str]] = None,
                  on_instance_stop_action: Optional[pulumi.Input['InstanceFromMachineImageSchedulingOnInstanceStopActionArgs']] = None,
                  preemptible: Optional[pulumi.Input[bool]] = None,
-                 provisioning_model: Optional[pulumi.Input[str]] = None):
+                 provisioning_model: Optional[pulumi.Input[str]] = None,
+                 termination_time: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] automatic_restart: Specifies if the instance should be restarted if it was terminated by Compute Engine (not a user).
         :param pulumi.Input[int] availability_domain: Specifies the availability domain, which this instance should be scheduled on.
@@ -12679,6 +12946,9 @@ class InstanceFromMachineImageSchedulingArgs:
         :param pulumi.Input['InstanceFromMachineImageSchedulingOnInstanceStopActionArgs'] on_instance_stop_action: Defines the behaviour for instances with the instance_termination_action.
         :param pulumi.Input[bool] preemptible: Whether the instance is preemptible.
         :param pulumi.Input[str] provisioning_model: Whether the instance is spot. If this is set as SPOT.
+        :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated,
+               in RFC3339 text format. If specified, the instance termination action
+               will be performed at the termination time.
         """
         if automatic_restart is not None:
             pulumi.set(__self__, "automatic_restart", automatic_restart)
@@ -12708,6 +12978,8 @@ class InstanceFromMachineImageSchedulingArgs:
             pulumi.set(__self__, "preemptible", preemptible)
         if provisioning_model is not None:
             pulumi.set(__self__, "provisioning_model", provisioning_model)
+        if termination_time is not None:
+            pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -12877,6 +13149,20 @@ class InstanceFromMachineImageSchedulingArgs:
     def provisioning_model(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "provisioning_model", value)
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies the timestamp, when the instance will be terminated,
+        in RFC3339 text format. If specified, the instance termination action
+        will be performed at the termination time.
+        """
+        return pulumi.get(self, "termination_time")
+
+    @termination_time.setter
+    def termination_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "termination_time", value)
+
 
 if not MYPY:
     class InstanceFromMachineImageSchedulingGracefulShutdownArgsDict(TypedDict):
@@ -15008,6 +15294,12 @@ if not MYPY:
         """
         Whether the instance is spot. If this is set as SPOT.
         """
+        termination_time: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the timestamp, when the instance will be terminated,
+        in RFC3339 text format. If specified, the instance termination action
+        will be performed at the termination time.
+        """
 elif False:
     InstanceFromTemplateSchedulingArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -15027,7 +15319,8 @@ class InstanceFromTemplateSchedulingArgs:
                  on_host_maintenance: Optional[pulumi.Input[str]] = None,
                  on_instance_stop_action: Optional[pulumi.Input['InstanceFromTemplateSchedulingOnInstanceStopActionArgs']] = None,
                  preemptible: Optional[pulumi.Input[bool]] = None,
-                 provisioning_model: Optional[pulumi.Input[str]] = None):
+                 provisioning_model: Optional[pulumi.Input[str]] = None,
+                 termination_time: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] automatic_restart: Specifies if the instance should be restarted if it was terminated by Compute Engine (not a user).
         :param pulumi.Input[int] availability_domain: Specifies the availability domain, which this instance should be scheduled on.
@@ -15045,6 +15338,9 @@ class InstanceFromTemplateSchedulingArgs:
         :param pulumi.Input['InstanceFromTemplateSchedulingOnInstanceStopActionArgs'] on_instance_stop_action: Defines the behaviour for instances with the instance_termination_action.
         :param pulumi.Input[bool] preemptible: Whether the instance is preemptible.
         :param pulumi.Input[str] provisioning_model: Whether the instance is spot. If this is set as SPOT.
+        :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated,
+               in RFC3339 text format. If specified, the instance termination action
+               will be performed at the termination time.
         """
         if automatic_restart is not None:
             pulumi.set(__self__, "automatic_restart", automatic_restart)
@@ -15074,6 +15370,8 @@ class InstanceFromTemplateSchedulingArgs:
             pulumi.set(__self__, "preemptible", preemptible)
         if provisioning_model is not None:
             pulumi.set(__self__, "provisioning_model", provisioning_model)
+        if termination_time is not None:
+            pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -15243,6 +15541,20 @@ class InstanceFromTemplateSchedulingArgs:
     def provisioning_model(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "provisioning_model", value)
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies the timestamp, when the instance will be terminated,
+        in RFC3339 text format. If specified, the instance termination action
+        will be performed at the termination time.
+        """
+        return pulumi.get(self, "termination_time")
+
+    @termination_time.setter
+    def termination_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "termination_time", value)
+
 
 if not MYPY:
     class InstanceFromTemplateSchedulingGracefulShutdownArgsDict(TypedDict):
@@ -18015,6 +18327,10 @@ if not MYPY:
         `false`. For more info about
         `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
         """
+        termination_time: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
 elif False:
     InstanceSchedulingArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -18034,7 +18350,8 @@ class InstanceSchedulingArgs:
                  on_host_maintenance: Optional[pulumi.Input[str]] = None,
                  on_instance_stop_action: Optional[pulumi.Input['InstanceSchedulingOnInstanceStopActionArgs']] = None,
                  preemptible: Optional[pulumi.Input[bool]] = None,
-                 provisioning_model: Optional[pulumi.Input[str]] = None):
+                 provisioning_model: Optional[pulumi.Input[str]] = None,
+                 termination_time: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] automatic_restart: Specifies if the instance should be
                restarted if it was terminated by Compute Engine (not a user).
@@ -18066,6 +18383,7 @@ class InstanceSchedulingArgs:
                `preemptible` should be `true` and `automatic_restart` should be
                `false`. For more info about
                `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
+        :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
         """
         if automatic_restart is not None:
             pulumi.set(__self__, "automatic_restart", automatic_restart)
@@ -18095,6 +18413,8 @@ class InstanceSchedulingArgs:
             pulumi.set(__self__, "preemptible", preemptible)
         if provisioning_model is not None:
             pulumi.set(__self__, "provisioning_model", provisioning_model)
+        if termination_time is not None:
+            pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -18280,6 +18600,18 @@ class InstanceSchedulingArgs:
     def provisioning_model(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "provisioning_model", value)
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
+        return pulumi.get(self, "termination_time")
+
+    @termination_time.setter
+    def termination_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "termination_time", value)
+
 
 if not MYPY:
     class InstanceSchedulingGracefulShutdownArgsDict(TypedDict):
@@ -20765,6 +21097,10 @@ if not MYPY:
         `false`. For more info about
         `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
         """
+        termination_time: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
 elif False:
     InstanceTemplateSchedulingArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -20784,7 +21120,8 @@ class InstanceTemplateSchedulingArgs:
                  on_host_maintenance: Optional[pulumi.Input[str]] = None,
                  on_instance_stop_action: Optional[pulumi.Input['InstanceTemplateSchedulingOnInstanceStopActionArgs']] = None,
                  preemptible: Optional[pulumi.Input[bool]] = None,
-                 provisioning_model: Optional[pulumi.Input[str]] = None):
+                 provisioning_model: Optional[pulumi.Input[str]] = None,
+                 termination_time: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -20815,6 +21152,7 @@ class InstanceTemplateSchedulingArgs:
                `preemptible` should be `true` and `automatic_restart` should be
                `false`. For more info about
                `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
+        :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
         """
         if automatic_restart is not None:
             pulumi.set(__self__, "automatic_restart", automatic_restart)
@@ -20844,6 +21182,8 @@ class InstanceTemplateSchedulingArgs:
             pulumi.set(__self__, "preemptible", preemptible)
         if provisioning_model is not None:
             pulumi.set(__self__, "provisioning_model", provisioning_model)
+        if termination_time is not None:
+            pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -21028,6 +21368,18 @@ class InstanceTemplateSchedulingArgs:
     def provisioning_model(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "provisioning_model", value)
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
+        return pulumi.get(self, "termination_time")
+
+    @termination_time.setter
+    def termination_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "termination_time", value)
+
 
 if not MYPY:
     class InstanceTemplateSchedulingGracefulShutdownArgsDict(TypedDict):
@@ -21538,6 +21890,132 @@ class InstanceTemplateShieldedInstanceConfigArgs:
         pulumi.set(self, "enable_vtpm", value)
 
 
+if not MYPY:
+    class InstantSnapshotIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    InstantSnapshotIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstantSnapshotIamBindingConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class InstantSnapshotIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[str]]
+elif False:
+    InstantSnapshotIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstantSnapshotIamMemberConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[str],
+                 title: pulumi.Input[str],
+                 description: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "description", value)
+
+
 if not MYPY:
     class InterconnectAttachmentPrivateInterconnectInfoArgsDict(TypedDict):
         tag8021q: NotRequired[pulumi.Input[int]]
@@ -27734,7 +28212,7 @@ if not MYPY:
         See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
         for an explanation of load balancing modes.
         Default value is `UTILIZATION`.
-        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         """
         capacity_scaler: NotRequired[pulumi.Input[float]]
         """
@@ -27747,6 +28225,11 @@ if not MYPY:
         A setting of 0 means the group is completely drained, offering
         0% of its available Capacity. Valid range is [0.0,1.0].
         """
+        custom_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceBackendCustomMetricArgsDict']]]]
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
         description: NotRequired[pulumi.Input[str]]
         """
         An optional description of this resource.
@@ -27826,6 +28309,7 @@ class RegionBackendServiceBackendArgs:
                  group: pulumi.Input[str],
                  balancing_mode: Optional[pulumi.Input[str]] = None,
                  capacity_scaler: Optional[pulumi.Input[float]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceBackendCustomMetricArgs']]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  failover: Optional[pulumi.Input[bool]] = None,
                  max_connections: Optional[pulumi.Input[int]] = None,
@@ -27856,7 +28340,7 @@ class RegionBackendServiceBackendArgs:
                See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
                for an explanation of load balancing modes.
                Default value is `UTILIZATION`.
-               Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+               Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         :param pulumi.Input[float] capacity_scaler: A multiplier applied to the group's maximum servicing capacity
                (based on UTILIZATION, RATE or CONNECTION).
                ~>**NOTE**: This field cannot be set for
@@ -27865,6 +28349,8 @@ class RegionBackendServiceBackendArgs:
                capacity_scaler for all backends must be non-zero.
                A setting of 0 means the group is completely drained, offering
                0% of its available Capacity. Valid range is [0.0,1.0].
+        :param pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceBackendCustomMetricArgs']]] custom_metrics: The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
                Provide this property when you create the resource.
         :param pulumi.Input[bool] failover: This field designates whether this is a failover backend. More
@@ -27914,6 +28400,8 @@ class RegionBackendServiceBackendArgs:
             pulumi.set(__self__, "balancing_mode", balancing_mode)
         if capacity_scaler is not None:
             pulumi.set(__self__, "capacity_scaler", capacity_scaler)
+        if custom_metrics is not None:
+            pulumi.set(__self__, "custom_metrics", custom_metrics)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if failover is not None:
@@ -27968,7 +28456,7 @@ class RegionBackendServiceBackendArgs:
         See the [Backend Services Overview](https://cloud.google.com/load-balancing/docs/backend-service#balancing-mode)
         for an explanation of load balancing modes.
         Default value is `UTILIZATION`.
-        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`.
+        Possible values are: `UTILIZATION`, `RATE`, `CONNECTION`, `CUSTOM_METRICS`.
         """
         return pulumi.get(self, "balancing_mode")
 
@@ -27995,6 +28483,19 @@ class RegionBackendServiceBackendArgs:
     def capacity_scaler(self, value: Optional[pulumi.Input[float]]):
         pulumi.set(self, "capacity_scaler", value)
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceBackendCustomMetricArgs']]]]:
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
+    @custom_metrics.setter
+    def custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceBackendCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -28138,6 +28639,103 @@ class RegionBackendServiceBackendArgs:
         pulumi.set(self, "max_utilization", value)
 
 
+if not MYPY:
+    class RegionBackendServiceBackendCustomMetricArgsDict(TypedDict):
+        dry_run: pulumi.Input[bool]
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        name: pulumi.Input[str]
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        max_utilization: NotRequired[pulumi.Input[float]]
+        """
+        Optional parameter to define a target utilization for the Custom Metrics
+        balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+elif False:
+    RegionBackendServiceBackendCustomMetricArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionBackendServiceBackendCustomMetricArgs:
+    def __init__(__self__, *,
+                 dry_run: pulumi.Input[bool],
+                 name: pulumi.Input[str],
+                 max_utilization: Optional[pulumi.Input[float]] = None):
+        """
+        :param pulumi.Input[bool] dry_run: If true, the metric data is not used for load balancing.
+        :param pulumi.Input[str] name: Name of a custom utilization signal. The name must be 1-64 characters
+               long and match the regular expression a-z? which
+               means the first character must be a lowercase letter, and all following
+               characters must be a dash, period, underscore, lowercase letter, or
+               digit, except the last character, which cannot be a dash, period, or
+               underscore. For usage guidelines, see Custom Metrics balancing mode. This
+               field can only be used for a global or regional backend service with the
+               loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+               <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        :param pulumi.Input[float] max_utilization: Optional parameter to define a target utilization for the Custom Metrics
+               balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
+        if max_utilization is not None:
+            pulumi.set(__self__, "max_utilization", max_utilization)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> pulumi.Input[bool]:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @dry_run.setter
+    def dry_run(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "dry_run", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="maxUtilization")
+    def max_utilization(self) -> Optional[pulumi.Input[float]]:
+        """
+        Optional parameter to define a target utilization for the Custom Metrics
+        balancing mode. The valid range is <code>[0.0, 1.0]</code>.
+        """
+        return pulumi.get(self, "max_utilization")
+
+    @max_utilization.setter
+    def max_utilization(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "max_utilization", value)
+
+
 if not MYPY:
     class RegionBackendServiceCdnPolicyArgsDict(TypedDict):
         cache_key_policy: NotRequired[pulumi.Input['RegionBackendServiceCdnPolicyCacheKeyPolicyArgsDict']]
@@ -29221,6 +29819,80 @@ class RegionBackendServiceConsistentHashHttpCookieTtlArgs:
         pulumi.set(self, "nanos", value)
 
 
+if not MYPY:
+    class RegionBackendServiceCustomMetricArgsDict(TypedDict):
+        dry_run: pulumi.Input[bool]
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        name: pulumi.Input[str]
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+elif False:
+    RegionBackendServiceCustomMetricArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RegionBackendServiceCustomMetricArgs:
+    def __init__(__self__, *,
+                 dry_run: pulumi.Input[bool],
+                 name: pulumi.Input[str]):
+        """
+        :param pulumi.Input[bool] dry_run: If true, the metric data is not used for load balancing.
+        :param pulumi.Input[str] name: Name of a custom utilization signal. The name must be 1-64 characters
+               long and match the regular expression a-z? which
+               means the first character must be a lowercase letter, and all following
+               characters must be a dash, period, underscore, lowercase letter, or
+               digit, except the last character, which cannot be a dash, period, or
+               underscore. For usage guidelines, see Custom Metrics balancing mode. This
+               field can only be used for a global or regional backend service with the
+               loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+               <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> pulumi.Input[bool]:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @dry_run.setter
+    def dry_run(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "dry_run", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name of a custom utilization signal. The name must be 1-64 characters
+        long and match the regular expression a-z? which
+        means the first character must be a lowercase letter, and all following
+        characters must be a dash, period, underscore, lowercase letter, or
+        digit, except the last character, which cannot be a dash, period, or
+        underscore. For usage guidelines, see Custom Metrics balancing mode. This
+        field can only be used for a global or regional backend service with the
+        loadBalancingScheme set to <code>EXTERNAL_MANAGED</code>,
+        <code>INTERNAL_MANAGED</code> <code>INTERNAL_SELF_MANAGED</code>.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+
 if not MYPY:
     class RegionBackendServiceFailoverPolicyArgsDict(TypedDict):
         disable_connection_drain_on_failover: NotRequired[pulumi.Input[bool]]
@@ -29576,6 +30248,16 @@ if not MYPY:
         """
         Whether to enable logging for the load balancer traffic served by this backend service.
         """
+        optional_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Specifies the fields to include in logging. This field can only be specified if logging is enabled for this backend service.
+        """
+        optional_mode: NotRequired[pulumi.Input[str]]
+        """
+        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`.
+        """
         sample_rate: NotRequired[pulumi.Input[float]]
         """
         This field can only be specified if logging is enabled for this backend service. The value of
@@ -29590,9 +30272,15 @@ elif False:
 class RegionBackendServiceLogConfigArgs:
     def __init__(__self__, *,
                  enable: Optional[pulumi.Input[bool]] = None,
+                 optional_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 optional_mode: Optional[pulumi.Input[str]] = None,
                  sample_rate: Optional[pulumi.Input[float]] = None):
         """
         :param pulumi.Input[bool] enable: Whether to enable logging for the load balancer traffic served by this backend service.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] optional_fields: Specifies the fields to include in logging. This field can only be specified if logging is enabled for this backend service.
+        :param pulumi.Input[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`.
         :param pulumi.Input[float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
                the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
                where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
@@ -29600,6 +30288,10 @@ class RegionBackendServiceLogConfigArgs:
         """
         if enable is not None:
             pulumi.set(__self__, "enable", enable)
+        if optional_fields is not None:
+            pulumi.set(__self__, "optional_fields", optional_fields)
+        if optional_mode is not None:
+            pulumi.set(__self__, "optional_mode", optional_mode)
         if sample_rate is not None:
             pulumi.set(__self__, "sample_rate", sample_rate)
 
@@ -29615,6 +30307,32 @@ class RegionBackendServiceLogConfigArgs:
     def enable(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "enable", value)
 
+    @property
+    @pulumi.getter(name="optionalFields")
+    def optional_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Specifies the fields to include in logging. This field can only be specified if logging is enabled for this backend service.
+        """
+        return pulumi.get(self, "optional_fields")
+
+    @optional_fields.setter
+    def optional_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "optional_fields", value)
+
+    @property
+    @pulumi.getter(name="optionalMode")
+    def optional_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        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`.
+        """
+        return pulumi.get(self, "optional_mode")
+
+    @optional_mode.setter
+    def optional_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "optional_mode", value)
+
     @property
     @pulumi.getter(name="sampleRate")
     def sample_rate(self) -> Optional[pulumi.Input[float]]:
@@ -30437,6 +31155,13 @@ if not MYPY:
         RFC 4648 base64 to either encrypt or decrypt this resource.
         **Note**: This property is sensitive and will not be displayed in the plan.
         """
+        rsa_encrypted_key: NotRequired[pulumi.Input[str]]
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit
+        customer-supplied encryption key to either encrypt or decrypt
+        this resource. You can provide either the rawKey or the rsaEncryptedKey.
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
         sha256: NotRequired[pulumi.Input[str]]
         """
         (Output)
@@ -30451,12 +31176,17 @@ class RegionDiskDiskEncryptionKeyArgs:
     def __init__(__self__, *,
                  kms_key_name: Optional[pulumi.Input[str]] = None,
                  raw_key: Optional[pulumi.Input[str]] = None,
+                 rsa_encrypted_key: Optional[pulumi.Input[str]] = None,
                  sha256: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
         :param pulumi.Input[str] raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
                RFC 4648 base64 to either encrypt or decrypt this resource.
                **Note**: This property is sensitive and will not be displayed in the plan.
+        :param pulumi.Input[str] rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit
+               customer-supplied encryption key to either encrypt or decrypt
+               this resource. You can provide either the rawKey or the rsaEncryptedKey.
+               **Note**: This property is sensitive and will not be displayed in the plan.
         :param pulumi.Input[str] sha256: (Output)
                The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
                encryption key that protects this resource.
@@ -30465,6 +31195,8 @@ class RegionDiskDiskEncryptionKeyArgs:
             pulumi.set(__self__, "kms_key_name", kms_key_name)
         if raw_key is not None:
             pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
         if sha256 is not None:
             pulumi.set(__self__, "sha256", sha256)
 
@@ -30494,6 +31226,21 @@ class RegionDiskDiskEncryptionKeyArgs:
     def raw_key(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "raw_key", value)
 
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit
+        customer-supplied encryption key to either encrypt or decrypt
+        this resource. You can provide either the rawKey or the rsaEncryptedKey.
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
+    @rsa_encrypted_key.setter
+    def rsa_encrypted_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "rsa_encrypted_key", value)
+
     @property
     @pulumi.getter
     def sha256(self) -> Optional[pulumi.Input[str]]:
@@ -34815,6 +35562,10 @@ if not MYPY:
         `false`. For more info about
         `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
         """
+        termination_time: NotRequired[pulumi.Input[str]]
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
 elif False:
     RegionInstanceTemplateSchedulingArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -34834,7 +35585,8 @@ class RegionInstanceTemplateSchedulingArgs:
                  on_host_maintenance: Optional[pulumi.Input[str]] = None,
                  on_instance_stop_action: Optional[pulumi.Input['RegionInstanceTemplateSchedulingOnInstanceStopActionArgs']] = None,
                  preemptible: Optional[pulumi.Input[bool]] = None,
-                 provisioning_model: Optional[pulumi.Input[str]] = None):
+                 provisioning_model: Optional[pulumi.Input[str]] = None,
+                 termination_time: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[bool] automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -34865,6 +35617,7 @@ class RegionInstanceTemplateSchedulingArgs:
                `preemptible` should be `true` and `automatic_restart` should be
                `false`. For more info about
                `SPOT`, read [here](https://cloud.google.com/compute/docs/instances/spot)
+        :param pulumi.Input[str] termination_time: Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
         """
         if automatic_restart is not None:
             pulumi.set(__self__, "automatic_restart", automatic_restart)
@@ -34894,6 +35647,8 @@ class RegionInstanceTemplateSchedulingArgs:
             pulumi.set(__self__, "preemptible", preemptible)
         if provisioning_model is not None:
             pulumi.set(__self__, "provisioning_model", provisioning_model)
+        if termination_time is not None:
+            pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -35078,6 +35833,18 @@ class RegionInstanceTemplateSchedulingArgs:
     def provisioning_model(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "provisioning_model", value)
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Specifies the timestamp, when the instance will be terminated, in RFC3339 text format. If specified, the instance termination action will be performed at the termination time.
+        """
+        return pulumi.get(self, "termination_time")
+
+    @termination_time.setter
+    def termination_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "termination_time", value)
+
 
 if not MYPY:
     class RegionInstanceTemplateSchedulingGracefulShutdownArgsDict(TypedDict):
@@ -51184,6 +51951,224 @@ class ResourcePolicySnapshotSchedulePolicySnapshotPropertiesArgs:
         pulumi.set(self, "storage_locations", value)
 
 
+if not MYPY:
+    class RouteAsPathArgsDict(TypedDict):
+        as_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
+        """
+        (Output)
+        The AS numbers of the AS Path.
+        """
+        path_segment_type: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The type of the AS Path, which can be one of the following values:
+        - 'AS_SET': unordered set of autonomous systems that the route in has traversed
+        - 'AS_SEQUENCE': ordered set of autonomous systems that the route has traversed
+        - 'AS_CONFED_SEQUENCE': ordered set of Member Autonomous Systems in the local confederation that the route has traversed
+        - 'AS_CONFED_SET': unordered set of Member Autonomous Systems in the local confederation that the route has traversed
+        """
+elif False:
+    RouteAsPathArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RouteAsPathArgs:
+    def __init__(__self__, *,
+                 as_lists: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
+                 path_segment_type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] as_lists: (Output)
+               The AS numbers of the AS Path.
+        :param pulumi.Input[str] path_segment_type: (Output)
+               The type of the AS Path, which can be one of the following values:
+               - 'AS_SET': unordered set of autonomous systems that the route in has traversed
+               - 'AS_SEQUENCE': ordered set of autonomous systems that the route has traversed
+               - 'AS_CONFED_SEQUENCE': ordered set of Member Autonomous Systems in the local confederation that the route has traversed
+               - 'AS_CONFED_SET': unordered set of Member Autonomous Systems in the local confederation that the route has traversed
+        """
+        if as_lists is not None:
+            pulumi.set(__self__, "as_lists", as_lists)
+        if path_segment_type is not None:
+            pulumi.set(__self__, "path_segment_type", path_segment_type)
+
+    @property
+    @pulumi.getter(name="asLists")
+    def as_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
+        """
+        (Output)
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @as_lists.setter
+    def as_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "as_lists", value)
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The type of the AS Path, which can be one of the following values:
+        - 'AS_SET': unordered set of autonomous systems that the route in has traversed
+        - 'AS_SEQUENCE': ordered set of autonomous systems that the route has traversed
+        - 'AS_CONFED_SEQUENCE': ordered set of Member Autonomous Systems in the local confederation that the route has traversed
+        - 'AS_CONFED_SET': unordered set of Member Autonomous Systems in the local confederation that the route has traversed
+        """
+        return pulumi.get(self, "path_segment_type")
+
+    @path_segment_type.setter
+    def path_segment_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path_segment_type", value)
+
+
+if not MYPY:
+    class RouteWarningArgsDict(TypedDict):
+        code: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A warning code, if applicable. For example, Compute Engine returns
+        NO_RESULTS_ON_PAGE if there are no results in the response.
+        """
+        datas: NotRequired[pulumi.Input[Sequence[pulumi.Input['RouteWarningDataArgsDict']]]]
+        """
+        (Output)
+        Metadata about this warning in key: value format. For example:
+        "data":   {  "key": "scope",  "value": "zones/us-east1-d"  }
+        Structure is [documented below.
+        """
+        message: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A human-readable description of the warning code.
+        """
+elif False:
+    RouteWarningArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RouteWarningArgs:
+    def __init__(__self__, *,
+                 code: Optional[pulumi.Input[str]] = None,
+                 datas: Optional[pulumi.Input[Sequence[pulumi.Input['RouteWarningDataArgs']]]] = None,
+                 message: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] code: (Output)
+               A warning code, if applicable. For example, Compute Engine returns
+               NO_RESULTS_ON_PAGE if there are no results in the response.
+        :param pulumi.Input[Sequence[pulumi.Input['RouteWarningDataArgs']]] datas: (Output)
+               Metadata about this warning in key: value format. For example:
+               "data":   {  "key": "scope",  "value": "zones/us-east1-d"  }
+               Structure is [documented below.
+        :param pulumi.Input[str] message: (Output)
+               A human-readable description of the warning code.
+        """
+        if code is not None:
+            pulumi.set(__self__, "code", code)
+        if datas is not None:
+            pulumi.set(__self__, "datas", datas)
+        if message is not None:
+            pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A warning code, if applicable. For example, Compute Engine returns
+        NO_RESULTS_ON_PAGE if there are no results in the response.
+        """
+        return pulumi.get(self, "code")
+
+    @code.setter
+    def code(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "code", value)
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RouteWarningDataArgs']]]]:
+        """
+        (Output)
+        Metadata about this warning in key: value format. For example:
+        "data":   {  "key": "scope",  "value": "zones/us-east1-d"  }
+        Structure is [documented below.
+        """
+        return pulumi.get(self, "datas")
+
+    @datas.setter
+    def datas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RouteWarningDataArgs']]]]):
+        pulumi.set(self, "datas", value)
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+    @message.setter
+    def message(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "message", value)
+
+
+if not MYPY:
+    class RouteWarningDataArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A key that provides more detail on the warning being returned. For example, for warnings where there are no results in a list request for a particular zone, this key might be scope and the key value might be the zone name. Other examples might be a key indicating a deprecated resource and a suggested replacement, or a warning about invalid network settings (for example, if an instance attempts to perform IP forwarding but is not enabled for IP forwarding).
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        A warning data value corresponding to the key.
+        """
+elif False:
+    RouteWarningDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RouteWarningDataArgs:
+    def __init__(__self__, *,
+                 key: Optional[pulumi.Input[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] key: (Output)
+               A key that provides more detail on the warning being returned. For example, for warnings where there are no results in a list request for a particular zone, this key might be scope and the key value might be the zone name. Other examples might be a key indicating a deprecated resource and a suggested replacement, or a warning about invalid network settings (for example, if an instance attempts to perform IP forwarding but is not enabled for IP forwarding).
+        :param pulumi.Input[str] value: (Output)
+               A warning data value corresponding to the key.
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A key that provides more detail on the warning being returned. For example, for warnings where there are no results in a list request for a particular zone, this key might be scope and the key value might be the zone name. Other examples might be a key indicating a deprecated resource and a suggested replacement, or a warning about invalid network settings (for example, if an instance attempts to perform IP forwarding but is not enabled for IP forwarding).
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class RouterBgpArgsDict(TypedDict):
         asn: pulumi.Input[int]
@@ -55972,6 +56957,15 @@ if not MYPY:
         timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
         Structure is documented below.
         """
+        max_stream_duration: NotRequired[pulumi.Input['URLMapDefaultRouteActionMaxStreamDurationArgsDict']]
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
         request_mirror_policy: NotRequired[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgsDict']]
         """
         Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
@@ -56015,6 +57009,7 @@ class URLMapDefaultRouteActionArgs:
     def __init__(__self__, *,
                  cors_policy: Optional[pulumi.Input['URLMapDefaultRouteActionCorsPolicyArgs']] = None,
                  fault_injection_policy: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['URLMapDefaultRouteActionMaxStreamDurationArgs']] = None,
                  request_mirror_policy: Optional[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs']] = None,
                  retry_policy: Optional[pulumi.Input['URLMapDefaultRouteActionRetryPolicyArgs']] = None,
                  timeout: Optional[pulumi.Input['URLMapDefaultRouteActionTimeoutArgs']] = None,
@@ -56030,6 +57025,12 @@ class URLMapDefaultRouteActionArgs:
                by the Loadbalancer for a percentage of requests.
                timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
                Structure is documented below.
+        :param pulumi.Input['URLMapDefaultRouteActionMaxStreamDurationArgs'] max_stream_duration: Specifies the maximum duration (timeout) for streams on the selected route.
+               Unlike the `Timeout` field where the timeout duration starts from the time the request
+               has been fully processed (known as end-of-stream), the duration in this field
+               is computed from the beginning of the stream until the response has been processed,
+               including all retries. A stream that does not complete in this duration is closed.
+               Structure is documented below.
         :param pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
                Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
                the host / authority header is suffixed with -shadow.
@@ -56055,6 +57056,8 @@ class URLMapDefaultRouteActionArgs:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if fault_injection_policy is not None:
             pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if request_mirror_policy is not None:
             pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
         if retry_policy is not None:
@@ -56097,6 +57100,23 @@ class URLMapDefaultRouteActionArgs:
     def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionFaultInjectionPolicyArgs']]):
         pulumi.set(self, "fault_injection_policy", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionMaxStreamDurationArgs']]:
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['URLMapDefaultRouteActionMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionRequestMirrorPolicyArgs']]:
@@ -56592,6 +57612,63 @@ class URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs:
         pulumi.set(self, "seconds", value)
 
 
+if not MYPY:
+    class URLMapDefaultRouteActionMaxStreamDurationArgsDict(TypedDict):
+        seconds: pulumi.Input[str]
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        nanos: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    URLMapDefaultRouteActionMaxStreamDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class URLMapDefaultRouteActionMaxStreamDurationArgs:
+    def __init__(__self__, *,
+                 seconds: pulumi.Input[str],
+                 nanos: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        :param pulumi.Input[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.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> pulumi.Input[str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: pulumi.Input[str]):
+        pulumi.set(self, "seconds", value)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[pulumi.Input[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")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "nanos", value)
+
+
 if not MYPY:
     class URLMapDefaultRouteActionRequestMirrorPolicyArgsDict(TypedDict):
         backend_service: pulumi.Input[str]
@@ -58291,6 +59368,15 @@ if not MYPY:
         timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
         Structure is documented below.
         """
+        max_stream_duration: NotRequired[pulumi.Input['URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgsDict']]
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
         request_mirror_policy: NotRequired[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgsDict']]
         """
         Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
@@ -58334,6 +59420,7 @@ class URLMapPathMatcherDefaultRouteActionArgs:
     def __init__(__self__, *,
                  cors_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionCorsPolicyArgs']] = None,
                  fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs']] = None,
                  request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs']] = None,
                  retry_policy: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRetryPolicyArgs']] = None,
                  timeout: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionTimeoutArgs']] = None,
@@ -58349,6 +59436,12 @@ class URLMapPathMatcherDefaultRouteActionArgs:
                by the Loadbalancer for a percentage of requests.
                timeout and retryPolicy will be ignored by clients that are configured with a faultInjectionPolicy.
                Structure is documented below.
+        :param pulumi.Input['URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs'] max_stream_duration: Specifies the maximum duration (timeout) for streams on the selected route.
+               Unlike the `Timeout` field where the timeout duration starts from the time the request
+               has been fully processed (known as end-of-stream), the duration in this field
+               is computed from the beginning of the stream until the response has been processed,
+               including all retries. A stream that does not complete in this duration is closed.
+               Structure is documented below.
         :param pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are shadowed to a separate mirrored backend service.
                Loadbalancer does not wait for responses from the shadow service. Prior to sending traffic to the shadow service,
                the host / authority header is suffixed with -shadow.
@@ -58374,6 +59467,8 @@ class URLMapPathMatcherDefaultRouteActionArgs:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if fault_injection_policy is not None:
             pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if request_mirror_policy is not None:
             pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
         if retry_policy is not None:
@@ -58416,6 +59511,23 @@ class URLMapPathMatcherDefaultRouteActionArgs:
     def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyArgs']]):
         pulumi.set(self, "fault_injection_policy", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs']]:
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgs']]:
@@ -58911,6 +60023,63 @@ class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs
         pulumi.set(self, "seconds", value)
 
 
+if not MYPY:
+    class URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgsDict(TypedDict):
+        seconds: pulumi.Input[str]
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        nanos: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class URLMapPathMatcherDefaultRouteActionMaxStreamDurationArgs:
+    def __init__(__self__, *,
+                 seconds: pulumi.Input[str],
+                 nanos: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        :param pulumi.Input[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.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> pulumi.Input[str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: pulumi.Input[str]):
+        pulumi.set(self, "seconds", value)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[pulumi.Input[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")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "nanos", value)
+
+
 if not MYPY:
     class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicyArgsDict(TypedDict):
         backend_service: pulumi.Input[str]
@@ -60411,6 +61580,15 @@ if not MYPY:
         ignored by clients that are configured with a fault_injection_policy.
         Structure is documented below.
         """
+        max_stream_duration: NotRequired[pulumi.Input['URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgsDict']]
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
         request_mirror_policy: NotRequired[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgsDict']]
         """
         Specifies the policy on how requests intended for the route's backends are
@@ -60458,6 +61636,7 @@ class URLMapPathMatcherPathRuleRouteActionArgs:
     def __init__(__self__, *,
                  cors_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs']] = None,
                  fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs']] = None,
                  request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']] = None,
                  retry_policy: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs']] = None,
                  timeout: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionTimeoutArgs']] = None,
@@ -60475,6 +61654,12 @@ class URLMapPathMatcherPathRuleRouteActionArgs:
                Loadbalancer for a percentage of requests. timeout and retry_policy will be
                ignored by clients that are configured with a fault_injection_policy.
                Structure is documented below.
+        :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs'] max_stream_duration: Specifies the maximum duration (timeout) for streams on the selected route.
+               Unlike the `Timeout` field where the timeout duration starts from the time the request
+               has been fully processed (known as end-of-stream), the duration in this field
+               is computed from the beginning of the stream until the response has been processed,
+               including all retries. A stream that does not complete in this duration is closed.
+               Structure is documented below.
         :param pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are
                shadowed to a separate mirrored backend service. Loadbalancer does not wait for
                responses from the shadow service. Prior to sending traffic to the shadow
@@ -60504,6 +61689,8 @@ class URLMapPathMatcherPathRuleRouteActionArgs:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if fault_injection_policy is not None:
             pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if request_mirror_policy is not None:
             pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
         if retry_policy is not None:
@@ -60548,6 +61735,23 @@ class URLMapPathMatcherPathRuleRouteActionArgs:
     def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs']]):
         pulumi.set(self, "fault_injection_policy", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs']]:
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs']]:
@@ -61041,6 +62245,63 @@ class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArg
         pulumi.set(self, "nanos", value)
 
 
+if not MYPY:
+    class URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgsDict(TypedDict):
+        seconds: pulumi.Input[str]
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        nanos: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class URLMapPathMatcherPathRuleRouteActionMaxStreamDurationArgs:
+    def __init__(__self__, *,
+                 seconds: pulumi.Input[str],
+                 nanos: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        :param pulumi.Input[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.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> pulumi.Input[str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: pulumi.Input[str]):
+        pulumi.set(self, "seconds", value)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[pulumi.Input[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")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "nanos", value)
+
+
 if not MYPY:
     class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgsDict(TypedDict):
         backend_service: pulumi.Input[str]
@@ -63203,6 +64464,15 @@ if not MYPY:
         ignored by clients that are configured with a fault_injection_policy.
         Structure is documented below.
         """
+        max_stream_duration: NotRequired[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgsDict']]
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
         request_mirror_policy: NotRequired[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgsDict']]
         """
         Specifies the policy on how requests intended for the route's backends are
@@ -63250,6 +64520,7 @@ class URLMapPathMatcherRouteRuleRouteActionArgs:
     def __init__(__self__, *,
                  cors_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionCorsPolicyArgs']] = None,
                  fault_injection_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs']] = None,
                  request_mirror_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']] = None,
                  retry_policy: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRetryPolicyArgs']] = None,
                  timeout: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionTimeoutArgs']] = None,
@@ -63267,6 +64538,12 @@ class URLMapPathMatcherRouteRuleRouteActionArgs:
                Loadbalancer for a percentage of requests. timeout and retry_policy will be
                ignored by clients that are configured with a fault_injection_policy.
                Structure is documented below.
+        :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs'] max_stream_duration: Specifies the maximum duration (timeout) for streams on the selected route.
+               Unlike the `Timeout` field where the timeout duration starts from the time the request
+               has been fully processed (known as end-of-stream), the duration in this field
+               is computed from the beginning of the stream until the response has been processed,
+               including all retries. A stream that does not complete in this duration is closed.
+               Structure is documented below.
         :param pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs'] request_mirror_policy: Specifies the policy on how requests intended for the route's backends are
                shadowed to a separate mirrored backend service. Loadbalancer does not wait for
                responses from the shadow service. Prior to sending traffic to the shadow
@@ -63296,6 +64573,8 @@ class URLMapPathMatcherRouteRuleRouteActionArgs:
             pulumi.set(__self__, "cors_policy", cors_policy)
         if fault_injection_policy is not None:
             pulumi.set(__self__, "fault_injection_policy", fault_injection_policy)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if request_mirror_policy is not None:
             pulumi.set(__self__, "request_mirror_policy", request_mirror_policy)
         if retry_policy is not None:
@@ -63340,6 +64619,23 @@ class URLMapPathMatcherRouteRuleRouteActionArgs:
     def fault_injection_policy(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs']]):
         pulumi.set(self, "fault_injection_policy", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs']]:
+        """
+        Specifies the maximum duration (timeout) for streams on the selected route.
+        Unlike the `Timeout` field where the timeout duration starts from the time the request
+        has been fully processed (known as end-of-stream), the duration in this field
+        is computed from the beginning of the stream until the response has been processed,
+        including all retries. A stream that does not complete in this duration is closed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional[pulumi.Input['URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs']]:
@@ -63838,6 +65134,63 @@ class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayAr
         pulumi.set(self, "nanos", value)
 
 
+if not MYPY:
+    class URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgsDict(TypedDict):
+        seconds: pulumi.Input[str]
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        nanos: NotRequired[pulumi.Input[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.
+        """
+elif False:
+    URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class URLMapPathMatcherRouteRuleRouteActionMaxStreamDurationArgs:
+    def __init__(__self__, *,
+                 seconds: pulumi.Input[str],
+                 nanos: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+               Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        :param pulumi.Input[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.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> pulumi.Input[str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
+        Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: pulumi.Input[str]):
+        pulumi.set(self, "seconds", value)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[pulumi.Input[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")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "nanos", value)
+
+
 if not MYPY:
     class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgsDict(TypedDict):
         backend_service: pulumi.Input[str]