pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719470057__py3-none-any.whl

pulumi_gcp/networkservices/_inputs.py

@@ -4,198 +4,92 @@
 
 import copy
 import warnings
-import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
-if sys.version_info >= (3, 11):
-    from typing import NotRequired, TypedDict, TypeAlias
-else:
-    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'EdgeCacheKeysetPublicKeyArgs',
-    'EdgeCacheKeysetPublicKeyArgsDict',
     'EdgeCacheKeysetValidationSharedKeyArgs',
-    'EdgeCacheKeysetValidationSharedKeyArgsDict',
     'EdgeCacheOriginAwsV4AuthenticationArgs',
-    'EdgeCacheOriginAwsV4AuthenticationArgsDict',
     'EdgeCacheOriginOriginOverrideActionArgs',
-    'EdgeCacheOriginOriginOverrideActionArgsDict',
     'EdgeCacheOriginOriginOverrideActionHeaderActionArgs',
-    'EdgeCacheOriginOriginOverrideActionHeaderActionArgsDict',
     'EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs',
-    'EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgsDict',
     'EdgeCacheOriginOriginOverrideActionUrlRewriteArgs',
-    'EdgeCacheOriginOriginOverrideActionUrlRewriteArgsDict',
     'EdgeCacheOriginOriginRedirectArgs',
-    'EdgeCacheOriginOriginRedirectArgsDict',
     'EdgeCacheOriginTimeoutArgs',
-    'EdgeCacheOriginTimeoutArgsDict',
     'EdgeCacheServiceLogConfigArgs',
-    'EdgeCacheServiceLogConfigArgsDict',
     'EdgeCacheServiceRoutingArgs',
-    'EdgeCacheServiceRoutingArgsDict',
     'EdgeCacheServiceRoutingHostRuleArgs',
-    'EdgeCacheServiceRoutingHostRuleArgsDict',
     'EdgeCacheServiceRoutingPathMatcherArgs',
-    'EdgeCacheServiceRoutingPathMatcherArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgsDict',
     'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs',
-    'EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict',
     'EndpointPolicyEndpointMatcherArgs',
-    'EndpointPolicyEndpointMatcherArgsDict',
     'EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs',
-    'EndpointPolicyEndpointMatcherMetadataLabelMatcherArgsDict',
     'EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs',
-    'EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgsDict',
     'EndpointPolicyTrafficPortSelectorArgs',
-    'EndpointPolicyTrafficPortSelectorArgsDict',
     'GrpcRouteRuleArgs',
-    'GrpcRouteRuleArgsDict',
     'GrpcRouteRuleActionArgs',
-    'GrpcRouteRuleActionArgsDict',
     'GrpcRouteRuleActionDestinationArgs',
-    'GrpcRouteRuleActionDestinationArgsDict',
     'GrpcRouteRuleActionFaultInjectionPolicyArgs',
-    'GrpcRouteRuleActionFaultInjectionPolicyArgsDict',
     'GrpcRouteRuleActionFaultInjectionPolicyAbortArgs',
-    'GrpcRouteRuleActionFaultInjectionPolicyAbortArgsDict',
     'GrpcRouteRuleActionFaultInjectionPolicyDelayArgs',
-    'GrpcRouteRuleActionFaultInjectionPolicyDelayArgsDict',
     'GrpcRouteRuleActionRetryPolicyArgs',
-    'GrpcRouteRuleActionRetryPolicyArgsDict',
     'GrpcRouteRuleMatchArgs',
-    'GrpcRouteRuleMatchArgsDict',
     'GrpcRouteRuleMatchHeaderArgs',
-    'GrpcRouteRuleMatchHeaderArgsDict',
     'GrpcRouteRuleMatchMethodArgs',
-    'GrpcRouteRuleMatchMethodArgsDict',
     'HttpRouteRuleArgs',
-    'HttpRouteRuleArgsDict',
     'HttpRouteRuleActionArgs',
-    'HttpRouteRuleActionArgsDict',
     'HttpRouteRuleActionCorsPolicyArgs',
-    'HttpRouteRuleActionCorsPolicyArgsDict',
     'HttpRouteRuleActionDestinationArgs',
-    'HttpRouteRuleActionDestinationArgsDict',
     'HttpRouteRuleActionFaultInjectionPolicyArgs',
-    'HttpRouteRuleActionFaultInjectionPolicyArgsDict',
     'HttpRouteRuleActionFaultInjectionPolicyAbortArgs',
-    'HttpRouteRuleActionFaultInjectionPolicyAbortArgsDict',
     'HttpRouteRuleActionFaultInjectionPolicyDelayArgs',
-    'HttpRouteRuleActionFaultInjectionPolicyDelayArgsDict',
     'HttpRouteRuleActionRedirectArgs',
-    'HttpRouteRuleActionRedirectArgsDict',
     'HttpRouteRuleActionRequestHeaderModifierArgs',
-    'HttpRouteRuleActionRequestHeaderModifierArgsDict',
     'HttpRouteRuleActionRequestMirrorPolicyArgs',
-    'HttpRouteRuleActionRequestMirrorPolicyArgsDict',
     'HttpRouteRuleActionRequestMirrorPolicyDestinationArgs',
-    'HttpRouteRuleActionRequestMirrorPolicyDestinationArgsDict',
     'HttpRouteRuleActionResponseHeaderModifierArgs',
-    'HttpRouteRuleActionResponseHeaderModifierArgsDict',
     'HttpRouteRuleActionRetryPolicyArgs',
-    'HttpRouteRuleActionRetryPolicyArgsDict',
     'HttpRouteRuleActionUrlRewriteArgs',
-    'HttpRouteRuleActionUrlRewriteArgsDict',
     'HttpRouteRuleMatchArgs',
-    'HttpRouteRuleMatchArgsDict',
     'HttpRouteRuleMatchHeaderArgs',
-    'HttpRouteRuleMatchHeaderArgsDict',
     'HttpRouteRuleMatchHeaderRangeMatchArgs',
-    'HttpRouteRuleMatchHeaderRangeMatchArgsDict',
     'HttpRouteRuleMatchQueryParameterArgs',
-    'HttpRouteRuleMatchQueryParameterArgsDict',
     'LbRouteExtensionExtensionChainArgs',
-    'LbRouteExtensionExtensionChainArgsDict',
     'LbRouteExtensionExtensionChainExtensionArgs',
-    'LbRouteExtensionExtensionChainExtensionArgsDict',
     'LbRouteExtensionExtensionChainMatchConditionArgs',
-    'LbRouteExtensionExtensionChainMatchConditionArgsDict',
     'LbTrafficExtensionExtensionChainArgs',
-    'LbTrafficExtensionExtensionChainArgsDict',
     'LbTrafficExtensionExtensionChainExtensionArgs',
-    'LbTrafficExtensionExtensionChainExtensionArgsDict',
     'LbTrafficExtensionExtensionChainMatchConditionArgs',
-    'LbTrafficExtensionExtensionChainMatchConditionArgsDict',
     'ServiceLbPoliciesAutoCapacityDrainArgs',
-    'ServiceLbPoliciesAutoCapacityDrainArgsDict',
     'ServiceLbPoliciesFailoverConfigArgs',
-    'ServiceLbPoliciesFailoverConfigArgsDict',
     'TcpRouteRuleArgs',
-    'TcpRouteRuleArgsDict',
     'TcpRouteRuleActionArgs',
-    'TcpRouteRuleActionArgsDict',
     'TcpRouteRuleActionDestinationArgs',
-    'TcpRouteRuleActionDestinationArgsDict',
     'TcpRouteRuleMatchArgs',
-    'TcpRouteRuleMatchArgsDict',
     'TlsRouteRuleArgs',
-    'TlsRouteRuleArgsDict',
     'TlsRouteRuleActionArgs',
-    'TlsRouteRuleActionArgsDict',
     'TlsRouteRuleActionDestinationArgs',
-    'TlsRouteRuleActionDestinationArgsDict',
     'TlsRouteRuleMatchArgs',
-    'TlsRouteRuleMatchArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class EdgeCacheKeysetPublicKeyArgsDict(TypedDict):
-        id: pulumi.Input[str]
-        """
-        The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035.
-        The name must be 1-64 characters long, and match the regular expression [a-zA-Z][a-zA-Z0-9_-]*
-        which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
-        """
-        managed: NotRequired[pulumi.Input[bool]]
-        """
-        Set to true to have the CDN automatically manage this public key value.
-        """
-        value: NotRequired[pulumi.Input[str]]
-        """
-        The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes).
-        Representations or encodings of the public key other than this will be rejected with an error.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-elif False:
-    EdgeCacheKeysetPublicKeyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheKeysetPublicKeyArgs:
     def __init__(__self__, *,
@@ -258,20 +152,6 @@ class EdgeCacheKeysetPublicKeyArgs:
         pulumi.set(self, "value", value)
 
 
-if not MYPY:
-    class EdgeCacheKeysetValidationSharedKeyArgsDict(TypedDict):
-        secret_version: pulumi.Input[str]
-        """
-        The name of the secret version in Secret Manager.
-        The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves.
-        The secrets must be at least 16 bytes large.  The recommended secret size depends on the signature algorithm you are using.
-        * If you are using HMAC-SHA1, we suggest 20-byte secrets.
-        * If you are using HMAC-SHA256, we suggest 32-byte secrets.
-        See RFC 2104, Section 3 for more details on these recommendations.
-        """
-elif False:
-    EdgeCacheKeysetValidationSharedKeyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheKeysetValidationSharedKeyArgs:
     def __init__(__self__, *,
@@ -304,25 +184,6 @@ class EdgeCacheKeysetValidationSharedKeyArgs:
         pulumi.set(self, "secret_version", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginAwsV4AuthenticationArgsDict(TypedDict):
-        access_key_id: pulumi.Input[str]
-        """
-        The access key ID your origin uses to identify the key.
-        """
-        origin_region: pulumi.Input[str]
-        """
-        The name of the AWS region that your origin is in.
-        """
-        secret_access_key_version: pulumi.Input[str]
-        """
-        The Secret Manager secret version of the secret access key used by your origin.
-
-        This is the resource name of the secret version in the format 'projects/*/secrets/*/versions/*' where the '*' values are replaced by the project, secret, and version you require.
-        """
-elif False:
-    EdgeCacheOriginAwsV4AuthenticationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginAwsV4AuthenticationArgs:
     def __init__(__self__, *,
@@ -379,23 +240,6 @@ class EdgeCacheOriginAwsV4AuthenticationArgs:
         pulumi.set(self, "secret_access_key_version", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginOriginOverrideActionArgsDict(TypedDict):
-        header_action: NotRequired[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionArgsDict']]
-        """
-        The header actions, including adding and removing
-        headers, for request handled by this origin.
-        Structure is documented below.
-        """
-        url_rewrite: NotRequired[pulumi.Input['EdgeCacheOriginOriginOverrideActionUrlRewriteArgsDict']]
-        """
-        The URL rewrite configuration for request that are
-        handled by this origin.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheOriginOriginOverrideActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginOriginOverrideActionArgs:
     def __init__(__self__, *,
@@ -443,17 +287,6 @@ class EdgeCacheOriginOriginOverrideActionArgs:
         pulumi.set(self, "url_rewrite", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginOriginOverrideActionHeaderActionArgsDict(TypedDict):
-        request_headers_to_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgsDict']]]]
-        """
-        Describes a header to add.
-        You may add a maximum of 25 request headers.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheOriginOriginOverrideActionHeaderActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginOriginOverrideActionHeaderActionArgs:
     def __init__(__self__, *,
@@ -481,28 +314,6 @@ class EdgeCacheOriginOriginOverrideActionHeaderActionArgs:
         pulumi.set(self, "request_headers_to_adds", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        The name of the header to add.
-        """
-        header_value: pulumi.Input[str]
-        """
-        The value of the header to add.
-        """
-        replace: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to replace all existing headers with the same name.
-        By default, added header values are appended
-        to the response or request headers with the
-        same field names. The added values are
-        separated by commas.
-        To overwrite existing values, set `replace` to `true`.
-        """
-elif False:
-    EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs:
     def __init__(__self__, *,
@@ -566,18 +377,6 @@ class EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs:
         pulumi.set(self, "replace", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginOriginOverrideActionUrlRewriteArgsDict(TypedDict):
-        host_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected
-        origin, the request's host header is replaced with
-        contents of the hostRewrite.
-        This value must be between 1 and 255 characters.
-        """
-elif False:
-    EdgeCacheOriginOriginOverrideActionUrlRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginOriginOverrideActionUrlRewriteArgs:
     def __init__(__self__, *,
@@ -607,18 +406,6 @@ class EdgeCacheOriginOriginOverrideActionUrlRewriteArgs:
         pulumi.set(self, "host_rewrite", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginOriginRedirectArgsDict(TypedDict):
-        redirect_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        The set of redirect response codes that the CDN
-        follows. Values of
-        [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions)
-        are accepted.
-        """
-elif False:
-    EdgeCacheOriginOriginRedirectArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginOriginRedirectArgs:
     def __init__(__self__, *,
@@ -648,40 +435,6 @@ class EdgeCacheOriginOriginRedirectArgs:
         pulumi.set(self, "redirect_conditions", value)
 
 
-if not MYPY:
-    class EdgeCacheOriginTimeoutArgsDict(TypedDict):
-        connect_timeout: NotRequired[pulumi.Input[str]]
-        """
-        The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment.
-        Defaults to 5 seconds. The timeout must be a value between 1s and 15s.
-        The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout.  The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.
-        """
-        max_attempts_timeout: NotRequired[pulumi.Input[str]]
-        """
-        The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned.
-        Defaults to 15 seconds. The timeout must be a value between 1s and 30s.
-        If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.
-        """
-        read_timeout: NotRequired[pulumi.Input[str]]
-        """
-        The maximum duration to wait between reads of a single HTTP connection/stream.
-        Defaults to 15 seconds.  The timeout must be a value between 1s and 30s.
-        The readTimeout is capped by the responseTimeout.  All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout.
-        If the response headers have already been written to the connection, the response will be truncated and logged.
-
-        <a name="nested_aws_v4_authentication"></a>The `aws_v4_authentication` block supports:
-        """
-        response_timeout: NotRequired[pulumi.Input[str]]
-        """
-        The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream.
-        Defaults to 30 seconds. The timeout must be a value between 1s and 120s.
-        The responseTimeout starts after the connection has been established.
-        This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client.
-        If the response headers have already been written to the connection, the response will be truncated and logged.
-        """
-elif False:
-    EdgeCacheOriginTimeoutArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheOriginTimeoutArgs:
     def __init__(__self__, *,
@@ -779,20 +532,6 @@ class EdgeCacheOriginTimeoutArgs:
         pulumi.set(self, "response_timeout", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceLogConfigArgsDict(TypedDict):
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to enable logging for traffic served by this service.
-        """
-        sample_rate: NotRequired[pulumi.Input[float]]
-        """
-        Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1].
-        This field can only be specified if logging is enabled for this service.
-        """
-elif False:
-    EdgeCacheServiceLogConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceLogConfigArgs:
     def __init__(__self__, *,
@@ -834,21 +573,6 @@ class EdgeCacheServiceLogConfigArgs:
         pulumi.set(self, "sample_rate", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingArgsDict(TypedDict):
-        host_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingHostRuleArgsDict']]]
-        """
-        The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply.
-        Structure is documented below.
-        """
-        path_matchers: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherArgsDict']]]
-        """
-        The list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheServiceRoutingArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingArgs:
     def __init__(__self__, *,
@@ -890,33 +614,6 @@ class EdgeCacheServiceRoutingArgs:
         pulumi.set(self, "path_matchers", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingHostRuleArgsDict(TypedDict):
-        hosts: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        The list of host patterns to match.
-        Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string.
-        When multiple hosts are specified, hosts are matched in the following priority:
-        1. Exact domain names: ``www.foo.com``.
-        2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
-        3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
-        4. Special wildcard ``*`` matching any domain.
-        Notes:
-        The wildcard will not match the empty string. e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not ``-bar.foo.com``. The longest wildcards match first. Only a single host in the entire service can match on ``*``. A domain must be unique across all configured hosts within a service.
-        Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request.
-        You may specify up to 10 hosts.
-        """
-        path_matcher: pulumi.Input[str]
-        """
-        The name of the pathMatcher associated with this hostRule.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        A human-readable description of the hostRule.
-        """
-elif False:
-    EdgeCacheServiceRoutingHostRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingHostRuleArgs:
     def __init__(__self__, *,
@@ -990,24 +687,6 @@ class EdgeCacheServiceRoutingHostRuleArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name to which this PathMatcher is referred by the HostRule.
-        """
-        route_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleArgsDict']]]
-        """
-        The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods.
-        Structure is documented below.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        A human-readable description of the resource.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherArgs:
     def __init__(__self__, *,
@@ -1063,48 +742,6 @@ class EdgeCacheServiceRoutingPathMatcherArgs:
         pulumi.set(self, "description", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleArgsDict(TypedDict):
-        match_rules: pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgsDict']]]
-        """
-        The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
-        within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule.
-        Structure is documented below.
-        """
-        priority: pulumi.Input[str]
-        """
-        The priority of this route rule, where 1 is the highest priority.
-        You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive.
-        Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers
-        to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.
-        """
-        description: NotRequired[pulumi.Input[str]]
-        """
-        A human-readable description of the routeRule.
-        """
-        header_action: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgsDict']]
-        """
-        The header actions, including adding & removing headers, for requests that match this route.
-        Structure is documented below.
-        """
-        origin: NotRequired[pulumi.Input[str]]
-        """
-        The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin"
-        Only one of origin or urlRedirect can be set.
-        """
-        route_action: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgsDict']]
-        """
-        In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
-        Structure is documented below.
-        """
-        url_redirect: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict']]
-        """
-        The URL redirect configuration for requests that match this route.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
     def __init__(__self__, *,
@@ -1240,32 +877,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleArgs:
         pulumi.set(self, "url_redirect", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgsDict(TypedDict):
-        request_header_to_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgsDict']]]]
-        """
-        Describes a header to add.
-        Structure is documented below.
-        """
-        request_header_to_removes: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgsDict']]]]
-        """
-        A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
-        Structure is documented below.
-        """
-        response_header_to_adds: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgsDict']]]]
-        """
-        Headers to add to the response prior to sending it back to the client.
-        Response headers are only sent to the client, and do not have an effect on the cache serving the response.
-        Structure is documented below.
-        """
-        response_header_to_removes: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgsDict']]]]
-        """
-        A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs:
     def __init__(__self__, *,
@@ -1347,23 +958,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs:
         pulumi.set(self, "response_header_to_removes", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        The name of the header to add.
-        """
-        header_value: pulumi.Input[str]
-        """
-        The value of the header to add.
-        """
-        replace: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to replace all existing headers with the same name.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs:
     def __init__(__self__, *,
@@ -1417,15 +1011,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddA
         pulumi.set(self, "replace", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        The name of the header to remove.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs:
     def __init__(__self__, *,
@@ -1448,23 +1033,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemo
         pulumi.set(self, "header_name", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        The name of the header to add.
-        """
-        header_value: pulumi.Input[str]
-        """
-        The value of the header to add.
-        """
-        replace: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to replace all existing headers with the same name.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs:
     def __init__(__self__, *,
@@ -1518,16 +1086,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd
         pulumi.set(self, "replace", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        Headers to remove from the response prior to sending it back to the client.
-        Response headers are only sent to the client, and do not have an effect on the cache serving the response.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs:
     def __init__(__self__, *,
@@ -1552,44 +1110,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRem
         pulumi.set(self, "header_name", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgsDict(TypedDict):
-        full_path_match: NotRequired[pulumi.Input[str]]
-        """
-        For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.
-        """
-        header_matches: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgsDict']]]]
-        """
-        Specifies a list of header match criteria, all of which must match corresponding headers in the request.
-        Structure is documented below.
-        """
-        ignore_case: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies that prefixMatch and fullPathMatch matches are case sensitive.
-        """
-        path_template_match: NotRequired[pulumi.Input[str]]
-        """
-        For satisfying the matchRule condition, the path of the request
-        must match the wildcard pattern specified in pathTemplateMatch
-        after removing any query parameters and anchor that may be part
-        of the original URL.
-        pathTemplateMatch must be between 1 and 255 characters
-        (inclusive).  The pattern specified by pathTemplateMatch may
-        have at most 5 wildcard operators and at most 5 variable
-        captures in total.
-        """
-        prefix_match: NotRequired[pulumi.Input[str]]
-        """
-        For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.
-        """
-        query_parameter_matches: NotRequired[pulumi.Input[Sequence[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgsDict']]]]
-        """
-        Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs:
     def __init__(__self__, *,
@@ -1711,36 +1231,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs:
         pulumi.set(self, "query_parameter_matches", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgsDict(TypedDict):
-        header_name: pulumi.Input[str]
-        """
-        The header name to match on.
-        """
-        exact_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header should exactly match contents of exactMatch.
-        """
-        invert_match: NotRequired[pulumi.Input[bool]]
-        """
-        If set to false (default), the headerMatch is considered a match if the match criteria above are met.
-        If set to true, the headerMatch is considered a match if the match criteria above are NOT met.
-        """
-        prefix_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header must start with the contents of prefixMatch.
-        """
-        present_match: NotRequired[pulumi.Input[bool]]
-        """
-        A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.
-        """
-        suffix_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header must end with the contents of suffixMatch.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs:
     def __init__(__self__, *,
@@ -1845,23 +1335,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs:
         pulumi.set(self, "suffix_match", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
-        """
-        exact_match: NotRequired[pulumi.Input[str]]
-        """
-        The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
-        """
-        present_match: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs:
     def __init__(__self__, *,
@@ -1916,26 +1389,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArg
         pulumi.set(self, "present_match", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgsDict(TypedDict):
-        cdn_policy: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgsDict']]
-        """
-        The policy to use for defining caching and signed request behaviour for requests that match this route.
-        Structure is documented below.
-        """
-        cors_policy: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict']]
-        """
-        CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
-        Structure is documented below.
-        """
-        url_rewrite: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgsDict']]
-        """
-        The URL rewrite configuration for requests that match this route.
-        Structure is documented below.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
     def __init__(__self__, *,
@@ -1967,133 +1420,35 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs:
         return pulumi.get(self, "cdn_policy")
 
     @cdn_policy.setter
-    def cdn_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']]):
-        pulumi.set(self, "cdn_policy", value)
-
-    @property
-    @pulumi.getter(name="corsPolicy")
-    def cors_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
-        """
-        CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "cors_policy")
-
-    @cors_policy.setter
-    def cors_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]):
-        pulumi.set(self, "cors_policy", value)
-
-    @property
-    @pulumi.getter(name="urlRewrite")
-    def url_rewrite(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]:
-        """
-        The URL rewrite configuration for requests that match this route.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "url_rewrite")
-
-    @url_rewrite.setter
-    def url_rewrite(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]):
-        pulumi.set(self, "url_rewrite", value)
-
-
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgsDict(TypedDict):
-        add_signatures: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgsDict']]
-        """
-        Enable signature generation or propagation on this route.
-        This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS.
-        Structure is documented below.
-        """
-        cache_key_policy: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgsDict']]
-        """
-        Defines the request parameters that contribute to the cache key.
-        Structure is documented below.
-        """
-        cache_mode: NotRequired[pulumi.Input[str]]
-        """
-        Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses.
-        For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client.
-        Possible values are: `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, `BYPASS_CACHE`.
-        """
-        client_ttl: NotRequired[pulumi.Input[str]]
-        """
-        Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.
-        - The TTL must be > 0 and <= 86400s (1 day)
-        - The clientTtl cannot be larger than the defaultTtl (if set)
-        - Fractions of a second are not allowed.
-        Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL.
-        When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
-        A duration in seconds terminated by 's'. Example: "3s".
-        """
-        default_ttl: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age).
-        Defaults to 3600s (1 hour).
-        - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
-        - Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
-        - The value of defaultTTL cannot be set to a value greater than that of maxTTL.
-        - Fractions of a second are not allowed.
-        - When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses.
-        Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin.
-        When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
-        A duration in seconds terminated by 's'. Example: "3s".
-        """
-        max_ttl: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the maximum allowed TTL for cached content served by this origin.
-        Defaults to 86400s (1 day).
-        Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.
-        - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
-        - Setting a TTL of "0" means "always revalidate"
-        - The value of maxTtl must be equal to or greater than defaultTtl.
-        - Fractions of a second are not allowed.
-        When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field.
-        A duration in seconds terminated by 's'. Example: "3s".
-        """
-        negative_caching: NotRequired[pulumi.Input[bool]]
-        """
-        Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency.
-        By default, the CDNPolicy will apply the following default TTLs to these status codes:
-        - HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
-        - HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
-        - HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s
-        These defaults can be overridden in negativeCachingPolicy
-        """
-        negative_caching_policy: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
-        - Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
-        - TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day)
-        Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.
-        """
-        signed_request_keyset: NotRequired[pulumi.Input[str]]
-        """
-        The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.
-        """
-        signed_request_maximum_expiration_ttl: NotRequired[pulumi.Input[str]]
-        """
-        Limit how far into the future the expiration time of a signed request may be.
-        When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.
-        - The TTL must be > 0.
-        - Fractions of a second are not allowed.
-        By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.
-        """
-        signed_request_mode: NotRequired[pulumi.Input[str]]
+    def cdn_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs']]):
+        pulumi.set(self, "cdn_policy", value)
+
+    @property
+    @pulumi.getter(name="corsPolicy")
+    def cors_policy(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]:
         """
-        Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access.
-        You must also set a signedRequestKeyset to enable signed requests.
-        When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged.
-        Possible values are: `DISABLED`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.
+        CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
+        Structure is documented below.
         """
-        signed_token_options: NotRequired[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgsDict']]
+        return pulumi.get(self, "cors_policy")
+
+    @cors_policy.setter
+    def cors_policy(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs']]):
+        pulumi.set(self, "cors_policy", value)
+
+    @property
+    @pulumi.getter(name="urlRewrite")
+    def url_rewrite(self) -> Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]:
         """
-        Additional options for signed tokens.
-        signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS.
+        The URL rewrite configuration for requests that match this route.
         Structure is documented below.
         """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "url_rewrite")
+
+    @url_rewrite.setter
+    def url_rewrite(self, value: Optional[pulumi.Input['EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs']]):
+        pulumi.set(self, "url_rewrite", value)
+
 
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs:
@@ -2384,45 +1739,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs:
         pulumi.set(self, "signed_token_options", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgsDict(TypedDict):
-        actions: pulumi.Input[str]
-        """
-        The actions to take to add signatures to responses.
-        Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.
-        """
-        copied_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        The parameters to copy from the verified token to the generated token.
-        Only the following parameters may be copied:
-        * `PathGlobs`
-        """
-        keyset: NotRequired[pulumi.Input[str]]
-        """
-        The keyset to use for signature generation.
-        The following are both valid paths to an EdgeCacheKeyset resource:
-        * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`
-        * `yourKeyset`
-        This must be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.  This field may not be specified otherwise.
-        """
-        token_query_parameter: NotRequired[pulumi.Input[str]]
-        """
-        The query parameter in which to put the generated token.
-        If not specified, defaults to `edge-cache-token`.
-        If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
-        This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.
-        """
-        token_ttl: NotRequired[pulumi.Input[str]]
-        """
-        The duration the token is valid starting from the moment the token is first generated.
-        Defaults to `86400s` (1 day).
-        The TTL must be >= 0 and <= 604,800 seconds (1 week).
-        This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.
-        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs:
     def __init__(__self__, *,
@@ -2537,57 +1853,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignatur
         pulumi.set(self, "token_ttl", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgsDict(TypedDict):
-        exclude_host: NotRequired[pulumi.Input[bool]]
-        """
-        If true, requests to different hosts will be cached separately.
-        Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.
-        """
-        exclude_query_string: NotRequired[pulumi.Input[bool]]
-        """
-        If true, exclude query string parameters from the cache key
-        If false (the default), include the query string parameters in
-        the cache key according to includeQueryParameters and
-        excludeQueryParameters. If neither includeQueryParameters nor
-        excludeQueryParameters is set, the entire query string will be
-        included.
-        """
-        excluded_query_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Names of query string parameters to exclude from cache keys. All other parameters will be included.
-        Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
-        """
-        include_protocol: NotRequired[pulumi.Input[bool]]
-        """
-        If true, http and https requests will be cached separately.
-        """
-        included_cookie_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Names of Cookies to include in cache keys.  The cookie name and cookie value of each cookie named will be used as part of the cache key.
-        Cookie names:
-        - must be valid RFC 6265 "cookie-name" tokens
-        - are case sensitive
-        - cannot start with "Edge-Cache-" (case insensitive)
-        Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
-        You may specify up to three cookie names.
-        """
-        included_header_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.
-        - Header names must be valid HTTP RFC 7230 header field values.
-        - Header field names are case insensitive
-        - To include the HTTP method, use ":method"
-        Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
-        """
-        included_query_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Names of query string parameters to include in cache keys. All other parameters will be excluded.
-        Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs:
     def __init__(__self__, *,
@@ -2743,24 +2008,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPol
         pulumi.set(self, "included_query_parameters", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgsDict(TypedDict):
-        allowed_signature_algorithms: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        The allowed signature algorithms to use.
-        Defaults to using only ED25519.
-        You may specify up to 3 signature algorithms to use.
-        Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.
-        """
-        token_query_parameter: NotRequired[pulumi.Input[str]]
-        """
-        The query parameter in which to find the token.
-        The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
-        Defaults to `edge-cache-token`.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs:
     def __init__(__self__, *,
@@ -2810,45 +2057,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedToken
         pulumi.set(self, "token_query_parameter", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict(TypedDict):
-        max_age: pulumi.Input[str]
-        """
-        Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).
-        - Setting the value to -1 forces a pre-flight check for all requests (not recommended)
-        - A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
-        - This translates to the Access-Control-Max-Age header.
-        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
-        """
-        allow_credentials: NotRequired[pulumi.Input[bool]]
-        """
-        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
-        This translates to the Access-Control-Allow-Credentials response header.
-        """
-        allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for the Access-Control-Allow-Headers response header.
-        """
-        allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for the Access-Control-Allow-Methods response header.
-        """
-        allow_origins: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the list of origins that will be allowed to do CORS requests.
-        This translates to the Access-Control-Allow-Origin response header.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
-        """
-        expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for the Access-Control-Allow-Headers response header.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs:
     def __init__(__self__, *,
@@ -2979,33 +2187,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs:
         pulumi.set(self, "expose_headers", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgsDict(TypedDict):
-        host_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.
-        """
-        path_prefix_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.
-        """
-        path_template_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected origin, if the
-        request matched a pathTemplateMatch, the matching portion of the
-        request's path is replaced re-written using the pattern specified
-        by pathTemplateRewrite.
-        pathTemplateRewrite must be between 1 and 255 characters
-        (inclusive), must start with a '/', and must only use variables
-        captured by the route's pathTemplate matchers.
-        pathTemplateRewrite may only be used when all of a route's
-        MatchRules specify pathTemplate.
-        Only one of pathPrefixRewrite and pathTemplateRewrite may be
-        specified.
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs:
     def __init__(__self__, *,
@@ -3081,48 +2262,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs:
         pulumi.set(self, "path_template_rewrite", value)
 
 
-if not MYPY:
-    class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict(TypedDict):
-        host_redirect: NotRequired[pulumi.Input[str]]
-        """
-        The host that will be used in the redirect response instead of the one that was supplied in the request.
-        """
-        https_redirect: NotRequired[pulumi.Input[bool]]
-        """
-        If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request.
-        This can only be set if there is at least one (1) edgeSslCertificate set on the service.
-        """
-        path_redirect: NotRequired[pulumi.Input[str]]
-        """
-        The path that will be used in the redirect response instead of the one that was supplied in the request.
-        pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
-        The path value must be between 1 and 1024 characters.
-        """
-        prefix_redirect: NotRequired[pulumi.Input[str]]
-        """
-        The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request.
-        prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
-        """
-        redirect_response_code: NotRequired[pulumi.Input[str]]
-        """
-        The HTTP Status code to use for this RedirectAction.
-        The supported values are:
-        - `MOVED_PERMANENTLY_DEFAULT`, which is the default value and corresponds to 301.
-        - `FOUND`, which corresponds to 302.
-        - `SEE_OTHER` which corresponds to 303.
-        - `TEMPORARY_REDIRECT`, which corresponds to 307. in this case, the request method will be retained.
-        - `PERMANENT_REDIRECT`, which corresponds to 308. in this case, the request method will be retained.
-        Possible values are: `MOVED_PERMANENTLY_DEFAULT`, `FOUND`, `SEE_OTHER`, `TEMPORARY_REDIRECT`, `PERMANENT_REDIRECT`.
-        """
-        strip_query: NotRequired[pulumi.Input[bool]]
-        """
-        If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.
-
-        - - -
-        """
-elif False:
-    EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs:
     def __init__(__self__, *,
@@ -3252,16 +2391,6 @@ class EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs:
         pulumi.set(self, "strip_query", value)
 
 
-if not MYPY:
-    class EndpointPolicyEndpointMatcherArgsDict(TypedDict):
-        metadata_label_matcher: pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherArgsDict']
-        """
-        The matcher is based on node metadata presented by xDS clients.
-        Structure is documented below.
-        """
-elif False:
-    EndpointPolicyEndpointMatcherArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EndpointPolicyEndpointMatcherArgs:
     def __init__(__self__, *,
@@ -3286,21 +2415,6 @@ class EndpointPolicyEndpointMatcherArgs:
         pulumi.set(self, "metadata_label_matcher", value)
 
 
-if not MYPY:
-    class EndpointPolicyEndpointMatcherMetadataLabelMatcherArgsDict(TypedDict):
-        metadata_label_match_criteria: pulumi.Input[str]
-        """
-        Specifies how matching should be done.
-        Possible values are: `MATCH_ANY`, `MATCH_ALL`.
-        """
-        metadata_labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgsDict']]]]
-        """
-        The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria
-        Structure is documented below.
-        """
-elif False:
-    EndpointPolicyEndpointMatcherMetadataLabelMatcherArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs:
     def __init__(__self__, *,
@@ -3343,21 +2457,6 @@ class EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs:
         pulumi.set(self, "metadata_labels", value)
 
 
-if not MYPY:
-    class EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgsDict(TypedDict):
-        label_name: pulumi.Input[str]
-        """
-        Required. Label name presented as key in xDS Node Metadata.
-        """
-        label_value: pulumi.Input[str]
-        """
-        Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.
-
-        - - -
-        """
-elif False:
-    EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs:
     def __init__(__self__, *,
@@ -3399,15 +2498,6 @@ class EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs:
         pulumi.set(self, "label_value", value)
 
 
-if not MYPY:
-    class EndpointPolicyTrafficPortSelectorArgsDict(TypedDict):
-        ports: pulumi.Input[Sequence[pulumi.Input[str]]]
-        """
-        List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.
-        """
-elif False:
-    EndpointPolicyTrafficPortSelectorArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EndpointPolicyTrafficPortSelectorArgs:
     def __init__(__self__, *,
@@ -3430,21 +2520,6 @@ class EndpointPolicyTrafficPortSelectorArgs:
         pulumi.set(self, "ports", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleArgsDict(TypedDict):
-        action: NotRequired[pulumi.Input['GrpcRouteRuleActionArgsDict']]
-        """
-        Required. A detailed rule defining how to route traffic.
-        Structure is documented below.
-        """
-        matches: NotRequired[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchArgsDict']]]]
-        """
-        Matches define conditions used for matching the rule against incoming gRPC requests.
-        Structure is documented below.
-        """
-elif False:
-    GrpcRouteRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleArgs:
     def __init__(__self__, *,
@@ -3488,30 +2563,6 @@ class GrpcRouteRuleArgs:
         pulumi.set(self, "matches", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleActionArgsDict(TypedDict):
-        destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleActionDestinationArgsDict']]]]
-        """
-        The destination to which traffic should be forwarded.
-        Structure is documented below.
-        """
-        fault_injection_policy: NotRequired[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyArgsDict']]
-        """
-        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
-        Structure is documented below.
-        """
-        retry_policy: NotRequired[pulumi.Input['GrpcRouteRuleActionRetryPolicyArgsDict']]
-        """
-        Specifies the retry policy associated with this route.
-        Structure is documented below.
-        """
-        timeout: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the timeout for selected route.
-        """
-elif False:
-    GrpcRouteRuleActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleActionArgs:
     def __init__(__self__, *,
@@ -3584,24 +2635,11 @@ class GrpcRouteRuleActionArgs:
         """
         return pulumi.get(self, "timeout")
 
-    @timeout.setter
-    def timeout(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "timeout", value)
-
-
-if not MYPY:
-    class GrpcRouteRuleActionDestinationArgsDict(TypedDict):
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The URL of a BackendService to route traffic to.
-        """
-        weight: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
-        """
-elif False:
-    GrpcRouteRuleActionDestinationArgsDict: TypeAlias = Mapping[str, Any]
-
+    @timeout.setter
+    def timeout(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "timeout", value)
+
+
 @pulumi.input_type
 class GrpcRouteRuleActionDestinationArgs:
     def __init__(__self__, *,
@@ -3641,21 +2679,6 @@ class GrpcRouteRuleActionDestinationArgs:
         pulumi.set(self, "weight", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleActionFaultInjectionPolicyArgsDict(TypedDict):
-        abort: NotRequired[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyAbortArgsDict']]
-        """
-        Specification of how client requests are aborted as part of fault injection before being sent to a destination.
-        Structure is documented below.
-        """
-        delay: NotRequired[pulumi.Input['GrpcRouteRuleActionFaultInjectionPolicyDelayArgsDict']]
-        """
-        Specification of how client requests are delayed as part of fault injection before being sent to a destination.
-        Structure is documented below.
-        """
-elif False:
-    GrpcRouteRuleActionFaultInjectionPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleActionFaultInjectionPolicyArgs:
     def __init__(__self__, *,
@@ -3699,19 +2722,6 @@ class GrpcRouteRuleActionFaultInjectionPolicyArgs:
         pulumi.set(self, "delay", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleActionFaultInjectionPolicyAbortArgsDict(TypedDict):
-        http_status: NotRequired[pulumi.Input[int]]
-        """
-        The HTTP status code used to abort the request.
-        """
-        percentage: NotRequired[pulumi.Input[int]]
-        """
-        The percentage of traffic which will be aborted.
-        """
-elif False:
-    GrpcRouteRuleActionFaultInjectionPolicyAbortArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleActionFaultInjectionPolicyAbortArgs:
     def __init__(__self__, *,
@@ -3751,19 +2761,6 @@ class GrpcRouteRuleActionFaultInjectionPolicyAbortArgs:
         pulumi.set(self, "percentage", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleActionFaultInjectionPolicyDelayArgsDict(TypedDict):
-        fixed_delay: NotRequired[pulumi.Input[str]]
-        """
-        Specify a fixed delay before forwarding the request.
-        """
-        percentage: NotRequired[pulumi.Input[int]]
-        """
-        The percentage of traffic on which delay will be injected.
-        """
-elif False:
-    GrpcRouteRuleActionFaultInjectionPolicyDelayArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleActionFaultInjectionPolicyDelayArgs:
     def __init__(__self__, *,
@@ -3803,22 +2800,6 @@ class GrpcRouteRuleActionFaultInjectionPolicyDelayArgs:
         pulumi.set(self, "percentage", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleActionRetryPolicyArgsDict(TypedDict):
-        num_retries: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the allowed number of retries.
-
-        - - -
-        """
-        retry_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies one or more conditions when this retry policy applies.
-        Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.
-        """
-elif False:
-    GrpcRouteRuleActionRetryPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleActionRetryPolicyArgs:
     def __init__(__self__, *,
@@ -3864,21 +2845,6 @@ class GrpcRouteRuleActionRetryPolicyArgs:
         pulumi.set(self, "retry_conditions", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleMatchArgsDict(TypedDict):
-        headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['GrpcRouteRuleMatchHeaderArgsDict']]]]
-        """
-        Specifies a list of HTTP request headers to match against.
-        Structure is documented below.
-        """
-        method: NotRequired[pulumi.Input['GrpcRouteRuleMatchMethodArgsDict']]
-        """
-        A gRPC method to match against. If this field is empty or omitted, will match all methods.
-        Structure is documented below.
-        """
-elif False:
-    GrpcRouteRuleMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleMatchArgs:
     def __init__(__self__, *,
@@ -3922,25 +2888,6 @@ class GrpcRouteRuleMatchArgs:
         pulumi.set(self, "method", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleMatchHeaderArgsDict(TypedDict):
-        key: pulumi.Input[str]
-        """
-        Required. The key of the header.
-        """
-        value: pulumi.Input[str]
-        """
-        Required. The value of the header.
-        """
-        type: NotRequired[pulumi.Input[str]]
-        """
-        The type of match.
-        Default value is `EXACT`.
-        Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.
-        """
-elif False:
-    GrpcRouteRuleMatchHeaderArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleMatchHeaderArgs:
     def __init__(__self__, *,
@@ -3998,23 +2945,6 @@ class GrpcRouteRuleMatchHeaderArgs:
         pulumi.set(self, "type", value)
 
 
-if not MYPY:
-    class GrpcRouteRuleMatchMethodArgsDict(TypedDict):
-        grpc_method: pulumi.Input[str]
-        """
-        Required. Name of the method to match against.
-        """
-        grpc_service: pulumi.Input[str]
-        """
-        Required. Name of the service to match against.
-        """
-        case_sensitive: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies that matches are case sensitive. The default value is true.
-        """
-elif False:
-    GrpcRouteRuleMatchMethodArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class GrpcRouteRuleMatchMethodArgs:
     def __init__(__self__, *,
@@ -4068,23 +2998,6 @@ class GrpcRouteRuleMatchMethodArgs:
         pulumi.set(self, "case_sensitive", value)
 
 
-if not MYPY:
-    class HttpRouteRuleArgsDict(TypedDict):
-        action: NotRequired[pulumi.Input['HttpRouteRuleActionArgsDict']]
-        """
-        The detailed rule defining how to route matched traffic.
-        Structure is documented below.
-        """
-        matches: NotRequired[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchArgsDict']]]]
-        """
-        A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.
-        If no matches field is specified, this rule will unconditionally match traffic.
-        If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list.
-        Structure is documented below.
-        """
-elif False:
-    HttpRouteRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleArgs:
     def __init__(__self__, *,
@@ -4132,60 +3045,6 @@ class HttpRouteRuleArgs:
         pulumi.set(self, "matches", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionArgsDict(TypedDict):
-        cors_policy: NotRequired[pulumi.Input['HttpRouteRuleActionCorsPolicyArgsDict']]
-        """
-        The specification for allowing client side cross-origin requests.
-        Structure is documented below.
-        """
-        destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleActionDestinationArgsDict']]]]
-        """
-        The destination to which traffic should be forwarded.
-        Structure is documented below.
-        """
-        fault_injection_policy: NotRequired[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyArgsDict']]
-        """
-        The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
-        Structure is documented below.
-        """
-        redirect: NotRequired[pulumi.Input['HttpRouteRuleActionRedirectArgsDict']]
-        """
-        If set, the request is directed as configured by this field.
-        Structure is documented below.
-        """
-        request_header_modifier: NotRequired[pulumi.Input['HttpRouteRuleActionRequestHeaderModifierArgsDict']]
-        """
-        The specification for modifying the headers of a matching request prior to delivery of the request to the destination.
-        Structure is documented below.
-        """
-        request_mirror_policy: NotRequired[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyArgsDict']]
-        """
-        Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination.
-        Structure is documented below.
-        """
-        response_header_modifier: NotRequired[pulumi.Input['HttpRouteRuleActionResponseHeaderModifierArgsDict']]
-        """
-        The specification for modifying the headers of a response prior to sending the response back to the client.
-        Structure is documented below.
-        """
-        retry_policy: NotRequired[pulumi.Input['HttpRouteRuleActionRetryPolicyArgsDict']]
-        """
-        Specifies the retry policy associated with this route.
-        Structure is documented below.
-        """
-        timeout: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the timeout for selected route.
-        """
-        url_rewrite: NotRequired[pulumi.Input['HttpRouteRuleActionUrlRewriteArgsDict']]
-        """
-        The specification for rewrite URL before forwarding requests to the destination.
-        Structure is documented below.
-        """
-elif False:
-    HttpRouteRuleActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionArgs:
     def __init__(__self__, *,
@@ -4371,45 +3230,6 @@ class HttpRouteRuleActionArgs:
         pulumi.set(self, "url_rewrite", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionCorsPolicyArgsDict(TypedDict):
-        allow_credentials: NotRequired[pulumi.Input[bool]]
-        """
-        In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
-        """
-        allow_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for Access-Control-Allow-Headers header.
-        """
-        allow_methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for Access-Control-Allow-Methods header.
-        """
-        allow_origin_regexes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the regular expression patterns that match allowed origins.
-        """
-        allow_origins: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the list of origins that will be allowed to do CORS requests.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        If true, the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
-
-        - - -
-        """
-        expose_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies the content for Access-Control-Expose-Headers header.
-        """
-        max_age: NotRequired[pulumi.Input[str]]
-        """
-        Specifies how long result of a preflight request can be cached in seconds.
-        """
-elif False:
-    HttpRouteRuleActionCorsPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionCorsPolicyArgs:
     def __init__(__self__, *,
@@ -4549,22 +3369,6 @@ class HttpRouteRuleActionCorsPolicyArgs:
         pulumi.set(self, "max_age", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionDestinationArgsDict(TypedDict):
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The URL of a BackendService to route traffic to.
-        """
-        weight: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
-        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
-        If weights are specified for any one service name, they need to be specified for all of them.
-        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
-        """
-elif False:
-    HttpRouteRuleActionDestinationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionDestinationArgs:
     def __init__(__self__, *,
@@ -4610,21 +3414,6 @@ class HttpRouteRuleActionDestinationArgs:
         pulumi.set(self, "weight", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionFaultInjectionPolicyArgsDict(TypedDict):
-        abort: NotRequired[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyAbortArgsDict']]
-        """
-        Specification of how client requests are aborted as part of fault injection before being sent to a destination.
-        Structure is documented below.
-        """
-        delay: NotRequired[pulumi.Input['HttpRouteRuleActionFaultInjectionPolicyDelayArgsDict']]
-        """
-        Specification of how client requests are delayed as part of fault injection before being sent to a destination.
-        Structure is documented below.
-        """
-elif False:
-    HttpRouteRuleActionFaultInjectionPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionFaultInjectionPolicyArgs:
     def __init__(__self__, *,
@@ -4668,19 +3457,6 @@ class HttpRouteRuleActionFaultInjectionPolicyArgs:
         pulumi.set(self, "delay", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionFaultInjectionPolicyAbortArgsDict(TypedDict):
-        http_status: NotRequired[pulumi.Input[int]]
-        """
-        The HTTP status code used to abort the request.
-        """
-        percentage: NotRequired[pulumi.Input[int]]
-        """
-        The percentage of traffic which will be aborted.
-        """
-elif False:
-    HttpRouteRuleActionFaultInjectionPolicyAbortArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionFaultInjectionPolicyAbortArgs:
     def __init__(__self__, *,
@@ -4720,19 +3496,6 @@ class HttpRouteRuleActionFaultInjectionPolicyAbortArgs:
         pulumi.set(self, "percentage", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionFaultInjectionPolicyDelayArgsDict(TypedDict):
-        fixed_delay: NotRequired[pulumi.Input[str]]
-        """
-        Specify a fixed delay before forwarding the request.
-        """
-        percentage: NotRequired[pulumi.Input[int]]
-        """
-        The percentage of traffic on which delay will be injected.
-        """
-elif False:
-    HttpRouteRuleActionFaultInjectionPolicyDelayArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionFaultInjectionPolicyDelayArgs:
     def __init__(__self__, *,
@@ -4772,39 +3535,6 @@ class HttpRouteRuleActionFaultInjectionPolicyDelayArgs:
         pulumi.set(self, "percentage", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionRedirectArgsDict(TypedDict):
-        host_redirect: NotRequired[pulumi.Input[str]]
-        """
-        The host that will be used in the redirect response instead of the one that was supplied in the request.
-        """
-        https_redirect: NotRequired[pulumi.Input[bool]]
-        """
-        If set to true, the URL scheme in the redirected request is set to https.
-        """
-        path_redirect: NotRequired[pulumi.Input[str]]
-        """
-        The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect can not be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
-        """
-        port_redirect: NotRequired[pulumi.Input[int]]
-        """
-        The port that will be used in the redirected request instead of the one that was supplied in the request.
-        """
-        prefix_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Indicates that during redirection, the matched prefix (or path) should be swapped with this value.
-        """
-        response_code: NotRequired[pulumi.Input[str]]
-        """
-        The HTTP Status code to use for the redirect.
-        """
-        strip_query: NotRequired[pulumi.Input[bool]]
-        """
-        If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request.
-        """
-elif False:
-    HttpRouteRuleActionRedirectArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionRedirectArgs:
     def __init__(__self__, *,
@@ -4924,23 +3654,6 @@ class HttpRouteRuleActionRedirectArgs:
         pulumi.set(self, "strip_query", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionRequestHeaderModifierArgsDict(TypedDict):
-        add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Add the headers with given map where key is the name of the header, value is the value of the header.
-        """
-        removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Remove headers (matching by header names) specified in the list.
-        """
-        set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
-        """
-elif False:
-    HttpRouteRuleActionRequestHeaderModifierArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionRequestHeaderModifierArgs:
     def __init__(__self__, *,
@@ -4996,16 +3709,6 @@ class HttpRouteRuleActionRequestHeaderModifierArgs:
         pulumi.set(self, "set", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionRequestMirrorPolicyArgsDict(TypedDict):
-        destination: NotRequired[pulumi.Input['HttpRouteRuleActionRequestMirrorPolicyDestinationArgsDict']]
-        """
-        The destination the requests will be mirrored to.
-        Structure is documented below.
-        """
-elif False:
-    HttpRouteRuleActionRequestMirrorPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionRequestMirrorPolicyArgs:
     def __init__(__self__, *,
@@ -5031,22 +3734,6 @@ class HttpRouteRuleActionRequestMirrorPolicyArgs:
         pulumi.set(self, "destination", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionRequestMirrorPolicyDestinationArgsDict(TypedDict):
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The URL of a BackendService to route traffic to.
-        """
-        weight: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
-        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
-        If weights are specified for any one service name, they need to be specified for all of them.
-        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
-        """
-elif False:
-    HttpRouteRuleActionRequestMirrorPolicyDestinationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionRequestMirrorPolicyDestinationArgs:
     def __init__(__self__, *,
@@ -5092,23 +3779,6 @@ class HttpRouteRuleActionRequestMirrorPolicyDestinationArgs:
         pulumi.set(self, "weight", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionResponseHeaderModifierArgsDict(TypedDict):
-        add: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Add the headers with given map where key is the name of the header, value is the value of the header.
-        """
-        removes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Remove headers (matching by header names) specified in the list.
-        """
-        set: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
-        """
-elif False:
-    HttpRouteRuleActionResponseHeaderModifierArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionResponseHeaderModifierArgs:
     def __init__(__self__, *,
@@ -5164,23 +3834,6 @@ class HttpRouteRuleActionResponseHeaderModifierArgs:
         pulumi.set(self, "set", value)
 
 
-if not MYPY:
-    class HttpRouteRuleActionRetryPolicyArgsDict(TypedDict):
-        num_retries: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the allowed number of retries.
-        """
-        per_try_timeout: NotRequired[pulumi.Input[str]]
-        """
-        Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        """
-        retry_conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Specifies one or more conditions when this retry policy applies.
-        """
-elif False:
-    HttpRouteRuleActionRetryPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleActionRetryPolicyArgs:
     def __init__(__self__, *,
@@ -5233,21 +3886,8 @@ class HttpRouteRuleActionRetryPolicyArgs:
 
     @retry_conditions.setter
     def retry_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "retry_conditions", value)
-
-
-if not MYPY:
-    class HttpRouteRuleActionUrlRewriteArgsDict(TypedDict):
-        host_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.
-        """
-        path_prefix_rewrite: NotRequired[pulumi.Input[str]]
-        """
-        Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.
-        """
-elif False:
-    HttpRouteRuleActionUrlRewriteArgsDict: TypeAlias = Mapping[str, Any]
+        pulumi.set(self, "retry_conditions", value)
+
 
 @pulumi.input_type
 class HttpRouteRuleActionUrlRewriteArgs:
@@ -5288,37 +3928,6 @@ class HttpRouteRuleActionUrlRewriteArgs:
         pulumi.set(self, "path_prefix_rewrite", value)
 
 
-if not MYPY:
-    class HttpRouteRuleMatchArgsDict(TypedDict):
-        full_path_match: NotRequired[pulumi.Input[str]]
-        """
-        The HTTP request path value should exactly match this value.
-        """
-        headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchHeaderArgsDict']]]]
-        """
-        Specifies a list of HTTP request headers to match against.
-        Structure is documented below.
-        """
-        ignore_case: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.
-        """
-        prefix_match: NotRequired[pulumi.Input[str]]
-        """
-        The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.
-        """
-        query_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['HttpRouteRuleMatchQueryParameterArgsDict']]]]
-        """
-        Specifies a list of query parameters to match against.
-        Structure is documented below.
-        """
-        regex_match: NotRequired[pulumi.Input[str]]
-        """
-        The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
-        """
-elif False:
-    HttpRouteRuleMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleMatchArgs:
     def __init__(__self__, *,
@@ -5426,44 +4035,6 @@ class HttpRouteRuleMatchArgs:
         pulumi.set(self, "regex_match", value)
 
 
-if not MYPY:
-    class HttpRouteRuleMatchHeaderArgsDict(TypedDict):
-        exact_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header should match exactly the content of exactMatch.
-        """
-        header: NotRequired[pulumi.Input[str]]
-        """
-        The name of the HTTP header to match against.
-        """
-        invert_match: NotRequired[pulumi.Input[bool]]
-        """
-        If specified, the match result will be inverted before checking. Default value is set to false.
-        """
-        prefix_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header must start with the contents of prefixMatch.
-        """
-        present_match: NotRequired[pulumi.Input[bool]]
-        """
-        A header with headerName must exist. The match takes place whether or not the header has a value.
-        """
-        range_match: NotRequired[pulumi.Input['HttpRouteRuleMatchHeaderRangeMatchArgsDict']]
-        """
-        If specified, the rule will match if the request header value is within the range.
-        Structure is documented below.
-        """
-        regex_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header must match the regular expression specified in regexMatch.
-        """
-        suffix_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the header must end with the contents of suffixMatch.
-        """
-elif False:
-    HttpRouteRuleMatchHeaderArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleMatchHeaderArgs:
     def __init__(__self__, *,
@@ -5601,19 +4172,6 @@ class HttpRouteRuleMatchHeaderArgs:
         pulumi.set(self, "suffix_match", value)
 
 
-if not MYPY:
-    class HttpRouteRuleMatchHeaderRangeMatchArgsDict(TypedDict):
-        end: pulumi.Input[int]
-        """
-        End of the range (exclusive).
-        """
-        start: pulumi.Input[int]
-        """
-        Start of the range (inclusive).
-        """
-elif False:
-    HttpRouteRuleMatchHeaderRangeMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleMatchHeaderRangeMatchArgs:
     def __init__(__self__, *,
@@ -5651,27 +4209,6 @@ class HttpRouteRuleMatchHeaderRangeMatchArgs:
         pulumi.set(self, "start", value)
 
 
-if not MYPY:
-    class HttpRouteRuleMatchQueryParameterArgsDict(TypedDict):
-        exact_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the query parameter must exactly match the contents of exactMatch.
-        """
-        present_match: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not.
-        """
-        query_parameter: NotRequired[pulumi.Input[str]]
-        """
-        The name of the query parameter to match.
-        """
-        regex_match: NotRequired[pulumi.Input[str]]
-        """
-        The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
-        """
-elif False:
-    HttpRouteRuleMatchQueryParameterArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class HttpRouteRuleMatchQueryParameterArgs:
     def __init__(__self__, *,
@@ -5743,30 +4280,6 @@ class HttpRouteRuleMatchQueryParameterArgs:
         pulumi.set(self, "regex_match", value)
 
 
-if not MYPY:
-    class LbRouteExtensionExtensionChainArgsDict(TypedDict):
-        extensions: pulumi.Input[Sequence[pulumi.Input['LbRouteExtensionExtensionChainExtensionArgsDict']]]
-        """
-        A set of extensions to execute for the matching request.
-        At least one extension is required. Up to 3 extensions can be defined for each extension chain for
-        LbTrafficExtension resource. LbRouteExtension chains are limited to 1 extension per extension chain.
-        Structure is documented below.
-        """
-        match_condition: pulumi.Input['LbRouteExtensionExtensionChainMatchConditionArgsDict']
-        """
-        Conditions under which this chain is invoked for a request.
-        Structure is documented below.
-        """
-        name: pulumi.Input[str]
-        """
-        The name for this extension chain. The name is logged as part of the HTTP request logs.
-        The name must conform with RFC-1034, is restricted to lower-cased letters, numbers and hyphens,
-        and can have a maximum length of 63 characters. Additionally, the first character must be a letter
-        and the last character must be a letter or a number.
-        """
-elif False:
-    LbRouteExtensionExtensionChainArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbRouteExtensionExtensionChainArgs:
     def __init__(__self__, *,
@@ -5833,47 +4346,6 @@ class LbRouteExtensionExtensionChainArgs:
         pulumi.set(self, "name", value)
 
 
-if not MYPY:
-    class LbRouteExtensionExtensionChainExtensionArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name for this extension. The name is logged as part of the HTTP request logs.
-        The name must conform with RFC-1034, is restricted to lower-cased letters, numbers and hyphens,
-        and can have a maximum length of 63 characters. Additionally, the first character must be a letter
-        and the last a letter or a number.
-        """
-        service: pulumi.Input[str]
-        """
-        The reference to the service that runs the extension. Must be a reference to a backend service
-        """
-        authority: NotRequired[pulumi.Input[str]]
-        """
-        The :authority header in the gRPC request sent from Envoy to the extension service.
-        """
-        fail_open: NotRequired[pulumi.Input[bool]]
-        """
-        Determines how the proxy behaves if the call to the extension fails or times out.
-        When set to TRUE, request or response processing continues without error.
-        Any subsequent extensions in the extension chain are also executed.
-        When set to FALSE: * If response headers have not been delivered to the downstream client,
-        a generic 500 error is returned to the client. The error response can be tailored by
-        configuring a custom error response in the load balancer.
-        """
-        forward_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        List of the HTTP headers to forward to the extension (from the client or backend).
-        If omitted, all headers are sent. Each element is a string indicating the header name.
-
-        - - -
-        """
-        timeout: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the timeout for each individual message on the stream. The timeout must be between 10-1000 milliseconds.
-        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        """
-elif False:
-    LbRouteExtensionExtensionChainExtensionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbRouteExtensionExtensionChainExtensionArgs:
     def __init__(__self__, *,
@@ -5999,15 +4471,6 @@ class LbRouteExtensionExtensionChainExtensionArgs:
         pulumi.set(self, "timeout", value)
 
 
-if not MYPY:
-    class LbRouteExtensionExtensionChainMatchConditionArgsDict(TypedDict):
-        cel_expression: pulumi.Input[str]
-        """
-        A Common Expression Language (CEL) expression that is used to match requests for which the extension chain is executed.
-        """
-elif False:
-    LbRouteExtensionExtensionChainMatchConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbRouteExtensionExtensionChainMatchConditionArgs:
     def __init__(__self__, *,
@@ -6030,30 +4493,6 @@ class LbRouteExtensionExtensionChainMatchConditionArgs:
         pulumi.set(self, "cel_expression", value)
 
 
-if not MYPY:
-    class LbTrafficExtensionExtensionChainArgsDict(TypedDict):
-        extensions: pulumi.Input[Sequence[pulumi.Input['LbTrafficExtensionExtensionChainExtensionArgsDict']]]
-        """
-        A set of extensions to execute for the matching request.
-        At least one extension is required. Up to 3 extensions can be defined for each extension chain for
-        LbTrafficExtension resource. LbRouteExtension chains are limited to 1 extension per extension chain.
-        Structure is documented below.
-        """
-        match_condition: pulumi.Input['LbTrafficExtensionExtensionChainMatchConditionArgsDict']
-        """
-        Conditions under which this chain is invoked for a request.
-        Structure is documented below.
-        """
-        name: pulumi.Input[str]
-        """
-        The name for this extension chain. The name is logged as part of the HTTP request logs.
-        The name must conform with RFC-1034, is restricted to lower-cased letters, numbers and hyphens,
-        and can have a maximum length of 63 characters. Additionally, the first character must be a letter
-        and the last a letter or a number.
-        """
-elif False:
-    LbTrafficExtensionExtensionChainArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbTrafficExtensionExtensionChainArgs:
     def __init__(__self__, *,
@@ -6120,54 +4559,6 @@ class LbTrafficExtensionExtensionChainArgs:
         pulumi.set(self, "name", value)
 
 
-if not MYPY:
-    class LbTrafficExtensionExtensionChainExtensionArgsDict(TypedDict):
-        name: pulumi.Input[str]
-        """
-        The name for this extension. The name is logged as part of the HTTP request logs.
-        The name must conform with RFC-1034, is restricted to lower-cased letters, numbers and hyphens,
-        and can have a maximum length of 63 characters. Additionally, the first character must be a letter
-        and the last a letter or a number.
-        """
-        service: pulumi.Input[str]
-        """
-        The reference to the service that runs the extension. Must be a reference to a backend service
-        """
-        authority: NotRequired[pulumi.Input[str]]
-        """
-        The :authority header in the gRPC request sent from Envoy to the extension service.
-        """
-        fail_open: NotRequired[pulumi.Input[bool]]
-        """
-        Determines how the proxy behaves if the call to the extension fails or times out.
-        When set to TRUE, request or response processing continues without error.
-        Any subsequent extensions in the extension chain are also executed.
-        When set to FALSE: * If response headers have not been delivered to the downstream client,
-        a generic 500 error is returned to the client. The error response can be tailored by
-        configuring a custom error response in the load balancer.
-        """
-        forward_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        List of the HTTP headers to forward to the extension (from the client or backend).
-        If omitted, all headers are sent. Each element is a string indicating the header name.
-        """
-        supported_events: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        A set of events during request or response processing for which this extension is called.
-        This field is required for the LbTrafficExtension resource. It's not relevant for the LbRouteExtension
-        resource. Possible values:`EVENT_TYPE_UNSPECIFIED`, `REQUEST_HEADERS`, `REQUEST_BODY`, `RESPONSE_HEADERS`,
-        `RESPONSE_BODY`, `RESPONSE_BODY` and `RESPONSE_BODY`.
-
-        - - -
-        """
-        timeout: NotRequired[pulumi.Input[str]]
-        """
-        Specifies the timeout for each individual message on the stream. The timeout must be between 10-1000 milliseconds.
-        A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
-        """
-elif False:
-    LbTrafficExtensionExtensionChainExtensionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbTrafficExtensionExtensionChainExtensionArgs:
     def __init__(__self__, *,
@@ -6315,15 +4706,6 @@ class LbTrafficExtensionExtensionChainExtensionArgs:
         pulumi.set(self, "timeout", value)
 
 
-if not MYPY:
-    class LbTrafficExtensionExtensionChainMatchConditionArgsDict(TypedDict):
-        cel_expression: pulumi.Input[str]
-        """
-        A Common Expression Language (CEL) expression that is used to match requests for which the extension chain is executed.
-        """
-elif False:
-    LbTrafficExtensionExtensionChainMatchConditionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class LbTrafficExtensionExtensionChainMatchConditionArgs:
     def __init__(__self__, *,
@@ -6346,15 +4728,6 @@ class LbTrafficExtensionExtensionChainMatchConditionArgs:
         pulumi.set(self, "cel_expression", value)
 
 
-if not MYPY:
-    class ServiceLbPoliciesAutoCapacityDrainArgsDict(TypedDict):
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Optional. If set to 'True', an unhealthy MIG/NEG will be set as drained. - An MIG/NEG is considered unhealthy if less than 25% of the instances/endpoints in the MIG/NEG are healthy. - This option will never result in draining more than 50% of the configured IGs/NEGs for the Backend Service.
-        """
-elif False:
-    ServiceLbPoliciesAutoCapacityDrainArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ServiceLbPoliciesAutoCapacityDrainArgs:
     def __init__(__self__, *,
@@ -6378,15 +4751,6 @@ class ServiceLbPoliciesAutoCapacityDrainArgs:
         pulumi.set(self, "enable", value)
 
 
-if not MYPY:
-    class ServiceLbPoliciesFailoverConfigArgsDict(TypedDict):
-        failover_health_threshold: pulumi.Input[int]
-        """
-        Optional. The percentage threshold that a load balancer will begin to send traffic to failover backends. If the percentage of endpoints in a MIG/NEG is smaller than this value, traffic would be sent to failover backends if possible. This field should be set to a value between 1 and 99. The default value is 50 for Global external HTTP(S) load balancer (classic) and Proxyless service mesh, and 70 for others.
-        """
-elif False:
-    ServiceLbPoliciesFailoverConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ServiceLbPoliciesFailoverConfigArgs:
     def __init__(__self__, *,
@@ -6409,22 +4773,6 @@ class ServiceLbPoliciesFailoverConfigArgs:
         pulumi.set(self, "failover_health_threshold", value)
 
 
-if not MYPY:
-    class TcpRouteRuleArgsDict(TypedDict):
-        action: pulumi.Input['TcpRouteRuleActionArgsDict']
-        """
-        A detailed rule defining how to route traffic.
-        Structure is documented below.
-        """
-        matches: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleMatchArgsDict']]]]
-        """
-        RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation.
-        If no routeMatch field is specified, this rule will unconditionally match traffic.
-        Structure is documented below.
-        """
-elif False:
-    TcpRouteRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TcpRouteRuleArgs:
     def __init__(__self__, *,
@@ -6469,20 +4817,6 @@ class TcpRouteRuleArgs:
         pulumi.set(self, "matches", value)
 
 
-if not MYPY:
-    class TcpRouteRuleActionArgsDict(TypedDict):
-        destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TcpRouteRuleActionDestinationArgsDict']]]]
-        """
-        The destination services to which traffic should be forwarded. At least one destination service is required.
-        Structure is documented below.
-        """
-        original_destination: NotRequired[pulumi.Input[bool]]
-        """
-        If true, Router will use the destination IP and port of the original connection as the destination of the request.
-        """
-elif False:
-    TcpRouteRuleActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TcpRouteRuleActionArgs:
     def __init__(__self__, *,
@@ -6524,24 +4858,6 @@ class TcpRouteRuleActionArgs:
         pulumi.set(self, "original_destination", value)
 
 
-if not MYPY:
-    class TcpRouteRuleActionDestinationArgsDict(TypedDict):
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The URL of a BackendService to route traffic to.
-        """
-        weight: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
-        If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
-        If weights are specified for any one service name, they need to be specified for all of them.
-        If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
-
-        - - -
-        """
-elif False:
-    TcpRouteRuleActionDestinationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TcpRouteRuleActionDestinationArgs:
     def __init__(__self__, *,
@@ -6591,20 +4907,6 @@ class TcpRouteRuleActionDestinationArgs:
         pulumi.set(self, "weight", value)
 
 
-if not MYPY:
-    class TcpRouteRuleMatchArgsDict(TypedDict):
-        address: pulumi.Input[str]
-        """
-        Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask.
-        By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.
-        """
-        port: pulumi.Input[str]
-        """
-        Specifies the destination port to match against.
-        """
-elif False:
-    TcpRouteRuleMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TcpRouteRuleMatchArgs:
     def __init__(__self__, *,
@@ -6644,21 +4946,6 @@ class TcpRouteRuleMatchArgs:
         pulumi.set(self, "port", value)
 
 
-if not MYPY:
-    class TlsRouteRuleArgsDict(TypedDict):
-        action: pulumi.Input['TlsRouteRuleActionArgsDict']
-        """
-        Required. A detailed rule defining how to route traffic.
-        Structure is documented below.
-        """
-        matches: pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleMatchArgsDict']]]
-        """
-        Matches define the predicate used to match requests to a given action.
-        Structure is documented below.
-        """
-elif False:
-    TlsRouteRuleArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TlsRouteRuleArgs:
     def __init__(__self__, *,
@@ -6700,16 +4987,6 @@ class TlsRouteRuleArgs:
         pulumi.set(self, "matches", value)
 
 
-if not MYPY:
-    class TlsRouteRuleActionArgsDict(TypedDict):
-        destinations: NotRequired[pulumi.Input[Sequence[pulumi.Input['TlsRouteRuleActionDestinationArgsDict']]]]
-        """
-        The destination to which traffic should be forwarded.
-        Structure is documented below.
-        """
-elif False:
-    TlsRouteRuleActionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TlsRouteRuleActionArgs:
     def __init__(__self__, *,
@@ -6735,21 +5012,6 @@ class TlsRouteRuleActionArgs:
         pulumi.set(self, "destinations", value)
 
 
-if not MYPY:
-    class TlsRouteRuleActionDestinationArgsDict(TypedDict):
-        service_name: NotRequired[pulumi.Input[str]]
-        """
-        The URL of a BackendService to route traffic to.
-        """
-        weight: NotRequired[pulumi.Input[int]]
-        """
-        Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
-
-        - - -
-        """
-elif False:
-    TlsRouteRuleActionDestinationArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TlsRouteRuleActionDestinationArgs:
     def __init__(__self__, *,
@@ -6793,20 +5055,6 @@ class TlsRouteRuleActionDestinationArgs:
         pulumi.set(self, "weight", value)
 
 
-if not MYPY:
-    class TlsRouteRuleMatchArgsDict(TypedDict):
-        alpns: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.
-        """
-        sni_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com.
-        Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.
-        """
-elif False:
-    TlsRouteRuleMatchArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class TlsRouteRuleMatchArgs:
     def __init__(__self__, *,