pulumi-gcp 8.37.0a1751903932__py3-none-any.whl → 8.39.0__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -78,6 +78,7 @@ __all__ = [
     'FirewallAllow',
     'FirewallDeny',
     'FirewallLogConfig',
+    'FirewallParams',
     'FirewallPolicyRuleMatch',
     'FirewallPolicyRuleMatchLayer4Config',
     'FirewallPolicyRuleMatchSrcSecureTag',
@@ -89,6 +90,9 @@ __all__ = [
     'FirewallPolicyWithRulesRuleMatch',
     'FirewallPolicyWithRulesRuleMatchLayer4Config',
     'ForwardingRuleServiceDirectoryRegistrations',
+    'FutureReservationAggregateReservation',
+    'FutureReservationAggregateReservationReservedResource',
+    'FutureReservationAggregateReservationReservedResourceAccelerator',
     'FutureReservationAutoCreatedReservationsDuration',
     'FutureReservationCommitmentInfo',
     'FutureReservationShareSettings',
@@ -268,6 +272,11 @@ __all__ = [
     'InstanceTemplateShieldedInstanceConfig',
     'InstantSnapshotIamBindingCondition',
     'InstantSnapshotIamMemberCondition',
+    'InterconnectApplicationAwareInterconnect',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage',
+    'InterconnectApplicationAwareInterconnectShapeAveragePercentage',
+    'InterconnectApplicationAwareInterconnectStrictPriorityPolicy',
     'InterconnectAttachmentGroupAttachment',
     'InterconnectAttachmentGroupConfigured',
     'InterconnectAttachmentGroupConfiguredAvailabilitySla',
@@ -573,6 +582,8 @@ __all__ = [
     'RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAdd',
     'RegionUrlMapPathMatcherRouteRuleUrlRedirect',
     'RegionUrlMapTest',
+    'ReservationDeleteAfterDuration',
+    'ReservationReservationSharingPolicy',
     'ReservationShareSettings',
     'ReservationShareSettingsProjectMap',
     'ReservationSpecificReservation',
@@ -613,6 +624,7 @@ __all__ = [
     'ResourcePolicySnapshotSchedulePolicySnapshotProperties',
     'ResourcePolicyWorkloadPolicy',
     'RouteAsPath',
+    'RouteParams',
     'RouteWarning',
     'RouteWarningData',
     'RouterBgp',
@@ -632,10 +644,12 @@ __all__ = [
     'RouterRoutePolicyTermMatch',
     'RouterStatusBestRouteResult',
     'RouterStatusBestRouteAsPathResult',
+    'RouterStatusBestRouteParamResult',
     'RouterStatusBestRouteWarningResult',
     'RouterStatusBestRouteWarningDataResult',
     'RouterStatusBestRoutesForRouterResult',
     'RouterStatusBestRoutesForRouterAsPathResult',
+    'RouterStatusBestRoutesForRouterParamResult',
     'RouterStatusBestRoutesForRouterWarningResult',
     'RouterStatusBestRoutesForRouterWarningDataResult',
     'SecurityPolicyAdaptiveProtectionConfig',
@@ -929,6 +943,7 @@ __all__ = [
     'GetMachineTypesMachineTypeAcceleratorResult',
     'GetMachineTypesMachineTypeBundledLocalSsdResult',
     'GetMachineTypesMachineTypeDeprecatedResult',
+    'GetNetworkAttachmentConnectionEndpointResult',
     'GetRegionBackendServiceBackendResult',
     'GetRegionBackendServiceBackendCustomMetricResult',
     'GetRegionBackendServiceCdnPolicyResult',
@@ -1005,6 +1020,8 @@ __all__ = [
     'GetRegionNetworkEndpointGroupCloudRunResult',
     'GetRegionNetworkEndpointGroupPscDataResult',
     'GetRegionNetworkEndpointGroupServerlessDeploymentResult',
+    'GetReservationDeleteAfterDurationResult',
+    'GetReservationReservationSharingPolicyResult',
     'GetReservationShareSettingResult',
     'GetReservationShareSettingProjectMapResult',
     'GetReservationSpecificReservationResult',
@@ -1035,10 +1052,12 @@ __all__ = [
     'GetRouterNatSubnetworkResult',
     'GetRouterStatusBestRouteResult',
     'GetRouterStatusBestRouteAsPathResult',
+    'GetRouterStatusBestRouteParamResult',
     'GetRouterStatusBestRouteWarningResult',
     'GetRouterStatusBestRouteWarningDataResult',
     'GetRouterStatusBestRoutesForRouterResult',
     'GetRouterStatusBestRoutesForRouterAsPathResult',
+    'GetRouterStatusBestRoutesForRouterParamResult',
     'GetRouterStatusBestRoutesForRouterWarningResult',
     'GetRouterStatusBestRoutesForRouterWarningDataResult',
     'GetSecurityPolicyAdaptiveProtectionConfigResult',
@@ -1770,7 +1789,7 @@ class AutoscalerAutoscalingPolicyScalingSchedule(dict):
         :param builtins.int min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
         :param builtins.str name: The identifier for this object. Format specified above.
         :param builtins.str schedule: The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
-        :param builtins.str description: An optional description of this resource.
+        :param builtins.str description: A description of a scaling schedule.
         :param builtins.bool disabled: A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
         :param builtins.str time_zone: The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
         """
@@ -1821,7 +1840,7 @@ class AutoscalerAutoscalingPolicyScalingSchedule(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         return pulumi.get(self, "description")
 
@@ -5386,6 +5405,52 @@ class FirewallLogConfig(dict):
         return pulumi.get(self, "metadata")
 
 
+@pulumi.output_type
+class FirewallParams(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 FirewallParams. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FirewallParams.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FirewallParams.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[Mapping[str, builtins.str]] = None):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the firewall. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        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, builtins.str]]:
+        """
+        Resource manager tags to be bound to the firewall. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class FirewallPolicyRuleMatch(dict):
     @staticmethod
@@ -5691,8 +5756,6 @@ class FirewallPolicyRuleMatchSrcSecureTag(dict):
         :param builtins.str name: Name of the secure tag, created with TagManager's TagValue API.
         :param builtins.str state: (Output)
                State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -5713,8 +5776,6 @@ class FirewallPolicyRuleMatchSrcSecureTag(dict):
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -5798,8 +5859,7 @@ class FirewallPolicyWithRulesPredefinedRule(dict):
         :param builtins.str action: (Output)
                The Action to perform when the client connection triggers the rule. Can currently be either
                "allow", "deny", "apply_security_profile_group" or "goto_next".
-        :param builtins.str description: (Output)
-               A description of the rule.
+        :param builtins.str description: An optional description of this resource.
         :param builtins.str direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param builtins.bool disabled: (Output)
@@ -5877,8 +5937,7 @@ class FirewallPolicyWithRulesPredefinedRule(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -6842,6 +6901,146 @@ class ForwardingRuleServiceDirectoryRegistrations(dict):
         return pulumi.get(self, "service")
 
 
+@pulumi.output_type
+class FutureReservationAggregateReservation(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "reservedResources":
+            suggest = "reserved_resources"
+        elif key == "vmFamily":
+            suggest = "vm_family"
+        elif key == "workloadType":
+            suggest = "workload_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationAggregateReservation. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationAggregateReservation.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationAggregateReservation.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 reserved_resources: Sequence['outputs.FutureReservationAggregateReservationReservedResource'],
+                 vm_family: Optional[builtins.str] = None,
+                 workload_type: Optional[builtins.str] = None):
+        """
+        :param Sequence['FutureReservationAggregateReservationReservedResourceArgs'] reserved_resources: futureReservations.list of reserved resources (CPUs, memory, accelerators).
+               Structure is documented below.
+        :param builtins.str vm_family: The VM family that all instances scheduled against this reservation must belong to.
+               Possible values are: `VM_FAMILY_CLOUD_TPU_DEVICE_CT3`, `VM_FAMILY_CLOUD_TPU_LITE_DEVICE_CT5L`, `VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT5LP`, `VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT6E`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT3P`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT4P`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT5P`.
+        :param builtins.str workload_type: The workload type of the instances that will target this reservation.
+               Possible values are: `BATCH`, `SERVING`, `UNSPECIFIED`.
+        """
+        pulumi.set(__self__, "reserved_resources", reserved_resources)
+        if vm_family is not None:
+            pulumi.set(__self__, "vm_family", vm_family)
+        if workload_type is not None:
+            pulumi.set(__self__, "workload_type", workload_type)
+
+    @property
+    @pulumi.getter(name="reservedResources")
+    def reserved_resources(self) -> Sequence['outputs.FutureReservationAggregateReservationReservedResource']:
+        """
+        futureReservations.list of reserved resources (CPUs, memory, accelerators).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "reserved_resources")
+
+    @property
+    @pulumi.getter(name="vmFamily")
+    def vm_family(self) -> Optional[builtins.str]:
+        """
+        The VM family that all instances scheduled against this reservation must belong to.
+        Possible values are: `VM_FAMILY_CLOUD_TPU_DEVICE_CT3`, `VM_FAMILY_CLOUD_TPU_LITE_DEVICE_CT5L`, `VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT5LP`, `VM_FAMILY_CLOUD_TPU_LITE_POD_SLICE_CT6E`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT3P`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT4P`, `VM_FAMILY_CLOUD_TPU_POD_SLICE_CT5P`.
+        """
+        return pulumi.get(self, "vm_family")
+
+    @property
+    @pulumi.getter(name="workloadType")
+    def workload_type(self) -> Optional[builtins.str]:
+        """
+        The workload type of the instances that will target this reservation.
+        Possible values are: `BATCH`, `SERVING`, `UNSPECIFIED`.
+        """
+        return pulumi.get(self, "workload_type")
+
+
+@pulumi.output_type
+class FutureReservationAggregateReservationReservedResource(dict):
+    def __init__(__self__, *,
+                 accelerator: Optional['outputs.FutureReservationAggregateReservationReservedResourceAccelerator'] = None):
+        """
+        :param 'FutureReservationAggregateReservationReservedResourceAcceleratorArgs' accelerator: Properties of accelerator resources in this reservation.
+               Structure is documented below.
+        """
+        if accelerator is not None:
+            pulumi.set(__self__, "accelerator", accelerator)
+
+    @property
+    @pulumi.getter
+    def accelerator(self) -> Optional['outputs.FutureReservationAggregateReservationReservedResourceAccelerator']:
+        """
+        Properties of accelerator resources in this reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "accelerator")
+
+
+@pulumi.output_type
+class FutureReservationAggregateReservationReservedResourceAccelerator(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "acceleratorCount":
+            suggest = "accelerator_count"
+        elif key == "acceleratorType":
+            suggest = "accelerator_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in FutureReservationAggregateReservationReservedResourceAccelerator. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        FutureReservationAggregateReservationReservedResourceAccelerator.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        FutureReservationAggregateReservationReservedResourceAccelerator.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 accelerator_count: Optional[builtins.int] = None,
+                 accelerator_type: Optional[builtins.str] = None):
+        """
+        :param builtins.int accelerator_count: Number of accelerators of specified type.
+        :param builtins.str accelerator_type: Full or partial URL to accelerator type. e.g. "projects/{PROJECT}/zones/{ZONE}/acceleratorTypes/ct4l"
+        """
+        if accelerator_count is not None:
+            pulumi.set(__self__, "accelerator_count", accelerator_count)
+        if accelerator_type is not None:
+            pulumi.set(__self__, "accelerator_type", accelerator_type)
+
+    @property
+    @pulumi.getter(name="acceleratorCount")
+    def accelerator_count(self) -> Optional[builtins.int]:
+        """
+        Number of accelerators of specified type.
+        """
+        return pulumi.get(self, "accelerator_count")
+
+    @property
+    @pulumi.getter(name="acceleratorType")
+    def accelerator_type(self) -> Optional[builtins.str]:
+        """
+        Full or partial URL to accelerator type. e.g. "projects/{PROJECT}/zones/{ZONE}/acceleratorTypes/ct4l"
+        """
+        return pulumi.get(self, "accelerator_type")
+
+
 @pulumi.output_type
 class FutureReservationAutoCreatedReservationsDuration(dict):
     def __init__(__self__, *,
@@ -7395,7 +7594,7 @@ class FutureReservationStatus(dict):
         :param builtins.str lock_time: The lock time of the FutureReservation before an amendment was requested.
         :param builtins.str procurement_status: The status of the last known good state for the Future Reservation
                Possible values are: .
-        :param 'FutureReservationStatusSpecificSkuPropertiesArgs' specific_sku_properties: The previous instance related properties of the Future Reservation.
+        :param 'FutureReservationStatusSpecificSkuPropertiesArgs' specific_sku_properties: Future Reservation configuration to indicate instance properties and total count.
                Structure is documented below.
         """
         if amendment_status is not None:
@@ -7468,7 +7667,7 @@ class FutureReservationStatus(dict):
     @pulumi.getter(name="specificSkuProperties")
     def specific_sku_properties(self) -> Optional['outputs.FutureReservationStatusSpecificSkuProperties']:
         """
-        The previous instance related properties of the Future Reservation.
+        Future Reservation configuration to indicate instance properties and total count.
         Structure is documented below.
         """
         return pulumi.get(self, "specific_sku_properties")
@@ -7509,13 +7708,13 @@ class FutureReservationStatusLastKnownGoodState(dict):
                  name_prefix: Optional[builtins.str] = None,
                  procurement_status: Optional[builtins.str] = None):
         """
-        :param builtins.str description: The description of the FutureReservation before an amendment was requested.
+        :param builtins.str description: An optional description of this resource.
         :param 'FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfoArgs' existing_matching_usage_info: Represents the matching usage for the future reservation before an amendment was requested.
                Structure is documented below.
         :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs' future_reservation_specs: The previous instance-related properties of the Future Reservation.
                Structure is documented below.
         :param builtins.str lock_time: The lock time of the FutureReservation before an amendment was requested.
-        :param builtins.str name_prefix: The name prefix of the Future Reservation before an amendment was requested.
+        :param builtins.str name_prefix: Name prefix for the reservations to be created at the time of delivery. The name prefix must comply with RFC1035. Maximum allowed length for name prefix is 20. Automatically created reservations name format will be -date-####.
         :param builtins.str procurement_status: The status of the last known good state for the Future Reservation
                Possible values are: .
         """
@@ -7536,7 +7735,7 @@ class FutureReservationStatusLastKnownGoodState(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        The description of the FutureReservation before an amendment was requested.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -7570,7 +7769,7 @@ class FutureReservationStatusLastKnownGoodState(dict):
     @pulumi.getter(name="namePrefix")
     def name_prefix(self) -> Optional[builtins.str]:
         """
-        The name prefix of the Future Reservation before an amendment was requested.
+        Name prefix for the reservations to be created at the time of delivery. The name prefix must comply with RFC1035. Maximum allowed length for name prefix is 20. Automatically created reservations name format will be -date-####.
         """
         return pulumi.get(self, "name_prefix")
 
@@ -7660,9 +7859,9 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecs(dict):
                  specific_sku_properties: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties'] = None,
                  time_window: Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindow'] = None):
         """
-        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs' share_settings: The previous share settings of the Future Reservation.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs' share_settings: Settings for sharing the future reservation
                Structure is documented below.
-        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs' specific_sku_properties: The previous instance related properties of the Future Reservation.
+        :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs' specific_sku_properties: Future Reservation configuration to indicate instance properties and total count.
                Structure is documented below.
         :param 'FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowArgs' time_window: Time window for this Future Reservation.
                Structure is documented below.
@@ -7678,7 +7877,7 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecs(dict):
     @pulumi.getter(name="shareSettings")
     def share_settings(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettings']:
         """
-        The previous share settings of the Future Reservation.
+        Settings for sharing the future reservation
         Structure is documented below.
         """
         return pulumi.get(self, "share_settings")
@@ -7687,7 +7886,7 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecs(dict):
     @pulumi.getter(name="specificSkuProperties")
     def specific_sku_properties(self) -> Optional['outputs.FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuProperties']:
         """
-        The previous instance related properties of the Future Reservation.
+        Future Reservation configuration to indicate instance properties and total count.
         Structure is documented below.
         """
         return pulumi.get(self, "specific_sku_properties")
@@ -7791,7 +7990,8 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettin
                  project: builtins.str,
                  project_id: Optional[builtins.str] = None):
         """
-        :param builtins.str project: (Required) The identifier for this object. Format specified above.
+        :param builtins.str project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
         :param builtins.str project_id: The project ID, should be same as the key of this project config in the parent map.
         """
         pulumi.set(__self__, "project", project)
@@ -7802,7 +8002,8 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettin
     @pulumi.getter
     def project(self) -> builtins.str:
         """
-        (Required) The identifier for this object. Format specified above.
+        The ID of the project in which the resource belongs.
+        If it is not provided, the provider project is used.
         """
         return pulumi.get(self, "project")
 
@@ -8178,8 +8379,6 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowD
                  seconds: Optional[builtins.str] = None):
         """
         :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
-               
-               - - -
         :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
         if nanos is not None:
@@ -8192,8 +8391,6 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowD
     def nanos(self) -> Optional[builtins.int]:
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         return pulumi.get(self, "nanos")
 
@@ -8312,8 +8509,6 @@ class FutureReservationTimeWindowDuration(dict):
                  seconds: Optional[builtins.str] = None):
         """
         :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
-               
-               - - -
         :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive.
         """
         if nanos is not None:
@@ -8326,8 +8521,6 @@ class FutureReservationTimeWindowDuration(dict):
     def nanos(self) -> Optional[builtins.int]:
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         return pulumi.get(self, "nanos")
 
@@ -20651,6 +20844,242 @@ class InstantSnapshotIamMemberCondition(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class InterconnectApplicationAwareInterconnect(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bandwidthPercentagePolicy":
+            suggest = "bandwidth_percentage_policy"
+        elif key == "profileDescription":
+            suggest = "profile_description"
+        elif key == "shapeAveragePercentages":
+            suggest = "shape_average_percentages"
+        elif key == "strictPriorityPolicy":
+            suggest = "strict_priority_policy"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InterconnectApplicationAwareInterconnect. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InterconnectApplicationAwareInterconnect.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InterconnectApplicationAwareInterconnect.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bandwidth_percentage_policy: Optional['outputs.InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy'] = None,
+                 profile_description: Optional[builtins.str] = None,
+                 shape_average_percentages: Optional[Sequence['outputs.InterconnectApplicationAwareInterconnectShapeAveragePercentage']] = None,
+                 strict_priority_policy: Optional['outputs.InterconnectApplicationAwareInterconnectStrictPriorityPolicy'] = None):
+        """
+        :param 'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs' bandwidth_percentage_policy: Bandwidth Percentage policy allows you to have granular control over how your Interconnect
+               bandwidth is utilized among your workloads mapping to different traffic classes.
+               Structure is documented below.
+        :param builtins.str profile_description: A description for the AAI profile on this interconnect.
+        :param Sequence['InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs'] shape_average_percentages: Optional field to specify a list of shape average percentages to be
+               applied in conjunction with StrictPriorityPolicy or BandwidthPercentagePolicy
+               Structure is documented below.
+        :param 'InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs' strict_priority_policy: Specify configuration for StrictPriorityPolicy.
+        """
+        if bandwidth_percentage_policy is not None:
+            pulumi.set(__self__, "bandwidth_percentage_policy", bandwidth_percentage_policy)
+        if profile_description is not None:
+            pulumi.set(__self__, "profile_description", profile_description)
+        if shape_average_percentages is not None:
+            pulumi.set(__self__, "shape_average_percentages", shape_average_percentages)
+        if strict_priority_policy is not None:
+            pulumi.set(__self__, "strict_priority_policy", strict_priority_policy)
+
+    @property
+    @pulumi.getter(name="bandwidthPercentagePolicy")
+    def bandwidth_percentage_policy(self) -> Optional['outputs.InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy']:
+        """
+        Bandwidth Percentage policy allows you to have granular control over how your Interconnect
+        bandwidth is utilized among your workloads mapping to different traffic classes.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "bandwidth_percentage_policy")
+
+    @property
+    @pulumi.getter(name="profileDescription")
+    def profile_description(self) -> Optional[builtins.str]:
+        """
+        A description for the AAI profile on this interconnect.
+        """
+        return pulumi.get(self, "profile_description")
+
+    @property
+    @pulumi.getter(name="shapeAveragePercentages")
+    def shape_average_percentages(self) -> Optional[Sequence['outputs.InterconnectApplicationAwareInterconnectShapeAveragePercentage']]:
+        """
+        Optional field to specify a list of shape average percentages to be
+        applied in conjunction with StrictPriorityPolicy or BandwidthPercentagePolicy
+        Structure is documented below.
+        """
+        return pulumi.get(self, "shape_average_percentages")
+
+    @property
+    @pulumi.getter(name="strictPriorityPolicy")
+    def strict_priority_policy(self) -> Optional['outputs.InterconnectApplicationAwareInterconnectStrictPriorityPolicy']:
+        """
+        Specify configuration for StrictPriorityPolicy.
+        """
+        return pulumi.get(self, "strict_priority_policy")
+
+
+@pulumi.output_type
+class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bandwidthPercentages":
+            suggest = "bandwidth_percentages"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InterconnectApplicationAwareInterconnectBandwidthPercentagePolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 bandwidth_percentages: Optional[Sequence['outputs.InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage']] = None):
+        """
+        :param Sequence['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs'] bandwidth_percentages: Specify bandwidth percentages for various traffic classes for queuing
+               type Bandwidth Percent.
+               Structure is documented below.
+        """
+        if bandwidth_percentages is not None:
+            pulumi.set(__self__, "bandwidth_percentages", bandwidth_percentages)
+
+    @property
+    @pulumi.getter(name="bandwidthPercentages")
+    def bandwidth_percentages(self) -> Optional[Sequence['outputs.InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage']]:
+        """
+        Specify bandwidth percentages for various traffic classes for queuing
+        type Bandwidth Percent.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "bandwidth_percentages")
+
+
+@pulumi.output_type
+class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "trafficClass":
+            suggest = "traffic_class"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentage.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 percentage: Optional[builtins.int] = None,
+                 traffic_class: Optional[builtins.str] = None):
+        """
+        :param builtins.int percentage: Bandwidth percentage for a specific traffic class.
+        :param builtins.str traffic_class: Enum representing the various traffic classes offered by AAI.
+               Default value is `TC_UNSPECIFIED`.
+               Possible values are: `TC_UNSPECIFIED`, `TC1`, `TC2`, `TC3`, `TC4`, `TC5`, `TC6`.
+        """
+        if percentage is not None:
+            pulumi.set(__self__, "percentage", percentage)
+        if traffic_class is not None:
+            pulumi.set(__self__, "traffic_class", traffic_class)
+
+    @property
+    @pulumi.getter
+    def percentage(self) -> Optional[builtins.int]:
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        return pulumi.get(self, "percentage")
+
+    @property
+    @pulumi.getter(name="trafficClass")
+    def traffic_class(self) -> Optional[builtins.str]:
+        """
+        Enum representing the various traffic classes offered by AAI.
+        Default value is `TC_UNSPECIFIED`.
+        Possible values are: `TC_UNSPECIFIED`, `TC1`, `TC2`, `TC3`, `TC4`, `TC5`, `TC6`.
+        """
+        return pulumi.get(self, "traffic_class")
+
+
+@pulumi.output_type
+class InterconnectApplicationAwareInterconnectShapeAveragePercentage(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "trafficClass":
+            suggest = "traffic_class"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InterconnectApplicationAwareInterconnectShapeAveragePercentage. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InterconnectApplicationAwareInterconnectShapeAveragePercentage.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InterconnectApplicationAwareInterconnectShapeAveragePercentage.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 percentage: Optional[builtins.int] = None,
+                 traffic_class: Optional[builtins.str] = None):
+        """
+        :param builtins.int percentage: Bandwidth percentage for a specific traffic class.
+        :param builtins.str traffic_class: Enum representing the various traffic classes offered by AAI.
+               Default value is `TC_UNSPECIFIED`.
+               Possible values are: `TC_UNSPECIFIED`, `TC1`, `TC2`, `TC3`, `TC4`, `TC5`, `TC6`.
+        """
+        if percentage is not None:
+            pulumi.set(__self__, "percentage", percentage)
+        if traffic_class is not None:
+            pulumi.set(__self__, "traffic_class", traffic_class)
+
+    @property
+    @pulumi.getter
+    def percentage(self) -> Optional[builtins.int]:
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        return pulumi.get(self, "percentage")
+
+    @property
+    @pulumi.getter(name="trafficClass")
+    def traffic_class(self) -> Optional[builtins.str]:
+        """
+        Enum representing the various traffic classes offered by AAI.
+        Default value is `TC_UNSPECIFIED`.
+        Possible values are: `TC_UNSPECIFIED`, `TC1`, `TC2`, `TC3`, `TC4`, `TC5`, `TC6`.
+        """
+        return pulumi.get(self, "traffic_class")
+
+
+@pulumi.output_type
+class InterconnectApplicationAwareInterconnectStrictPriorityPolicy(dict):
+    def __init__(__self__):
+        pass
+
+
 @pulumi.output_type
 class InterconnectAttachmentGroupAttachment(dict):
     def __init__(__self__, *,
@@ -20815,9 +21244,12 @@ class InterconnectAttachmentGroupConfiguredAvailabilitySlaIntendedSlaBlocker(dic
                  regions: Optional[Sequence[builtins.str]] = None,
                  zones: Optional[Sequence[builtins.str]] = None):
         """
-        :param Sequence[builtins.str] attachments: (Output)
-               URLs of any particular Attachments to explain this
-               blocker in more detail.
+        :param Sequence[builtins.str] attachments: Attachments in the AttachmentGroup. Keys are arbitrary user-specified
+               strings. Users are encouraged, but not required, to use their preferred
+               format for resource links as keys.
+               Note that there are add-members and remove-members methods in gcloud.
+               The size of this map is limited by an "Attachments per group" quota.
+               Structure is documented below.
         :param builtins.str blocker_type: (Output)
                The category of an unmet SLA requirement.
         :param builtins.str documentation_link: (Output)
@@ -20860,9 +21292,12 @@ class InterconnectAttachmentGroupConfiguredAvailabilitySlaIntendedSlaBlocker(dic
     @pulumi.getter
     def attachments(self) -> Optional[Sequence[builtins.str]]:
         """
-        (Output)
-        URLs of any particular Attachments to explain this
-        blocker in more detail.
+        Attachments in the AttachmentGroup. Keys are arbitrary user-specified
+        strings. Users are encouraged, but not required, to use their preferred
+        format for resource links as keys.
+        Note that there are add-members and remove-members methods in gcloud.
+        The size of this map is limited by an "Attachments per group" quota.
+        Structure is documented below.
         """
         return pulumi.get(self, "attachments")
 
@@ -20955,8 +21390,6 @@ class InterconnectAttachmentGroupIntent(dict):
         """
         :param builtins.str availability_sla: Which SLA the user intends this group to support.
                Possible values are: `PRODUCTION_NON_CRITICAL`, `PRODUCTION_CRITICAL`, `NO_SLA`, `AVAILABILITY_SLA_UNSPECIFIED`.
-               
-               - - -
         """
         if availability_sla is not None:
             pulumi.set(__self__, "availability_sla", availability_sla)
@@ -20967,8 +21400,6 @@ class InterconnectAttachmentGroupIntent(dict):
         """
         Which SLA the user intends this group to support.
         Possible values are: `PRODUCTION_NON_CRITICAL`, `PRODUCTION_CRITICAL`, `NO_SLA`, `AVAILABILITY_SLA_UNSPECIFIED`.
-
-        - - -
         """
         return pulumi.get(self, "availability_sla")
 
@@ -21587,9 +22018,12 @@ class InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlocker(dic
                Facilities used to explain this blocker in more detail.
                Like physicalStructure.metros.facilities.facility, this is a numeric
                string like "5467".
-        :param Sequence[builtins.str] interconnects: (Output)
-               Interconnects used to explain this blocker in more
-               detail.
+        :param Sequence[builtins.str] interconnects: Interconnects in the InterconnectGroup. Keys are arbitrary user-specified
+               strings. Users are encouraged, but not required, to use their preferred
+               format for resource links as keys.
+               Note that there are add-members and remove-members methods in gcloud.
+               The size of this map is limited by an "Interconnects per group" quota.
+               Structure is documented below.
         :param Sequence[builtins.str] metros: (Output)
                Metros used to explain this blocker in more detail.
                These are three-letter lowercase strings like "iad". A blocker like
@@ -21660,9 +22094,12 @@ class InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlocker(dic
     @pulumi.getter
     def interconnects(self) -> Optional[Sequence[builtins.str]]:
         """
-        (Output)
-        Interconnects used to explain this blocker in more
-        detail.
+        Interconnects in the InterconnectGroup. Keys are arbitrary user-specified
+        strings. Users are encouraged, but not required, to use their preferred
+        format for resource links as keys.
+        Note that there are add-members and remove-members methods in gcloud.
+        The size of this map is limited by an "Interconnects per group" quota.
+        Structure is documented below.
         """
         return pulumi.get(self, "interconnects")
 
@@ -21714,8 +22151,6 @@ class InterconnectGroupIntent(dict):
         :param builtins.str topology_capability: The reliability the user intends this group to be capable of, in terms
                of the Interconnect product SLAs.
                Possible values are: `PRODUCTION_NON_CRITICAL`, `PRODUCTION_CRITICAL`, `NO_SLA`, `AVAILABILITY_SLA_UNSPECIFIED`.
-               
-               - - -
         """
         if topology_capability is not None:
             pulumi.set(__self__, "topology_capability", topology_capability)
@@ -21727,8 +22162,6 @@ class InterconnectGroupIntent(dict):
         The reliability the user intends this group to be capable of, in terms
         of the Interconnect product SLAs.
         Possible values are: `PRODUCTION_NON_CRITICAL`, `PRODUCTION_CRITICAL`, `NO_SLA`, `AVAILABILITY_SLA_UNSPECIFIED`.
-
-        - - -
         """
         return pulumi.get(self, "topology_capability")
 
@@ -21880,9 +22313,12 @@ class InterconnectGroupPhysicalStructureMetroFacilityZone(dict):
                  interconnects: Optional[Sequence[builtins.str]] = None,
                  zone: Optional[builtins.str] = None):
         """
-        :param Sequence[builtins.str] interconnects: (Output)
-               Interconnects used to explain this blocker in more
-               detail.
+        :param Sequence[builtins.str] interconnects: Interconnects in the InterconnectGroup. Keys are arbitrary user-specified
+               strings. Users are encouraged, but not required, to use their preferred
+               format for resource links as keys.
+               Note that there are add-members and remove-members methods in gcloud.
+               The size of this map is limited by an "Interconnects per group" quota.
+               Structure is documented below.
         :param builtins.str zone: (Output)
                The name of the zone, either "zone1" or "zone2".
                This is the second component of the location of Interconnects in
@@ -21897,9 +22333,12 @@ class InterconnectGroupPhysicalStructureMetroFacilityZone(dict):
     @pulumi.getter
     def interconnects(self) -> Optional[Sequence[builtins.str]]:
         """
-        (Output)
-        Interconnects used to explain this blocker in more
-        detail.
+        Interconnects in the InterconnectGroup. Keys are arbitrary user-specified
+        strings. Users are encouraged, but not required, to use their preferred
+        format for resource links as keys.
+        Note that there are add-members and remove-members methods in gcloud.
+        The size of this map is limited by an "Interconnects per group" quota.
+        Structure is documented below.
         """
         return pulumi.get(self, "interconnects")
 
@@ -22909,8 +23348,6 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
         :param builtins.str name: Name of the secure tag, created with TagManager's TagValue API.
         :param builtins.str state: (Output)
                State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -22931,8 +23368,6 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -23016,8 +23451,7 @@ class NetworkFirewallPolicyWithRulesPredefinedRule(dict):
         :param builtins.str action: (Output)
                The Action to perform when the client connection triggers the rule. Can currently be either
                "allow", "deny", "apply_security_profile_group" or "goto_next".
-        :param builtins.str description: (Output)
-               A description of the rule.
+        :param builtins.str description: An optional description of this resource.
         :param builtins.str direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param builtins.bool disabled: (Output)
@@ -23103,8 +23537,7 @@ class NetworkFirewallPolicyWithRulesPredefinedRule(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -23581,8 +24014,6 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTag(dict):
                [Output Only] State of the secure tag, either `EFFECTIVE` or
                `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
                or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -23606,8 +24037,6 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTag(dict):
         [Output Only] State of the secure tag, either `EFFECTIVE` or
         `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
         or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -24242,8 +24671,6 @@ class NetworkFirewallPolicyWithRulesRuleTargetSecureTag(dict):
                [Output Only] State of the secure tag, either `EFFECTIVE` or
                `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
                or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -24267,8 +24694,6 @@ class NetworkFirewallPolicyWithRulesRuleTargetSecureTag(dict):
         [Output Only] State of the secure tag, either `EFFECTIVE` or
         `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
         or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -25093,8 +25518,6 @@ class PacketMirroringMirroredResourcesInstance(dict):
                  url: builtins.str):
         """
         :param builtins.str url: The URL of the instances where this rule should be active.
-               
-               - - -
         """
         pulumi.set(__self__, "url", url)
 
@@ -25103,8 +25526,6 @@ class PacketMirroringMirroredResourcesInstance(dict):
     def url(self) -> builtins.str:
         """
         The URL of the instances where this rule should be active.
-
-        - - -
         """
         return pulumi.get(self, "url")
 
@@ -26185,7 +26606,7 @@ class RegionAutoscalerAutoscalingPolicyScalingSchedule(dict):
         :param builtins.int min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
         :param builtins.str name: The identifier for this object. Format specified above.
         :param builtins.str schedule: The start timestamps of time intervals when this scaling schedule should provide a scaling signal. This field uses the extended cron format (with an optional year field).
-        :param builtins.str description: An optional description of this resource.
+        :param builtins.str description: A description of a scaling schedule.
         :param builtins.bool disabled: A boolean value that specifies if a scaling schedule can influence autoscaler recommendations. If set to true, then a scaling schedule has no effect.
         :param builtins.str time_zone: The time zone to be used when interpreting the schedule. The value of this field must be a time zone name from the tz database: http://en.wikipedia.org/wiki/Tz_database.
         """
@@ -26236,7 +26657,7 @@ class RegionAutoscalerAutoscalingPolicyScalingSchedule(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         return pulumi.get(self, "description")
 
@@ -33394,8 +33815,6 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
         :param builtins.str name: Name of the secure tag, created with TagManager's TagValue API.
         :param builtins.str state: (Output)
                State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -33416,8 +33835,6 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTag(dict):
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -33501,8 +33918,7 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRule(dict):
         :param builtins.str action: (Output)
                The Action to perform when the client connection triggers the rule. Can currently be either
                "allow", "deny", "apply_security_profile_group" or "goto_next".
-        :param builtins.str description: (Output)
-               A description of the rule.
+        :param builtins.str description: An optional description of this resource.
         :param builtins.str direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param builtins.bool disabled: (Output)
@@ -33588,8 +34004,7 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRule(dict):
     @pulumi.getter
     def description(self) -> Optional[builtins.str]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -34066,8 +34481,6 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTag(dict):
                [Output Only] State of the secure tag, either `EFFECTIVE` or
                `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
                or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -34091,8 +34504,6 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTag(dict):
         [Output Only] State of the secure tag, either `EFFECTIVE` or
         `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
         or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -34727,8 +35138,6 @@ class RegionNetworkFirewallPolicyWithRulesRuleTargetSecureTag(dict):
                [Output Only] State of the secure tag, either `EFFECTIVE` or
                `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
                or its network is deleted.
-               
-               - - -
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -34752,8 +35161,6 @@ class RegionNetworkFirewallPolicyWithRulesRuleTargetSecureTag(dict):
         [Output Only] State of the secure tag, either `EFFECTIVE` or
         `INEFFECTIVE`. A secure tag is `INEFFECTIVE` when it is deleted
         or its network is deleted.
-
-        - - -
         """
         return pulumi.get(self, "state")
 
@@ -43519,6 +43926,75 @@ class RegionUrlMapTest(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class ReservationDeleteAfterDuration(dict):
+    def __init__(__self__, *,
+                 nanos: Optional[builtins.int] = None,
+                 seconds: Optional[builtins.str] = None):
+        """
+        :param builtins.int nanos: Number of nanoseconds for the auto-delete duration.
+        :param builtins.str seconds: Number of seconds for the auto-delete duration.
+        """
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+        if seconds is not None:
+            pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[builtins.int]:
+        """
+        Number of nanoseconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> Optional[builtins.str]:
+        """
+        Number of seconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class ReservationReservationSharingPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "serviceShareType":
+            suggest = "service_share_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ReservationReservationSharingPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ReservationReservationSharingPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ReservationReservationSharingPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 service_share_type: Optional[builtins.str] = None):
+        """
+        :param builtins.str service_share_type: Sharing config for all Google Cloud services.
+               Possible values are: `ALLOW_ALL`, `DISALLOW_ALL`.
+        """
+        if service_share_type is not None:
+            pulumi.set(__self__, "service_share_type", service_share_type)
+
+    @property
+    @pulumi.getter(name="serviceShareType")
+    def service_share_type(self) -> Optional[builtins.str]:
+        """
+        Sharing config for all Google Cloud services.
+        Possible values are: `ALLOW_ALL`, `DISALLOW_ALL`.
+        """
+        return pulumi.get(self, "service_share_type")
+
+
 @pulumi.output_type
 class ReservationShareSettings(dict):
     @staticmethod
@@ -43542,15 +44018,19 @@ class ReservationShareSettings(dict):
 
     def __init__(__self__, *,
                  project_maps: Optional[Sequence['outputs.ReservationShareSettingsProjectMap']] = None,
+                 projects: Optional[Sequence[builtins.str]] = None,
                  share_type: Optional[builtins.str] = None):
         """
         :param Sequence['ReservationShareSettingsProjectMapArgs'] project_maps: A map of project number and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
                Structure is documented below.
+        :param Sequence[builtins.str] projects: List of project IDs with which the reservation is shared.
         :param builtins.str share_type: Type of sharing for this shared-reservation
                Possible values are: `LOCAL`, `SPECIFIC_PROJECTS`.
         """
         if project_maps is not None:
             pulumi.set(__self__, "project_maps", project_maps)
+        if projects is not None:
+            pulumi.set(__self__, "projects", projects)
         if share_type is not None:
             pulumi.set(__self__, "share_type", share_type)
 
@@ -43563,6 +44043,14 @@ class ReservationShareSettings(dict):
         """
         return pulumi.get(self, "project_maps")
 
+    @property
+    @pulumi.getter
+    def projects(self) -> Optional[Sequence[builtins.str]]:
+        """
+        List of project IDs with which the reservation is shared.
+        """
+        return pulumi.get(self, "projects")
+
     @property
     @pulumi.getter(name="shareType")
     def share_type(self) -> Optional[builtins.str]:
@@ -43625,10 +44113,12 @@ class ReservationSpecificReservation(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "instanceProperties":
-            suggest = "instance_properties"
-        elif key == "inUseCount":
+        if key == "inUseCount":
             suggest = "in_use_count"
+        elif key == "instanceProperties":
+            suggest = "instance_properties"
+        elif key == "sourceInstanceTemplate":
+            suggest = "source_instance_template"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ReservationSpecificReservation. Access the value via the '{suggest}' property getter instead.")
@@ -43643,19 +44133,25 @@ class ReservationSpecificReservation(dict):
 
     def __init__(__self__, *,
                  count: builtins.int,
-                 instance_properties: 'outputs.ReservationSpecificReservationInstanceProperties',
-                 in_use_count: Optional[builtins.int] = None):
+                 in_use_count: Optional[builtins.int] = None,
+                 instance_properties: Optional['outputs.ReservationSpecificReservationInstanceProperties'] = None,
+                 source_instance_template: Optional[builtins.str] = None):
         """
         :param builtins.int count: The number of resources that are allocated.
-        :param 'ReservationSpecificReservationInstancePropertiesArgs' instance_properties: The instance properties for the reservation.
-               Structure is documented below.
         :param builtins.int in_use_count: (Output)
                How many instances are in use.
+        :param 'ReservationSpecificReservationInstancePropertiesArgs' instance_properties: The instance properties for the reservation.
+               Structure is documented below.
+        :param builtins.str source_instance_template: Specifies the instance template to create the reservation. If you use this field, you must exclude the
+               instanceProperties field.
         """
         pulumi.set(__self__, "count", count)
-        pulumi.set(__self__, "instance_properties", instance_properties)
         if in_use_count is not None:
             pulumi.set(__self__, "in_use_count", in_use_count)
+        if instance_properties is not None:
+            pulumi.set(__self__, "instance_properties", instance_properties)
+        if source_instance_template is not None:
+            pulumi.set(__self__, "source_instance_template", source_instance_template)
 
     @property
     @pulumi.getter
@@ -43665,9 +44161,18 @@ class ReservationSpecificReservation(dict):
         """
         return pulumi.get(self, "count")
 
+    @property
+    @pulumi.getter(name="inUseCount")
+    def in_use_count(self) -> Optional[builtins.int]:
+        """
+        (Output)
+        How many instances are in use.
+        """
+        return pulumi.get(self, "in_use_count")
+
     @property
     @pulumi.getter(name="instanceProperties")
-    def instance_properties(self) -> 'outputs.ReservationSpecificReservationInstanceProperties':
+    def instance_properties(self) -> Optional['outputs.ReservationSpecificReservationInstanceProperties']:
         """
         The instance properties for the reservation.
         Structure is documented below.
@@ -43675,13 +44180,13 @@ class ReservationSpecificReservation(dict):
         return pulumi.get(self, "instance_properties")
 
     @property
-    @pulumi.getter(name="inUseCount")
-    def in_use_count(self) -> Optional[builtins.int]:
+    @pulumi.getter(name="sourceInstanceTemplate")
+    def source_instance_template(self) -> Optional[builtins.str]:
         """
-        (Output)
-        How many instances are in use.
+        Specifies the instance template to create the reservation. If you use this field, you must exclude the
+        instanceProperties field.
         """
-        return pulumi.get(self, "in_use_count")
+        return pulumi.get(self, "source_instance_template")
 
 
 @pulumi.output_type
@@ -43695,6 +44200,8 @@ class ReservationSpecificReservationInstanceProperties(dict):
             suggest = "guest_accelerators"
         elif key == "localSsds":
             suggest = "local_ssds"
+        elif key == "maintenanceInterval":
+            suggest = "maintenance_interval"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
 
@@ -43713,6 +44220,7 @@ class ReservationSpecificReservationInstanceProperties(dict):
                  machine_type: builtins.str,
                  guest_accelerators: Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesGuestAccelerator']] = None,
                  local_ssds: Optional[Sequence['outputs.ReservationSpecificReservationInstancePropertiesLocalSsd']] = None,
+                 maintenance_interval: Optional[builtins.str] = None,
                  min_cpu_platform: Optional[builtins.str] = None):
         """
         :param builtins.str machine_type: The name of the machine type to reserve.
@@ -43721,6 +44229,8 @@ class ReservationSpecificReservationInstanceProperties(dict):
         :param Sequence['ReservationSpecificReservationInstancePropertiesLocalSsdArgs'] local_ssds: The amount of local ssd to reserve with each instance. This
                reserves disks of type `local-ssd`.
                Structure is documented below.
+        :param builtins.str maintenance_interval: Specifies the frequency of planned maintenance events.
+               Possible values are: `AS_NEEDED`, `PERIODIC`, `RECURRENT`.
         :param builtins.str min_cpu_platform: The minimum CPU platform for the reservation. For example,
                `"Intel Skylake"`. See
                the CPU platform availability reference](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform#availablezones)
@@ -43731,6 +44241,8 @@ class ReservationSpecificReservationInstanceProperties(dict):
             pulumi.set(__self__, "guest_accelerators", guest_accelerators)
         if local_ssds is not None:
             pulumi.set(__self__, "local_ssds", local_ssds)
+        if maintenance_interval is not None:
+            pulumi.set(__self__, "maintenance_interval", maintenance_interval)
         if min_cpu_platform is not None:
             pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
 
@@ -43761,6 +44273,15 @@ class ReservationSpecificReservationInstanceProperties(dict):
         """
         return pulumi.get(self, "local_ssds")
 
+    @property
+    @pulumi.getter(name="maintenanceInterval")
+    def maintenance_interval(self) -> Optional[builtins.str]:
+        """
+        Specifies the frequency of planned maintenance events.
+        Possible values are: `AS_NEEDED`, `PERIODIC`, `RECURRENT`.
+        """
+        return pulumi.get(self, "maintenance_interval")
+
     @property
     @pulumi.getter(name="minCpuPlatform")
     def min_cpu_platform(self) -> Optional[builtins.str]:
@@ -43853,8 +44374,6 @@ class ReservationSpecificReservationInstancePropertiesLocalSsd(dict):
                  interface: Optional[builtins.str] = None):
         """
         :param builtins.int disk_size_gb: The size of the disk in base-2 GB.
-               
-               - - -
         :param builtins.str interface: The disk interface to use for attaching this disk.
                Default value is `SCSI`.
                Possible values are: `SCSI`, `NVME`.
@@ -43868,8 +44387,6 @@ class ReservationSpecificReservationInstancePropertiesLocalSsd(dict):
     def disk_size_gb(self) -> builtins.int:
         """
         The size of the disk in base-2 GB.
-
-        - - -
         """
         return pulumi.get(self, "disk_size_gb")
 
@@ -45760,6 +46277,52 @@ class RouteAsPath(dict):
         return pulumi.get(self, "path_segment_type")
 
 
+@pulumi.output_type
+class RouteParams(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 RouteParams. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RouteParams.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RouteParams.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[Mapping[str, builtins.str]] = None):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the route. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        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, builtins.str]]:
+        """
+        Resource manager tags to be bound to the route. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class RouteWarning(dict):
     def __init__(__self__, *,
@@ -46594,21 +47157,29 @@ class RouterPeerMd5AuthenticationKey(dict):
 @pulumi.output_type
 class RouterRoutePolicyTerm(dict):
     def __init__(__self__, *,
+                 match: 'outputs.RouterRoutePolicyTermMatch',
                  priority: builtins.int,
-                 actions: Optional[Sequence['outputs.RouterRoutePolicyTermAction']] = None,
-                 match: Optional['outputs.RouterRoutePolicyTermMatch'] = None):
+                 actions: Optional[Sequence['outputs.RouterRoutePolicyTermAction']] = None):
         """
+        :param 'RouterRoutePolicyTermMatchArgs' match: CEL expression evaluated against a route to determine if this term applies (see Policy Language).
+               Structure is documented below.
         :param builtins.int priority: The evaluation priority for this term, which must be between 0 (inclusive) and 231 (exclusive), and unique within the list.
         :param Sequence['RouterRoutePolicyTermActionArgs'] actions: 'CEL expressions to evaluate to modify a route when this term matches.'\\
                Structure is documented below.
-        :param 'RouterRoutePolicyTermMatchArgs' match: CEL expression evaluated against a route to determine if this term applies (see Policy Language). When not set, the term applies to all routes.
-               Structure is documented below.
         """
+        pulumi.set(__self__, "match", match)
         pulumi.set(__self__, "priority", priority)
         if actions is not None:
             pulumi.set(__self__, "actions", actions)
-        if match is not None:
-            pulumi.set(__self__, "match", match)
+
+    @property
+    @pulumi.getter
+    def match(self) -> 'outputs.RouterRoutePolicyTermMatch':
+        """
+        CEL expression evaluated against a route to determine if this term applies (see Policy Language).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "match")
 
     @property
     @pulumi.getter
@@ -46627,15 +47198,6 @@ class RouterRoutePolicyTerm(dict):
         """
         return pulumi.get(self, "actions")
 
-    @property
-    @pulumi.getter
-    def match(self) -> Optional['outputs.RouterRoutePolicyTermMatch']:
-        """
-        CEL expression evaluated against a route to determine if this term applies (see Policy Language). When not set, the term applies to all routes.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "match")
-
 
 @pulumi.output_type
 class RouterRoutePolicyTermAction(dict):
@@ -46650,8 +47212,6 @@ class RouterRoutePolicyTermAction(dict):
         :param builtins.str description: Description of the expression
         :param builtins.str location: String indicating the location of the expression for error
                reporting, e.g. a file name and a position in the file
-               
-               - - -
         :param builtins.str title: Title for the expression, i.e. a short string describing its
                purpose.
         """
@@ -46686,8 +47246,6 @@ class RouterRoutePolicyTermAction(dict):
         """
         String indicating the location of the expression for error
         reporting, e.g. a file name and a position in the file
-
-        - - -
         """
         return pulumi.get(self, "location")
 
@@ -46776,6 +47334,7 @@ class RouterStatusBestRouteResult(dict):
                  next_hop_origin: builtins.str,
                  next_hop_peering: builtins.str,
                  next_hop_vpn_tunnel: builtins.str,
+                 params: Sequence['outputs.RouterStatusBestRouteParamResult'],
                  priority: builtins.int,
                  project: builtins.str,
                  route_status: builtins.str,
@@ -46830,6 +47389,7 @@ class RouterStatusBestRouteResult(dict):
         :param builtins.str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
         :param builtins.str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param builtins.str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
+        :param Sequence['RouterStatusBestRouteParamArgs'] params: Additional params passed with the request, but not persisted as part of resource payload
         :param builtins.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.
                
@@ -46868,6 +47428,7 @@ class RouterStatusBestRouteResult(dict):
         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__, "params", params)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
         pulumi.set(__self__, "route_status", route_status)
@@ -47046,6 +47607,14 @@ class RouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_vpn_tunnel")
 
+    @property
+    @pulumi.getter
+    def params(self) -> Sequence['outputs.RouterStatusBestRouteParamResult']:
+        """
+        Additional params passed with the request, but not persisted as part of resource payload
+        """
+        return pulumi.get(self, "params")
+
     @property
     @pulumi.getter
     def priority(self) -> builtins.int:
@@ -47150,6 +47719,34 @@ class RouterStatusBestRouteAsPathResult(dict):
         return pulumi.get(self, "path_segment_type")
 
 
+@pulumi.output_type
+class RouterStatusBestRouteParamResult(dict):
+    def __init__(__self__, *,
+                 resource_manager_tags: Mapping[str, builtins.str]):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the route. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Mapping[str, builtins.str]:
+        """
+        Resource manager tags to be bound to the route. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class RouterStatusBestRouteWarningResult(dict):
     def __init__(__self__, *,
@@ -47244,6 +47841,7 @@ class RouterStatusBestRoutesForRouterResult(dict):
                  next_hop_origin: builtins.str,
                  next_hop_peering: builtins.str,
                  next_hop_vpn_tunnel: builtins.str,
+                 params: Sequence['outputs.RouterStatusBestRoutesForRouterParamResult'],
                  priority: builtins.int,
                  project: builtins.str,
                  route_status: builtins.str,
@@ -47298,6 +47896,7 @@ class RouterStatusBestRoutesForRouterResult(dict):
         :param builtins.str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
         :param builtins.str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param builtins.str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
+        :param Sequence['RouterStatusBestRoutesForRouterParamArgs'] params: Additional params passed with the request, but not persisted as part of resource payload
         :param builtins.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.
                
@@ -47336,6 +47935,7 @@ class RouterStatusBestRoutesForRouterResult(dict):
         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__, "params", params)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
         pulumi.set(__self__, "route_status", route_status)
@@ -47514,6 +48114,14 @@ class RouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_vpn_tunnel")
 
+    @property
+    @pulumi.getter
+    def params(self) -> Sequence['outputs.RouterStatusBestRoutesForRouterParamResult']:
+        """
+        Additional params passed with the request, but not persisted as part of resource payload
+        """
+        return pulumi.get(self, "params")
+
     @property
     @pulumi.getter
     def priority(self) -> builtins.int:
@@ -47618,6 +48226,34 @@ class RouterStatusBestRoutesForRouterAsPathResult(dict):
         return pulumi.get(self, "path_segment_type")
 
 
+@pulumi.output_type
+class RouterStatusBestRoutesForRouterParamResult(dict):
+    def __init__(__self__, *,
+                 resource_manager_tags: Mapping[str, builtins.str]):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the route. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Mapping[str, builtins.str]:
+        """
+        Resource manager tags to be bound to the route. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class RouterStatusBestRoutesForRouterWarningResult(dict):
     def __init__(__self__, *,
@@ -48104,6 +48740,8 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
             suggest = "json_parsing"
         elif key == "logLevel":
             suggest = "log_level"
+        elif key == "requestBodyInspectionSize":
+            suggest = "request_body_inspection_size"
         elif key == "userIpRequestHeaders":
             suggest = "user_ip_request_headers"
 
@@ -48122,6 +48760,7 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
                  json_custom_config: Optional['outputs.SecurityPolicyAdvancedOptionsConfigJsonCustomConfig'] = None,
                  json_parsing: Optional[builtins.str] = None,
                  log_level: Optional[builtins.str] = None,
+                 request_body_inspection_size: Optional[builtins.str] = None,
                  user_ip_request_headers: Optional[Sequence[builtins.str]] = None):
         """
         :param 'SecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs' json_custom_config: Custom configuration to apply the JSON parsing. Only applicable when
@@ -48133,6 +48772,7 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
         :param builtins.str log_level: Log level to use. Defaults to `NORMAL`.
                * `NORMAL` - Normal log level.
                * `VERBOSE` - Verbose log level.
+        :param builtins.str request_body_inspection_size: The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB". Values are case insensitive.
         :param Sequence[builtins.str] user_ip_request_headers: An optional list of case-insensitive request header names to use for resolving the callers client IP address.
         """
         if json_custom_config is not None:
@@ -48141,6 +48781,8 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
             pulumi.set(__self__, "json_parsing", json_parsing)
         if log_level is not None:
             pulumi.set(__self__, "log_level", log_level)
+        if request_body_inspection_size is not None:
+            pulumi.set(__self__, "request_body_inspection_size", request_body_inspection_size)
         if user_ip_request_headers is not None:
             pulumi.set(__self__, "user_ip_request_headers", user_ip_request_headers)
 
@@ -48174,6 +48816,14 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
         """
         return pulumi.get(self, "log_level")
 
+    @property
+    @pulumi.getter(name="requestBodyInspectionSize")
+    def request_body_inspection_size(self) -> Optional[builtins.str]:
+        """
+        The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB". Values are case insensitive.
+        """
+        return pulumi.get(self, "request_body_inspection_size")
+
     @property
     @pulumi.getter(name="userIpRequestHeaders")
     def user_ip_request_headers(self) -> Optional[Sequence[builtins.str]]:
@@ -49934,8 +50584,6 @@ class SnapshotSettingsStorageLocationLocation(dict):
         :param builtins.str location: The identifier for this object. Format specified above.
         :param builtins.str name: Name of the location. It should be one of the Cloud Storage buckets.
                Only one location can be specified. (should match location)
-               
-               - - -
         """
         pulumi.set(__self__, "location", location)
         pulumi.set(__self__, "name", name)
@@ -49954,8 +50602,6 @@ class SnapshotSettingsStorageLocationLocation(dict):
         """
         Name of the location. It should be one of the Cloud Storage buckets.
         Only one location can be specified. (should match location)
-
-        - - -
         """
         return pulumi.get(self, "name")
 
@@ -67622,6 +68268,68 @@ class GetMachineTypesMachineTypeDeprecatedResult(dict):
         return pulumi.get(self, "state")
 
 
+@pulumi.output_type
+class GetNetworkAttachmentConnectionEndpointResult(dict):
+    def __init__(__self__, *,
+                 ip_address: builtins.str,
+                 project_id_or_num: builtins.str,
+                 secondary_ip_cidr_ranges: builtins.str,
+                 status: builtins.str,
+                 subnetwork: builtins.str):
+        """
+        :param builtins.str ip_address: The IPv4 address assigned to the producer instance network interface. This value will be a range in case of Serverless.
+        :param builtins.str project_id_or_num: The project id or number of the interface to which the IP was assigned.
+        :param builtins.str secondary_ip_cidr_ranges: Alias IP ranges from the same subnetwork.
+        :param builtins.str status: The status of a connected endpoint to this network attachment.
+        :param builtins.str subnetwork: The subnetwork used to assign the IP to the producer instance network interface.
+        """
+        pulumi.set(__self__, "ip_address", ip_address)
+        pulumi.set(__self__, "project_id_or_num", project_id_or_num)
+        pulumi.set(__self__, "secondary_ip_cidr_ranges", secondary_ip_cidr_ranges)
+        pulumi.set(__self__, "status", status)
+        pulumi.set(__self__, "subnetwork", subnetwork)
+
+    @property
+    @pulumi.getter(name="ipAddress")
+    def ip_address(self) -> builtins.str:
+        """
+        The IPv4 address assigned to the producer instance network interface. This value will be a range in case of Serverless.
+        """
+        return pulumi.get(self, "ip_address")
+
+    @property
+    @pulumi.getter(name="projectIdOrNum")
+    def project_id_or_num(self) -> builtins.str:
+        """
+        The project id or number of the interface to which the IP was assigned.
+        """
+        return pulumi.get(self, "project_id_or_num")
+
+    @property
+    @pulumi.getter(name="secondaryIpCidrRanges")
+    def secondary_ip_cidr_ranges(self) -> builtins.str:
+        """
+        Alias IP ranges from the same subnetwork.
+        """
+        return pulumi.get(self, "secondary_ip_cidr_ranges")
+
+    @property
+    @pulumi.getter
+    def status(self) -> builtins.str:
+        """
+        The status of a connected endpoint to this network attachment.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def subnetwork(self) -> builtins.str:
+        """
+        The subnetwork used to assign the IP to the producer instance network interface.
+        """
+        return pulumi.get(self, "subnetwork")
+
+
 @pulumi.output_type
 class GetRegionBackendServiceBackendResult(dict):
     def __init__(__self__, *,
@@ -71787,16 +72495,66 @@ class GetRegionNetworkEndpointGroupServerlessDeploymentResult(dict):
         return pulumi.get(self, "version")
 
 
+@pulumi.output_type
+class GetReservationDeleteAfterDurationResult(dict):
+    def __init__(__self__, *,
+                 nanos: builtins.int,
+                 seconds: builtins.str):
+        """
+        :param builtins.int nanos: Number of nanoseconds for the auto-delete duration.
+        :param builtins.str seconds: Number of seconds for the auto-delete duration.
+        """
+        pulumi.set(__self__, "nanos", nanos)
+        pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> builtins.int:
+        """
+        Number of nanoseconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> builtins.str:
+        """
+        Number of seconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "seconds")
+
+
+@pulumi.output_type
+class GetReservationReservationSharingPolicyResult(dict):
+    def __init__(__self__, *,
+                 service_share_type: builtins.str):
+        """
+        :param builtins.str service_share_type: Sharing config for all Google Cloud services. Possible values: ["ALLOW_ALL", "DISALLOW_ALL"]
+        """
+        pulumi.set(__self__, "service_share_type", service_share_type)
+
+    @property
+    @pulumi.getter(name="serviceShareType")
+    def service_share_type(self) -> builtins.str:
+        """
+        Sharing config for all Google Cloud services. Possible values: ["ALLOW_ALL", "DISALLOW_ALL"]
+        """
+        return pulumi.get(self, "service_share_type")
+
+
 @pulumi.output_type
 class GetReservationShareSettingResult(dict):
     def __init__(__self__, *,
                  project_maps: Sequence['outputs.GetReservationShareSettingProjectMapResult'],
+                 projects: Sequence[builtins.str],
                  share_type: builtins.str):
         """
         :param Sequence['GetReservationShareSettingProjectMapArgs'] project_maps: A map of project number and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
+        :param Sequence[builtins.str] projects: List of project IDs with which the reservation is shared.
         :param builtins.str share_type: Type of sharing for this shared-reservation Possible values: ["LOCAL", "SPECIFIC_PROJECTS"]
         """
         pulumi.set(__self__, "project_maps", project_maps)
+        pulumi.set(__self__, "projects", projects)
         pulumi.set(__self__, "share_type", share_type)
 
     @property
@@ -71807,6 +72565,14 @@ class GetReservationShareSettingResult(dict):
         """
         return pulumi.get(self, "project_maps")
 
+    @property
+    @pulumi.getter
+    def projects(self) -> Sequence[builtins.str]:
+        """
+        List of project IDs with which the reservation is shared.
+        """
+        return pulumi.get(self, "projects")
+
     @property
     @pulumi.getter(name="shareType")
     def share_type(self) -> builtins.str:
@@ -71846,15 +72612,19 @@ class GetReservationSpecificReservationResult(dict):
     def __init__(__self__, *,
                  count: builtins.int,
                  in_use_count: builtins.int,
-                 instance_properties: Sequence['outputs.GetReservationSpecificReservationInstancePropertyResult']):
+                 instance_properties: Sequence['outputs.GetReservationSpecificReservationInstancePropertyResult'],
+                 source_instance_template: builtins.str):
         """
         :param builtins.int count: The number of resources that are allocated.
         :param builtins.int in_use_count: How many instances are in use.
         :param Sequence['GetReservationSpecificReservationInstancePropertyArgs'] instance_properties: The instance properties for the reservation.
+        :param builtins.str source_instance_template: Specifies the instance template to create the reservation. If you use this field, you must exclude the
+               instanceProperties field.
         """
         pulumi.set(__self__, "count", count)
         pulumi.set(__self__, "in_use_count", in_use_count)
         pulumi.set(__self__, "instance_properties", instance_properties)
+        pulumi.set(__self__, "source_instance_template", source_instance_template)
 
     @property
     @pulumi.getter
@@ -71880,6 +72650,15 @@ class GetReservationSpecificReservationResult(dict):
         """
         return pulumi.get(self, "instance_properties")
 
+    @property
+    @pulumi.getter(name="sourceInstanceTemplate")
+    def source_instance_template(self) -> builtins.str:
+        """
+        Specifies the instance template to create the reservation. If you use this field, you must exclude the
+        instanceProperties field.
+        """
+        return pulumi.get(self, "source_instance_template")
+
 
 @pulumi.output_type
 class GetReservationSpecificReservationInstancePropertyResult(dict):
@@ -71887,12 +72666,14 @@ class GetReservationSpecificReservationInstancePropertyResult(dict):
                  guest_accelerators: Sequence['outputs.GetReservationSpecificReservationInstancePropertyGuestAcceleratorResult'],
                  local_ssds: Sequence['outputs.GetReservationSpecificReservationInstancePropertyLocalSsdResult'],
                  machine_type: builtins.str,
+                 maintenance_interval: builtins.str,
                  min_cpu_platform: builtins.str):
         """
         :param Sequence['GetReservationSpecificReservationInstancePropertyGuestAcceleratorArgs'] guest_accelerators: Guest accelerator type and count.
         :param Sequence['GetReservationSpecificReservationInstancePropertyLocalSsdArgs'] local_ssds: The amount of local ssd to reserve with each instance. This
                reserves disks of type 'local-ssd'.
         :param builtins.str machine_type: The name of the machine type to reserve.
+        :param builtins.str maintenance_interval: Specifies the frequency of planned maintenance events. Possible values: ["AS_NEEDED", "PERIODIC", "RECURRENT"]
         :param builtins.str min_cpu_platform: The minimum CPU platform for the reservation. For example,
                '"Intel Skylake"'. See
                the CPU platform availability reference](https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform#availablezones)
@@ -71901,6 +72682,7 @@ class GetReservationSpecificReservationInstancePropertyResult(dict):
         pulumi.set(__self__, "guest_accelerators", guest_accelerators)
         pulumi.set(__self__, "local_ssds", local_ssds)
         pulumi.set(__self__, "machine_type", machine_type)
+        pulumi.set(__self__, "maintenance_interval", maintenance_interval)
         pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
 
     @property
@@ -71928,6 +72710,14 @@ class GetReservationSpecificReservationInstancePropertyResult(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maintenanceInterval")
+    def maintenance_interval(self) -> builtins.str:
+        """
+        Specifies the frequency of planned maintenance events. Possible values: ["AS_NEEDED", "PERIODIC", "RECURRENT"]
+        """
+        return pulumi.get(self, "maintenance_interval")
+
     @property
     @pulumi.getter(name="minCpuPlatform")
     def min_cpu_platform(self) -> builtins.str:
@@ -72991,6 +73781,7 @@ class GetRouterStatusBestRouteResult(dict):
                  next_hop_origin: builtins.str,
                  next_hop_peering: builtins.str,
                  next_hop_vpn_tunnel: builtins.str,
+                 params: Sequence['outputs.GetRouterStatusBestRouteParamResult'],
                  priority: builtins.int,
                  project: builtins.str,
                  route_status: builtins.str,
@@ -73045,6 +73836,7 @@ class GetRouterStatusBestRouteResult(dict):
         :param builtins.str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
         :param builtins.str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param builtins.str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
+        :param Sequence['GetRouterStatusBestRouteParamArgs'] params: Additional params passed with the request, but not persisted as part of resource payload
         :param builtins.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.
                
@@ -73083,6 +73875,7 @@ class GetRouterStatusBestRouteResult(dict):
         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__, "params", params)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
         pulumi.set(__self__, "route_status", route_status)
@@ -73261,6 +74054,14 @@ class GetRouterStatusBestRouteResult(dict):
         """
         return pulumi.get(self, "next_hop_vpn_tunnel")
 
+    @property
+    @pulumi.getter
+    def params(self) -> Sequence['outputs.GetRouterStatusBestRouteParamResult']:
+        """
+        Additional params passed with the request, but not persisted as part of resource payload
+        """
+        return pulumi.get(self, "params")
+
     @property
     @pulumi.getter
     def priority(self) -> builtins.int:
@@ -73365,6 +74166,34 @@ class GetRouterStatusBestRouteAsPathResult(dict):
         return pulumi.get(self, "path_segment_type")
 
 
+@pulumi.output_type
+class GetRouterStatusBestRouteParamResult(dict):
+    def __init__(__self__, *,
+                 resource_manager_tags: Mapping[str, builtins.str]):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the route. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Mapping[str, builtins.str]:
+        """
+        Resource manager tags to be bound to the route. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class GetRouterStatusBestRouteWarningResult(dict):
     def __init__(__self__, *,
@@ -73459,6 +74288,7 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
                  next_hop_origin: builtins.str,
                  next_hop_peering: builtins.str,
                  next_hop_vpn_tunnel: builtins.str,
+                 params: Sequence['outputs.GetRouterStatusBestRoutesForRouterParamResult'],
                  priority: builtins.int,
                  project: builtins.str,
                  route_status: builtins.str,
@@ -73513,6 +74343,7 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         :param builtins.str next_hop_origin: Indicates the origin of the route. Can be IGP (Interior Gateway Protocol), EGP (Exterior Gateway Protocol), or INCOMPLETE.
         :param builtins.str next_hop_peering: The network peering name that should handle matching packets, which should conform to RFC1035.
         :param builtins.str next_hop_vpn_tunnel: URL to a VpnTunnel that should handle matching packets.
+        :param Sequence['GetRouterStatusBestRoutesForRouterParamArgs'] params: Additional params passed with the request, but not persisted as part of resource payload
         :param builtins.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.
                
@@ -73551,6 +74382,7 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         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__, "params", params)
         pulumi.set(__self__, "priority", priority)
         pulumi.set(__self__, "project", project)
         pulumi.set(__self__, "route_status", route_status)
@@ -73729,6 +74561,14 @@ class GetRouterStatusBestRoutesForRouterResult(dict):
         """
         return pulumi.get(self, "next_hop_vpn_tunnel")
 
+    @property
+    @pulumi.getter
+    def params(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterParamResult']:
+        """
+        Additional params passed with the request, but not persisted as part of resource payload
+        """
+        return pulumi.get(self, "params")
+
     @property
     @pulumi.getter
     def priority(self) -> builtins.int:
@@ -73833,6 +74673,34 @@ class GetRouterStatusBestRoutesForRouterAsPathResult(dict):
         return pulumi.get(self, "path_segment_type")
 
 
+@pulumi.output_type
+class GetRouterStatusBestRoutesForRouterParamResult(dict):
+    def __init__(__self__, *,
+                 resource_manager_tags: Mapping[str, builtins.str]):
+        """
+        :param Mapping[str, builtins.str] resource_manager_tags: Resource manager tags to be bound to the route. Tag keys and values have the
+               same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+               and values are in the format tagValues/456. The field is ignored when empty.
+               The field is immutable and causes resource replacement when mutated. This field is only
+               set at create time and modifying this field after creation will trigger recreation.
+               To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
+
+    @property
+    @pulumi.getter(name="resourceManagerTags")
+    def resource_manager_tags(self) -> Mapping[str, builtins.str]:
+        """
+        Resource manager tags to be bound to the route. Tag keys and values have the
+        same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id},
+        and values are in the format tagValues/456. The field is ignored when empty.
+        The field is immutable and causes resource replacement when mutated. This field is only
+        set at create time and modifying this field after creation will trigger recreation.
+        To apply tags to an existing resource, see the tags.TagBinding resource.
+        """
+        return pulumi.get(self, "resource_manager_tags")
+
+
 @pulumi.output_type
 class GetRouterStatusBestRoutesForRouterWarningResult(dict):
     def __init__(__self__, *,
@@ -74146,16 +75014,19 @@ class GetSecurityPolicyAdvancedOptionsConfigResult(dict):
                  json_custom_configs: Sequence['outputs.GetSecurityPolicyAdvancedOptionsConfigJsonCustomConfigResult'],
                  json_parsing: builtins.str,
                  log_level: builtins.str,
+                 request_body_inspection_size: builtins.str,
                  user_ip_request_headers: Sequence[builtins.str]):
         """
         :param Sequence['GetSecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs'] json_custom_configs: Custom configuration to apply the JSON parsing. Only applicable when JSON parsing is set to STANDARD.
         :param builtins.str json_parsing: JSON body parsing. Supported values include: "DISABLED", "STANDARD".
         :param builtins.str log_level: Logging level. Supported values include: "NORMAL", "VERBOSE".
+        :param builtins.str request_body_inspection_size: The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB". Values are case insensitive.
         :param Sequence[builtins.str] user_ip_request_headers: An optional list of case-insensitive request header names to use for resolving the callers client IP address.
         """
         pulumi.set(__self__, "json_custom_configs", json_custom_configs)
         pulumi.set(__self__, "json_parsing", json_parsing)
         pulumi.set(__self__, "log_level", log_level)
+        pulumi.set(__self__, "request_body_inspection_size", request_body_inspection_size)
         pulumi.set(__self__, "user_ip_request_headers", user_ip_request_headers)
 
     @property
@@ -74182,6 +75053,14 @@ class GetSecurityPolicyAdvancedOptionsConfigResult(dict):
         """
         return pulumi.get(self, "log_level")
 
+    @property
+    @pulumi.getter(name="requestBodyInspectionSize")
+    def request_body_inspection_size(self) -> builtins.str:
+        """
+        The maximum request size chosen by the customer with Waf enabled. Values supported are "8KB", "16KB, "32KB", "48KB" and "64KB". Values are case insensitive.
+        """
+        return pulumi.get(self, "request_body_inspection_size")
+
     @property
     @pulumi.getter(name="userIpRequestHeaders")
     def user_ip_request_headers(self) -> Sequence[builtins.str]: