pulumi-gcp 7.24.0__py3-none-any.whl → 7.24.0a1715926460__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -182,10 +182,6 @@ __all__ = [
     'InstanceTemplateServiceAccount',
     'InstanceTemplateShieldedInstanceConfig',
     'InterconnectAttachmentPrivateInterconnectInfo',
-    'InterconnectCircuitInfo',
-    'InterconnectExpectedOutage',
-    'InterconnectMacsec',
-    'InterconnectMacsecPreSharedKey',
     'MachineImageIamBindingCondition',
     'MachineImageIamMemberCondition',
     'MachineImageMachineImageEncryptionKey',
@@ -314,7 +310,6 @@ __all__ = [
     'RegionSecurityPolicyDdosProtectionConfig',
     'RegionSecurityPolicyRuleMatch',
     'RegionSecurityPolicyRuleMatchConfig',
-    'RegionSecurityPolicyRuleMatchExpr',
     'RegionSecurityPolicyRuleNetworkMatch',
     'RegionSecurityPolicyRuleNetworkMatchUserDefinedField',
     'RegionSecurityPolicyRulePreconfiguredWafConfig',
@@ -3126,25 +3121,6 @@ class BackendServiceLocalityLbPolicyPolicy(dict):
                Note that specifying the same policy more than once for a backend is
                not a valid configuration and will be rejected.
                The possible values are:
-               * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
-               is selected in round robin order.
-               * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
-               hosts and picks the host which has fewer active requests.
-               * `RING_HASH`: The ring/modulo hash load balancer implements consistent
-               hashing to backends. The algorithm has the property that the
-               addition/removal of a host from a set of N hosts only affects
-               1/N of the requests.
-               * `RANDOM`: The load balancer selects a random healthy host.
-               * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
-               connection metadata, i.e., connections are opened
-               to the same address as the destination address of
-               the incoming connection before the connection
-               was redirected to the load balancer.
-               * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
-               Maglev is not as stable as ring hash but has faster table lookup
-               build times and host selection times. For more information about
-               Maglev, refer to https://ai.google/research/pubs/pub44824
-               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`.
         """
         pulumi.set(__self__, "name", name)
 
@@ -3160,25 +3136,6 @@ class BackendServiceLocalityLbPolicyPolicy(dict):
         Note that specifying the same policy more than once for a backend is
         not a valid configuration and will be rejected.
         The possible values are:
-        * `ROUND_ROBIN`: This is a simple policy in which each healthy backend
-        is selected in round robin order.
-        * `LEAST_REQUEST`: An O(1) algorithm which selects two random healthy
-        hosts and picks the host which has fewer active requests.
-        * `RING_HASH`: The ring/modulo hash load balancer implements consistent
-        hashing to backends. The algorithm has the property that the
-        addition/removal of a host from a set of N hosts only affects
-        1/N of the requests.
-        * `RANDOM`: The load balancer selects a random healthy host.
-        * `ORIGINAL_DESTINATION`: Backend host is selected based on the client
-        connection metadata, i.e., connections are opened
-        to the same address as the destination address of
-        the incoming connection before the connection
-        was redirected to the load balancer.
-        * `MAGLEV`: used as a drop in replacement for the ring hash load balancer.
-        Maglev is not as stable as ring hash but has faster table lookup
-        build times and host selection times. For more information about
-        Maglev, refer to https://ai.google/research/pubs/pub44824
-        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`.
         """
         return pulumi.get(self, "name")
 
@@ -4718,15 +4675,6 @@ class HealthCheckGrpcHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, gRPC health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         if grpc_service_name is not None:
             pulumi.set(__self__, "grpc_service_name", grpc_service_name)
@@ -4774,15 +4722,6 @@ class HealthCheckGrpcHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, gRPC health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -4986,15 +4925,6 @@ class HealthCheckHttpHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTP health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -5054,15 +4984,6 @@ class HealthCheckHttpHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTP health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -5140,15 +5061,6 @@ class HealthCheckHttpsHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTPS health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -5208,15 +5120,6 @@ class HealthCheckHttpsHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTPS health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -5309,15 +5212,6 @@ class HealthCheckSslHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTP2 health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -5367,15 +5261,6 @@ class HealthCheckSslHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTP2 health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -5449,15 +5334,6 @@ class HealthCheckTcpHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, TCP health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -5507,15 +5383,6 @@ class HealthCheckTcpHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, TCP health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -13318,382 +13185,6 @@ class InterconnectAttachmentPrivateInterconnectInfo(dict):
         return pulumi.get(self, "tag8021q")
 
 
-@pulumi.output_type
-class InterconnectCircuitInfo(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "customerDemarcId":
-            suggest = "customer_demarc_id"
-        elif key == "googleCircuitId":
-            suggest = "google_circuit_id"
-        elif key == "googleDemarcId":
-            suggest = "google_demarc_id"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in InterconnectCircuitInfo. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        InterconnectCircuitInfo.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        InterconnectCircuitInfo.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 customer_demarc_id: Optional[str] = None,
-                 google_circuit_id: Optional[str] = None,
-                 google_demarc_id: Optional[str] = None):
-        """
-        :param str customer_demarc_id: (Output)
-               Customer-side demarc ID for this circuit.
-        :param str google_circuit_id: (Output)
-               Google-assigned unique ID for this circuit. Assigned at circuit turn-up.
-        :param str google_demarc_id: (Output)
-               Google-side demarc ID for this circuit. Assigned at circuit turn-up and provided by
-               Google to the customer in the LOA.
-        """
-        if customer_demarc_id is not None:
-            pulumi.set(__self__, "customer_demarc_id", customer_demarc_id)
-        if google_circuit_id is not None:
-            pulumi.set(__self__, "google_circuit_id", google_circuit_id)
-        if google_demarc_id is not None:
-            pulumi.set(__self__, "google_demarc_id", google_demarc_id)
-
-    @property
-    @pulumi.getter(name="customerDemarcId")
-    def customer_demarc_id(self) -> Optional[str]:
-        """
-        (Output)
-        Customer-side demarc ID for this circuit.
-        """
-        return pulumi.get(self, "customer_demarc_id")
-
-    @property
-    @pulumi.getter(name="googleCircuitId")
-    def google_circuit_id(self) -> Optional[str]:
-        """
-        (Output)
-        Google-assigned unique ID for this circuit. Assigned at circuit turn-up.
-        """
-        return pulumi.get(self, "google_circuit_id")
-
-    @property
-    @pulumi.getter(name="googleDemarcId")
-    def google_demarc_id(self) -> Optional[str]:
-        """
-        (Output)
-        Google-side demarc ID for this circuit. Assigned at circuit turn-up and provided by
-        Google to the customer in the LOA.
-        """
-        return pulumi.get(self, "google_demarc_id")
-
-
-@pulumi.output_type
-class InterconnectExpectedOutage(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "affectedCircuits":
-            suggest = "affected_circuits"
-        elif key == "endTime":
-            suggest = "end_time"
-        elif key == "issueType":
-            suggest = "issue_type"
-        elif key == "startTime":
-            suggest = "start_time"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in InterconnectExpectedOutage. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        InterconnectExpectedOutage.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        InterconnectExpectedOutage.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 affected_circuits: Optional[Sequence[str]] = None,
-                 description: Optional[str] = None,
-                 end_time: Optional[str] = None,
-                 issue_type: Optional[str] = None,
-                 name: Optional[str] = None,
-                 source: Optional[str] = None,
-                 start_time: Optional[str] = None,
-                 state: Optional[str] = None):
-        """
-        :param Sequence[str] affected_circuits: (Output)
-               If issueType is IT_PARTIAL_OUTAGE, a list of the Google-side circuit IDs that will be
-               affected.
-        :param str description: An optional description of this resource. Provide this property when you create the resource.
-        :param str end_time: (Output)
-               Scheduled end time for the outage (milliseconds since Unix epoch).
-        :param str issue_type: (Output)
-               Form this outage is expected to take. Note that the versions of this enum prefixed with
-               "IT_" have been deprecated in favor of the unprefixed values. Can take one of the
-               following values:
-               - OUTAGE: The Interconnect may be completely out of service for some or all of the
-               specified window.
-               - PARTIAL_OUTAGE: Some circuits comprising the Interconnect as a whole should remain
-               up, but with reduced bandwidth.
-        :param str name: Name of the resource. Provided by the client when the resource is created. The name must be
-               1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters
-               long and match the regular expression `a-z?` which means the first
-               character must be a lowercase letter, and all following characters must be a dash,
-               lowercase letter, or digit, except the last character, which cannot be a dash.
-        :param str source: (Output)
-               The party that generated this notification. Note that the value of NSRC_GOOGLE has been
-               deprecated in favor of GOOGLE. Can take the following value:
-               - GOOGLE: this notification as generated by Google.
-        :param str start_time: (Output)
-               Scheduled start time for the outage (milliseconds since Unix epoch).
-        :param str state: (Output)
-               State of this notification. Note that the versions of this enum prefixed with "NS_" have
-               been deprecated in favor of the unprefixed values. Can take one of the following values:
-               - ACTIVE: This outage notification is active. The event could be in the past, present,
-               or future. See startTime and endTime for scheduling.
-               - CANCELLED: The outage associated with this notification was cancelled before the
-               outage was due to start.
-               - COMPLETED: The outage associated with this notification is complete.
-        """
-        if affected_circuits is not None:
-            pulumi.set(__self__, "affected_circuits", affected_circuits)
-        if description is not None:
-            pulumi.set(__self__, "description", description)
-        if end_time is not None:
-            pulumi.set(__self__, "end_time", end_time)
-        if issue_type is not None:
-            pulumi.set(__self__, "issue_type", issue_type)
-        if name is not None:
-            pulumi.set(__self__, "name", name)
-        if source is not None:
-            pulumi.set(__self__, "source", source)
-        if start_time is not None:
-            pulumi.set(__self__, "start_time", start_time)
-        if state is not None:
-            pulumi.set(__self__, "state", state)
-
-    @property
-    @pulumi.getter(name="affectedCircuits")
-    def affected_circuits(self) -> Optional[Sequence[str]]:
-        """
-        (Output)
-        If issueType is IT_PARTIAL_OUTAGE, a list of the Google-side circuit IDs that will be
-        affected.
-        """
-        return pulumi.get(self, "affected_circuits")
-
-    @property
-    @pulumi.getter
-    def description(self) -> Optional[str]:
-        """
-        An optional description of this resource. Provide this property when you create the resource.
-        """
-        return pulumi.get(self, "description")
-
-    @property
-    @pulumi.getter(name="endTime")
-    def end_time(self) -> Optional[str]:
-        """
-        (Output)
-        Scheduled end time for the outage (milliseconds since Unix epoch).
-        """
-        return pulumi.get(self, "end_time")
-
-    @property
-    @pulumi.getter(name="issueType")
-    def issue_type(self) -> Optional[str]:
-        """
-        (Output)
-        Form this outage is expected to take. Note that the versions of this enum prefixed with
-        "IT_" have been deprecated in favor of the unprefixed values. Can take one of the
-        following values:
-        - OUTAGE: The Interconnect may be completely out of service for some or all of the
-        specified window.
-        - PARTIAL_OUTAGE: Some circuits comprising the Interconnect as a whole should remain
-        up, but with reduced bandwidth.
-        """
-        return pulumi.get(self, "issue_type")
-
-    @property
-    @pulumi.getter
-    def name(self) -> Optional[str]:
-        """
-        Name of the resource. Provided by the client when the resource is created. The name must be
-        1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters
-        long and match the regular expression `a-z?` which means the first
-        character must be a lowercase letter, and all following characters must be a dash,
-        lowercase letter, or digit, except the last character, which cannot be a dash.
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter
-    def source(self) -> Optional[str]:
-        """
-        (Output)
-        The party that generated this notification. Note that the value of NSRC_GOOGLE has been
-        deprecated in favor of GOOGLE. Can take the following value:
-        - GOOGLE: this notification as generated by Google.
-        """
-        return pulumi.get(self, "source")
-
-    @property
-    @pulumi.getter(name="startTime")
-    def start_time(self) -> Optional[str]:
-        """
-        (Output)
-        Scheduled start time for the outage (milliseconds since Unix epoch).
-        """
-        return pulumi.get(self, "start_time")
-
-    @property
-    @pulumi.getter
-    def state(self) -> Optional[str]:
-        """
-        (Output)
-        State of this notification. Note that the versions of this enum prefixed with "NS_" have
-        been deprecated in favor of the unprefixed values. Can take one of the following values:
-        - ACTIVE: This outage notification is active. The event could be in the past, present,
-        or future. See startTime and endTime for scheduling.
-        - CANCELLED: The outage associated with this notification was cancelled before the
-        outage was due to start.
-        - COMPLETED: The outage associated with this notification is complete.
-        """
-        return pulumi.get(self, "state")
-
-
-@pulumi.output_type
-class InterconnectMacsec(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "preSharedKeys":
-            suggest = "pre_shared_keys"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in InterconnectMacsec. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        InterconnectMacsec.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        InterconnectMacsec.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 pre_shared_keys: Sequence['outputs.InterconnectMacsecPreSharedKey']):
-        """
-        :param Sequence['InterconnectMacsecPreSharedKeyArgs'] pre_shared_keys: A keychain placeholder describing a set of named key objects along with their
-               start times. A MACsec CKN/CAK is generated for each key in the key chain.
-               Google router automatically picks the key with the most recent startTime when establishing
-               or re-establishing a MACsec secure link.
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "pre_shared_keys", pre_shared_keys)
-
-    @property
-    @pulumi.getter(name="preSharedKeys")
-    def pre_shared_keys(self) -> Sequence['outputs.InterconnectMacsecPreSharedKey']:
-        """
-        A keychain placeholder describing a set of named key objects along with their
-        start times. A MACsec CKN/CAK is generated for each key in the key chain.
-        Google router automatically picks the key with the most recent startTime when establishing
-        or re-establishing a MACsec secure link.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "pre_shared_keys")
-
-
-@pulumi.output_type
-class InterconnectMacsecPreSharedKey(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "failOpen":
-            suggest = "fail_open"
-        elif key == "startTime":
-            suggest = "start_time"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in InterconnectMacsecPreSharedKey. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        InterconnectMacsecPreSharedKey.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        InterconnectMacsecPreSharedKey.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 name: str,
-                 fail_open: Optional[bool] = None,
-                 start_time: Optional[str] = None):
-        """
-        :param str name: A name for this pre-shared key. The name must be 1-63 characters long, and
-               comply with RFC1035. Specifically, the name must be 1-63 characters long and match
-               the regular expression `a-z?` which means the first character
-               must be a lowercase letter, and all following characters must be a dash, lowercase
-               letter, or digit, except the last character, which cannot be a dash.
-        :param bool fail_open: If set to true, the Interconnect connection is configured with a should-secure
-               MACsec security policy, that allows the Google router to fallback to cleartext
-               traffic if the MKA session cannot be established. By default, the Interconnect
-               connection is configured with a must-secure security policy that drops all traffic
-               if the MKA session cannot be established with your router.
-        :param str start_time: A RFC3339 timestamp on or after which the key is valid. startTime can be in the
-               future. If the keychain has a single key, startTime can be omitted. If the keychain
-               has multiple keys, startTime is mandatory for each key. The start times of keys must
-               be in increasing order. The start times of two consecutive keys must be at least 6
-               hours apart.
-        """
-        pulumi.set(__self__, "name", name)
-        if fail_open is not None:
-            pulumi.set(__self__, "fail_open", fail_open)
-        if start_time is not None:
-            pulumi.set(__self__, "start_time", start_time)
-
-    @property
-    @pulumi.getter
-    def name(self) -> str:
-        """
-        A name for this pre-shared key. The name must be 1-63 characters long, and
-        comply with RFC1035. Specifically, the name must be 1-63 characters long and match
-        the regular expression `a-z?` which means the first character
-        must be a lowercase letter, and all following characters must be a dash, lowercase
-        letter, or digit, except the last character, which cannot be a dash.
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter(name="failOpen")
-    def fail_open(self) -> Optional[bool]:
-        """
-        If set to true, the Interconnect connection is configured with a should-secure
-        MACsec security policy, that allows the Google router to fallback to cleartext
-        traffic if the MKA session cannot be established. By default, the Interconnect
-        connection is configured with a must-secure security policy that drops all traffic
-        if the MKA session cannot be established with your router.
-        """
-        return pulumi.get(self, "fail_open")
-
-    @property
-    @pulumi.getter(name="startTime")
-    def start_time(self) -> Optional[str]:
-        """
-        A RFC3339 timestamp on or after which the key is valid. startTime can be in the
-        future. If the keychain has a single key, startTime can be omitted. If the keychain
-        has multiple keys, startTime is mandatory for each key. The start times of keys must
-        be in increasing order. The start times of two consecutive keys must be at least 6
-        hours apart.
-        """
-        return pulumi.get(self, "start_time")
-
-
 @pulumi.output_type
 class MachineImageIamBindingCondition(dict):
     def __init__(__self__, *,
@@ -18306,15 +17797,6 @@ class RegionHealthCheckGrpcHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, gRPC health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         if grpc_service_name is not None:
             pulumi.set(__self__, "grpc_service_name", grpc_service_name)
@@ -18362,15 +17844,6 @@ class RegionHealthCheckGrpcHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, gRPC health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -18574,15 +18047,6 @@ class RegionHealthCheckHttpHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTP health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -18642,15 +18106,6 @@ class RegionHealthCheckHttpHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTP health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -18728,15 +18183,6 @@ class RegionHealthCheckHttpsHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTPS health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -18796,15 +18242,6 @@ class RegionHealthCheckHttpsHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTPS health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -18897,15 +18334,6 @@ class RegionHealthCheckSslHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, HTTP2 health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -18955,15 +18383,6 @@ class RegionHealthCheckSslHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, HTTP2 health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -19037,15 +18456,6 @@ class RegionHealthCheckTcpHealthCheck(dict):
                port_name are defined, port takes precedence.
         :param str port_specification: Specifies how port is selected for health checking, can be one of the
                following values:
-               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-               * `USE_NAMED_PORT`: The `portName` is used for health checking.
-               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-               network endpoint is used for health checking. For other backends, the
-               port or named port specified in the Backend Service is used for health
-               checking.
-               If not specified, TCP health check follows behavior specified in `port` and
-               `portName` fields.
-               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         :param str proxy_header: Specifies the type of proxy header to append before sending data to the
                backend.
                Default value is `NONE`.
@@ -19095,15 +18505,6 @@ class RegionHealthCheckTcpHealthCheck(dict):
         """
         Specifies how port is selected for health checking, can be one of the
         following values:
-        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
-        * `USE_NAMED_PORT`: The `portName` is used for health checking.
-        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
-        network endpoint is used for health checking. For other backends, the
-        port or named port specified in the Backend Service is used for health
-        checking.
-        If not specified, TCP health check follows behavior specified in `port` and
-        `portName` fields.
-        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
         """
         return pulumi.get(self, "port_specification")
 
@@ -22655,22 +22056,17 @@ class RegionSecurityPolicyRuleMatch(dict):
 
     def __init__(__self__, *,
                  config: Optional['outputs.RegionSecurityPolicyRuleMatchConfig'] = None,
-                 expr: Optional['outputs.RegionSecurityPolicyRuleMatchExpr'] = None,
                  versioned_expr: Optional[str] = None):
         """
         :param 'RegionSecurityPolicyRuleMatchConfigArgs' config: The configuration options available when specifying versionedExpr.
                This field must be specified if versionedExpr is specified and cannot be specified if versionedExpr is not specified.
                Structure is documented below.
-        :param 'RegionSecurityPolicyRuleMatchExprArgs' expr: User defined CEVAL expression. A CEVAL expression is used to specify match criteria such as origin.ip, source.region_code and contents in the request header.
-               Structure is documented below.
         :param str versioned_expr: Preconfigured versioned expression. If this field is specified, config must also be specified.
                Available preconfigured expressions along with their requirements are: SRC_IPS_V1 - must specify the corresponding srcIpRange field in config.
                Possible values are: `SRC_IPS_V1`.
         """
         if config is not None:
             pulumi.set(__self__, "config", config)
-        if expr is not None:
-            pulumi.set(__self__, "expr", expr)
         if versioned_expr is not None:
             pulumi.set(__self__, "versioned_expr", versioned_expr)
 
@@ -22684,15 +22080,6 @@ class RegionSecurityPolicyRuleMatch(dict):
         """
         return pulumi.get(self, "config")
 
-    @property
-    @pulumi.getter
-    def expr(self) -> Optional['outputs.RegionSecurityPolicyRuleMatchExpr']:
-        """
-        User defined CEVAL expression. A CEVAL expression is used to specify match criteria such as origin.ip, source.region_code and contents in the request header.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "expr")
-
     @property
     @pulumi.getter(name="versionedExpr")
     def versioned_expr(self) -> Optional[str]:
@@ -22740,24 +22127,6 @@ class RegionSecurityPolicyRuleMatchConfig(dict):
         return pulumi.get(self, "src_ip_ranges")
 
 
-@pulumi.output_type
-class RegionSecurityPolicyRuleMatchExpr(dict):
-    def __init__(__self__, *,
-                 expression: str):
-        """
-        :param str expression: Textual representation of an expression in Common Expression Language syntax. The application context of the containing message determines which well-known feature set of CEL is supported.
-        """
-        pulumi.set(__self__, "expression", expression)
-
-    @property
-    @pulumi.getter
-    def expression(self) -> str:
-        """
-        Textual representation of an expression in Common Expression Language syntax. The application context of the containing message determines which well-known feature set of CEL is supported.
-        """
-        return pulumi.get(self, "expression")
-
-
 @pulumi.output_type
 class RegionSecurityPolicyRuleNetworkMatch(dict):
     @staticmethod
@@ -31131,11 +30500,7 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
         :param 'SecurityPolicyAdvancedOptionsConfigJsonCustomConfigArgs' json_custom_config: Custom configuration to apply the JSON parsing. Only applicable when
                `json_parsing` is set to `STANDARD`. Structure is documented below.
         :param str json_parsing: Whether or not to JSON parse the payload body. Defaults to `DISABLED`.
-               * `DISABLED` - Don't parse JSON payloads in POST bodies.
-               * `STANDARD` - Parse JSON payloads in POST bodies.
         :param str log_level: Log level to use. Defaults to `NORMAL`.
-               * `NORMAL` - Normal log level.
-               * `VERBOSE` - Verbose log level.
         :param Sequence[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:
@@ -31161,8 +30526,6 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
     def json_parsing(self) -> Optional[str]:
         """
         Whether or not to JSON parse the payload body. Defaults to `DISABLED`.
-        * `DISABLED` - Don't parse JSON payloads in POST bodies.
-        * `STANDARD` - Parse JSON payloads in POST bodies.
         """
         return pulumi.get(self, "json_parsing")
 
@@ -31171,8 +30534,6 @@ class SecurityPolicyAdvancedOptionsConfig(dict):
     def log_level(self) -> Optional[str]:
         """
         Log level to use. Defaults to `NORMAL`.
-        * `NORMAL` - Normal log level.
-        * `VERBOSE` - Verbose log level.
         """
         return pulumi.get(self, "log_level")
 
@@ -31982,22 +31343,10 @@ class SecurityPolicyRuleRateLimitOptions(dict):
                If specified, the key will be banned for the configured `ban_duration_sec` when the number of requests that exceed the `rate_limit_threshold` also
                exceed this `ban_threshold`. Structure is documented below.
         :param str enforce_on_key: Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to `ALL`.
-               
-               * `ALL`: A single rate limit threshold is applied to all the requests matching this rule.
-               * `IP`: The source IP address of the request is the key. Each IP has this limit enforced separately.
-               * `HTTP_HEADER`: The value of the HTTP header whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to `ALL`.
-               * `XFF_IP`: The first IP address (i.e. the originating client IP address) specified in the list of IPs under `X-Forwarded-For` HTTP header. If no such header is present or the value is not a valid IP, the key type defaults to `ALL`.
-               * `HTTP_COOKIE`: The value of the HTTP cookie whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to `ALL`.
-               * `HTTP_PATH`: The URL path of the HTTP request. The key value is truncated to the first 128 bytes
-               * `SNI`: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to `ALL` on a HTTP session.
-               * `REGION_CODE`: The country/region from which the request originates.
         :param Sequence['SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfigArgs'] enforce_on_key_configs: If specified, any combination of values of enforce_on_key_type/enforce_on_key_name is treated as the key on which rate limit threshold/action is enforced. You can specify up to 3 enforce_on_key_configs. If `enforce_on_key_configs` is specified, `enforce_on_key` must be set to an empty string. Structure is documented below.
                
                **Note:** To avoid the conflict between `enforce_on_key` and `enforce_on_key_configs`, the field `enforce_on_key` needs to be set to an empty string.
         :param str enforce_on_key_name: Rate limit key name applicable only for the following key types:
-               
-               * `HTTP_HEADER` -- Name of the HTTP header whose value is taken as the key value.
-               * `HTTP_COOKIE` -- Name of the HTTP cookie whose value is taken as the key value.
         :param 'SecurityPolicyRuleRateLimitOptionsExceedRedirectOptionsArgs' exceed_redirect_options: Parameters defining the redirect action that is used as the exceed action. Cannot be specified if the exceed action is not redirect.
         """
         pulumi.set(__self__, "conform_action", conform_action)
@@ -32065,15 +31414,6 @@ class SecurityPolicyRuleRateLimitOptions(dict):
     def enforce_on_key(self) -> Optional[str]:
         """
         Determines the key to enforce the rate_limit_threshold on. If not specified, defaults to `ALL`.
-
-        * `ALL`: A single rate limit threshold is applied to all the requests matching this rule.
-        * `IP`: The source IP address of the request is the key. Each IP has this limit enforced separately.
-        * `HTTP_HEADER`: The value of the HTTP header whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to `ALL`.
-        * `XFF_IP`: The first IP address (i.e. the originating client IP address) specified in the list of IPs under `X-Forwarded-For` HTTP header. If no such header is present or the value is not a valid IP, the key type defaults to `ALL`.
-        * `HTTP_COOKIE`: The value of the HTTP cookie whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to `ALL`.
-        * `HTTP_PATH`: The URL path of the HTTP request. The key value is truncated to the first 128 bytes
-        * `SNI`: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to `ALL` on a HTTP session.
-        * `REGION_CODE`: The country/region from which the request originates.
         """
         return pulumi.get(self, "enforce_on_key")
 
@@ -32092,9 +31432,6 @@ class SecurityPolicyRuleRateLimitOptions(dict):
     def enforce_on_key_name(self) -> Optional[str]:
         """
         Rate limit key name applicable only for the following key types:
-
-        * `HTTP_HEADER` -- Name of the HTTP header whose value is taken as the key value.
-        * `HTTP_COOKIE` -- Name of the HTTP cookie whose value is taken as the key value.
         """
         return pulumi.get(self, "enforce_on_key_name")
 
@@ -32179,19 +31516,7 @@ class SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig(dict):
                  enforce_on_key_type: Optional[str] = None):
         """
         :param str enforce_on_key_name: Rate limit key name applicable only for the following key types:
-               
-               * `HTTP_HEADER` -- Name of the HTTP header whose value is taken as the key value.
-               * `HTTP_COOKIE` -- Name of the HTTP cookie whose value is taken as the key value.
         :param str enforce_on_key_type: Determines the key to enforce the `rate_limit_threshold` on. If not specified, defaults to `ALL`.
-               
-               * `ALL`: A single rate limit threshold is applied to all the requests matching this rule.
-               * `IP`: The source IP address of the request is the key. Each IP has this limit enforced separately.
-               * `HTTP_HEADER`: The value of the HTTP header whose name is configured on `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to `ALL`.
-               * `XFF_IP`: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key type defaults to `ALL`.
-               * `HTTP_COOKIE`: The value of the HTTP cookie whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to `ALL`.
-               * `HTTP_PATH`: The URL path of the HTTP request. The key value is truncated to the first 128 bytes
-               * `SNI`: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to `ALL` on a HTTP session.
-               * `REGION_CODE`: The country/region from which the request originates.
         """
         if enforce_on_key_name is not None:
             pulumi.set(__self__, "enforce_on_key_name", enforce_on_key_name)
@@ -32203,9 +31528,6 @@ class SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig(dict):
     def enforce_on_key_name(self) -> Optional[str]:
         """
         Rate limit key name applicable only for the following key types:
-
-        * `HTTP_HEADER` -- Name of the HTTP header whose value is taken as the key value.
-        * `HTTP_COOKIE` -- Name of the HTTP cookie whose value is taken as the key value.
         """
         return pulumi.get(self, "enforce_on_key_name")
 
@@ -32214,15 +31536,6 @@ class SecurityPolicyRuleRateLimitOptionsEnforceOnKeyConfig(dict):
     def enforce_on_key_type(self) -> Optional[str]:
         """
         Determines the key to enforce the `rate_limit_threshold` on. If not specified, defaults to `ALL`.
-
-        * `ALL`: A single rate limit threshold is applied to all the requests matching this rule.
-        * `IP`: The source IP address of the request is the key. Each IP has this limit enforced separately.
-        * `HTTP_HEADER`: The value of the HTTP header whose name is configured on `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the header value. If no such header is present in the request, the key type defaults to `ALL`.
-        * `XFF_IP`: The first IP address (i.e. the originating client IP address) specified in the list of IPs under X-Forwarded-For HTTP header. If no such header is present or the value is not a valid IP, the key type defaults to `ALL`.
-        * `HTTP_COOKIE`: The value of the HTTP cookie whose name is configured under `enforce_on_key_name`. The key value is truncated to the first 128 bytes of the cookie value. If no such cookie is present in the request, the key type defaults to `ALL`.
-        * `HTTP_PATH`: The URL path of the HTTP request. The key value is truncated to the first 128 bytes
-        * `SNI`: Server name indication in the TLS session of the HTTPS request. The key value is truncated to the first 128 bytes. The key type defaults to `ALL` on a HTTP session.
-        * `REGION_CODE`: The country/region from which the request originates.
         """
         return pulumi.get(self, "enforce_on_key_type")
 
