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

pulumi_gcp/compute/outputs.py

@@ -32,6 +32,7 @@ __all__ = [
     'BackendBucketIamBindingCondition',
     'BackendBucketIamMemberCondition',
     'BackendServiceBackend',
+    'BackendServiceBackendCustomMetric',
     'BackendServiceCdnPolicy',
     'BackendServiceCdnPolicyBypassCacheOnRequestHeader',
     'BackendServiceCdnPolicyCacheKeyPolicy',
@@ -41,6 +42,7 @@ __all__ = [
     'BackendServiceConsistentHash',
     'BackendServiceConsistentHashHttpCookie',
     'BackendServiceConsistentHashHttpCookieTtl',
+    'BackendServiceCustomMetric',
     'BackendServiceIamBindingCondition',
     'BackendServiceIamMemberCondition',
     'BackendServiceIap',
@@ -61,6 +63,7 @@ __all__ = [
     'DiskGuestOsFeature',
     'DiskIamBindingCondition',
     'DiskIamMemberCondition',
+    'DiskParams',
     'DiskSourceImageEncryptionKey',
     'DiskSourceSnapshotEncryptionKey',
     'ExternalVpnGatewayInterface',
@@ -210,6 +213,8 @@ __all__ = [
     'InstanceTemplateSchedulingOnInstanceStopAction',
     'InstanceTemplateServiceAccount',
     'InstanceTemplateShieldedInstanceConfig',
+    'InstantSnapshotIamBindingCondition',
+    'InstantSnapshotIamMemberCondition',
     'InterconnectAttachmentPrivateInterconnectInfo',
     'InterconnectCircuitInfo',
     'InterconnectExpectedOutage',
@@ -272,6 +277,7 @@ __all__ = [
     'RegionAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas',
     'RegionAutoscalerAutoscalingPolicyScalingSchedule',
     'RegionBackendServiceBackend',
+    'RegionBackendServiceBackendCustomMetric',
     'RegionBackendServiceCdnPolicy',
     'RegionBackendServiceCdnPolicyCacheKeyPolicy',
     'RegionBackendServiceCdnPolicyNegativeCachingPolicy',
@@ -281,6 +287,7 @@ __all__ = [
     'RegionBackendServiceConsistentHash',
     'RegionBackendServiceConsistentHashHttpCookie',
     'RegionBackendServiceConsistentHashHttpCookieTtl',
+    'RegionBackendServiceCustomMetric',
     'RegionBackendServiceFailoverPolicy',
     'RegionBackendServiceIamBindingCondition',
     'RegionBackendServiceIamMemberCondition',
@@ -512,6 +519,9 @@ __all__ = [
     'ResourcePolicySnapshotSchedulePolicyScheduleWeeklySchedule',
     'ResourcePolicySnapshotSchedulePolicyScheduleWeeklyScheduleDayOfWeek',
     'ResourcePolicySnapshotSchedulePolicySnapshotProperties',
+    'RouteAsPath',
+    'RouteWarning',
+    'RouteWarningData',
     'RouterBgp',
     'RouterBgpAdvertisedIpRange',
     'RouterNatLogConfig',
@@ -526,7 +536,13 @@ __all__ = [
     'RouterRoutePolicyTermAction',
     'RouterRoutePolicyTermMatch',
     'RouterStatusBestRouteResult',
+    'RouterStatusBestRouteAsPathResult',
+    'RouterStatusBestRouteWarningResult',
+    'RouterStatusBestRouteWarningDataResult',
     'RouterStatusBestRoutesForRouterResult',
+    'RouterStatusBestRoutesForRouterAsPathResult',
+    'RouterStatusBestRoutesForRouterWarningResult',
+    'RouterStatusBestRoutesForRouterWarningDataResult',
     'SecurityPolicyAdaptiveProtectionConfig',
     'SecurityPolicyAdaptiveProtectionConfigAutoDeployConfig',
     'SecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfig',
@@ -577,6 +593,7 @@ __all__ = [
     'URLMapDefaultRouteActionFaultInjectionPolicyAbort',
     'URLMapDefaultRouteActionFaultInjectionPolicyDelay',
     'URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay',
+    'URLMapDefaultRouteActionMaxStreamDuration',
     'URLMapDefaultRouteActionRequestMirrorPolicy',
     'URLMapDefaultRouteActionRetryPolicy',
     'URLMapDefaultRouteActionRetryPolicyPerTryTimeout',
@@ -600,6 +617,7 @@ __all__ = [
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyAbort',
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelay',
     'URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay',
+    'URLMapPathMatcherDefaultRouteActionMaxStreamDuration',
     'URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy',
     'URLMapPathMatcherDefaultRouteActionRetryPolicy',
     'URLMapPathMatcherDefaultRouteActionRetryPolicyPerTryTimeout',
@@ -622,6 +640,7 @@ __all__ = [
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbort',
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelay',
     'URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
+    'URLMapPathMatcherPathRuleRouteActionMaxStreamDuration',
     'URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy',
     'URLMapPathMatcherPathRuleRouteActionRetryPolicy',
     'URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeout',
@@ -648,6 +667,7 @@ __all__ = [
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbort',
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelay',
     'URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay',
+    'URLMapPathMatcherRouteRuleRouteActionMaxStreamDuration',
     'URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy',
     'URLMapPathMatcherRouteRuleRouteActionRetryPolicy',
     'URLMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeout',
@@ -665,6 +685,7 @@ __all__ = [
     'GetBackendBucketCdnPolicyCacheKeyPolicyResult',
     'GetBackendBucketCdnPolicyNegativeCachingPolicyResult',
     'GetBackendServiceBackendResult',
+    'GetBackendServiceBackendCustomMetricResult',
     'GetBackendServiceCdnPolicyResult',
     'GetBackendServiceCdnPolicyBypassCacheOnRequestHeaderResult',
     'GetBackendServiceCdnPolicyCacheKeyPolicyResult',
@@ -674,6 +695,7 @@ __all__ = [
     'GetBackendServiceConsistentHashResult',
     'GetBackendServiceConsistentHashHttpCookyResult',
     'GetBackendServiceConsistentHashHttpCookyTtlResult',
+    'GetBackendServiceCustomMetricResult',
     'GetBackendServiceIapResult',
     'GetBackendServiceLocalityLbPolicyResult',
     'GetBackendServiceLocalityLbPolicyCustomPolicyResult',
@@ -689,6 +711,7 @@ __all__ = [
     'GetDiskAsyncPrimaryDiskResult',
     'GetDiskDiskEncryptionKeyResult',
     'GetDiskGuestOsFeatureResult',
+    'GetDiskParamResult',
     'GetDiskSourceImageEncryptionKeyResult',
     'GetDiskSourceSnapshotEncryptionKeyResult',
     'GetForwardingRuleServiceDirectoryRegistrationResult',
@@ -854,7 +877,13 @@ __all__ = [
     'GetRouterNatRuleActionResult',
     'GetRouterNatSubnetworkResult',
     'GetRouterStatusBestRouteResult',
+    'GetRouterStatusBestRouteAsPathResult',
+    'GetRouterStatusBestRouteWarningResult',
+    'GetRouterStatusBestRouteWarningDataResult',
     'GetRouterStatusBestRoutesForRouterResult',
+    'GetRouterStatusBestRoutesForRouterAsPathResult',
+    'GetRouterStatusBestRoutesForRouterWarningResult',
+    'GetRouterStatusBestRoutesForRouterWarningDataResult',
     'GetSecurityPolicyAdaptiveProtectionConfigResult',
     'GetSecurityPolicyAdaptiveProtectionConfigAutoDeployConfigResult',
     'GetSecurityPolicyAdaptiveProtectionConfigLayer7DdosDefenseConfigResult',
@@ -2049,6 +2078,8 @@ class BackendServiceBackend(dict):
             suggest = "balancing_mode"
         elif key == "capacityScaler":
             suggest = "capacity_scaler"
+        elif key == "customMetrics":
+            suggest = "custom_metrics"
         elif key == "maxConnections":
             suggest = "max_connections"
         elif key == "maxConnectionsPerEndpoint":
@@ -2079,6 +2110,7 @@ class BackendServiceBackend(dict):
                  group: str,
                  balancing_mode: Optional[str] = None,
                  capacity_scaler: Optional[float] = None,
+                 custom_metrics: Optional[Sequence['outputs.BackendServiceBackendCustomMetric']] = None,
                  description: Optional[str] = None,
                  max_connections: Optional[int] = None,
                  max_connections_per_endpoint: Optional[int] = None,
@@ -2104,18 +2136,20 @@ class BackendServiceBackend(dict):
                partial URL.
         :param 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 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 Sequence['BackendServiceBackendCustomMetricArgs'] custom_metrics: The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+               Structure is documented below.
         :param str description: An optional description of this resource.
                Provide this property when you create the resource.
         :param int max_connections: The max number of simultaneous connections for the group. Can
@@ -2156,6 +2190,8 @@ class BackendServiceBackend(dict):
             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:
@@ -2200,12 +2236,12 @@ class BackendServiceBackend(dict):
         """
         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")
 
@@ -2222,6 +2258,15 @@ class BackendServiceBackend(dict):
         """
         return pulumi.get(self, "capacity_scaler")
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[Sequence['outputs.BackendServiceBackendCustomMetric']]:
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
     @property
     @pulumi.getter
     def description(self) -> Optional[str]:
@@ -2313,6 +2358,84 @@ class BackendServiceBackend(dict):
         return pulumi.get(self, "max_utilization")
 
 
+@pulumi.output_type
+class BackendServiceBackendCustomMetric(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dryRun":
+            suggest = "dry_run"
+        elif key == "maxUtilization":
+            suggest = "max_utilization"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackendServiceBackendCustomMetric. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackendServiceBackendCustomMetric.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackendServiceBackendCustomMetric.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 name: str,
+                 max_utilization: Optional[float] = None):
+        """
+        :param bool dry_run: If true, the metric data is not used for load balancing.
+        :param 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 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) -> bool:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter
+    def name(self) -> 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")
+
+    @property
+    @pulumi.getter(name="maxUtilization")
+    def max_utilization(self) -> Optional[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")
+
+
 @pulumi.output_type
 class BackendServiceCdnPolicy(dict):
     @staticmethod
@@ -3052,6 +3175,68 @@ class BackendServiceConsistentHashHttpCookieTtl(dict):
         return pulumi.get(self, "nanos")
 
 
+@pulumi.output_type
+class BackendServiceCustomMetric(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dryRun":
+            suggest = "dry_run"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BackendServiceCustomMetric. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BackendServiceCustomMetric.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BackendServiceCustomMetric.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 name: str):
+        """
+        :param bool dry_run: If true, the metric data is not used for load balancing.
+        :param 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) -> bool:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter
+    def name(self) -> 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")
+
+
 @pulumi.output_type
 class BackendServiceIamBindingCondition(dict):
     def __init__(__self__, *,
@@ -4216,6 +4401,46 @@ class DiskIamMemberCondition(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class DiskParams(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "resourceManagerTags":
+            suggest = "resource_manager_tags"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DiskParams. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DiskParams.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DiskParams.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[Mapping[str, str]] = None):
+        """
+        :param Mapping[str, 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[Mapping[str, 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")
+
+
 @pulumi.output_type
 class DiskSourceImageEncryptionKey(dict):
     @staticmethod
@@ -9220,6 +9445,8 @@ class InstanceFromMachineImageScheduling(dict):
             suggest = "on_instance_stop_action"
         elif key == "provisioningModel":
             suggest = "provisioning_model"
+        elif key == "terminationTime":
+            suggest = "termination_time"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceFromMachineImageScheduling. Access the value via the '{suggest}' property getter instead.")
@@ -9246,7 +9473,8 @@ class InstanceFromMachineImageScheduling(dict):
                  on_host_maintenance: Optional[str] = None,
                  on_instance_stop_action: Optional['outputs.InstanceFromMachineImageSchedulingOnInstanceStopAction'] = None,
                  preemptible: Optional[bool] = None,
-                 provisioning_model: Optional[str] = None):
+                 provisioning_model: Optional[str] = None,
+                 termination_time: Optional[str] = None):
         """
         :param bool automatic_restart: Specifies if the instance should be restarted if it was terminated by Compute Engine (not a user).
         :param int availability_domain: Specifies the availability domain, which this instance should be scheduled on.
@@ -9264,6 +9492,9 @@ class InstanceFromMachineImageScheduling(dict):
         :param 'InstanceFromMachineImageSchedulingOnInstanceStopActionArgs' on_instance_stop_action: Defines the behaviour for instances with the instance_termination_action.
         :param bool preemptible: Whether the instance is preemptible.
         :param str provisioning_model: Whether the instance is spot. If this is set as SPOT.
+        :param 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)
@@ -9293,6 +9524,8 @@ class InstanceFromMachineImageScheduling(dict):
             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")
@@ -9406,6 +9639,16 @@ class InstanceFromMachineImageScheduling(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[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")
+
 
 @pulumi.output_type
 class InstanceFromMachineImageSchedulingGracefulShutdown(dict):
@@ -11027,6 +11270,8 @@ class InstanceFromTemplateScheduling(dict):
             suggest = "on_instance_stop_action"
         elif key == "provisioningModel":
             suggest = "provisioning_model"
+        elif key == "terminationTime":
+            suggest = "termination_time"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceFromTemplateScheduling. Access the value via the '{suggest}' property getter instead.")
@@ -11053,7 +11298,8 @@ class InstanceFromTemplateScheduling(dict):
                  on_host_maintenance: Optional[str] = None,
                  on_instance_stop_action: Optional['outputs.InstanceFromTemplateSchedulingOnInstanceStopAction'] = None,
                  preemptible: Optional[bool] = None,
-                 provisioning_model: Optional[str] = None):
+                 provisioning_model: Optional[str] = None,
+                 termination_time: Optional[str] = None):
         """
         :param bool automatic_restart: Specifies if the instance should be restarted if it was terminated by Compute Engine (not a user).
         :param int availability_domain: Specifies the availability domain, which this instance should be scheduled on.
@@ -11071,6 +11317,9 @@ class InstanceFromTemplateScheduling(dict):
         :param 'InstanceFromTemplateSchedulingOnInstanceStopActionArgs' on_instance_stop_action: Defines the behaviour for instances with the instance_termination_action.
         :param bool preemptible: Whether the instance is preemptible.
         :param str provisioning_model: Whether the instance is spot. If this is set as SPOT.
+        :param 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)
@@ -11100,6 +11349,8 @@ class InstanceFromTemplateScheduling(dict):
             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")
@@ -11213,6 +11464,16 @@ class InstanceFromTemplateScheduling(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[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")
+
 
 @pulumi.output_type
 class InstanceFromTemplateSchedulingGracefulShutdown(dict):
@@ -13357,6 +13618,8 @@ class InstanceScheduling(dict):
             suggest = "on_instance_stop_action"
         elif key == "provisioningModel":
             suggest = "provisioning_model"
+        elif key == "terminationTime":
+            suggest = "termination_time"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceScheduling. Access the value via the '{suggest}' property getter instead.")
@@ -13383,7 +13646,8 @@ class InstanceScheduling(dict):
                  on_host_maintenance: Optional[str] = None,
                  on_instance_stop_action: Optional['outputs.InstanceSchedulingOnInstanceStopAction'] = None,
                  preemptible: Optional[bool] = None,
-                 provisioning_model: Optional[str] = None):
+                 provisioning_model: Optional[str] = None,
+                 termination_time: Optional[str] = None):
         """
         :param bool automatic_restart: Specifies if the instance should be
                restarted if it was terminated by Compute Engine (not a user).
@@ -13415,6 +13679,7 @@ class InstanceScheduling(dict):
                `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 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)
@@ -13444,6 +13709,8 @@ class InstanceScheduling(dict):
             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")
@@ -13573,6 +13840,14 @@ class InstanceScheduling(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[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")
+
 
 @pulumi.output_type
 class InstanceSchedulingGracefulShutdown(dict):
@@ -15409,6 +15684,8 @@ class InstanceTemplateScheduling(dict):
             suggest = "on_instance_stop_action"
         elif key == "provisioningModel":
             suggest = "provisioning_model"
+        elif key == "terminationTime":
+            suggest = "termination_time"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateScheduling. Access the value via the '{suggest}' property getter instead.")
@@ -15435,7 +15712,8 @@ class InstanceTemplateScheduling(dict):
                  on_host_maintenance: Optional[str] = None,
                  on_instance_stop_action: Optional['outputs.InstanceTemplateSchedulingOnInstanceStopAction'] = None,
                  preemptible: Optional[bool] = None,
-                 provisioning_model: Optional[str] = None):
+                 provisioning_model: Optional[str] = None,
+                 termination_time: Optional[str] = None):
         """
         :param bool automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -15466,6 +15744,7 @@ class InstanceTemplateScheduling(dict):
                `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 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)
@@ -15495,6 +15774,8 @@ class InstanceTemplateScheduling(dict):
             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")
@@ -15623,6 +15904,14 @@ class InstanceTemplateScheduling(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[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")
+
 
 @pulumi.output_type
 class InstanceTemplateSchedulingGracefulShutdown(dict):
@@ -15985,6 +16274,80 @@ class InstanceTemplateShieldedInstanceConfig(dict):
         return pulumi.get(self, "enable_vtpm")
 
 
+@pulumi.output_type
+class InstantSnapshotIamBindingCondition(dict):
+    def __init__(__self__, *,
+                 expression: str,
+                 title: str,
+                 description: Optional[str] = None):
+        """
+        :param str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param 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) -> str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def title(self) -> str:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class InstantSnapshotIamMemberCondition(dict):
+    def __init__(__self__, *,
+                 expression: str,
+                 title: str,
+                 description: Optional[str] = None):
+        """
+        :param str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param 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) -> str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def title(self) -> str:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        return pulumi.get(self, "description")
+
+
 @pulumi.output_type
 class InterconnectAttachmentPrivateInterconnectInfo(dict):
     def __init__(__self__, *,
@@ -20567,6 +20930,8 @@ class RegionBackendServiceBackend(dict):
             suggest = "balancing_mode"
         elif key == "capacityScaler":
             suggest = "capacity_scaler"
+        elif key == "customMetrics":
+            suggest = "custom_metrics"
         elif key == "maxConnections":
             suggest = "max_connections"
         elif key == "maxConnectionsPerEndpoint":
@@ -20597,6 +20962,7 @@ class RegionBackendServiceBackend(dict):
                  group: str,
                  balancing_mode: Optional[str] = None,
                  capacity_scaler: Optional[float] = None,
+                 custom_metrics: Optional[Sequence['outputs.RegionBackendServiceBackendCustomMetric']] = None,
                  description: Optional[str] = None,
                  failover: Optional[bool] = None,
                  max_connections: Optional[int] = None,
@@ -20627,7 +20993,7 @@ class RegionBackendServiceBackend(dict):
                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 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
@@ -20636,6 +21002,8 @@ class RegionBackendServiceBackend(dict):
                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 Sequence['RegionBackendServiceBackendCustomMetricArgs'] custom_metrics: The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+               Structure is documented below.
         :param str description: An optional description of this resource.
                Provide this property when you create the resource.
         :param bool failover: This field designates whether this is a failover backend. More
@@ -20685,6 +21053,8 @@ class RegionBackendServiceBackend(dict):
             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:
@@ -20735,7 +21105,7 @@ class RegionBackendServiceBackend(dict):
         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")
 
@@ -20754,6 +21124,15 @@ class RegionBackendServiceBackend(dict):
         """
         return pulumi.get(self, "capacity_scaler")
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[Sequence['outputs.RegionBackendServiceBackendCustomMetric']]:
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
     @property
     @pulumi.getter
     def description(self) -> Optional[str]:
@@ -20861,6 +21240,84 @@ class RegionBackendServiceBackend(dict):
         return pulumi.get(self, "max_utilization")
 
 
+@pulumi.output_type
+class RegionBackendServiceBackendCustomMetric(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dryRun":
+            suggest = "dry_run"
+        elif key == "maxUtilization":
+            suggest = "max_utilization"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceBackendCustomMetric. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RegionBackendServiceBackendCustomMetric.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RegionBackendServiceBackendCustomMetric.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 name: str,
+                 max_utilization: Optional[float] = None):
+        """
+        :param bool dry_run: If true, the metric data is not used for load balancing.
+        :param 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 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) -> bool:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter
+    def name(self) -> 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")
+
+    @property
+    @pulumi.getter(name="maxUtilization")
+    def max_utilization(self) -> Optional[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")
+
+
 @pulumi.output_type
 class RegionBackendServiceCdnPolicy(dict):
     @staticmethod
@@ -21655,6 +22112,68 @@ class RegionBackendServiceConsistentHashHttpCookieTtl(dict):
         return pulumi.get(self, "nanos")
 
 
+@pulumi.output_type
+class RegionBackendServiceCustomMetric(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "dryRun":
+            suggest = "dry_run"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RegionBackendServiceCustomMetric. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RegionBackendServiceCustomMetric.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RegionBackendServiceCustomMetric.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 name: str):
+        """
+        :param bool dry_run: If true, the metric data is not used for load balancing.
+        :param 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) -> bool:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter
+    def name(self) -> 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")
+
+
 @pulumi.output_type
 class RegionBackendServiceFailoverPolicy(dict):
     @staticmethod
@@ -21913,7 +22432,11 @@ class RegionBackendServiceLogConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "sampleRate":
+        if key == "optionalFields":
+            suggest = "optional_fields"
+        elif key == "optionalMode":
+            suggest = "optional_mode"
+        elif key == "sampleRate":
             suggest = "sample_rate"
 
         if suggest:
@@ -21929,9 +22452,15 @@ class RegionBackendServiceLogConfig(dict):
 
     def __init__(__self__, *,
                  enable: Optional[bool] = None,
+                 optional_fields: Optional[Sequence[str]] = None,
+                 optional_mode: Optional[str] = None,
                  sample_rate: Optional[float] = None):
         """
         :param bool enable: Whether to enable logging for the load balancer traffic served by this backend service.
+        :param Sequence[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 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 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.
@@ -21939,6 +22468,10 @@ class RegionBackendServiceLogConfig(dict):
         """
         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)
 
@@ -21950,6 +22483,24 @@ class RegionBackendServiceLogConfig(dict):
         """
         return pulumi.get(self, "enable")
 
+    @property
+    @pulumi.getter(name="optionalFields")
+    def optional_fields(self) -> Optional[Sequence[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")
+
+    @property
+    @pulumi.getter(name="optionalMode")
+    def optional_mode(self) -> Optional[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")
+
     @property
     @pulumi.getter(name="sampleRate")
     def sample_rate(self) -> Optional[float]:
@@ -22521,6 +23072,8 @@ class RegionDiskDiskEncryptionKey(dict):
             suggest = "kms_key_name"
         elif key == "rawKey":
             suggest = "raw_key"
+        elif key == "rsaEncryptedKey":
+            suggest = "rsa_encrypted_key"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegionDiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -22536,12 +23089,17 @@ class RegionDiskDiskEncryptionKey(dict):
     def __init__(__self__, *,
                  kms_key_name: Optional[str] = None,
                  raw_key: Optional[str] = None,
+                 rsa_encrypted_key: Optional[str] = None,
                  sha256: Optional[str] = None):
         """
         :param str kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
         :param 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 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 str sha256: (Output)
                The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
                encryption key that protects this resource.
@@ -22550,6 +23108,8 @@ class RegionDiskDiskEncryptionKey(dict):
             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)
 
@@ -22571,6 +23131,17 @@ class RegionDiskDiskEncryptionKey(dict):
         """
         return pulumi.get(self, "raw_key")
 
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[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")
+
     @property
     @pulumi.getter
     def sha256(self) -> Optional[str]:
@@ -25910,6 +26481,8 @@ class RegionInstanceTemplateScheduling(dict):
             suggest = "on_instance_stop_action"
         elif key == "provisioningModel":
             suggest = "provisioning_model"
+        elif key == "terminationTime":
+            suggest = "termination_time"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegionInstanceTemplateScheduling. Access the value via the '{suggest}' property getter instead.")
@@ -25936,7 +26509,8 @@ class RegionInstanceTemplateScheduling(dict):
                  on_host_maintenance: Optional[str] = None,
                  on_instance_stop_action: Optional['outputs.RegionInstanceTemplateSchedulingOnInstanceStopAction'] = None,
                  preemptible: Optional[bool] = None,
-                 provisioning_model: Optional[str] = None):
+                 provisioning_model: Optional[str] = None,
+                 termination_time: Optional[str] = None):
         """
         :param bool automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -25967,6 +26541,7 @@ class RegionInstanceTemplateScheduling(dict):
                `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 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)
@@ -25996,6 +26571,8 @@ class RegionInstanceTemplateScheduling(dict):
             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")
@@ -26124,6 +26701,14 @@ class RegionInstanceTemplateScheduling(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> Optional[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")
+
 
 @pulumi.output_type
 class RegionInstanceTemplateSchedulingGracefulShutdown(dict):
@@ -38224,6 +38809,158 @@ class ResourcePolicySnapshotSchedulePolicySnapshotProperties(dict):
         return pulumi.get(self, "storage_locations")
 
 
+@pulumi.output_type
+class RouteAsPath(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "asLists":
+            suggest = "as_lists"
+        elif key == "pathSegmentType":
+            suggest = "path_segment_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RouteAsPath. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RouteAsPath.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RouteAsPath.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 as_lists: Optional[Sequence[int]] = None,
+                 path_segment_type: Optional[str] = None):
+        """
+        :param Sequence[int] as_lists: (Output)
+               The AS numbers of the AS Path.
+        :param 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[Sequence[int]]:
+        """
+        (Output)
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> Optional[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")
+
+
+@pulumi.output_type
+class RouteWarning(dict):
+    def __init__(__self__, *,
+                 code: Optional[str] = None,
+                 datas: Optional[Sequence['outputs.RouteWarningData']] = None,
+                 message: Optional[str] = None):
+        """
+        :param 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 Sequence['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 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[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")
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Optional[Sequence['outputs.RouteWarningData']]:
+        """
+        (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")
+
+    @property
+    @pulumi.getter
+    def message(self) -> Optional[str]:
+        """
+        (Output)
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class RouteWarningData(dict):
+    def __init__(__self__, *,
+                 key: Optional[str] = None,
+                 value: Optional[str] = None):
+        """
+        :param 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 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[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")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        (Output)
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class RouterBgp(dict):
     @staticmethod
@@ -39065,11 +39802,14 @@ class RouterRoutePolicyTermMatch(dict):
 @pulumi.output_type
 class RouterStatusBestRouteResult(dict):
     def __init__(__self__, *,
+                 as_paths: Sequence['outputs.RouterStatusBestRouteAsPathResult'],
+                 creation_timestamp: str,
                  description: str,
                  dest_range: str,
                  name: str,
                  network: str,
                  next_hop_gateway: str,
+                 next_hop_hub: str,
                  next_hop_ilb: str,
                  next_hop_instance: str,
                  next_hop_instance_zone: str,
@@ -39078,12 +39818,17 @@ class RouterStatusBestRouteResult(dict):
                  next_hop_med: str,
                  next_hop_network: str,
                  next_hop_origin: str,
+                 next_hop_peering: str,
                  next_hop_vpn_tunnel: str,
                  priority: int,
                  project: str,
+                 route_status: str,
+                 route_type: str,
                  self_link: str,
-                 tags: Sequence[str]):
+                 tags: Sequence[str],
+                 warnings: Sequence['outputs.RouterStatusBestRouteWarningResult']):
         """
+        :param str creation_timestamp: Creation timestamp in RFC3339 text format.
         :param str description: An optional description of this resource. Provide this property
                when you create the resource.
         :param str dest_range: The destination range of outgoing packets that this route applies to.
@@ -39098,6 +39843,7 @@ class RouterStatusBestRouteResult(dict):
                * 'projects/project/global/gateways/default-internet-gateway'
                * 'global/gateways/default-internet-gateway'
                * The string 'default-internet-gateway'.
+        :param str next_hop_hub: The hub network that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_ilb: The IP address or URL to a forwarding rule of type
                loadBalancingScheme=INTERNAL that should handle matching
                packets.
@@ -39126,6 +39872,7 @@ class RouterStatusBestRouteResult(dict):
         :param str next_hop_med: Multi-Exit Discriminator, a BGP route metric that indicates the desirability of a particular route in a network.
         :param str next_hop_network: URL to a Network that should handle matching packets.
         :param str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
+        :param str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
         :param int priority: The priority of this route. Priority is used to break ties in cases
                where there is more than one matching route of equal prefix length.
@@ -39136,13 +39883,25 @@ class RouterStatusBestRouteResult(dict):
                Default value is 1000. Valid range is 0 through 65535.
         :param str project: The ID of the project in which the resource
                belongs. If it is not provided, the provider project is used.
+        :param str route_status: The status of the route, which can be one of the following values:
+               - 'ACTIVE' for an active route
+               - 'INACTIVE' for an inactive route
+        :param str route_type: The type of this route, which can be one of the following values:
+               - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+               - 'SUBNET' for a route from a subnet of the VPC
+               - 'BGP' for a route learned from a BGP peer of this router
+               - 'STATIC' for a static route
         :param Sequence[str] tags: A list of instance tags to which this route applies.
+        :param Sequence['RouterStatusBestRouteWarningArgs'] warnings: If potential misconfigurations are detected for this route, this field will be populated with warning messages.
         """
+        pulumi.set(__self__, "as_paths", as_paths)
+        pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "dest_range", dest_range)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network", network)
         pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
+        pulumi.set(__self__, "next_hop_hub", next_hop_hub)
         pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
         pulumi.set(__self__, "next_hop_instance", next_hop_instance)
         pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
@@ -39151,11 +39910,28 @@ class RouterStatusBestRouteResult(dict):
         pulumi.set(__self__, "next_hop_med", next_hop_med)
         pulumi.set(__self__, "next_hop_network", next_hop_network)
         pulumi.set(__self__, "next_hop_origin", next_hop_origin)
+        pulumi.set(__self__, "next_hop_peering", next_hop_peering)
         pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
+        pulumi.set(__self__, "route_status", route_status)
+        pulumi.set(__self__, "route_type", route_type)
         pulumi.set(__self__, "self_link", self_link)
         pulumi.set(__self__, "tags", tags)
+        pulumi.set(__self__, "warnings", warnings)
+
+    @property
+    @pulumi.getter(name="asPaths")
+    def as_paths(self) -> Sequence['outputs.RouterStatusBestRouteAsPathResult']:
+        return pulumi.get(self, "as_paths")
+
+    @property
+    @pulumi.getter(name="creationTimestamp")
+    def creation_timestamp(self) -> str:
+        """
+        Creation timestamp in RFC3339 text format.
+        """
+        return pulumi.get(self, "creation_timestamp")
 
     @property
     @pulumi.getter
@@ -39206,6 +39982,14 @@ class RouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_gateway")
 
+    @property
+    @pulumi.getter(name="nextHopHub")
+    def next_hop_hub(self) -> str:
+        """
+        The hub network that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_hub")
+
     @property
     @pulumi.getter(name="nextHopIlb")
     def next_hop_ilb(self) -> str:
@@ -39290,6 +40074,14 @@ class RouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_origin")
 
+    @property
+    @pulumi.getter(name="nextHopPeering")
+    def next_hop_peering(self) -> str:
+        """
+        The network peering name that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_peering")
+
     @property
     @pulumi.getter(name="nextHopVpnTunnel")
     def next_hop_vpn_tunnel(self) -> str:
@@ -39321,6 +40113,28 @@ class RouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "project")
 
+    @property
+    @pulumi.getter(name="routeStatus")
+    def route_status(self) -> str:
+        """
+        The status of the route, which can be one of the following values:
+        - 'ACTIVE' for an active route
+        - 'INACTIVE' for an inactive route
+        """
+        return pulumi.get(self, "route_status")
+
+    @property
+    @pulumi.getter(name="routeType")
+    def route_type(self) -> str:
+        """
+        The type of this route, which can be one of the following values:
+        - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+        - 'SUBNET' for a route from a subnet of the VPC
+        - 'BGP' for a route learned from a BGP peer of this router
+        - 'STATIC' for a static route
+        """
+        return pulumi.get(self, "route_type")
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
@@ -39334,15 +40148,136 @@ class RouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter
+    def warnings(self) -> Sequence['outputs.RouterStatusBestRouteWarningResult']:
+        """
+        If potential misconfigurations are detected for this route, this field will be populated with warning messages.
+        """
+        return pulumi.get(self, "warnings")
+
+
+@pulumi.output_type
+class RouterStatusBestRouteAsPathResult(dict):
+    def __init__(__self__, *,
+                 as_lists: Sequence[int],
+                 path_segment_type: str):
+        """
+        :param Sequence[int] as_lists: The AS numbers of the AS Path.
+        :param str path_segment_type: 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
+        """
+        pulumi.set(__self__, "as_lists", as_lists)
+        pulumi.set(__self__, "path_segment_type", path_segment_type)
+
+    @property
+    @pulumi.getter(name="asLists")
+    def as_lists(self) -> Sequence[int]:
+        """
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> str:
+        """
+        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")
+
+
+@pulumi.output_type
+class RouterStatusBestRouteWarningResult(dict):
+    def __init__(__self__, *,
+                 code: str,
+                 datas: Sequence['outputs.RouterStatusBestRouteWarningDataResult'],
+                 message: str):
+        """
+        :param str code: A warning code, if applicable. For example, Compute Engine returns
+               NO_RESULTS_ON_PAGE if there are no results in the response.
+        :param Sequence['RouterStatusBestRouteWarningDataArgs'] datas: Metadata about this warning in key: value format. For example:
+               "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        :param str message: A human-readable description of the warning code.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "datas", datas)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Sequence['outputs.RouterStatusBestRouteWarningDataResult']:
+        """
+        Metadata about this warning in key: value format. For example:
+        "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        """
+        return pulumi.get(self, "datas")
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class RouterStatusBestRouteWarningDataResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: 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 str value: A warning data value corresponding to the key.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
 
 @pulumi.output_type
 class RouterStatusBestRoutesForRouterResult(dict):
     def __init__(__self__, *,
+                 as_paths: Sequence['outputs.RouterStatusBestRoutesForRouterAsPathResult'],
+                 creation_timestamp: str,
                  description: str,
                  dest_range: str,
                  name: str,
                  network: str,
                  next_hop_gateway: str,
+                 next_hop_hub: str,
                  next_hop_ilb: str,
                  next_hop_instance: str,
                  next_hop_instance_zone: str,
@@ -39351,12 +40286,17 @@ class RouterStatusBestRoutesForRouterResult(dict):
                  next_hop_med: str,
                  next_hop_network: str,
                  next_hop_origin: str,
+                 next_hop_peering: str,
                  next_hop_vpn_tunnel: str,
                  priority: int,
                  project: str,
+                 route_status: str,
+                 route_type: str,
                  self_link: str,
-                 tags: Sequence[str]):
+                 tags: Sequence[str],
+                 warnings: Sequence['outputs.RouterStatusBestRoutesForRouterWarningResult']):
         """
+        :param str creation_timestamp: Creation timestamp in RFC3339 text format.
         :param str description: An optional description of this resource. Provide this property
                when you create the resource.
         :param str dest_range: The destination range of outgoing packets that this route applies to.
@@ -39371,6 +40311,7 @@ class RouterStatusBestRoutesForRouterResult(dict):
                * 'projects/project/global/gateways/default-internet-gateway'
                * 'global/gateways/default-internet-gateway'
                * The string 'default-internet-gateway'.
+        :param str next_hop_hub: The hub network that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_ilb: The IP address or URL to a forwarding rule of type
                loadBalancingScheme=INTERNAL that should handle matching
                packets.
@@ -39399,6 +40340,7 @@ class RouterStatusBestRoutesForRouterResult(dict):
         :param str next_hop_med: Multi-Exit Discriminator, a BGP route metric that indicates the desirability of a particular route in a network.
         :param str next_hop_network: URL to a Network that should handle matching packets.
         :param str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
+        :param str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
         :param int priority: The priority of this route. Priority is used to break ties in cases
                where there is more than one matching route of equal prefix length.
@@ -39409,13 +40351,25 @@ class RouterStatusBestRoutesForRouterResult(dict):
                Default value is 1000. Valid range is 0 through 65535.
         :param str project: The ID of the project in which the resource
                belongs. If it is not provided, the provider project is used.
+        :param str route_status: The status of the route, which can be one of the following values:
+               - 'ACTIVE' for an active route
+               - 'INACTIVE' for an inactive route
+        :param str route_type: The type of this route, which can be one of the following values:
+               - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+               - 'SUBNET' for a route from a subnet of the VPC
+               - 'BGP' for a route learned from a BGP peer of this router
+               - 'STATIC' for a static route
         :param Sequence[str] tags: A list of instance tags to which this route applies.
+        :param Sequence['RouterStatusBestRoutesForRouterWarningArgs'] warnings: If potential misconfigurations are detected for this route, this field will be populated with warning messages.
         """
+        pulumi.set(__self__, "as_paths", as_paths)
+        pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "dest_range", dest_range)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network", network)
         pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
+        pulumi.set(__self__, "next_hop_hub", next_hop_hub)
         pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
         pulumi.set(__self__, "next_hop_instance", next_hop_instance)
         pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
@@ -39424,11 +40378,28 @@ class RouterStatusBestRoutesForRouterResult(dict):
         pulumi.set(__self__, "next_hop_med", next_hop_med)
         pulumi.set(__self__, "next_hop_network", next_hop_network)
         pulumi.set(__self__, "next_hop_origin", next_hop_origin)
+        pulumi.set(__self__, "next_hop_peering", next_hop_peering)
         pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
+        pulumi.set(__self__, "route_status", route_status)
+        pulumi.set(__self__, "route_type", route_type)
         pulumi.set(__self__, "self_link", self_link)
         pulumi.set(__self__, "tags", tags)
+        pulumi.set(__self__, "warnings", warnings)
+
+    @property
+    @pulumi.getter(name="asPaths")
+    def as_paths(self) -> Sequence['outputs.RouterStatusBestRoutesForRouterAsPathResult']:
+        return pulumi.get(self, "as_paths")
+
+    @property
+    @pulumi.getter(name="creationTimestamp")
+    def creation_timestamp(self) -> str:
+        """
+        Creation timestamp in RFC3339 text format.
+        """
+        return pulumi.get(self, "creation_timestamp")
 
     @property
     @pulumi.getter
@@ -39479,6 +40450,14 @@ class RouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_gateway")
 
+    @property
+    @pulumi.getter(name="nextHopHub")
+    def next_hop_hub(self) -> str:
+        """
+        The hub network that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_hub")
+
     @property
     @pulumi.getter(name="nextHopIlb")
     def next_hop_ilb(self) -> str:
@@ -39563,6 +40542,14 @@ class RouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_origin")
 
+    @property
+    @pulumi.getter(name="nextHopPeering")
+    def next_hop_peering(self) -> str:
+        """
+        The network peering name that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_peering")
+
     @property
     @pulumi.getter(name="nextHopVpnTunnel")
     def next_hop_vpn_tunnel(self) -> str:
@@ -39594,6 +40581,28 @@ class RouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "project")
 
+    @property
+    @pulumi.getter(name="routeStatus")
+    def route_status(self) -> str:
+        """
+        The status of the route, which can be one of the following values:
+        - 'ACTIVE' for an active route
+        - 'INACTIVE' for an inactive route
+        """
+        return pulumi.get(self, "route_status")
+
+    @property
+    @pulumi.getter(name="routeType")
+    def route_type(self) -> str:
+        """
+        The type of this route, which can be one of the following values:
+        - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+        - 'SUBNET' for a route from a subnet of the VPC
+        - 'BGP' for a route learned from a BGP peer of this router
+        - 'STATIC' for a static route
+        """
+        return pulumi.get(self, "route_type")
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
@@ -39607,6 +40616,124 @@ class RouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter
+    def warnings(self) -> Sequence['outputs.RouterStatusBestRoutesForRouterWarningResult']:
+        """
+        If potential misconfigurations are detected for this route, this field will be populated with warning messages.
+        """
+        return pulumi.get(self, "warnings")
+
+
+@pulumi.output_type
+class RouterStatusBestRoutesForRouterAsPathResult(dict):
+    def __init__(__self__, *,
+                 as_lists: Sequence[int],
+                 path_segment_type: str):
+        """
+        :param Sequence[int] as_lists: The AS numbers of the AS Path.
+        :param str path_segment_type: 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
+        """
+        pulumi.set(__self__, "as_lists", as_lists)
+        pulumi.set(__self__, "path_segment_type", path_segment_type)
+
+    @property
+    @pulumi.getter(name="asLists")
+    def as_lists(self) -> Sequence[int]:
+        """
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> str:
+        """
+        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")
+
+
+@pulumi.output_type
+class RouterStatusBestRoutesForRouterWarningResult(dict):
+    def __init__(__self__, *,
+                 code: str,
+                 datas: Sequence['outputs.RouterStatusBestRoutesForRouterWarningDataResult'],
+                 message: str):
+        """
+        :param str code: A warning code, if applicable. For example, Compute Engine returns
+               NO_RESULTS_ON_PAGE if there are no results in the response.
+        :param Sequence['RouterStatusBestRoutesForRouterWarningDataArgs'] datas: Metadata about this warning in key: value format. For example:
+               "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        :param str message: A human-readable description of the warning code.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "datas", datas)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Sequence['outputs.RouterStatusBestRoutesForRouterWarningDataResult']:
+        """
+        Metadata about this warning in key: value format. For example:
+        "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        """
+        return pulumi.get(self, "datas")
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class RouterStatusBestRoutesForRouterWarningDataResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: 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 str value: A warning data value corresponding to the key.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
 
 @pulumi.output_type
 class SecurityPolicyAdaptiveProtectionConfig(dict):
@@ -42396,6 +43523,8 @@ class URLMapDefaultRouteAction(dict):
             suggest = "cors_policy"
         elif key == "faultInjectionPolicy":
             suggest = "fault_injection_policy"
+        elif key == "maxStreamDuration":
+            suggest = "max_stream_duration"
         elif key == "requestMirrorPolicy":
             suggest = "request_mirror_policy"
         elif key == "retryPolicy":
@@ -42419,6 +43548,7 @@ class URLMapDefaultRouteAction(dict):
     def __init__(__self__, *,
                  cors_policy: Optional['outputs.URLMapDefaultRouteActionCorsPolicy'] = None,
                  fault_injection_policy: Optional['outputs.URLMapDefaultRouteActionFaultInjectionPolicy'] = None,
+                 max_stream_duration: Optional['outputs.URLMapDefaultRouteActionMaxStreamDuration'] = None,
                  request_mirror_policy: Optional['outputs.URLMapDefaultRouteActionRequestMirrorPolicy'] = None,
                  retry_policy: Optional['outputs.URLMapDefaultRouteActionRetryPolicy'] = None,
                  timeout: Optional['outputs.URLMapDefaultRouteActionTimeout'] = None,
@@ -42434,6 +43564,12 @@ class URLMapDefaultRouteAction(dict):
                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 '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 '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.
@@ -42459,6 +43595,8 @@ class URLMapDefaultRouteAction(dict):
             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:
@@ -42493,6 +43631,19 @@ class URLMapDefaultRouteAction(dict):
         """
         return pulumi.get(self, "fault_injection_policy")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional['outputs.URLMapDefaultRouteActionMaxStreamDuration']:
+        """
+        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")
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional['outputs.URLMapDefaultRouteActionRequestMirrorPolicy']:
@@ -42865,6 +44016,40 @@ class URLMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelay(dict):
         return pulumi.get(self, "seconds")
 
 
+@pulumi.output_type
+class URLMapDefaultRouteActionMaxStreamDuration(dict):
+    def __init__(__self__, *,
+                 seconds: str,
+                 nanos: Optional[int] = None):
+        """
+        :param 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 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) -> 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")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[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")
+
+
 @pulumi.output_type
 class URLMapDefaultRouteActionRequestMirrorPolicy(dict):
     @staticmethod
@@ -44209,6 +45394,8 @@ class URLMapPathMatcherDefaultRouteAction(dict):
             suggest = "cors_policy"
         elif key == "faultInjectionPolicy":
             suggest = "fault_injection_policy"
+        elif key == "maxStreamDuration":
+            suggest = "max_stream_duration"
         elif key == "requestMirrorPolicy":
             suggest = "request_mirror_policy"
         elif key == "retryPolicy":
@@ -44232,6 +45419,7 @@ class URLMapPathMatcherDefaultRouteAction(dict):
     def __init__(__self__, *,
                  cors_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionCorsPolicy'] = None,
                  fault_injection_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionFaultInjectionPolicy'] = None,
+                 max_stream_duration: Optional['outputs.URLMapPathMatcherDefaultRouteActionMaxStreamDuration'] = None,
                  request_mirror_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy'] = None,
                  retry_policy: Optional['outputs.URLMapPathMatcherDefaultRouteActionRetryPolicy'] = None,
                  timeout: Optional['outputs.URLMapPathMatcherDefaultRouteActionTimeout'] = None,
@@ -44247,6 +45435,12 @@ class URLMapPathMatcherDefaultRouteAction(dict):
                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 '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 '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.
@@ -44272,6 +45466,8 @@ class URLMapPathMatcherDefaultRouteAction(dict):
             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:
@@ -44306,6 +45502,19 @@ class URLMapPathMatcherDefaultRouteAction(dict):
         """
         return pulumi.get(self, "fault_injection_policy")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionMaxStreamDuration']:
+        """
+        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")
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy']:
@@ -44678,6 +45887,40 @@ class URLMapPathMatcherDefaultRouteActionFaultInjectionPolicyDelayFixedDelay(dic
         return pulumi.get(self, "seconds")
 
 
+@pulumi.output_type
+class URLMapPathMatcherDefaultRouteActionMaxStreamDuration(dict):
+    def __init__(__self__, *,
+                 seconds: str,
+                 nanos: Optional[int] = None):
+        """
+        :param 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 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) -> 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")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[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")
+
+
 @pulumi.output_type
 class URLMapPathMatcherDefaultRouteActionRequestMirrorPolicy(dict):
     @staticmethod
@@ -45874,6 +47117,8 @@ class URLMapPathMatcherPathRuleRouteAction(dict):
             suggest = "cors_policy"
         elif key == "faultInjectionPolicy":
             suggest = "fault_injection_policy"
+        elif key == "maxStreamDuration":
+            suggest = "max_stream_duration"
         elif key == "requestMirrorPolicy":
             suggest = "request_mirror_policy"
         elif key == "retryPolicy":
@@ -45897,6 +47142,7 @@ class URLMapPathMatcherPathRuleRouteAction(dict):
     def __init__(__self__, *,
                  cors_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionCorsPolicy'] = None,
                  fault_injection_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicy'] = None,
+                 max_stream_duration: Optional['outputs.URLMapPathMatcherPathRuleRouteActionMaxStreamDuration'] = None,
                  request_mirror_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy'] = None,
                  retry_policy: Optional['outputs.URLMapPathMatcherPathRuleRouteActionRetryPolicy'] = None,
                  timeout: Optional['outputs.URLMapPathMatcherPathRuleRouteActionTimeout'] = None,
@@ -45914,6 +47160,12 @@ class URLMapPathMatcherPathRuleRouteAction(dict):
                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 '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 '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
@@ -45943,6 +47195,8 @@ class URLMapPathMatcherPathRuleRouteAction(dict):
             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:
@@ -45979,6 +47233,19 @@ class URLMapPathMatcherPathRuleRouteAction(dict):
         """
         return pulumi.get(self, "fault_injection_policy")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionMaxStreamDuration']:
+        """
+        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")
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy']:
@@ -46349,6 +47616,40 @@ class URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelay(di
         return pulumi.get(self, "nanos")
 
 
+@pulumi.output_type
+class URLMapPathMatcherPathRuleRouteActionMaxStreamDuration(dict):
+    def __init__(__self__, *,
+                 seconds: str,
+                 nanos: Optional[int] = None):
+        """
+        :param 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 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) -> 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")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[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")
+
+
 @pulumi.output_type
 class URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicy(dict):
     @staticmethod
@@ -48032,6 +49333,8 @@ class URLMapPathMatcherRouteRuleRouteAction(dict):
             suggest = "cors_policy"
         elif key == "faultInjectionPolicy":
             suggest = "fault_injection_policy"
+        elif key == "maxStreamDuration":
+            suggest = "max_stream_duration"
         elif key == "requestMirrorPolicy":
             suggest = "request_mirror_policy"
         elif key == "retryPolicy":
@@ -48055,6 +49358,7 @@ class URLMapPathMatcherRouteRuleRouteAction(dict):
     def __init__(__self__, *,
                  cors_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionCorsPolicy'] = None,
                  fault_injection_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicy'] = None,
+                 max_stream_duration: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionMaxStreamDuration'] = None,
                  request_mirror_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy'] = None,
                  retry_policy: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRetryPolicy'] = None,
                  timeout: Optional['outputs.URLMapPathMatcherRouteRuleRouteActionTimeout'] = None,
@@ -48072,6 +49376,12 @@ class URLMapPathMatcherRouteRuleRouteAction(dict):
                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 '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 '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
@@ -48101,6 +49411,8 @@ class URLMapPathMatcherRouteRuleRouteAction(dict):
             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:
@@ -48137,6 +49449,19 @@ class URLMapPathMatcherRouteRuleRouteAction(dict):
         """
         return pulumi.get(self, "fault_injection_policy")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionMaxStreamDuration']:
+        """
+        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")
+
     @property
     @pulumi.getter(name="requestMirrorPolicy")
     def request_mirror_policy(self) -> Optional['outputs.URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy']:
@@ -48512,6 +49837,40 @@ class URLMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelay(d
         return pulumi.get(self, "nanos")
 
 
+@pulumi.output_type
+class URLMapPathMatcherRouteRuleRouteActionMaxStreamDuration(dict):
+    def __init__(__self__, *,
+                 seconds: str,
+                 nanos: Optional[int] = None):
+        """
+        :param 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 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) -> 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")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[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")
+
+
 @pulumi.output_type
 class URLMapPathMatcherRouteRuleRouteActionRequestMirrorPolicy(dict):
     @staticmethod
@@ -49616,6 +50975,7 @@ class GetBackendServiceBackendResult(dict):
     def __init__(__self__, *,
                  balancing_mode: str,
                  capacity_scaler: float,
+                 custom_metrics: Sequence['outputs.GetBackendServiceBackendCustomMetricResult'],
                  description: str,
                  group: str,
                  max_connections: int,
@@ -49629,11 +50989,11 @@ class GetBackendServiceBackendResult(dict):
         :param 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: "UTILIZATION" Possible values: ["UTILIZATION", "RATE", "CONNECTION"]
+               for an explanation of load balancing modes. Default value: "UTILIZATION" Possible values: ["UTILIZATION", "RATE", "CONNECTION", "CUSTOM_METRICS"]
         :param float capacity_scaler: A multiplier applied to the group's maximum servicing capacity
                (based on UTILIZATION, RATE or CONNECTION).
                
@@ -49641,6 +51001,7 @@ class GetBackendServiceBackendResult(dict):
                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 Sequence['GetBackendServiceBackendCustomMetricArgs'] custom_metrics: The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
         :param str description: Textual description for the Backend Service.
         :param str group: The fully-qualified URL of an Instance Group or Network Endpoint
                Group resource. In case of instance group this defines the list
@@ -49698,6 +51059,7 @@ class GetBackendServiceBackendResult(dict):
         """
         pulumi.set(__self__, "balancing_mode", balancing_mode)
         pulumi.set(__self__, "capacity_scaler", capacity_scaler)
+        pulumi.set(__self__, "custom_metrics", custom_metrics)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "group", group)
         pulumi.set(__self__, "max_connections", max_connections)
@@ -49715,11 +51077,11 @@ class GetBackendServiceBackendResult(dict):
         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: "UTILIZATION" Possible values: ["UTILIZATION", "RATE", "CONNECTION"]
+        for an explanation of load balancing modes. Default value: "UTILIZATION" Possible values: ["UTILIZATION", "RATE", "CONNECTION", "CUSTOM_METRICS"]
         """
         return pulumi.get(self, "balancing_mode")
 
@@ -49737,6 +51099,14 @@ class GetBackendServiceBackendResult(dict):
         """
         return pulumi.get(self, "capacity_scaler")
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Sequence['outputs.GetBackendServiceBackendCustomMetricResult']:
+        """
+        The set of custom metrics that are used for <code>CUSTOM_METRICS</code> BalancingMode.
+        """
+        return pulumi.get(self, "custom_metrics")
+
     @property
     @pulumi.getter
     def description(self) -> str:
@@ -49855,6 +51225,54 @@ class GetBackendServiceBackendResult(dict):
         return pulumi.get(self, "max_utilization")
 
 
+@pulumi.output_type
+class GetBackendServiceBackendCustomMetricResult(dict):
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 max_utilization: float,
+                 name: str):
+        """
+        :param bool dry_run: If true, the metric data is collected and reported to Cloud
+               Monitoring, but is not used for load balancing.
+        :param 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>.
+        :param str name: The name of the Backend Service.
+               
+               - - -
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "max_utilization", max_utilization)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> bool:
+        """
+        If true, the metric data is collected and reported to Cloud
+        Monitoring, but is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter(name="maxUtilization")
+    def max_utilization(self) -> 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")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the Backend Service.
+
+        - - -
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class GetBackendServiceCdnPolicyResult(dict):
     def __init__(__self__, *,
@@ -50430,6 +51848,39 @@ class GetBackendServiceConsistentHashHttpCookyTtlResult(dict):
         return pulumi.get(self, "seconds")
 
 
+@pulumi.output_type
+class GetBackendServiceCustomMetricResult(dict):
+    def __init__(__self__, *,
+                 dry_run: bool,
+                 name: str):
+        """
+        :param bool dry_run: If true, the metric data is not used for load balancing.
+        :param str name: The name of the Backend Service.
+               
+               - - -
+        """
+        pulumi.set(__self__, "dry_run", dry_run)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="dryRun")
+    def dry_run(self) -> bool:
+        """
+        If true, the metric data is not used for load balancing.
+        """
+        return pulumi.get(self, "dry_run")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the Backend Service.
+
+        - - -
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class GetBackendServiceIapResult(dict):
     def __init__(__self__, *,
@@ -51158,6 +52609,28 @@ class GetDiskGuestOsFeatureResult(dict):
         return pulumi.get(self, "type")
 
 
+@pulumi.output_type
+class GetDiskParamResult(dict):
+    def __init__(__self__, *,
+                 resource_manager_tags: Mapping[str, str]):
+        """
+        :param Mapping[str, 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.
+        """
+        pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Mapping[str, 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")
+
+
 @pulumi.output_type
 class GetDiskSourceImageEncryptionKeyResult(dict):
     def __init__(__self__, *,
@@ -54162,7 +55635,7 @@ class GetInstanceNetworkInterfaceResult(dict):
         :param str ipv6_address: An IPv6 internal network address for this network interface. If not specified, Google Cloud will automatically assign an internal IPv6 address from the instance's subnetwork.
         :param str name: The name of the instance. One of `name` or `self_link` must be provided.
         :param str network: The name or self_link of the network attached to this interface.
-        :param str network_attachment: Beta The URL of the network attachment to this interface.
+        :param str network_attachment: The URL of the network attachment to this interface.
         :param str network_ip: The internal ip address of the instance, either manually or dynamically assigned.
         :param str nic_type: The type of vNIC to be used on this interface. Possible values:GVNIC, VIRTIO_NET, IDPF, MRDMA, and IRDMA
         :param int queue_count: The networking queue count that's specified by users for the network interface. Both Rx and Tx queues will be set to this number. It will be empty if not specified.
@@ -54257,7 +55730,7 @@ class GetInstanceNetworkInterfaceResult(dict):
     @pulumi.getter(name="networkAttachment")
     def network_attachment(self) -> str:
         """
-        Beta The URL of the network attachment to this interface.
+        The URL of the network attachment to this interface.
         """
         return pulumi.get(self, "network_attachment")
 
@@ -54585,7 +56058,8 @@ class GetInstanceSchedulingResult(dict):
                  on_host_maintenance: str,
                  on_instance_stop_actions: Sequence['outputs.GetInstanceSchedulingOnInstanceStopActionResult'],
                  preemptible: bool,
-                 provisioning_model: str):
+                 provisioning_model: str,
+                 termination_time: str):
         """
         :param bool automatic_restart: Specifies if the instance should be
                restarted if it was terminated by Compute Engine (not a user).
@@ -54606,6 +56080,9 @@ class GetInstanceSchedulingResult(dict):
         :param Sequence['GetInstanceSchedulingOnInstanceStopActionArgs'] on_instance_stop_actions: Defines the behaviour for instances with the instance_termination_action.
         :param bool preemptible: Whether the instance is preemptible.
         :param str provisioning_model: Describe the type of preemptible VM.
+        :param 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.
         """
         pulumi.set(__self__, "automatic_restart", automatic_restart)
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -54621,6 +56098,7 @@ class GetInstanceSchedulingResult(dict):
         pulumi.set(__self__, "on_instance_stop_actions", on_instance_stop_actions)
         pulumi.set(__self__, "preemptible", preemptible)
         pulumi.set(__self__, "provisioning_model", provisioning_model)
+        pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -54737,6 +56215,16 @@ class GetInstanceSchedulingResult(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> 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")
+
 
 @pulumi.output_type
 class GetInstanceSchedulingGracefulShutdownResult(dict):
@@ -55996,7 +57484,8 @@ class GetInstanceTemplateSchedulingResult(dict):
                  on_host_maintenance: str,
                  on_instance_stop_actions: Sequence['outputs.GetInstanceTemplateSchedulingOnInstanceStopActionResult'],
                  preemptible: bool,
-                 provisioning_model: str):
+                 provisioning_model: str,
+                 termination_time: str):
         """
         :param bool automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -56024,6 +57513,9 @@ class GetInstanceTemplateSchedulingResult(dict):
                false. Read more on this
                [here](https://cloud.google.com/compute/docs/instances/preemptible).
         :param str provisioning_model: Describe the type of preemptible VM.
+        :param 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.
         """
         pulumi.set(__self__, "automatic_restart", automatic_restart)
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -56039,6 +57531,7 @@ class GetInstanceTemplateSchedulingResult(dict):
         pulumi.set(__self__, "on_instance_stop_actions", on_instance_stop_actions)
         pulumi.set(__self__, "preemptible", preemptible)
         pulumi.set(__self__, "provisioning_model", provisioning_model)
+        pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -56164,6 +57657,16 @@ class GetInstanceTemplateSchedulingResult(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> 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")
+
 
 @pulumi.output_type
 class GetInstanceTemplateSchedulingGracefulShutdownResult(dict):
@@ -56678,16 +58181,21 @@ class GetRegionDiskDiskEncryptionKeyResult(dict):
     def __init__(__self__, *,
                  kms_key_name: str,
                  raw_key: str,
+                 rsa_encrypted_key: str,
                  sha256: str):
         """
         :param str kms_key_name: The name of the encryption key that is stored in Google Cloud KMS.
         :param str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in
                RFC 4648 base64 to either encrypt or decrypt this resource.
+        :param 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.
         :param str sha256: The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied
                encryption key that protects this resource.
         """
         pulumi.set(__self__, "kms_key_name", kms_key_name)
         pulumi.set(__self__, "raw_key", raw_key)
+        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
         pulumi.set(__self__, "sha256", sha256)
 
     @property
@@ -56707,6 +58215,16 @@ class GetRegionDiskDiskEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "raw_key")
 
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> 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.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
     @property
     @pulumi.getter
     def sha256(self) -> str:
@@ -58421,7 +59939,8 @@ class GetRegionInstanceTemplateSchedulingResult(dict):
                  on_host_maintenance: str,
                  on_instance_stop_actions: Sequence['outputs.GetRegionInstanceTemplateSchedulingOnInstanceStopActionResult'],
                  preemptible: bool,
-                 provisioning_model: str):
+                 provisioning_model: str,
+                 termination_time: str):
         """
         :param bool automatic_restart: Specifies whether the instance should be
                automatically restarted if it is terminated by Compute Engine (not
@@ -58449,6 +59968,9 @@ class GetRegionInstanceTemplateSchedulingResult(dict):
                false. Read more on this
                [here](https://cloud.google.com/compute/docs/instances/preemptible).
         :param str provisioning_model: Describe the type of preemptible VM.
+        :param 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.
         """
         pulumi.set(__self__, "automatic_restart", automatic_restart)
         pulumi.set(__self__, "availability_domain", availability_domain)
@@ -58464,6 +59986,7 @@ class GetRegionInstanceTemplateSchedulingResult(dict):
         pulumi.set(__self__, "on_instance_stop_actions", on_instance_stop_actions)
         pulumi.set(__self__, "preemptible", preemptible)
         pulumi.set(__self__, "provisioning_model", provisioning_model)
+        pulumi.set(__self__, "termination_time", termination_time)
 
     @property
     @pulumi.getter(name="automaticRestart")
@@ -58589,6 +60112,16 @@ class GetRegionInstanceTemplateSchedulingResult(dict):
         """
         return pulumi.get(self, "provisioning_model")
 
+    @property
+    @pulumi.getter(name="terminationTime")
+    def termination_time(self) -> 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")
+
 
 @pulumi.output_type
 class GetRegionInstanceTemplateSchedulingGracefulShutdownResult(dict):
@@ -60196,11 +61729,14 @@ class GetRouterNatSubnetworkResult(dict):
 @pulumi.output_type
 class GetRouterStatusBestRouteResult(dict):
     def __init__(__self__, *,
+                 as_paths: Sequence['outputs.GetRouterStatusBestRouteAsPathResult'],
+                 creation_timestamp: str,
                  description: str,
                  dest_range: str,
                  name: str,
                  network: str,
                  next_hop_gateway: str,
+                 next_hop_hub: str,
                  next_hop_ilb: str,
                  next_hop_instance: str,
                  next_hop_instance_zone: str,
@@ -60209,12 +61745,17 @@ class GetRouterStatusBestRouteResult(dict):
                  next_hop_med: str,
                  next_hop_network: str,
                  next_hop_origin: str,
+                 next_hop_peering: str,
                  next_hop_vpn_tunnel: str,
                  priority: int,
                  project: str,
+                 route_status: str,
+                 route_type: str,
                  self_link: str,
-                 tags: Sequence[str]):
+                 tags: Sequence[str],
+                 warnings: Sequence['outputs.GetRouterStatusBestRouteWarningResult']):
         """
+        :param str creation_timestamp: Creation timestamp in RFC3339 text format.
         :param str description: An optional description of this resource. Provide this property
                when you create the resource.
         :param str dest_range: The destination range of outgoing packets that this route applies to.
@@ -60229,6 +61770,7 @@ class GetRouterStatusBestRouteResult(dict):
                * 'projects/project/global/gateways/default-internet-gateway'
                * 'global/gateways/default-internet-gateway'
                * The string 'default-internet-gateway'.
+        :param str next_hop_hub: The hub network that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_ilb: The IP address or URL to a forwarding rule of type
                loadBalancingScheme=INTERNAL that should handle matching
                packets.
@@ -60257,6 +61799,7 @@ class GetRouterStatusBestRouteResult(dict):
         :param str next_hop_med: Multi-Exit Discriminator, a BGP route metric that indicates the desirability of a particular route in a network.
         :param str next_hop_network: URL to a Network that should handle matching packets.
         :param str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
+        :param str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
         :param int priority: The priority of this route. Priority is used to break ties in cases
                where there is more than one matching route of equal prefix length.
@@ -60267,13 +61810,25 @@ class GetRouterStatusBestRouteResult(dict):
                Default value is 1000. Valid range is 0 through 65535.
         :param str project: The ID of the project in which the resource
                belongs. If it is not provided, the provider project is used.
+        :param str route_status: The status of the route, which can be one of the following values:
+               - 'ACTIVE' for an active route
+               - 'INACTIVE' for an inactive route
+        :param str route_type: The type of this route, which can be one of the following values:
+               - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+               - 'SUBNET' for a route from a subnet of the VPC
+               - 'BGP' for a route learned from a BGP peer of this router
+               - 'STATIC' for a static route
         :param Sequence[str] tags: A list of instance tags to which this route applies.
+        :param Sequence['GetRouterStatusBestRouteWarningArgs'] warnings: If potential misconfigurations are detected for this route, this field will be populated with warning messages.
         """
+        pulumi.set(__self__, "as_paths", as_paths)
+        pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "dest_range", dest_range)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network", network)
         pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
+        pulumi.set(__self__, "next_hop_hub", next_hop_hub)
         pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
         pulumi.set(__self__, "next_hop_instance", next_hop_instance)
         pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
@@ -60282,11 +61837,28 @@ class GetRouterStatusBestRouteResult(dict):
         pulumi.set(__self__, "next_hop_med", next_hop_med)
         pulumi.set(__self__, "next_hop_network", next_hop_network)
         pulumi.set(__self__, "next_hop_origin", next_hop_origin)
+        pulumi.set(__self__, "next_hop_peering", next_hop_peering)
         pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
+        pulumi.set(__self__, "route_status", route_status)
+        pulumi.set(__self__, "route_type", route_type)
         pulumi.set(__self__, "self_link", self_link)
         pulumi.set(__self__, "tags", tags)
+        pulumi.set(__self__, "warnings", warnings)
+
+    @property
+    @pulumi.getter(name="asPaths")
+    def as_paths(self) -> Sequence['outputs.GetRouterStatusBestRouteAsPathResult']:
+        return pulumi.get(self, "as_paths")
+
+    @property
+    @pulumi.getter(name="creationTimestamp")
+    def creation_timestamp(self) -> str:
+        """
+        Creation timestamp in RFC3339 text format.
+        """
+        return pulumi.get(self, "creation_timestamp")
 
     @property
     @pulumi.getter
@@ -60337,6 +61909,14 @@ class GetRouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_gateway")
 
+    @property
+    @pulumi.getter(name="nextHopHub")
+    def next_hop_hub(self) -> str:
+        """
+        The hub network that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_hub")
+
     @property
     @pulumi.getter(name="nextHopIlb")
     def next_hop_ilb(self) -> str:
@@ -60421,6 +62001,14 @@ class GetRouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_origin")
 
+    @property
+    @pulumi.getter(name="nextHopPeering")
+    def next_hop_peering(self) -> str:
+        """
+        The network peering name that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_peering")
+
     @property
     @pulumi.getter(name="nextHopVpnTunnel")
     def next_hop_vpn_tunnel(self) -> str:
@@ -60452,6 +62040,28 @@ class GetRouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "project")
 
+    @property
+    @pulumi.getter(name="routeStatus")
+    def route_status(self) -> str:
+        """
+        The status of the route, which can be one of the following values:
+        - 'ACTIVE' for an active route
+        - 'INACTIVE' for an inactive route
+        """
+        return pulumi.get(self, "route_status")
+
+    @property
+    @pulumi.getter(name="routeType")
+    def route_type(self) -> str:
+        """
+        The type of this route, which can be one of the following values:
+        - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+        - 'SUBNET' for a route from a subnet of the VPC
+        - 'BGP' for a route learned from a BGP peer of this router
+        - 'STATIC' for a static route
+        """
+        return pulumi.get(self, "route_type")
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
@@ -60465,15 +62075,136 @@ class GetRouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter
+    def warnings(self) -> Sequence['outputs.GetRouterStatusBestRouteWarningResult']:
+        """
+        If potential misconfigurations are detected for this route, this field will be populated with warning messages.
+        """
+        return pulumi.get(self, "warnings")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRouteAsPathResult(dict):
+    def __init__(__self__, *,
+                 as_lists: Sequence[int],
+                 path_segment_type: str):
+        """
+        :param Sequence[int] as_lists: The AS numbers of the AS Path.
+        :param str path_segment_type: 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
+        """
+        pulumi.set(__self__, "as_lists", as_lists)
+        pulumi.set(__self__, "path_segment_type", path_segment_type)
+
+    @property
+    @pulumi.getter(name="asLists")
+    def as_lists(self) -> Sequence[int]:
+        """
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> str:
+        """
+        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")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRouteWarningResult(dict):
+    def __init__(__self__, *,
+                 code: str,
+                 datas: Sequence['outputs.GetRouterStatusBestRouteWarningDataResult'],
+                 message: str):
+        """
+        :param str code: A warning code, if applicable. For example, Compute Engine returns
+               NO_RESULTS_ON_PAGE if there are no results in the response.
+        :param Sequence['GetRouterStatusBestRouteWarningDataArgs'] datas: Metadata about this warning in key: value format. For example:
+               "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        :param str message: A human-readable description of the warning code.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "datas", datas)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Sequence['outputs.GetRouterStatusBestRouteWarningDataResult']:
+        """
+        Metadata about this warning in key: value format. For example:
+        "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        """
+        return pulumi.get(self, "datas")
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRouteWarningDataResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: 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 str value: A warning data value corresponding to the key.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
 
 @pulumi.output_type
 class GetRouterStatusBestRoutesForRouterResult(dict):
     def __init__(__self__, *,
+                 as_paths: Sequence['outputs.GetRouterStatusBestRoutesForRouterAsPathResult'],
+                 creation_timestamp: str,
                  description: str,
                  dest_range: str,
                  name: str,
                  network: str,
                  next_hop_gateway: str,
+                 next_hop_hub: str,
                  next_hop_ilb: str,
                  next_hop_instance: str,
                  next_hop_instance_zone: str,
@@ -60482,12 +62213,17 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
                  next_hop_med: str,
                  next_hop_network: str,
                  next_hop_origin: str,
+                 next_hop_peering: str,
                  next_hop_vpn_tunnel: str,
                  priority: int,
                  project: str,
+                 route_status: str,
+                 route_type: str,
                  self_link: str,
-                 tags: Sequence[str]):
+                 tags: Sequence[str],
+                 warnings: Sequence['outputs.GetRouterStatusBestRoutesForRouterWarningResult']):
         """
+        :param str creation_timestamp: Creation timestamp in RFC3339 text format.
         :param str description: An optional description of this resource. Provide this property
                when you create the resource.
         :param str dest_range: The destination range of outgoing packets that this route applies to.
@@ -60502,6 +62238,7 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
                * 'projects/project/global/gateways/default-internet-gateway'
                * 'global/gateways/default-internet-gateway'
                * The string 'default-internet-gateway'.
+        :param str next_hop_hub: The hub network that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_ilb: The IP address or URL to a forwarding rule of type
                loadBalancingScheme=INTERNAL that should handle matching
                packets.
@@ -60530,6 +62267,7 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         :param str next_hop_med: Multi-Exit Discriminator, a BGP route metric that indicates the desirability of a particular route in a network.
         :param str next_hop_network: URL to a Network that should handle matching packets.
         :param str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
+        :param str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
         :param int priority: The priority of this route. Priority is used to break ties in cases
                where there is more than one matching route of equal prefix length.
@@ -60540,13 +62278,25 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
                Default value is 1000. Valid range is 0 through 65535.
         :param str project: The ID of the project in which the resource
                belongs. If it is not provided, the provider project is used.
+        :param str route_status: The status of the route, which can be one of the following values:
+               - 'ACTIVE' for an active route
+               - 'INACTIVE' for an inactive route
+        :param str route_type: The type of this route, which can be one of the following values:
+               - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+               - 'SUBNET' for a route from a subnet of the VPC
+               - 'BGP' for a route learned from a BGP peer of this router
+               - 'STATIC' for a static route
         :param Sequence[str] tags: A list of instance tags to which this route applies.
+        :param Sequence['GetRouterStatusBestRoutesForRouterWarningArgs'] warnings: If potential misconfigurations are detected for this route, this field will be populated with warning messages.
         """
+        pulumi.set(__self__, "as_paths", as_paths)
+        pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         pulumi.set(__self__, "description", description)
         pulumi.set(__self__, "dest_range", dest_range)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "network", network)
         pulumi.set(__self__, "next_hop_gateway", next_hop_gateway)
+        pulumi.set(__self__, "next_hop_hub", next_hop_hub)
         pulumi.set(__self__, "next_hop_ilb", next_hop_ilb)
         pulumi.set(__self__, "next_hop_instance", next_hop_instance)
         pulumi.set(__self__, "next_hop_instance_zone", next_hop_instance_zone)
@@ -60555,11 +62305,28 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         pulumi.set(__self__, "next_hop_med", next_hop_med)
         pulumi.set(__self__, "next_hop_network", next_hop_network)
         pulumi.set(__self__, "next_hop_origin", next_hop_origin)
+        pulumi.set(__self__, "next_hop_peering", next_hop_peering)
         pulumi.set(__self__, "next_hop_vpn_tunnel", next_hop_vpn_tunnel)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
+        pulumi.set(__self__, "route_status", route_status)
+        pulumi.set(__self__, "route_type", route_type)
         pulumi.set(__self__, "self_link", self_link)
         pulumi.set(__self__, "tags", tags)
+        pulumi.set(__self__, "warnings", warnings)
+
+    @property
+    @pulumi.getter(name="asPaths")
+    def as_paths(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterAsPathResult']:
+        return pulumi.get(self, "as_paths")
+
+    @property
+    @pulumi.getter(name="creationTimestamp")
+    def creation_timestamp(self) -> str:
+        """
+        Creation timestamp in RFC3339 text format.
+        """
+        return pulumi.get(self, "creation_timestamp")
 
     @property
     @pulumi.getter
@@ -60610,6 +62377,14 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_gateway")
 
+    @property
+    @pulumi.getter(name="nextHopHub")
+    def next_hop_hub(self) -> str:
+        """
+        The hub network that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_hub")
+
     @property
     @pulumi.getter(name="nextHopIlb")
     def next_hop_ilb(self) -> str:
@@ -60694,6 +62469,14 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_origin")
 
+    @property
+    @pulumi.getter(name="nextHopPeering")
+    def next_hop_peering(self) -> str:
+        """
+        The network peering name that should handle matching packets, which should conform to RFC1035.
+        """
+        return pulumi.get(self, "next_hop_peering")
+
     @property
     @pulumi.getter(name="nextHopVpnTunnel")
     def next_hop_vpn_tunnel(self) -> str:
@@ -60725,6 +62508,28 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "project")
 
+    @property
+    @pulumi.getter(name="routeStatus")
+    def route_status(self) -> str:
+        """
+        The status of the route, which can be one of the following values:
+        - 'ACTIVE' for an active route
+        - 'INACTIVE' for an inactive route
+        """
+        return pulumi.get(self, "route_status")
+
+    @property
+    @pulumi.getter(name="routeType")
+    def route_type(self) -> str:
+        """
+        The type of this route, which can be one of the following values:
+        - 'TRANSIT' for a transit route that this router learned from another Cloud Router and will readvertise to one of its BGP peers
+        - 'SUBNET' for a route from a subnet of the VPC
+        - 'BGP' for a route learned from a BGP peer of this router
+        - 'STATIC' for a static route
+        """
+        return pulumi.get(self, "route_type")
+
     @property
     @pulumi.getter(name="selfLink")
     def self_link(self) -> str:
@@ -60738,6 +62543,124 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "tags")
 
+    @property
+    @pulumi.getter
+    def warnings(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterWarningResult']:
+        """
+        If potential misconfigurations are detected for this route, this field will be populated with warning messages.
+        """
+        return pulumi.get(self, "warnings")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRoutesForRouterAsPathResult(dict):
+    def __init__(__self__, *,
+                 as_lists: Sequence[int],
+                 path_segment_type: str):
+        """
+        :param Sequence[int] as_lists: The AS numbers of the AS Path.
+        :param str path_segment_type: 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
+        """
+        pulumi.set(__self__, "as_lists", as_lists)
+        pulumi.set(__self__, "path_segment_type", path_segment_type)
+
+    @property
+    @pulumi.getter(name="asLists")
+    def as_lists(self) -> Sequence[int]:
+        """
+        The AS numbers of the AS Path.
+        """
+        return pulumi.get(self, "as_lists")
+
+    @property
+    @pulumi.getter(name="pathSegmentType")
+    def path_segment_type(self) -> str:
+        """
+        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")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRoutesForRouterWarningResult(dict):
+    def __init__(__self__, *,
+                 code: str,
+                 datas: Sequence['outputs.GetRouterStatusBestRoutesForRouterWarningDataResult'],
+                 message: str):
+        """
+        :param str code: A warning code, if applicable. For example, Compute Engine returns
+               NO_RESULTS_ON_PAGE if there are no results in the response.
+        :param Sequence['GetRouterStatusBestRoutesForRouterWarningDataArgs'] datas: Metadata about this warning in key: value format. For example:
+               "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        :param str message: A human-readable description of the warning code.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "datas", datas)
+        pulumi.set(__self__, "message", message)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def datas(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterWarningDataResult']:
+        """
+        Metadata about this warning in key: value format. For example:
+        "data": [  {  "key": "scope",  "value": "zones/us-east1-d"  }
+        """
+        return pulumi.get(self, "datas")
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        A human-readable description of the warning code.
+        """
+        return pulumi.get(self, "message")
+
+
+@pulumi.output_type
+class GetRouterStatusBestRoutesForRouterWarningDataResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: 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 str value: A warning data value corresponding to the key.
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        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")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        A warning data value corresponding to the key.
+        """
+        return pulumi.get(self, "value")
+
 
 @pulumi.output_type
 class GetSecurityPolicyAdaptiveProtectionConfigResult(dict):