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

pulumi_gcp/compute/_inputs.py

@@ -138,6 +138,8 @@ __all__ = [
     'FirewallDenyArgsDict',
     'FirewallLogConfigArgs',
     'FirewallLogConfigArgsDict',
+    'FirewallParamsArgs',
+    'FirewallParamsArgsDict',
     'FirewallPolicyRuleMatchArgs',
     'FirewallPolicyRuleMatchArgsDict',
     'FirewallPolicyRuleMatchLayer4ConfigArgs',
@@ -160,6 +162,12 @@ __all__ = [
     'FirewallPolicyWithRulesRuleMatchLayer4ConfigArgsDict',
     'ForwardingRuleServiceDirectoryRegistrationsArgs',
     'ForwardingRuleServiceDirectoryRegistrationsArgsDict',
+    'FutureReservationAggregateReservationArgs',
+    'FutureReservationAggregateReservationArgsDict',
+    'FutureReservationAggregateReservationReservedResourceArgs',
+    'FutureReservationAggregateReservationReservedResourceArgsDict',
+    'FutureReservationAggregateReservationReservedResourceAcceleratorArgs',
+    'FutureReservationAggregateReservationReservedResourceAcceleratorArgsDict',
     'FutureReservationAutoCreatedReservationsDurationArgs',
     'FutureReservationAutoCreatedReservationsDurationArgsDict',
     'FutureReservationCommitmentInfoArgs',
@@ -518,6 +526,16 @@ __all__ = [
     'InstantSnapshotIamBindingConditionArgsDict',
     'InstantSnapshotIamMemberConditionArgs',
     'InstantSnapshotIamMemberConditionArgsDict',
+    'InterconnectApplicationAwareInterconnectArgs',
+    'InterconnectApplicationAwareInterconnectArgsDict',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgsDict',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs',
+    'InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgsDict',
+    'InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs',
+    'InterconnectApplicationAwareInterconnectShapeAveragePercentageArgsDict',
+    'InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs',
+    'InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgsDict',
     'InterconnectAttachmentGroupAttachmentArgs',
     'InterconnectAttachmentGroupAttachmentArgsDict',
     'InterconnectAttachmentGroupConfiguredArgs',
@@ -1128,6 +1146,10 @@ __all__ = [
     'RegionUrlMapPathMatcherRouteRuleUrlRedirectArgsDict',
     'RegionUrlMapTestArgs',
     'RegionUrlMapTestArgsDict',
+    'ReservationDeleteAfterDurationArgs',
+    'ReservationDeleteAfterDurationArgsDict',
+    'ReservationReservationSharingPolicyArgs',
+    'ReservationReservationSharingPolicyArgsDict',
     'ReservationShareSettingsArgs',
     'ReservationShareSettingsArgsDict',
     'ReservationShareSettingsProjectMapArgs',
@@ -1208,6 +1230,8 @@ __all__ = [
     'ResourcePolicyWorkloadPolicyArgsDict',
     'RouteAsPathArgs',
     'RouteAsPathArgsDict',
+    'RouteParamsArgs',
+    'RouteParamsArgsDict',
     'RouteWarningArgs',
     'RouteWarningArgsDict',
     'RouteWarningDataArgs',
@@ -2483,7 +2507,7 @@ if not MYPY:
         """
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         disabled: NotRequired[pulumi.Input[builtins.bool]]
         """
@@ -2511,7 +2535,7 @@ class AutoscalerAutoscalingPolicyScalingScheduleArgs:
         :param pulumi.Input[builtins.int] min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
         :param pulumi.Input[builtins.str] name: The identifier for this object. Format specified above.
         :param pulumi.Input[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 pulumi.Input[builtins.str] description: An optional description of this resource.
+        :param pulumi.Input[builtins.str] description: A description of a scaling schedule.
         :param pulumi.Input[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 pulumi.Input[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.
         """
@@ -2578,7 +2602,7 @@ class AutoscalerAutoscalingPolicyScalingScheduleArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         return pulumi.get(self, "description")
 
@@ -7441,6 +7465,53 @@ class FirewallLogConfigArgs:
         pulumi.set(self, "metadata", value)
 
 
+if not MYPY:
+    class FirewallParamsArgsDict(TypedDict):
+        resource_manager_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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.
+        """
+elif False:
+    FirewallParamsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FirewallParamsArgs:
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
+        """
+        :param pulumi.Input[Mapping[str, pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[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")
+
+    @resource_manager_tags.setter
+    def resource_manager_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "resource_manager_tags", value)
+
+
 if not MYPY:
     class FirewallPolicyRuleMatchArgsDict(TypedDict):
         layer4_configs: pulumi.Input[Sequence[pulumi.Input['FirewallPolicyRuleMatchLayer4ConfigArgsDict']]]
@@ -7840,8 +7911,6 @@ if not MYPY:
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
 elif False:
     FirewallPolicyRuleMatchSrcSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -7855,8 +7924,6 @@ class FirewallPolicyRuleMatchSrcSecureTagArgs:
         :param pulumi.Input[builtins.str] name: Name of the secure tag, created with TagManager's TagValue API.
         :param pulumi.Input[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)
@@ -7881,8 +7948,6 @@ class FirewallPolicyRuleMatchSrcSecureTagArgs:
         """
         (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")
 
@@ -7956,8 +8021,7 @@ if not MYPY:
         """
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         direction: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -8048,8 +8112,7 @@ class FirewallPolicyWithRulesPredefinedRuleArgs:
         :param pulumi.Input[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 pulumi.Input[builtins.str] description: (Output)
-               A description of the rule.
+        :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.str] direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param pulumi.Input[builtins.bool] disabled: (Output)
@@ -8131,8 +8194,7 @@ class FirewallPolicyWithRulesPredefinedRuleArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -9452,6 +9514,173 @@ class ForwardingRuleServiceDirectoryRegistrationsArgs:
         pulumi.set(self, "service", value)
 
 
+if not MYPY:
+    class FutureReservationAggregateReservationArgsDict(TypedDict):
+        reserved_resources: pulumi.Input[Sequence[pulumi.Input['FutureReservationAggregateReservationReservedResourceArgsDict']]]
+        """
+        futureReservations.list of reserved resources (CPUs, memory, accelerators).
+        Structure is documented below.
+        """
+        vm_family: NotRequired[pulumi.Input[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`.
+        """
+        workload_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The workload type of the instances that will target this reservation.
+        Possible values are: `BATCH`, `SERVING`, `UNSPECIFIED`.
+        """
+elif False:
+    FutureReservationAggregateReservationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FutureReservationAggregateReservationArgs:
+    def __init__(__self__, *,
+                 reserved_resources: pulumi.Input[Sequence[pulumi.Input['FutureReservationAggregateReservationReservedResourceArgs']]],
+                 vm_family: Optional[pulumi.Input[builtins.str]] = None,
+                 workload_type: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['FutureReservationAggregateReservationReservedResourceArgs']]] reserved_resources: futureReservations.list of reserved resources (CPUs, memory, accelerators).
+               Structure is documented below.
+        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[Sequence[pulumi.Input['FutureReservationAggregateReservationReservedResourceArgs']]]:
+        """
+        futureReservations.list of reserved resources (CPUs, memory, accelerators).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "reserved_resources")
+
+    @reserved_resources.setter
+    def reserved_resources(self, value: pulumi.Input[Sequence[pulumi.Input['FutureReservationAggregateReservationReservedResourceArgs']]]):
+        pulumi.set(self, "reserved_resources", value)
+
+    @property
+    @pulumi.getter(name="vmFamily")
+    def vm_family(self) -> Optional[pulumi.Input[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")
+
+    @vm_family.setter
+    def vm_family(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "vm_family", value)
+
+    @property
+    @pulumi.getter(name="workloadType")
+    def workload_type(self) -> Optional[pulumi.Input[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")
+
+    @workload_type.setter
+    def workload_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "workload_type", value)
+
+
+if not MYPY:
+    class FutureReservationAggregateReservationReservedResourceArgsDict(TypedDict):
+        accelerator: NotRequired[pulumi.Input['FutureReservationAggregateReservationReservedResourceAcceleratorArgsDict']]
+        """
+        Properties of accelerator resources in this reservation.
+        Structure is documented below.
+        """
+elif False:
+    FutureReservationAggregateReservationReservedResourceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FutureReservationAggregateReservationReservedResourceArgs:
+    def __init__(__self__, *,
+                 accelerator: Optional[pulumi.Input['FutureReservationAggregateReservationReservedResourceAcceleratorArgs']] = None):
+        """
+        :param pulumi.Input['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[pulumi.Input['FutureReservationAggregateReservationReservedResourceAcceleratorArgs']]:
+        """
+        Properties of accelerator resources in this reservation.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "accelerator")
+
+    @accelerator.setter
+    def accelerator(self, value: Optional[pulumi.Input['FutureReservationAggregateReservationReservedResourceAcceleratorArgs']]):
+        pulumi.set(self, "accelerator", value)
+
+
+if not MYPY:
+    class FutureReservationAggregateReservationReservedResourceAcceleratorArgsDict(TypedDict):
+        accelerator_count: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Number of accelerators of specified type.
+        """
+        accelerator_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Full or partial URL to accelerator type. e.g. "projects/{PROJECT}/zones/{ZONE}/acceleratorTypes/ct4l"
+        """
+elif False:
+    FutureReservationAggregateReservationReservedResourceAcceleratorArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class FutureReservationAggregateReservationReservedResourceAcceleratorArgs:
+    def __init__(__self__, *,
+                 accelerator_count: Optional[pulumi.Input[builtins.int]] = None,
+                 accelerator_type: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.int] accelerator_count: Number of accelerators of specified type.
+        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
+        """
+        Number of accelerators of specified type.
+        """
+        return pulumi.get(self, "accelerator_count")
+
+    @accelerator_count.setter
+    def accelerator_count(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "accelerator_count", value)
+
+    @property
+    @pulumi.getter(name="acceleratorType")
+    def accelerator_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Full or partial URL to accelerator type. e.g. "projects/{PROJECT}/zones/{ZONE}/acceleratorTypes/ct4l"
+        """
+        return pulumi.get(self, "accelerator_type")
+
+    @accelerator_type.setter
+    def accelerator_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "accelerator_type", value)
+
+
 if not MYPY:
     class FutureReservationAutoCreatedReservationsDurationArgsDict(TypedDict):
         nanos: NotRequired[pulumi.Input[builtins.int]]
@@ -10085,7 +10314,7 @@ if not MYPY:
         """
         specific_sku_properties: NotRequired[pulumi.Input['FutureReservationStatusSpecificSkuPropertiesArgsDict']]
         """
-        The previous instance related properties of the Future Reservation.
+        Future Reservation configuration to indicate instance properties and total count.
         Structure is documented below.
         """
 elif False:
@@ -10111,7 +10340,7 @@ class FutureReservationStatusArgs:
         :param pulumi.Input[builtins.str] lock_time: The lock time of the FutureReservation before an amendment was requested.
         :param pulumi.Input[builtins.str] procurement_status: The status of the last known good state for the Future Reservation
                Possible values are: .
-        :param pulumi.Input['FutureReservationStatusSpecificSkuPropertiesArgs'] specific_sku_properties: The previous instance related properties of the Future Reservation.
+        :param pulumi.Input['FutureReservationStatusSpecificSkuPropertiesArgs'] specific_sku_properties: Future Reservation configuration to indicate instance properties and total count.
                Structure is documented below.
         """
         if amendment_status is not None:
@@ -10208,7 +10437,7 @@ class FutureReservationStatusArgs:
     @pulumi.getter(name="specificSkuProperties")
     def specific_sku_properties(self) -> Optional[pulumi.Input['FutureReservationStatusSpecificSkuPropertiesArgs']]:
         """
-        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")
@@ -10222,7 +10451,7 @@ if not MYPY:
     class FutureReservationStatusLastKnownGoodStateArgsDict(TypedDict):
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        The description of the FutureReservation before an amendment was requested.
+        An optional description of this resource.
         """
         existing_matching_usage_info: NotRequired[pulumi.Input['FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfoArgsDict']]
         """
@@ -10240,7 +10469,7 @@ if not MYPY:
         """
         name_prefix: NotRequired[pulumi.Input[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-####.
         """
         procurement_status: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -10260,13 +10489,13 @@ class FutureReservationStatusLastKnownGoodStateArgs:
                  name_prefix: Optional[pulumi.Input[builtins.str]] = None,
                  procurement_status: Optional[pulumi.Input[builtins.str]] = None):
         """
-        :param pulumi.Input[builtins.str] description: The description of the FutureReservation before an amendment was requested.
+        :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input['FutureReservationStatusLastKnownGoodStateExistingMatchingUsageInfoArgs'] existing_matching_usage_info: Represents the matching usage for the future reservation before an amendment was requested.
                Structure is documented below.
         :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs'] future_reservation_specs: The previous instance-related properties of the Future Reservation.
                Structure is documented below.
         :param pulumi.Input[builtins.str] lock_time: The lock time of the FutureReservation before an amendment was requested.
-        :param pulumi.Input[builtins.str] name_prefix: The name prefix of the Future Reservation before an amendment was requested.
+        :param pulumi.Input[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 pulumi.Input[builtins.str] procurement_status: The status of the last known good state for the Future Reservation
                Possible values are: .
         """
@@ -10287,7 +10516,7 @@ class FutureReservationStatusLastKnownGoodStateArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        The description of the FutureReservation before an amendment was requested.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -10337,7 +10566,7 @@ class FutureReservationStatusLastKnownGoodStateArgs:
     @pulumi.getter(name="namePrefix")
     def name_prefix(self) -> Optional[pulumi.Input[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")
 
@@ -10415,12 +10644,12 @@ if not MYPY:
     class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgsDict(TypedDict):
         share_settings: NotRequired[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgsDict']]
         """
-        The previous share settings of the Future Reservation.
+        Settings for sharing the future reservation
         Structure is documented below.
         """
         specific_sku_properties: NotRequired[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgsDict']]
         """
-        The previous instance related properties of the Future Reservation.
+        Future Reservation configuration to indicate instance properties and total count.
         Structure is documented below.
         """
         time_window: NotRequired[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowArgsDict']]
@@ -10438,9 +10667,9 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs:
                  specific_sku_properties: Optional[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs']] = None,
                  time_window: Optional[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowArgs']] = None):
         """
-        :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs'] share_settings: The previous share settings of the Future Reservation.
+        :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs'] share_settings: Settings for sharing the future reservation
                Structure is documented below.
-        :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs'] specific_sku_properties: The previous instance related properties of the Future Reservation.
+        :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs'] specific_sku_properties: Future Reservation configuration to indicate instance properties and total count.
                Structure is documented below.
         :param pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowArgs'] time_window: Time window for this Future Reservation.
                Structure is documented below.
@@ -10456,7 +10685,7 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs:
     @pulumi.getter(name="shareSettings")
     def share_settings(self) -> Optional[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsArgs']]:
         """
-        The previous share settings of the Future Reservation.
+        Settings for sharing the future reservation
         Structure is documented below.
         """
         return pulumi.get(self, "share_settings")
@@ -10469,7 +10698,7 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsArgs:
     @pulumi.getter(name="specificSkuProperties")
     def specific_sku_properties(self) -> Optional[pulumi.Input['FutureReservationStatusLastKnownGoodStateFutureReservationSpecsSpecificSkuPropertiesArgs']]:
         """
-        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")
@@ -10574,7 +10803,8 @@ if not MYPY:
     class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettingsProjectMapArgsDict(TypedDict):
         project: pulumi.Input[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.
         """
         project_id: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -10589,7 +10819,8 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettin
                  project: pulumi.Input[builtins.str],
                  project_id: Optional[pulumi.Input[builtins.str]] = None):
         """
-        :param pulumi.Input[builtins.str] project: (Required) The identifier for this object. Format specified above.
+        :param pulumi.Input[builtins.str] project: The ID of the project in which the resource belongs.
+               If it is not provided, the provider project is used.
         :param pulumi.Input[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)
@@ -10600,7 +10831,8 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsShareSettin
     @pulumi.getter
     def project(self) -> pulumi.Input[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")
 
@@ -11044,8 +11276,6 @@ if not MYPY:
         nanos: NotRequired[pulumi.Input[builtins.int]]
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         seconds: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -11061,8 +11291,6 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowD
                  seconds: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] nanos: Span of time that's a fraction of a second at nanosecond resolution.
-               
-               - - -
         :param pulumi.Input[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:
@@ -11075,8 +11303,6 @@ class FutureReservationStatusLastKnownGoodStateFutureReservationSpecsTimeWindowD
     def nanos(self) -> Optional[pulumi.Input[builtins.int]]:
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         return pulumi.get(self, "nanos")
 
@@ -11208,8 +11434,6 @@ if not MYPY:
         nanos: NotRequired[pulumi.Input[builtins.int]]
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         seconds: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -11225,8 +11449,6 @@ class FutureReservationTimeWindowDurationArgs:
                  seconds: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] nanos: Span of time that's a fraction of a second at nanosecond resolution.
-               
-               - - -
         :param pulumi.Input[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:
@@ -11239,8 +11461,6 @@ class FutureReservationTimeWindowDurationArgs:
     def nanos(self) -> Optional[pulumi.Input[builtins.int]]:
         """
         Span of time that's a fraction of a second at nanosecond resolution.
-
-        - - -
         """
         return pulumi.get(self, "nanos")
 
@@ -27503,6 +27723,276 @@ class InstantSnapshotIamMemberConditionArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class InterconnectApplicationAwareInterconnectArgsDict(TypedDict):
+        bandwidth_percentage_policy: NotRequired[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgsDict']]
+        """
+        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.
+        """
+        profile_description: NotRequired[pulumi.Input[builtins.str]]
+        """
+        A description for the AAI profile on this interconnect.
+        """
+        shape_average_percentages: NotRequired[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectShapeAveragePercentageArgsDict']]]]
+        """
+        Optional field to specify a list of shape average percentages to be
+        applied in conjunction with StrictPriorityPolicy or BandwidthPercentagePolicy
+        Structure is documented below.
+        """
+        strict_priority_policy: NotRequired[pulumi.Input['InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgsDict']]
+        """
+        Specify configuration for StrictPriorityPolicy.
+        """
+elif False:
+    InterconnectApplicationAwareInterconnectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InterconnectApplicationAwareInterconnectArgs:
+    def __init__(__self__, *,
+                 bandwidth_percentage_policy: Optional[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs']] = None,
+                 profile_description: Optional[pulumi.Input[builtins.str]] = None,
+                 shape_average_percentages: Optional[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs']]]] = None,
+                 strict_priority_policy: Optional[pulumi.Input['InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs']] = None):
+        """
+        :param pulumi.Input['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 pulumi.Input[builtins.str] profile_description: A description for the AAI profile on this interconnect.
+        :param pulumi.Input[Sequence[pulumi.Input['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 pulumi.Input['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[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs']]:
+        """
+        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")
+
+    @bandwidth_percentage_policy.setter
+    def bandwidth_percentage_policy(self, value: Optional[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs']]):
+        pulumi.set(self, "bandwidth_percentage_policy", value)
+
+    @property
+    @pulumi.getter(name="profileDescription")
+    def profile_description(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        A description for the AAI profile on this interconnect.
+        """
+        return pulumi.get(self, "profile_description")
+
+    @profile_description.setter
+    def profile_description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "profile_description", value)
+
+    @property
+    @pulumi.getter(name="shapeAveragePercentages")
+    def shape_average_percentages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs']]]]:
+        """
+        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")
+
+    @shape_average_percentages.setter
+    def shape_average_percentages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs']]]]):
+        pulumi.set(self, "shape_average_percentages", value)
+
+    @property
+    @pulumi.getter(name="strictPriorityPolicy")
+    def strict_priority_policy(self) -> Optional[pulumi.Input['InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs']]:
+        """
+        Specify configuration for StrictPriorityPolicy.
+        """
+        return pulumi.get(self, "strict_priority_policy")
+
+    @strict_priority_policy.setter
+    def strict_priority_policy(self, value: Optional[pulumi.Input['InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs']]):
+        pulumi.set(self, "strict_priority_policy", value)
+
+
+if not MYPY:
+    class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgsDict(TypedDict):
+        bandwidth_percentages: NotRequired[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgsDict']]]]
+        """
+        Specify bandwidth percentages for various traffic classes for queuing
+        type Bandwidth Percent.
+        Structure is documented below.
+        """
+elif False:
+    InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyArgs:
+    def __init__(__self__, *,
+                 bandwidth_percentages: Optional[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs']]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['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[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs']]]]:
+        """
+        Specify bandwidth percentages for various traffic classes for queuing
+        type Bandwidth Percent.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "bandwidth_percentages")
+
+    @bandwidth_percentages.setter
+    def bandwidth_percentages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs']]]]):
+        pulumi.set(self, "bandwidth_percentages", value)
+
+
+if not MYPY:
+    class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgsDict(TypedDict):
+        percentage: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        traffic_class: NotRequired[pulumi.Input[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`.
+        """
+elif False:
+    InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InterconnectApplicationAwareInterconnectBandwidthPercentagePolicyBandwidthPercentageArgs:
+    def __init__(__self__, *,
+                 percentage: Optional[pulumi.Input[builtins.int]] = None,
+                 traffic_class: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.int] percentage: Bandwidth percentage for a specific traffic class.
+        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        return pulumi.get(self, "percentage")
+
+    @percentage.setter
+    def percentage(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "percentage", value)
+
+    @property
+    @pulumi.getter(name="trafficClass")
+    def traffic_class(self) -> Optional[pulumi.Input[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")
+
+    @traffic_class.setter
+    def traffic_class(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "traffic_class", value)
+
+
+if not MYPY:
+    class InterconnectApplicationAwareInterconnectShapeAveragePercentageArgsDict(TypedDict):
+        percentage: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        traffic_class: NotRequired[pulumi.Input[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`.
+        """
+elif False:
+    InterconnectApplicationAwareInterconnectShapeAveragePercentageArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InterconnectApplicationAwareInterconnectShapeAveragePercentageArgs:
+    def __init__(__self__, *,
+                 percentage: Optional[pulumi.Input[builtins.int]] = None,
+                 traffic_class: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.int] percentage: Bandwidth percentage for a specific traffic class.
+        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
+        """
+        Bandwidth percentage for a specific traffic class.
+        """
+        return pulumi.get(self, "percentage")
+
+    @percentage.setter
+    def percentage(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "percentage", value)
+
+    @property
+    @pulumi.getter(name="trafficClass")
+    def traffic_class(self) -> Optional[pulumi.Input[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")
+
+    @traffic_class.setter
+    def traffic_class(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "traffic_class", value)
+
+
+if not MYPY:
+    class InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgsDict(TypedDict):
+        pass
+elif False:
+    InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InterconnectApplicationAwareInterconnectStrictPriorityPolicyArgs:
+    def __init__(__self__):
+        pass
+
+
 if not MYPY:
     class InterconnectAttachmentGroupAttachmentArgsDict(TypedDict):
         name: pulumi.Input[builtins.str]
@@ -27669,9 +28159,12 @@ if not MYPY:
     class InterconnectAttachmentGroupConfiguredAvailabilitySlaIntendedSlaBlockerArgsDict(TypedDict):
         attachments: NotRequired[pulumi.Input[Sequence[pulumi.Input[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.
         """
         blocker_type: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -27727,9 +28220,12 @@ class InterconnectAttachmentGroupConfiguredAvailabilitySlaIntendedSlaBlockerArgs
                  regions: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  zones: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] attachments: (Output)
-               URLs of any particular Attachments to explain this
-               blocker in more detail.
+        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[builtins.str] blocker_type: (Output)
                The category of an unmet SLA requirement.
         :param pulumi.Input[builtins.str] documentation_link: (Output)
@@ -27772,9 +28268,12 @@ class InterconnectAttachmentGroupConfiguredAvailabilitySlaIntendedSlaBlockerArgs
     @pulumi.getter
     def attachments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")
 
@@ -27877,8 +28376,6 @@ if not MYPY:
         """
         Which SLA the user intends this group to support.
         Possible values are: `PRODUCTION_NON_CRITICAL`, `PRODUCTION_CRITICAL`, `NO_SLA`, `AVAILABILITY_SLA_UNSPECIFIED`.
-
-        - - -
         """
 elif False:
     InterconnectAttachmentGroupIntentArgsDict: TypeAlias = Mapping[str, Any]
@@ -27890,8 +28387,6 @@ class InterconnectAttachmentGroupIntentArgs:
         """
         :param pulumi.Input[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)
@@ -27902,8 +28397,6 @@ class InterconnectAttachmentGroupIntentArgs:
         """
         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")
 
@@ -28740,9 +29233,12 @@ if not MYPY:
         """
         interconnects: NotRequired[pulumi.Input[Sequence[pulumi.Input[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.
         """
         metros: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
@@ -28786,9 +29282,12 @@ class InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockerArgs
                Facilities used to explain this blocker in more detail.
                Like physicalStructure.metros.facilities.facility, this is a numeric
                string like "5467".
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] interconnects: (Output)
-               Interconnects used to explain this blocker in more
-               detail.
+        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[builtins.str]]] metros: (Output)
                Metros used to explain this blocker in more detail.
                These are three-letter lowercase strings like "iad". A blocker like
@@ -28875,9 +29374,12 @@ class InterconnectGroupConfiguredTopologyCapabilityIntendedCapabilityBlockerArgs
     @pulumi.getter
     def interconnects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")
 
@@ -28923,8 +29425,6 @@ if not MYPY:
         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`.
-
-        - - -
         """
 elif False:
     InterconnectGroupIntentArgsDict: TypeAlias = Mapping[str, Any]
@@ -28937,8 +29437,6 @@ class InterconnectGroupIntentArgs:
         :param pulumi.Input[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)
@@ -28950,8 +29448,6 @@ class InterconnectGroupIntentArgs:
         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")
 
@@ -29196,9 +29692,12 @@ if not MYPY:
     class InterconnectGroupPhysicalStructureMetroFacilityZoneArgsDict(TypedDict):
         interconnects: NotRequired[pulumi.Input[Sequence[pulumi.Input[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.
         """
         zone: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -29216,9 +29715,12 @@ class InterconnectGroupPhysicalStructureMetroFacilityZoneArgs:
                  interconnects: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  zone: Optional[pulumi.Input[builtins.str]] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] interconnects: (Output)
-               Interconnects used to explain this blocker in more
-               detail.
+        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[builtins.str] zone: (Output)
                The name of the zone, either "zone1" or "zone2".
                This is the second component of the location of Interconnects in
@@ -29233,9 +29735,12 @@ class InterconnectGroupPhysicalStructureMetroFacilityZoneArgs:
     @pulumi.getter
     def interconnects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")
 
@@ -30579,8 +31084,6 @@ if not MYPY:
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
 elif False:
     NetworkFirewallPolicyRuleMatchSrcSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -30594,8 +31097,6 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTagArgs:
         :param pulumi.Input[builtins.str] name: Name of the secure tag, created with TagManager's TagValue API.
         :param pulumi.Input[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)
@@ -30620,8 +31121,6 @@ class NetworkFirewallPolicyRuleMatchSrcSecureTagArgs:
         """
         (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")
 
@@ -30695,8 +31194,7 @@ if not MYPY:
         """
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         direction: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -30795,8 +31293,7 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleArgs:
         :param pulumi.Input[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 pulumi.Input[builtins.str] description: (Output)
-               A description of the rule.
+        :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.str] direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param pulumi.Input[builtins.bool] disabled: (Output)
@@ -30886,8 +31383,7 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -31534,8 +32030,6 @@ if not MYPY:
         [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.
-
-        - - -
         """
 elif False:
     NetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -31552,8 +32046,6 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgs:
                [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)
@@ -31581,8 +32073,6 @@ class NetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgs:
         [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")
 
@@ -32468,8 +32958,6 @@ if not MYPY:
         [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.
-
-        - - -
         """
 elif False:
     NetworkFirewallPolicyWithRulesRuleTargetSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -32486,8 +32974,6 @@ class NetworkFirewallPolicyWithRulesRuleTargetSecureTagArgs:
                [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)
@@ -32515,8 +33001,6 @@ class NetworkFirewallPolicyWithRulesRuleTargetSecureTagArgs:
         [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")
 
@@ -33514,8 +33998,6 @@ if not MYPY:
         url: pulumi.Input[builtins.str]
         """
         The URL of the instances where this rule should be active.
-
-        - - -
         """
 elif False:
     PacketMirroringMirroredResourcesInstanceArgsDict: TypeAlias = Mapping[str, Any]
@@ -33526,8 +34008,6 @@ class PacketMirroringMirroredResourcesInstanceArgs:
                  url: pulumi.Input[builtins.str]):
         """
         :param pulumi.Input[builtins.str] url: The URL of the instances where this rule should be active.
-               
-               - - -
         """
         pulumi.set(__self__, "url", url)
 
@@ -33536,8 +34016,6 @@ class PacketMirroringMirroredResourcesInstanceArgs:
     def url(self) -> pulumi.Input[builtins.str]:
         """
         The URL of the instances where this rule should be active.
-
-        - - -
         """
         return pulumi.get(self, "url")
 
@@ -34969,7 +35447,7 @@ if not MYPY:
         """
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         disabled: NotRequired[pulumi.Input[builtins.bool]]
         """
@@ -34997,7 +35475,7 @@ class RegionAutoscalerAutoscalingPolicyScalingScheduleArgs:
         :param pulumi.Input[builtins.int] min_required_replicas: Minimum number of VM instances that autoscaler will recommend in time intervals starting according to schedule.
         :param pulumi.Input[builtins.str] name: The identifier for this object. Format specified above.
         :param pulumi.Input[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 pulumi.Input[builtins.str] description: An optional description of this resource.
+        :param pulumi.Input[builtins.str] description: A description of a scaling schedule.
         :param pulumi.Input[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 pulumi.Input[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.
         """
@@ -35064,7 +35542,7 @@ class RegionAutoscalerAutoscalingPolicyScalingScheduleArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        An optional description of this resource.
+        A description of a scaling schedule.
         """
         return pulumi.get(self, "description")
 
@@ -44526,8 +45004,6 @@ if not MYPY:
         """
         (Output)
         State of the secure tag, either EFFECTIVE or INEFFECTIVE. A secure tag is INEFFECTIVE when it is deleted or its network is deleted.
-
-        - - -
         """
 elif False:
     RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -44541,8 +45017,6 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgs:
         :param pulumi.Input[builtins.str] name: Name of the secure tag, created with TagManager's TagValue API.
         :param pulumi.Input[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)
@@ -44567,8 +45041,6 @@ class RegionNetworkFirewallPolicyRuleMatchSrcSecureTagArgs:
         """
         (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")
 
@@ -44642,8 +45114,7 @@ if not MYPY:
         """
         description: NotRequired[pulumi.Input[builtins.str]]
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         direction: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -44742,8 +45213,7 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleArgs:
         :param pulumi.Input[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 pulumi.Input[builtins.str] description: (Output)
-               A description of the rule.
+        :param pulumi.Input[builtins.str] description: An optional description of this resource.
         :param pulumi.Input[builtins.str] direction: (Output)
                The direction in which this rule applies. If unspecified an INGRESS rule is created.
         :param pulumi.Input[builtins.bool] disabled: (Output)
@@ -44833,8 +45303,7 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleArgs:
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        (Output)
-        A description of the rule.
+        An optional description of this resource.
         """
         return pulumi.get(self, "description")
 
@@ -45481,8 +45950,6 @@ if not MYPY:
         [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.
-
-        - - -
         """
 elif False:
     RegionNetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -45499,8 +45966,6 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgs:
                [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)
@@ -45528,8 +45993,6 @@ class RegionNetworkFirewallPolicyWithRulesPredefinedRuleTargetSecureTagArgs:
         [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")
 
@@ -46415,8 +46878,6 @@ if not MYPY:
         [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.
-
-        - - -
         """
 elif False:
     RegionNetworkFirewallPolicyWithRulesRuleTargetSecureTagArgsDict: TypeAlias = Mapping[str, Any]
@@ -46433,8 +46894,6 @@ class RegionNetworkFirewallPolicyWithRulesRuleTargetSecureTagArgs:
                [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)
@@ -46462,8 +46921,6 @@ class RegionNetworkFirewallPolicyWithRulesRuleTargetSecureTagArgs:
         [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")
 
@@ -58047,6 +58504,93 @@ class RegionUrlMapTestArgs:
         pulumi.set(self, "description", value)
 
 
+if not MYPY:
+    class ReservationDeleteAfterDurationArgsDict(TypedDict):
+        nanos: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Number of nanoseconds for the auto-delete duration.
+        """
+        seconds: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Number of seconds for the auto-delete duration.
+        """
+elif False:
+    ReservationDeleteAfterDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReservationDeleteAfterDurationArgs:
+    def __init__(__self__, *,
+                 nanos: Optional[pulumi.Input[builtins.int]] = None,
+                 seconds: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.int] nanos: Number of nanoseconds for the auto-delete duration.
+        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
+        """
+        Number of nanoseconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "nanos")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "nanos", value)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Number of seconds for the auto-delete duration.
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "seconds", value)
+
+
+if not MYPY:
+    class ReservationReservationSharingPolicyArgsDict(TypedDict):
+        service_share_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Sharing config for all Google Cloud services.
+        Possible values are: `ALLOW_ALL`, `DISALLOW_ALL`.
+        """
+elif False:
+    ReservationReservationSharingPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ReservationReservationSharingPolicyArgs:
+    def __init__(__self__, *,
+                 service_share_type: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
+        """
+        Sharing config for all Google Cloud services.
+        Possible values are: `ALLOW_ALL`, `DISALLOW_ALL`.
+        """
+        return pulumi.get(self, "service_share_type")
+
+    @service_share_type.setter
+    def service_share_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "service_share_type", value)
+
+
 if not MYPY:
     class ReservationShareSettingsArgsDict(TypedDict):
         project_maps: NotRequired[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgsDict']]]]
@@ -58054,6 +58598,10 @@ if not MYPY:
         A map of project number and project config. This is only valid when shareType's value is SPECIFIC_PROJECTS.
         Structure is documented below.
         """
+        projects: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        """
+        List of project IDs with which the reservation is shared.
+        """
         share_type: NotRequired[pulumi.Input[builtins.str]]
         """
         Type of sharing for this shared-reservation
@@ -58066,15 +58614,19 @@ elif False:
 class ReservationShareSettingsArgs:
     def __init__(__self__, *,
                  project_maps: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]]] = None,
+                 projects: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                  share_type: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['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 pulumi.Input[Sequence[pulumi.Input[builtins.str]]] projects: List of project IDs with which the reservation is shared.
         :param pulumi.Input[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)
 
@@ -58091,6 +58643,18 @@ class ReservationShareSettingsArgs:
     def project_maps(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationShareSettingsProjectMapArgs']]]]):
         pulumi.set(self, "project_maps", value)
 
+    @property
+    @pulumi.getter
+    def projects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        """
+        List of project IDs with which the reservation is shared.
+        """
+        return pulumi.get(self, "projects")
+
+    @projects.setter
+    def projects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "projects", value)
+
     @property
     @pulumi.getter(name="shareType")
     def share_type(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -58162,15 +58726,20 @@ if not MYPY:
         """
         The number of resources that are allocated.
         """
-        instance_properties: pulumi.Input['ReservationSpecificReservationInstancePropertiesArgsDict']
+        in_use_count: NotRequired[pulumi.Input[builtins.int]]
+        """
+        (Output)
+        How many instances are in use.
+        """
+        instance_properties: NotRequired[pulumi.Input['ReservationSpecificReservationInstancePropertiesArgsDict']]
         """
         The instance properties for the reservation.
         Structure is documented below.
         """
-        in_use_count: NotRequired[pulumi.Input[builtins.int]]
+        source_instance_template: NotRequired[pulumi.Input[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.
         """
 elif False:
     ReservationSpecificReservationArgsDict: TypeAlias = Mapping[str, Any]
@@ -58179,19 +58748,25 @@ elif False:
 class ReservationSpecificReservationArgs:
     def __init__(__self__, *,
                  count: pulumi.Input[builtins.int],
-                 instance_properties: pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs'],
-                 in_use_count: Optional[pulumi.Input[builtins.int]] = None):
+                 in_use_count: Optional[pulumi.Input[builtins.int]] = None,
+                 instance_properties: Optional[pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']] = None,
+                 source_instance_template: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] count: The number of resources that are allocated.
-        :param pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs'] instance_properties: The instance properties for the reservation.
-               Structure is documented below.
         :param pulumi.Input[builtins.int] in_use_count: (Output)
                How many instances are in use.
+        :param pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs'] instance_properties: The instance properties for the reservation.
+               Structure is documented below.
+        :param pulumi.Input[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
@@ -58205,9 +58780,22 @@ class ReservationSpecificReservationArgs:
     def count(self, value: pulumi.Input[builtins.int]):
         pulumi.set(self, "count", value)
 
+    @property
+    @pulumi.getter(name="inUseCount")
+    def in_use_count(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        (Output)
+        How many instances are in use.
+        """
+        return pulumi.get(self, "in_use_count")
+
+    @in_use_count.setter
+    def in_use_count(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "in_use_count", value)
+
     @property
     @pulumi.getter(name="instanceProperties")
-    def instance_properties(self) -> pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']:
+    def instance_properties(self) -> Optional[pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']]:
         """
         The instance properties for the reservation.
         Structure is documented below.
@@ -58215,21 +58803,21 @@ class ReservationSpecificReservationArgs:
         return pulumi.get(self, "instance_properties")
 
     @instance_properties.setter
-    def instance_properties(self, value: pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']):
+    def instance_properties(self, value: Optional[pulumi.Input['ReservationSpecificReservationInstancePropertiesArgs']]):
         pulumi.set(self, "instance_properties", value)
 
     @property
-    @pulumi.getter(name="inUseCount")
-    def in_use_count(self) -> Optional[pulumi.Input[builtins.int]]:
+    @pulumi.getter(name="sourceInstanceTemplate")
+    def source_instance_template(self) -> Optional[pulumi.Input[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")
 
-    @in_use_count.setter
-    def in_use_count(self, value: Optional[pulumi.Input[builtins.int]]):
-        pulumi.set(self, "in_use_count", value)
+    @source_instance_template.setter
+    def source_instance_template(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "source_instance_template", value)
 
 
 if not MYPY:
@@ -58249,6 +58837,11 @@ if not MYPY:
         reserves disks of type `local-ssd`.
         Structure is documented below.
         """
+        maintenance_interval: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies the frequency of planned maintenance events.
+        Possible values are: `AS_NEEDED`, `PERIODIC`, `RECURRENT`.
+        """
         min_cpu_platform: NotRequired[pulumi.Input[builtins.str]]
         """
         The minimum CPU platform for the reservation. For example,
@@ -58265,6 +58858,7 @@ class ReservationSpecificReservationInstancePropertiesArgs:
                  machine_type: pulumi.Input[builtins.str],
                  guest_accelerators: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesGuestAcceleratorArgs']]]] = None,
                  local_ssds: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]]] = None,
+                 maintenance_interval: Optional[pulumi.Input[builtins.str]] = None,
                  min_cpu_platform: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] machine_type: The name of the machine type to reserve.
@@ -58273,6 +58867,8 @@ class ReservationSpecificReservationInstancePropertiesArgs:
         :param pulumi.Input[Sequence[pulumi.Input['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 pulumi.Input[builtins.str] maintenance_interval: Specifies the frequency of planned maintenance events.
+               Possible values are: `AS_NEEDED`, `PERIODIC`, `RECURRENT`.
         :param pulumi.Input[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)
@@ -58283,6 +58879,8 @@ class ReservationSpecificReservationInstancePropertiesArgs:
             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)
 
@@ -58325,6 +58923,19 @@ class ReservationSpecificReservationInstancePropertiesArgs:
     def local_ssds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ReservationSpecificReservationInstancePropertiesLocalSsdArgs']]]]):
         pulumi.set(self, "local_ssds", value)
 
+    @property
+    @pulumi.getter(name="maintenanceInterval")
+    def maintenance_interval(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies the frequency of planned maintenance events.
+        Possible values are: `AS_NEEDED`, `PERIODIC`, `RECURRENT`.
+        """
+        return pulumi.get(self, "maintenance_interval")
+
+    @maintenance_interval.setter
+    def maintenance_interval(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "maintenance_interval", value)
+
     @property
     @pulumi.getter(name="minCpuPlatform")
     def min_cpu_platform(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -58408,8 +59019,6 @@ if not MYPY:
         disk_size_gb: pulumi.Input[builtins.int]
         """
         The size of the disk in base-2 GB.
-
-        - - -
         """
         interface: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -58427,8 +59036,6 @@ class ReservationSpecificReservationInstancePropertiesLocalSsdArgs:
                  interface: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] disk_size_gb: The size of the disk in base-2 GB.
-               
-               - - -
         :param pulumi.Input[builtins.str] interface: The disk interface to use for attaching this disk.
                Default value is `SCSI`.
                Possible values are: `SCSI`, `NVME`.
@@ -58442,8 +59049,6 @@ class ReservationSpecificReservationInstancePropertiesLocalSsdArgs:
     def disk_size_gb(self) -> pulumi.Input[builtins.int]:
         """
         The size of the disk in base-2 GB.
-
-        - - -
         """
         return pulumi.get(self, "disk_size_gb")
 
@@ -60948,6 +61553,53 @@ class RouteAsPathArgs:
         pulumi.set(self, "path_segment_type", value)
 
 
+if not MYPY:
+    class RouteParamsArgsDict(TypedDict):
+        resource_manager_tags: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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.
+        """
+elif False:
+    RouteParamsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RouteParamsArgs:
+    def __init__(__self__, *,
+                 resource_manager_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None):
+        """
+        :param pulumi.Input[Mapping[str, pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[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")
+
+    @resource_manager_tags.setter
+    def resource_manager_tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "resource_manager_tags", value)
+
+
 if not MYPY:
     class RouteWarningArgsDict(TypedDict):
         code: NotRequired[pulumi.Input[builtins.str]]
@@ -62144,6 +62796,11 @@ class RouterPeerMd5AuthenticationKeyArgs:
 
 if not MYPY:
     class RouterRoutePolicyTermArgsDict(TypedDict):
+        match: pulumi.Input['RouterRoutePolicyTermMatchArgsDict']
+        """
+        CEL expression evaluated against a route to determine if this term applies (see Policy Language).
+        Structure is documented below.
+        """
         priority: pulumi.Input[builtins.int]
         """
         The evaluation priority for this term, which must be between 0 (inclusive) and 231 (exclusive), and unique within the list.
@@ -62153,32 +62810,39 @@ if not MYPY:
         'CEL expressions to evaluate to modify a route when this term matches.'\\
         Structure is documented below.
         """
-        match: NotRequired[pulumi.Input['RouterRoutePolicyTermMatchArgsDict']]
-        """
-        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.
-        """
 elif False:
     RouterRoutePolicyTermArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class RouterRoutePolicyTermArgs:
     def __init__(__self__, *,
+                 match: pulumi.Input['RouterRoutePolicyTermMatchArgs'],
                  priority: pulumi.Input[builtins.int],
-                 actions: Optional[pulumi.Input[Sequence[pulumi.Input['RouterRoutePolicyTermActionArgs']]]] = None,
-                 match: Optional[pulumi.Input['RouterRoutePolicyTermMatchArgs']] = None):
+                 actions: Optional[pulumi.Input[Sequence[pulumi.Input['RouterRoutePolicyTermActionArgs']]]] = None):
         """
+        :param pulumi.Input['RouterRoutePolicyTermMatchArgs'] match: CEL expression evaluated against a route to determine if this term applies (see Policy Language).
+               Structure is documented below.
         :param pulumi.Input[builtins.int] priority: The evaluation priority for this term, which must be between 0 (inclusive) and 231 (exclusive), and unique within the list.
         :param pulumi.Input[Sequence[pulumi.Input['RouterRoutePolicyTermActionArgs']]] actions: 'CEL expressions to evaluate to modify a route when this term matches.'\\
                Structure is documented below.
-        :param pulumi.Input['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) -> pulumi.Input['RouterRoutePolicyTermMatchArgs']:
+        """
+        CEL expression evaluated against a route to determine if this term applies (see Policy Language).
+        Structure is documented below.
+        """
+        return pulumi.get(self, "match")
+
+    @match.setter
+    def match(self, value: pulumi.Input['RouterRoutePolicyTermMatchArgs']):
+        pulumi.set(self, "match", value)
 
     @property
     @pulumi.getter
@@ -62205,19 +62869,6 @@ class RouterRoutePolicyTermArgs:
     def actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RouterRoutePolicyTermActionArgs']]]]):
         pulumi.set(self, "actions", value)
 
-    @property
-    @pulumi.getter
-    def match(self) -> Optional[pulumi.Input['RouterRoutePolicyTermMatchArgs']]:
-        """
-        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")
-
-    @match.setter
-    def match(self, value: Optional[pulumi.Input['RouterRoutePolicyTermMatchArgs']]):
-        pulumi.set(self, "match", value)
-
 
 if not MYPY:
     class RouterRoutePolicyTermActionArgsDict(TypedDict):
@@ -62234,8 +62885,6 @@ if not MYPY:
         """
         String indicating the location of the expression for error
         reporting, e.g. a file name and a position in the file
-
-        - - -
         """
         title: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -62258,8 +62907,6 @@ class RouterRoutePolicyTermActionArgs:
         :param pulumi.Input[builtins.str] description: Description of the expression
         :param pulumi.Input[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 pulumi.Input[builtins.str] title: Title for the expression, i.e. a short string describing its
                purpose.
         """
@@ -62302,8 +62949,6 @@ class RouterRoutePolicyTermActionArgs:
         """
         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")
 
@@ -62926,6 +63571,10 @@ if not MYPY:
         * `NORMAL` - Normal log level.
         * `VERBOSE` - Verbose log level.
         """
+        request_body_inspection_size: NotRequired[pulumi.Input[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.
+        """
         user_ip_request_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
         An optional list of case-insensitive request header names to use for resolving the callers client IP address.
@@ -62939,6 +63588,7 @@ class SecurityPolicyAdvancedOptionsConfigArgs:
                  json_custom_config: Optional[pulumi.Input['SecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs']] = None,
                  json_parsing: Optional[pulumi.Input[builtins.str]] = None,
                  log_level: Optional[pulumi.Input[builtins.str]] = None,
+                 request_body_inspection_size: Optional[pulumi.Input[builtins.str]] = None,
                  user_ip_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
         """
         :param pulumi.Input['SecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs'] json_custom_config: Custom configuration to apply the JSON parsing. Only applicable when
@@ -62950,6 +63600,7 @@ class SecurityPolicyAdvancedOptionsConfigArgs:
         :param pulumi.Input[builtins.str] log_level: Log level to use. Defaults to `NORMAL`.
                * `NORMAL` - Normal log level.
                * `VERBOSE` - Verbose log level.
+        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[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:
@@ -62958,6 +63609,8 @@ class SecurityPolicyAdvancedOptionsConfigArgs:
             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)
 
@@ -63003,6 +63656,18 @@ class SecurityPolicyAdvancedOptionsConfigArgs:
     def log_level(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "log_level", value)
 
+    @property
+    @pulumi.getter(name="requestBodyInspectionSize")
+    def request_body_inspection_size(self) -> Optional[pulumi.Input[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")
+
+    @request_body_inspection_size.setter
+    def request_body_inspection_size(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "request_body_inspection_size", value)
+
     @property
     @pulumi.getter(name="userIpRequestHeaders")
     def user_ip_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
@@ -65295,8 +65960,6 @@ if not MYPY:
         """
         Name of the location. It should be one of the Cloud Storage buckets.
         Only one location can be specified. (should match location)
-
-        - - -
         """
 elif False:
     SnapshotSettingsStorageLocationLocationArgsDict: TypeAlias = Mapping[str, Any]
@@ -65310,8 +65973,6 @@ class SnapshotSettingsStorageLocationLocationArgs:
         :param pulumi.Input[builtins.str] location: The identifier for this object. Format specified above.
         :param pulumi.Input[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)
@@ -65334,8 +65995,6 @@ class SnapshotSettingsStorageLocationLocationArgs:
         """
         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")