@@ -32310,9 +31623,6 @@ class SecurityPolicyRuleRedirectOptions(dict):
                  target: Optional[str] = None):
         """
         :param str type: Type of redirect action.
-               
-               * `EXTERNAL_302`: Redirect to an external address, configured in `target`.
-               * `GOOGLE_RECAPTCHA`: Redirect to Google reCAPTCHA.
         :param str target: External redirection target when `EXTERNAL_302` is set in `type`.
         """
         pulumi.set(__self__, "type", type)
@@ -32324,9 +31634,6 @@ class SecurityPolicyRuleRedirectOptions(dict):
     def type(self) -> str:
         """
         Type of redirect action.
-
-        * `EXTERNAL_302`: Redirect to an external address, configured in `target`.
-        * `GOOGLE_RECAPTCHA`: Redirect to Google reCAPTCHA.
         """
         return pulumi.get(self, "type")
 
@@ -41746,8 +41053,6 @@ class GetForwardingRulesRuleResult(dict):
                For internal forwarding rules within the same VPC network, two or more
                forwarding rules cannot use the same '[IPAddress, IPProtocol]' pair, and
                cannot have overlapping 'portRange's.
-               
-               @pattern: \\d+(?:-\\d+)?
         :param Sequence[str] ports: The 'ports', 'portRange', and 'allPorts' fields are mutually exclusive.
                Only packets addressed to ports in the specified range will be forwarded
                to the backends configured with this forwarding rule.
@@ -41768,8 +41073,6 @@ class GetForwardingRulesRuleResult(dict):
                For internal forwarding rules within the same VPC network, two or more
                forwarding rules cannot use the same '[IPAddress, IPProtocol]' pair if
                they share at least one port number.
-               
-               @pattern: \\d+(?:-\\d+)?
         :param str project: The name of the project.
         :param str psc_connection_id: The PSC connection id of the PSC Forwarding Rule.
         :param str psc_connection_status: The PSC connection status of the PSC Forwarding Rule. Possible values: 'STATUS_UNSPECIFIED', 'PENDING', 'ACCEPTED', 'REJECTED', 'CLOSED'
@@ -42155,8 +41458,6 @@ class GetForwardingRulesRuleResult(dict):
         For internal forwarding rules within the same VPC network, two or more
         forwarding rules cannot use the same '[IPAddress, IPProtocol]' pair, and
         cannot have overlapping 'portRange's.
-
-        @pattern: \\d+(?:-\\d+)?
         """
         return pulumi.get(self, "port_range")
 
@@ -42184,8 +41485,6 @@ class GetForwardingRulesRuleResult(dict):
         For internal forwarding rules within the same VPC network, two or more
         forwarding rules cannot use the same '[IPAddress, IPProtocol]' pair if
         they share at least one port number.
-
-        @pattern: \\d+(?:-\\d+)?
         """
         return pulumi.get(self, "ports")