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

pulumi_gcp/compute/url_map.py

@@ -4,14 +4,9 @@
 
 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
 from . import outputs
 from ._inputs import *
@@ -21,7 +16,6 @@ __all__ = ['URLMapArgs', 'URLMap']
 @pulumi.input_type
 class URLMapArgs:
     def __init__(__self__, *,
-                 default_custom_error_response_policy: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']] = None,
                  default_route_action: Optional[pulumi.Input['URLMapDefaultRouteActionArgs']] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input['URLMapDefaultUrlRedirectArgs']] = None,
@@ -34,15 +28,6 @@ class URLMapArgs:
                  tests: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapTestArgs']]]] = None):
         """
         The set of arguments for constructing a URLMap resource.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input['URLMapDefaultRouteActionArgs'] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -80,8 +65,6 @@ class URLMapArgs:
                tests per UrlMap.
                Structure is documented below.
         """
-        if default_custom_error_response_policy is not None:
-            pulumi.set(__self__, "default_custom_error_response_policy", default_custom_error_response_policy)
         if default_route_action is not None:
             pulumi.set(__self__, "default_route_action", default_route_action)
         if default_service is not None:
@@ -103,26 +86,6 @@ class URLMapArgs:
         if tests is not None:
             pulumi.set(__self__, "tests", tests)
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
-    @default_custom_error_response_policy.setter
-    def default_custom_error_response_policy(self, value: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]):
-        pulumi.set(self, "default_custom_error_response_policy", value)
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionArgs']]:
@@ -274,7 +237,6 @@ class URLMapArgs:
 class _URLMapState:
     def __init__(__self__, *,
                  creation_timestamp: Optional[pulumi.Input[str]] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']] = None,
                  default_route_action: Optional[pulumi.Input['URLMapDefaultRouteActionArgs']] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input['URLMapDefaultUrlRedirectArgs']] = None,
@@ -291,15 +253,6 @@ class _URLMapState:
         """
         Input properties used for looking up and filtering URLMap resources.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input['URLMapDefaultRouteActionArgs'] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -343,8 +296,6 @@ class _URLMapState:
         """
         if creation_timestamp is not None:
             pulumi.set(__self__, "creation_timestamp", creation_timestamp)
-        if default_custom_error_response_policy is not None:
-            pulumi.set(__self__, "default_custom_error_response_policy", default_custom_error_response_policy)
         if default_route_action is not None:
             pulumi.set(__self__, "default_route_action", default_route_action)
         if default_service is not None:
@@ -384,26 +335,6 @@ class _URLMapState:
     def creation_timestamp(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "creation_timestamp", value)
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
-    @default_custom_error_response_policy.setter
-    def default_custom_error_response_policy(self, value: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]):
-        pulumi.set(self, "default_custom_error_response_policy", value)
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionArgs']]:
@@ -593,17 +524,16 @@ class URLMap(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
-                 default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
+                 default_route_action: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultRouteActionArgs']]] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
-                 default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
+                 default_url_redirect: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultUrlRedirectArgs']]] = None,
                  description: Optional[pulumi.Input[str]] = None,
-                 header_action: Optional[pulumi.Input[Union['URLMapHeaderActionArgs', 'URLMapHeaderActionArgsDict']]] = None,
-                 host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapHostRuleArgs', 'URLMapHostRuleArgsDict']]]]] = None,
+                 header_action: Optional[pulumi.Input[pulumi.InputType['URLMapHeaderActionArgs']]] = None,
+                 host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapHostRuleArgs']]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapPathMatcherArgs', 'URLMapPathMatcherArgsDict']]]]] = None,
+                 path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapPathMatcherArgs']]]]] = None,
                  project: Optional[pulumi.Input[str]] = None,
-                 tests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapTestArgs', 'URLMapTestArgsDict']]]]] = None,
+                 tests: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapTestArgs']]]]] = None,
                  __props__=None):
         """
         UrlMaps are used to route requests to a backend service based on rules
@@ -644,44 +574,44 @@ class URLMap(pulumi.CustomResource):
             description="a description",
             default_service=static.id,
             host_rules=[
-                {
-                    "hosts": ["mysite.com"],
-                    "pathMatcher": "mysite",
-                },
-                {
-                    "hosts": ["myothersite.com"],
-                    "pathMatcher": "otherpaths",
-                },
+                gcp.compute.URLMapHostRuleArgs(
+                    hosts=["mysite.com"],
+                    path_matcher="mysite",
+                ),
+                gcp.compute.URLMapHostRuleArgs(
+                    hosts=["myothersite.com"],
+                    path_matcher="otherpaths",
+                ),
             ],
             path_matchers=[
-                {
-                    "name": "mysite",
-                    "defaultService": static.id,
-                    "pathRules": [
-                        {
-                            "paths": ["/home"],
-                            "service": static.id,
-                        },
-                        {
-                            "paths": ["/login"],
-                            "service": login.id,
-                        },
-                        {
-                            "paths": ["/static"],
-                            "service": static.id,
-                        },
+                gcp.compute.URLMapPathMatcherArgs(
+                    name="mysite",
+                    default_service=static.id,
+                    path_rules=[
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/home"],
+                            service=static.id,
+                        ),
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/login"],
+                            service=login.id,
+                        ),
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/static"],
+                            service=static.id,
+                        ),
                     ],
-                },
-                {
-                    "name": "otherpaths",
-                    "defaultService": static.id,
-                },
+                ),
+                gcp.compute.URLMapPathMatcherArgs(
+                    name="otherpaths",
+                    default_service=static.id,
+                ),
             ],
-            tests=[{
-                "service": static.id,
-                "host": "example.com",
-                "path": "/home",
-            }])
+            tests=[gcp.compute.URLMapTestArgs(
+                service=static.id,
+                host="example.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Route
 
@@ -691,9 +621,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -705,63 +635,63 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "routeRules": [{
-                    "priority": 1,
-                    "headerAction": {
-                        "requestHeadersToRemoves": ["RemoveMe2"],
-                        "requestHeadersToAdds": [{
-                            "headerName": "AddSomethingElse",
-                            "headerValue": "MyOtherValue",
-                            "replace": True,
-                        }],
-                        "responseHeadersToRemoves": ["RemoveMe3"],
-                        "responseHeadersToAdds": [{
-                            "headerName": "AddMe",
-                            "headerValue": "MyValue",
-                            "replace": False,
-                        }],
-                    },
-                    "matchRules": [{
-                        "fullPathMatch": "a full path",
-                        "headerMatches": [{
-                            "headerName": "someheader",
-                            "exactMatch": "match this exactly",
-                            "invertMatch": True,
-                        }],
-                        "ignoreCase": True,
-                        "metadataFilters": [{
-                            "filterMatchCriteria": "MATCH_ANY",
-                            "filterLabels": [{
-                                "name": "PLANET",
-                                "value": "MARS",
-                            }],
-                        }],
-                        "queryParameterMatches": [{
-                            "name": "a query parameter",
-                            "presentMatch": True,
-                        }],
-                    }],
-                    "urlRedirect": {
-                        "hostRedirect": "A host",
-                        "httpsRedirect": False,
-                        "pathRedirect": "some/path",
-                        "redirectResponseCode": "TEMPORARY_REDIRECT",
-                        "stripQuery": True,
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                route_rules=[gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                    priority=1,
+                    header_action=gcp.compute.URLMapPathMatcherRouteRuleHeaderActionArgs(
+                        request_headers_to_removes=["RemoveMe2"],
+                        request_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs(
+                            header_name="AddSomethingElse",
+                            header_value="MyOtherValue",
+                            replace=True,
+                        )],
+                        response_headers_to_removes=["RemoveMe3"],
+                        response_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs(
+                            header_name="AddMe",
+                            header_value="MyValue",
+                            replace=False,
+                        )],
+                    ),
+                    match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                        full_path_match="a full path",
+                        header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                            header_name="someheader",
+                            exact_match="match this exactly",
+                            invert_match=True,
+                        )],
+                        ignore_case=True,
+                        metadata_filters=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs(
+                            filter_match_criteria="MATCH_ANY",
+                            filter_labels=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs(
+                                name="PLANET",
+                                value="MARS",
+                            )],
+                        )],
+                        query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                            name="a query parameter",
+                            present_match=True,
+                        )],
+                    )],
+                    url_redirect=gcp.compute.URLMapPathMatcherRouteRuleUrlRedirectArgs(
+                        host_redirect="A host",
+                        https_redirect=False,
+                        path_redirect="some/path",
+                        redirect_response_code="TEMPORARY_REDIRECT",
+                        strip_query=True,
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Route Partial
 
@@ -771,9 +701,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -785,34 +715,34 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "routeRules": [{
-                    "priority": 1,
-                    "matchRules": [{
-                        "prefixMatch": "/someprefix",
-                        "headerMatches": [{
-                            "headerName": "someheader",
-                            "exactMatch": "match this exactly",
-                            "invertMatch": True,
-                        }],
-                    }],
-                    "urlRedirect": {
-                        "pathRedirect": "some/path",
-                        "redirectResponseCode": "TEMPORARY_REDIRECT",
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                route_rules=[gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                    priority=1,
+                    match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                        prefix_match="/someprefix",
+                        header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                            header_name="someheader",
+                            exact_match="match this exactly",
+                            invert_match=True,
+                        )],
+                    )],
+                    url_redirect=gcp.compute.URLMapPathMatcherRouteRuleUrlRedirectArgs(
+                        path_redirect="some/path",
+                        redirect_response_code="TEMPORARY_REDIRECT",
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Path
 
@@ -822,9 +752,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -836,86 +766,86 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "pathRules": [{
-                    "paths": ["/home"],
-                    "routeAction": {
-                        "corsPolicy": {
-                            "allowCredentials": True,
-                            "allowHeaders": ["Allowed content"],
-                            "allowMethods": ["GET"],
-                            "allowOriginRegexes": ["abc.*"],
-                            "allowOrigins": ["Allowed origin"],
-                            "exposeHeaders": ["Exposed header"],
-                            "maxAge": 30,
-                            "disabled": False,
-                        },
-                        "faultInjectionPolicy": {
-                            "abort": {
-                                "httpStatus": 234,
-                                "percentage": 5.6,
-                            },
-                            "delay": {
-                                "fixedDelay": {
-                                    "seconds": "0",
-                                    "nanos": 50000,
-                                },
-                                "percentage": 7.8,
-                            },
-                        },
-                        "requestMirrorPolicy": {
-                            "backendService": home.id,
-                        },
-                        "retryPolicy": {
-                            "numRetries": 4,
-                            "perTryTimeout": {
-                                "seconds": "30",
-                            },
-                            "retryConditions": [
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/home"],
+                    route_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionArgs(
+                        cors_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
+                            allow_credentials=True,
+                            allow_headers=["Allowed content"],
+                            allow_methods=["GET"],
+                            allow_origin_regexes=["abc.*"],
+                            allow_origins=["Allowed origin"],
+                            expose_headers=["Exposed header"],
+                            max_age=30,
+                            disabled=False,
+                        ),
+                        fault_injection_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs(
+                            abort=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs(
+                                http_status=234,
+                                percentage=5.6,
+                            ),
+                            delay=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs(
+                                fixed_delay=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
+                                    seconds="0",
+                                    nanos=50000,
+                                ),
+                                percentage=7.8,
+                            ),
+                        ),
+                        request_mirror_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs(
+                            backend_service=home.id,
+                        ),
+                        retry_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs(
+                            num_retries=4,
+                            per_try_timeout=gcp.compute.URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs(
+                                seconds="30",
+                            ),
+                            retry_conditions=[
                                 "5xx",
                                 "deadline-exceeded",
                             ],
-                        },
-                        "timeout": {
-                            "seconds": "20",
-                            "nanos": 750000000,
-                        },
-                        "urlRewrite": {
-                            "hostRewrite": "dev.example.com",
-                            "pathPrefixRewrite": "/v1/api/",
-                        },
-                        "weightedBackendServices": [{
-                            "backendService": home.id,
-                            "weight": 400,
-                            "headerAction": {
-                                "requestHeadersToRemoves": ["RemoveMe"],
-                                "requestHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": True,
-                                }],
-                                "responseHeadersToRemoves": ["RemoveMe"],
-                                "responseHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": False,
-                                }],
-                            },
-                        }],
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+                        ),
+                        timeout=gcp.compute.URLMapPathMatcherPathRuleRouteActionTimeoutArgs(
+                            seconds="20",
+                            nanos=750000000,
+                        ),
+                        url_rewrite=gcp.compute.URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs(
+                            host_rewrite="dev.example.com",
+                            path_prefix_rewrite="/v1/api/",
+                        ),
+                        weighted_backend_services=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
+                            backend_service=home.id,
+                            weight=400,
+                            header_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
+                                request_headers_to_removes=["RemoveMe"],
+                                request_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=True,
+                                )],
+                                response_headers_to_removes=["RemoveMe"],
+                                response_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=False,
+                                )],
+                            ),
+                        )],
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Path Partial
 
@@ -925,9 +855,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -939,52 +869,52 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "pathRules": [{
-                    "paths": ["/home"],
-                    "routeAction": {
-                        "corsPolicy": {
-                            "allowCredentials": True,
-                            "allowHeaders": ["Allowed content"],
-                            "allowMethods": ["GET"],
-                            "allowOriginRegexes": ["abc.*"],
-                            "allowOrigins": ["Allowed origin"],
-                            "exposeHeaders": ["Exposed header"],
-                            "maxAge": 30,
-                            "disabled": False,
-                        },
-                        "weightedBackendServices": [{
-                            "backendService": home.id,
-                            "weight": 400,
-                            "headerAction": {
-                                "requestHeadersToRemoves": ["RemoveMe"],
-                                "requestHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": True,
-                                }],
-                                "responseHeadersToRemoves": ["RemoveMe"],
-                                "responseHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": False,
-                                }],
-                            },
-                        }],
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/home"],
+                    route_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionArgs(
+                        cors_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
+                            allow_credentials=True,
+                            allow_headers=["Allowed content"],
+                            allow_methods=["GET"],
+                            allow_origin_regexes=["abc.*"],
+                            allow_origins=["Allowed origin"],
+                            expose_headers=["Exposed header"],
+                            max_age=30,
+                            disabled=False,
+                        ),
+                        weighted_backend_services=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
+                            backend_service=home.id,
+                            weight=400,
+                            header_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
+                                request_headers_to_removes=["RemoveMe"],
+                                request_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=True,
+                                )],
+                                response_headers_to_removes=["RemoveMe"],
+                                response_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=False,
+                                )],
+                            ),
+                        )],
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Header Based Routing
 
@@ -1019,40 +949,40 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="header-based routing example",
             default_service=default.id,
-            host_rules=[{
-                "hosts": ["*"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default.id,
-                "routeRules": [
-                    {
-                        "priority": 1,
-                        "service": service_a.id,
-                        "matchRules": [{
-                            "prefixMatch": "/",
-                            "ignoreCase": True,
-                            "headerMatches": [{
-                                "headerName": "abtest",
-                                "exactMatch": "a",
-                            }],
-                        }],
-                    },
-                    {
-                        "priority": 2,
-                        "service": service_b.id,
-                        "matchRules": [{
-                            "ignoreCase": True,
-                            "prefixMatch": "/",
-                            "headerMatches": [{
-                                "headerName": "abtest",
-                                "exactMatch": "b",
-                            }],
-                        }],
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["*"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=1,
+                        service=service_a.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            prefix_match="/",
+                            ignore_case=True,
+                            header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                                header_name="abtest",
+                                exact_match="a",
+                            )],
+                        )],
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=2,
+                        service=service_b.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            ignore_case=True,
+                            prefix_match="/",
+                            header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                                header_name="abtest",
+                                exact_match="b",
+                            )],
+                        )],
+                    ),
                 ],
-            }])
+            )])
         ```
         ### Url Map Parameter Based Routing
 
@@ -1087,40 +1017,40 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="parameter-based routing example",
             default_service=default.id,
-            host_rules=[{
-                "hosts": ["*"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default.id,
-                "routeRules": [
-                    {
-                        "priority": 1,
-                        "service": service_a.id,
-                        "matchRules": [{
-                            "prefixMatch": "/",
-                            "ignoreCase": True,
-                            "queryParameterMatches": [{
-                                "name": "abtest",
-                                "exactMatch": "a",
-                            }],
-                        }],
-                    },
-                    {
-                        "priority": 2,
-                        "service": service_b.id,
-                        "matchRules": [{
-                            "ignoreCase": True,
-                            "prefixMatch": "/",
-                            "queryParameterMatches": [{
-                                "name": "abtest",
-                                "exactMatch": "b",
-                            }],
-                        }],
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["*"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=1,
+                        service=service_a.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            prefix_match="/",
+                            ignore_case=True,
+                            query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                                name="abtest",
+                                exact_match="a",
+                            )],
+                        )],
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=2,
+                        service=service_b.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            ignore_case=True,
+                            prefix_match="/",
+                            query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                                name="abtest",
+                                exact_match="b",
+                            )],
+                        )],
+                    ),
                 ],
-            }])
+            )])
         ```
         ### Url Map Path Template Match
 
@@ -1158,111 +1088,35 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=static.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": static.id,
-                "routeRules": [
-                    {
-                        "matchRules": [{
-                            "pathTemplateMatch": "/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
-                        }],
-                        "service": cart_backend.id,
-                        "priority": 1,
-                        "routeAction": {
-                            "urlRewrite": {
-                                "pathTemplateRewrite": "/{username}-{cartid}/",
-                            },
-                        },
-                    },
-                    {
-                        "matchRules": [{
-                            "pathTemplateMatch": "/xyzwebservices/v2/xyz/users/*/accountinfo/*",
-                        }],
-                        "service": user_backend.id,
-                        "priority": 2,
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="mysite",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="mysite",
+                default_service=static.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            path_template_match="/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
+                        )],
+                        service=cart_backend.id,
+                        priority=1,
+                        route_action=gcp.compute.URLMapPathMatcherRouteRuleRouteActionArgs(
+                            url_rewrite=gcp.compute.URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs(
+                                path_template_rewrite="/{username}-{cartid}/",
+                            ),
+                        ),
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            path_template_match="/xyzwebservices/v2/xyz/users/*/accountinfo/*",
+                        )],
+                        service=user_backend.id,
+                        priority=2,
+                    ),
                 ],
-            }])
-        ```
-        ### Url Map Custom Error Response Policy
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.HttpHealthCheck("default",
-            name="health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        example = gcp.compute.BackendService("example",
-            name="login",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            health_checks=default.id)
-        error_bucket = gcp.storage.Bucket("error",
-            name="static-asset-bucket",
-            location="US")
-        error = gcp.compute.BackendBucket("error",
-            name="error-backend-bucket",
-            bucket_name=error_bucket.name,
-            enable_cdn=True)
-        urlmap = gcp.compute.URLMap("urlmap",
-            name="urlmap",
-            description="a description",
-            default_service=example.id,
-            default_custom_error_response_policy={
-                "errorResponseRules": [{
-                    "matchResponseCodes": ["5xx"],
-                    "path": "/*",
-                    "overrideResponseCode": 502,
-                }],
-                "errorService": error.id,
-            },
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": example.id,
-                "defaultCustomErrorResponsePolicy": {
-                    "errorResponseRules": [
-                        {
-                            "matchResponseCodes": [
-                                "4xx",
-                                "5xx",
-                            ],
-                            "path": "/login",
-                            "overrideResponseCode": 404,
-                        },
-                        {
-                            "matchResponseCodes": ["503"],
-                            "path": "/example",
-                            "overrideResponseCode": 502,
-                        },
-                    ],
-                    "errorService": error.id,
-                },
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": example.id,
-                    "customErrorResponsePolicy": {
-                        "errorResponseRules": [{
-                            "matchResponseCodes": ["4xx"],
-                            "path": "/register",
-                            "overrideResponseCode": 401,
-                        }],
-                        "errorService": error.id,
-                    },
-                }],
-            }])
+            )])
         ```
 
         ## Import
@@ -1291,33 +1145,24 @@ class URLMap(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
-        :param pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
+        :param pulumi.Input[pulumi.InputType['URLMapDefaultRouteActionArgs']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
                is set, defaultRouteAction cannot contain any weightedBackendServices.
                Only one of defaultRouteAction or defaultUrlRedirect must be set.
                Structure is documented below.
         :param pulumi.Input[str] default_service: The backend service or backend bucket to use when none of the given rules match.
-        :param pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
+        :param pulumi.Input[pulumi.InputType['URLMapDefaultUrlRedirectArgs']] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
                by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
                defaultRouteAction must not be set.
                Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource. Provide this property when you create
                the resource.
-        :param pulumi.Input[Union['URLMapHeaderActionArgs', 'URLMapHeaderActionArgsDict']] header_action: Specifies changes to request and response headers that need to take effect for
+        :param pulumi.Input[pulumi.InputType['URLMapHeaderActionArgs']] header_action: Specifies changes to request and response headers that need to take effect for
                the selected backendService. The headerAction specified here take effect after
                headerAction specified under pathMatcher.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapHostRuleArgs', 'URLMapHostRuleArgsDict']]]] host_rules: The list of HostRules to use against the URL.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapHostRuleArgs']]]] host_rules: The list of HostRules to use against the URL.
                Structure is documented below.
         :param pulumi.Input[str] name: Name of the resource. Provided by the client when the resource is created. The
                name must be 1-63 characters long, and comply with RFC1035. Specifically, the
@@ -1328,11 +1173,11 @@ class URLMap(pulumi.CustomResource):
                
                
                - - -
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapPathMatcherArgs', 'URLMapPathMatcherArgsDict']]]] path_matchers: The list of named PathMatchers to use against the URL.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapPathMatcherArgs']]]] path_matchers: The list of named PathMatchers to use against the URL.
                Structure is documented below.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapTestArgs', 'URLMapTestArgsDict']]]] tests: The list of expected URL mapping tests. Request to update this UrlMap will
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapTestArgs']]]] tests: The list of expected URL mapping tests. Request to update this UrlMap will
                succeed only if all of the test cases pass. You can specify a maximum of 100
                tests per UrlMap.
                Structure is documented below.
@@ -1382,44 +1227,44 @@ class URLMap(pulumi.CustomResource):
             description="a description",
             default_service=static.id,
             host_rules=[
-                {
-                    "hosts": ["mysite.com"],
-                    "pathMatcher": "mysite",
-                },
-                {
-                    "hosts": ["myothersite.com"],
-                    "pathMatcher": "otherpaths",
-                },
+                gcp.compute.URLMapHostRuleArgs(
+                    hosts=["mysite.com"],
+                    path_matcher="mysite",
+                ),
+                gcp.compute.URLMapHostRuleArgs(
+                    hosts=["myothersite.com"],
+                    path_matcher="otherpaths",
+                ),
             ],
             path_matchers=[
-                {
-                    "name": "mysite",
-                    "defaultService": static.id,
-                    "pathRules": [
-                        {
-                            "paths": ["/home"],
-                            "service": static.id,
-                        },
-                        {
-                            "paths": ["/login"],
-                            "service": login.id,
-                        },
-                        {
-                            "paths": ["/static"],
-                            "service": static.id,
-                        },
+                gcp.compute.URLMapPathMatcherArgs(
+                    name="mysite",
+                    default_service=static.id,
+                    path_rules=[
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/home"],
+                            service=static.id,
+                        ),
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/login"],
+                            service=login.id,
+                        ),
+                        gcp.compute.URLMapPathMatcherPathRuleArgs(
+                            paths=["/static"],
+                            service=static.id,
+                        ),
                     ],
-                },
-                {
-                    "name": "otherpaths",
-                    "defaultService": static.id,
-                },
+                ),
+                gcp.compute.URLMapPathMatcherArgs(
+                    name="otherpaths",
+                    default_service=static.id,
+                ),
             ],
-            tests=[{
-                "service": static.id,
-                "host": "example.com",
-                "path": "/home",
-            }])
+            tests=[gcp.compute.URLMapTestArgs(
+                service=static.id,
+                host="example.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Route
 
@@ -1429,9 +1274,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -1443,63 +1288,63 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "routeRules": [{
-                    "priority": 1,
-                    "headerAction": {
-                        "requestHeadersToRemoves": ["RemoveMe2"],
-                        "requestHeadersToAdds": [{
-                            "headerName": "AddSomethingElse",
-                            "headerValue": "MyOtherValue",
-                            "replace": True,
-                        }],
-                        "responseHeadersToRemoves": ["RemoveMe3"],
-                        "responseHeadersToAdds": [{
-                            "headerName": "AddMe",
-                            "headerValue": "MyValue",
-                            "replace": False,
-                        }],
-                    },
-                    "matchRules": [{
-                        "fullPathMatch": "a full path",
-                        "headerMatches": [{
-                            "headerName": "someheader",
-                            "exactMatch": "match this exactly",
-                            "invertMatch": True,
-                        }],
-                        "ignoreCase": True,
-                        "metadataFilters": [{
-                            "filterMatchCriteria": "MATCH_ANY",
-                            "filterLabels": [{
-                                "name": "PLANET",
-                                "value": "MARS",
-                            }],
-                        }],
-                        "queryParameterMatches": [{
-                            "name": "a query parameter",
-                            "presentMatch": True,
-                        }],
-                    }],
-                    "urlRedirect": {
-                        "hostRedirect": "A host",
-                        "httpsRedirect": False,
-                        "pathRedirect": "some/path",
-                        "redirectResponseCode": "TEMPORARY_REDIRECT",
-                        "stripQuery": True,
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                route_rules=[gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                    priority=1,
+                    header_action=gcp.compute.URLMapPathMatcherRouteRuleHeaderActionArgs(
+                        request_headers_to_removes=["RemoveMe2"],
+                        request_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs(
+                            header_name="AddSomethingElse",
+                            header_value="MyOtherValue",
+                            replace=True,
+                        )],
+                        response_headers_to_removes=["RemoveMe3"],
+                        response_headers_to_adds=[gcp.compute.URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs(
+                            header_name="AddMe",
+                            header_value="MyValue",
+                            replace=False,
+                        )],
+                    ),
+                    match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                        full_path_match="a full path",
+                        header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                            header_name="someheader",
+                            exact_match="match this exactly",
+                            invert_match=True,
+                        )],
+                        ignore_case=True,
+                        metadata_filters=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs(
+                            filter_match_criteria="MATCH_ANY",
+                            filter_labels=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs(
+                                name="PLANET",
+                                value="MARS",
+                            )],
+                        )],
+                        query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                            name="a query parameter",
+                            present_match=True,
+                        )],
+                    )],
+                    url_redirect=gcp.compute.URLMapPathMatcherRouteRuleUrlRedirectArgs(
+                        host_redirect="A host",
+                        https_redirect=False,
+                        path_redirect="some/path",
+                        redirect_response_code="TEMPORARY_REDIRECT",
+                        strip_query=True,
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Route Partial
 
@@ -1509,9 +1354,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -1523,34 +1368,34 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "routeRules": [{
-                    "priority": 1,
-                    "matchRules": [{
-                        "prefixMatch": "/someprefix",
-                        "headerMatches": [{
-                            "headerName": "someheader",
-                            "exactMatch": "match this exactly",
-                            "invertMatch": True,
-                        }],
-                    }],
-                    "urlRedirect": {
-                        "pathRedirect": "some/path",
-                        "redirectResponseCode": "TEMPORARY_REDIRECT",
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                route_rules=[gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                    priority=1,
+                    match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                        prefix_match="/someprefix",
+                        header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                            header_name="someheader",
+                            exact_match="match this exactly",
+                            invert_match=True,
+                        )],
+                    )],
+                    url_redirect=gcp.compute.URLMapPathMatcherRouteRuleUrlRedirectArgs(
+                        path_redirect="some/path",
+                        redirect_response_code="TEMPORARY_REDIRECT",
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Path
 
@@ -1560,9 +1405,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -1574,86 +1419,86 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "pathRules": [{
-                    "paths": ["/home"],
-                    "routeAction": {
-                        "corsPolicy": {
-                            "allowCredentials": True,
-                            "allowHeaders": ["Allowed content"],
-                            "allowMethods": ["GET"],
-                            "allowOriginRegexes": ["abc.*"],
-                            "allowOrigins": ["Allowed origin"],
-                            "exposeHeaders": ["Exposed header"],
-                            "maxAge": 30,
-                            "disabled": False,
-                        },
-                        "faultInjectionPolicy": {
-                            "abort": {
-                                "httpStatus": 234,
-                                "percentage": 5.6,
-                            },
-                            "delay": {
-                                "fixedDelay": {
-                                    "seconds": "0",
-                                    "nanos": 50000,
-                                },
-                                "percentage": 7.8,
-                            },
-                        },
-                        "requestMirrorPolicy": {
-                            "backendService": home.id,
-                        },
-                        "retryPolicy": {
-                            "numRetries": 4,
-                            "perTryTimeout": {
-                                "seconds": "30",
-                            },
-                            "retryConditions": [
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/home"],
+                    route_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionArgs(
+                        cors_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
+                            allow_credentials=True,
+                            allow_headers=["Allowed content"],
+                            allow_methods=["GET"],
+                            allow_origin_regexes=["abc.*"],
+                            allow_origins=["Allowed origin"],
+                            expose_headers=["Exposed header"],
+                            max_age=30,
+                            disabled=False,
+                        ),
+                        fault_injection_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs(
+                            abort=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs(
+                                http_status=234,
+                                percentage=5.6,
+                            ),
+                            delay=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs(
+                                fixed_delay=gcp.compute.URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
+                                    seconds="0",
+                                    nanos=50000,
+                                ),
+                                percentage=7.8,
+                            ),
+                        ),
+                        request_mirror_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs(
+                            backend_service=home.id,
+                        ),
+                        retry_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs(
+                            num_retries=4,
+                            per_try_timeout=gcp.compute.URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs(
+                                seconds="30",
+                            ),
+                            retry_conditions=[
                                 "5xx",
                                 "deadline-exceeded",
                             ],
-                        },
-                        "timeout": {
-                            "seconds": "20",
-                            "nanos": 750000000,
-                        },
-                        "urlRewrite": {
-                            "hostRewrite": "dev.example.com",
-                            "pathPrefixRewrite": "/v1/api/",
-                        },
-                        "weightedBackendServices": [{
-                            "backendService": home.id,
-                            "weight": 400,
-                            "headerAction": {
-                                "requestHeadersToRemoves": ["RemoveMe"],
-                                "requestHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": True,
-                                }],
-                                "responseHeadersToRemoves": ["RemoveMe"],
-                                "responseHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": False,
-                                }],
-                            },
-                        }],
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+                        ),
+                        timeout=gcp.compute.URLMapPathMatcherPathRuleRouteActionTimeoutArgs(
+                            seconds="20",
+                            nanos=750000000,
+                        ),
+                        url_rewrite=gcp.compute.URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs(
+                            host_rewrite="dev.example.com",
+                            path_prefix_rewrite="/v1/api/",
+                        ),
+                        weighted_backend_services=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
+                            backend_service=home.id,
+                            weight=400,
+                            header_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
+                                request_headers_to_removes=["RemoveMe"],
+                                request_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=True,
+                                )],
+                                response_headers_to_removes=["RemoveMe"],
+                                response_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=False,
+                                )],
+                            ),
+                        )],
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Traffic Director Path Partial
 
@@ -1663,9 +1508,9 @@ class URLMap(pulumi.CustomResource):
 
         default = gcp.compute.HealthCheck("default",
             name="health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         home = gcp.compute.BackendService("home",
             name="home",
             port_name="http",
@@ -1677,52 +1522,52 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=home.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": home.id,
-                "pathRules": [{
-                    "paths": ["/home"],
-                    "routeAction": {
-                        "corsPolicy": {
-                            "allowCredentials": True,
-                            "allowHeaders": ["Allowed content"],
-                            "allowMethods": ["GET"],
-                            "allowOriginRegexes": ["abc.*"],
-                            "allowOrigins": ["Allowed origin"],
-                            "exposeHeaders": ["Exposed header"],
-                            "maxAge": 30,
-                            "disabled": False,
-                        },
-                        "weightedBackendServices": [{
-                            "backendService": home.id,
-                            "weight": 400,
-                            "headerAction": {
-                                "requestHeadersToRemoves": ["RemoveMe"],
-                                "requestHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": True,
-                                }],
-                                "responseHeadersToRemoves": ["RemoveMe"],
-                                "responseHeadersToAdds": [{
-                                    "headerName": "AddMe",
-                                    "headerValue": "MyValue",
-                                    "replace": False,
-                                }],
-                            },
-                        }],
-                    },
-                }],
-            }],
-            tests=[{
-                "service": home.id,
-                "host": "hi.com",
-                "path": "/home",
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=home.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/home"],
+                    route_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionArgs(
+                        cors_policy=gcp.compute.URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
+                            allow_credentials=True,
+                            allow_headers=["Allowed content"],
+                            allow_methods=["GET"],
+                            allow_origin_regexes=["abc.*"],
+                            allow_origins=["Allowed origin"],
+                            expose_headers=["Exposed header"],
+                            max_age=30,
+                            disabled=False,
+                        ),
+                        weighted_backend_services=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
+                            backend_service=home.id,
+                            weight=400,
+                            header_action=gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
+                                request_headers_to_removes=["RemoveMe"],
+                                request_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=True,
+                                )],
+                                response_headers_to_removes=["RemoveMe"],
+                                response_headers_to_adds=[gcp.compute.URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
+                                    header_name="AddMe",
+                                    header_value="MyValue",
+                                    replace=False,
+                                )],
+                            ),
+                        )],
+                    ),
+                )],
+            )],
+            tests=[gcp.compute.URLMapTestArgs(
+                service=home.id,
+                host="hi.com",
+                path="/home",
+            )])
         ```
         ### Url Map Header Based Routing
 
@@ -1757,40 +1602,40 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="header-based routing example",
             default_service=default.id,
-            host_rules=[{
-                "hosts": ["*"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default.id,
-                "routeRules": [
-                    {
-                        "priority": 1,
-                        "service": service_a.id,
-                        "matchRules": [{
-                            "prefixMatch": "/",
-                            "ignoreCase": True,
-                            "headerMatches": [{
-                                "headerName": "abtest",
-                                "exactMatch": "a",
-                            }],
-                        }],
-                    },
-                    {
-                        "priority": 2,
-                        "service": service_b.id,
-                        "matchRules": [{
-                            "ignoreCase": True,
-                            "prefixMatch": "/",
-                            "headerMatches": [{
-                                "headerName": "abtest",
-                                "exactMatch": "b",
-                            }],
-                        }],
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["*"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=1,
+                        service=service_a.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            prefix_match="/",
+                            ignore_case=True,
+                            header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                                header_name="abtest",
+                                exact_match="a",
+                            )],
+                        )],
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=2,
+                        service=service_b.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            ignore_case=True,
+                            prefix_match="/",
+                            header_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
+                                header_name="abtest",
+                                exact_match="b",
+                            )],
+                        )],
+                    ),
                 ],
-            }])
+            )])
         ```
         ### Url Map Parameter Based Routing
 
@@ -1825,40 +1670,40 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="parameter-based routing example",
             default_service=default.id,
-            host_rules=[{
-                "hosts": ["*"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default.id,
-                "routeRules": [
-                    {
-                        "priority": 1,
-                        "service": service_a.id,
-                        "matchRules": [{
-                            "prefixMatch": "/",
-                            "ignoreCase": True,
-                            "queryParameterMatches": [{
-                                "name": "abtest",
-                                "exactMatch": "a",
-                            }],
-                        }],
-                    },
-                    {
-                        "priority": 2,
-                        "service": service_b.id,
-                        "matchRules": [{
-                            "ignoreCase": True,
-                            "prefixMatch": "/",
-                            "queryParameterMatches": [{
-                                "name": "abtest",
-                                "exactMatch": "b",
-                            }],
-                        }],
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["*"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=1,
+                        service=service_a.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            prefix_match="/",
+                            ignore_case=True,
+                            query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                                name="abtest",
+                                exact_match="a",
+                            )],
+                        )],
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        priority=2,
+                        service=service_b.id,
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            ignore_case=True,
+                            prefix_match="/",
+                            query_parameter_matches=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
+                                name="abtest",
+                                exact_match="b",
+                            )],
+                        )],
+                    ),
                 ],
-            }])
+            )])
         ```
         ### Url Map Path Template Match
 
@@ -1896,111 +1741,35 @@ class URLMap(pulumi.CustomResource):
             name="urlmap",
             description="a description",
             default_service=static.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": static.id,
-                "routeRules": [
-                    {
-                        "matchRules": [{
-                            "pathTemplateMatch": "/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
-                        }],
-                        "service": cart_backend.id,
-                        "priority": 1,
-                        "routeAction": {
-                            "urlRewrite": {
-                                "pathTemplateRewrite": "/{username}-{cartid}/",
-                            },
-                        },
-                    },
-                    {
-                        "matchRules": [{
-                            "pathTemplateMatch": "/xyzwebservices/v2/xyz/users/*/accountinfo/*",
-                        }],
-                        "service": user_backend.id,
-                        "priority": 2,
-                    },
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="mysite",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="mysite",
+                default_service=static.id,
+                route_rules=[
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            path_template_match="/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
+                        )],
+                        service=cart_backend.id,
+                        priority=1,
+                        route_action=gcp.compute.URLMapPathMatcherRouteRuleRouteActionArgs(
+                            url_rewrite=gcp.compute.URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs(
+                                path_template_rewrite="/{username}-{cartid}/",
+                            ),
+                        ),
+                    ),
+                    gcp.compute.URLMapPathMatcherRouteRuleArgs(
+                        match_rules=[gcp.compute.URLMapPathMatcherRouteRuleMatchRuleArgs(
+                            path_template_match="/xyzwebservices/v2/xyz/users/*/accountinfo/*",
+                        )],
+                        service=user_backend.id,
+                        priority=2,
+                    ),
                 ],
-            }])
-        ```
-        ### Url Map Custom Error Response Policy
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.HttpHealthCheck("default",
-            name="health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        example = gcp.compute.BackendService("example",
-            name="login",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            health_checks=default.id)
-        error_bucket = gcp.storage.Bucket("error",
-            name="static-asset-bucket",
-            location="US")
-        error = gcp.compute.BackendBucket("error",
-            name="error-backend-bucket",
-            bucket_name=error_bucket.name,
-            enable_cdn=True)
-        urlmap = gcp.compute.URLMap("urlmap",
-            name="urlmap",
-            description="a description",
-            default_service=example.id,
-            default_custom_error_response_policy={
-                "errorResponseRules": [{
-                    "matchResponseCodes": ["5xx"],
-                    "path": "/*",
-                    "overrideResponseCode": 502,
-                }],
-                "errorService": error.id,
-            },
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": example.id,
-                "defaultCustomErrorResponsePolicy": {
-                    "errorResponseRules": [
-                        {
-                            "matchResponseCodes": [
-                                "4xx",
-                                "5xx",
-                            ],
-                            "path": "/login",
-                            "overrideResponseCode": 404,
-                        },
-                        {
-                            "matchResponseCodes": ["503"],
-                            "path": "/example",
-                            "overrideResponseCode": 502,
-                        },
-                    ],
-                    "errorService": error.id,
-                },
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": example.id,
-                    "customErrorResponsePolicy": {
-                        "errorResponseRules": [{
-                            "matchResponseCodes": ["4xx"],
-                            "path": "/register",
-                            "overrideResponseCode": 401,
-                        }],
-                        "errorService": error.id,
-                    },
-                }],
-            }])
+            )])
         ```
 
         ## Import
@@ -2042,17 +1811,16 @@ class URLMap(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
-                 default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
+                 default_route_action: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultRouteActionArgs']]] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
-                 default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
+                 default_url_redirect: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultUrlRedirectArgs']]] = None,
                  description: Optional[pulumi.Input[str]] = None,
-                 header_action: Optional[pulumi.Input[Union['URLMapHeaderActionArgs', 'URLMapHeaderActionArgsDict']]] = None,
-                 host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapHostRuleArgs', 'URLMapHostRuleArgsDict']]]]] = None,
+                 header_action: Optional[pulumi.Input[pulumi.InputType['URLMapHeaderActionArgs']]] = None,
+                 host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapHostRuleArgs']]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapPathMatcherArgs', 'URLMapPathMatcherArgsDict']]]]] = None,
+                 path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapPathMatcherArgs']]]]] = None,
                  project: Optional[pulumi.Input[str]] = None,
-                 tests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapTestArgs', 'URLMapTestArgsDict']]]]] = None,
+                 tests: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapTestArgs']]]]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
@@ -2062,7 +1830,6 @@ class URLMap(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = URLMapArgs.__new__(URLMapArgs)
 
-            __props__.__dict__["default_custom_error_response_policy"] = default_custom_error_response_policy
             __props__.__dict__["default_route_action"] = default_route_action
             __props__.__dict__["default_service"] = default_service
             __props__.__dict__["default_url_redirect"] = default_url_redirect
@@ -2088,20 +1855,19 @@ class URLMap(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
-            default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
-            default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
+            default_route_action: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultRouteActionArgs']]] = None,
             default_service: Optional[pulumi.Input[str]] = None,
-            default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
+            default_url_redirect: Optional[pulumi.Input[pulumi.InputType['URLMapDefaultUrlRedirectArgs']]] = None,
             description: Optional[pulumi.Input[str]] = None,
             fingerprint: Optional[pulumi.Input[str]] = None,
-            header_action: Optional[pulumi.Input[Union['URLMapHeaderActionArgs', 'URLMapHeaderActionArgsDict']]] = None,
-            host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapHostRuleArgs', 'URLMapHostRuleArgsDict']]]]] = None,
+            header_action: Optional[pulumi.Input[pulumi.InputType['URLMapHeaderActionArgs']]] = None,
+            host_rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapHostRuleArgs']]]]] = None,
             map_id: Optional[pulumi.Input[int]] = None,
             name: Optional[pulumi.Input[str]] = None,
-            path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapPathMatcherArgs', 'URLMapPathMatcherArgsDict']]]]] = None,
+            path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapPathMatcherArgs']]]]] = None,
             project: Optional[pulumi.Input[str]] = None,
             self_link: Optional[pulumi.Input[str]] = None,
-            tests: Optional[pulumi.Input[Sequence[pulumi.Input[Union['URLMapTestArgs', 'URLMapTestArgsDict']]]]] = None) -> 'URLMap':
+            tests: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapTestArgs']]]]] = None) -> 'URLMap':
         """
         Get an existing URLMap resource's state with the given name, id, and optional extra
         properties used to qualify the lookup.
@@ -2110,23 +1876,14 @@ class URLMap(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
-        :param pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
+        :param pulumi.Input[pulumi.InputType['URLMapDefaultRouteActionArgs']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
                is set, defaultRouteAction cannot contain any weightedBackendServices.
                Only one of defaultRouteAction or defaultUrlRedirect must be set.
                Structure is documented below.
         :param pulumi.Input[str] default_service: The backend service or backend bucket to use when none of the given rules match.
-        :param pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
+        :param pulumi.Input[pulumi.InputType['URLMapDefaultUrlRedirectArgs']] default_url_redirect: When none of the specified hostRules match, the request is redirected to a URL specified
                by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or
                defaultRouteAction must not be set.
                Structure is documented below.
@@ -2134,11 +1891,11 @@ class URLMap(pulumi.CustomResource):
                the resource.
         :param pulumi.Input[str] fingerprint: Fingerprint of this resource. A hash of the contents stored in this object. This
                field is used in optimistic locking.
-        :param pulumi.Input[Union['URLMapHeaderActionArgs', 'URLMapHeaderActionArgsDict']] header_action: Specifies changes to request and response headers that need to take effect for
+        :param pulumi.Input[pulumi.InputType['URLMapHeaderActionArgs']] header_action: Specifies changes to request and response headers that need to take effect for
                the selected backendService. The headerAction specified here take effect after
                headerAction specified under pathMatcher.
                Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapHostRuleArgs', 'URLMapHostRuleArgsDict']]]] host_rules: The list of HostRules to use against the URL.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapHostRuleArgs']]]] host_rules: The list of HostRules to use against the URL.
                Structure is documented below.
         :param pulumi.Input[int] map_id: The unique identifier for the resource.
         :param pulumi.Input[str] name: Name of the resource. Provided by the client when the resource is created. The
@@ -2150,12 +1907,12 @@ class URLMap(pulumi.CustomResource):
                
                
                - - -
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapPathMatcherArgs', 'URLMapPathMatcherArgsDict']]]] path_matchers: The list of named PathMatchers to use against the URL.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapPathMatcherArgs']]]] path_matchers: The list of named PathMatchers to use against the URL.
                Structure is documented below.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
         :param pulumi.Input[str] self_link: The URI of the created resource.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['URLMapTestArgs', 'URLMapTestArgsDict']]]] tests: The list of expected URL mapping tests. Request to update this UrlMap will
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['URLMapTestArgs']]]] tests: The list of expected URL mapping tests. Request to update this UrlMap will
                succeed only if all of the test cases pass. You can specify a maximum of 100
                tests per UrlMap.
                Structure is documented below.
@@ -2165,7 +1922,6 @@ class URLMap(pulumi.CustomResource):
         __props__ = _URLMapState.__new__(_URLMapState)
 
         __props__.__dict__["creation_timestamp"] = creation_timestamp
-        __props__.__dict__["default_custom_error_response_policy"] = default_custom_error_response_policy
         __props__.__dict__["default_route_action"] = default_route_action
         __props__.__dict__["default_service"] = default_service
         __props__.__dict__["default_url_redirect"] = default_url_redirect
@@ -2189,22 +1945,6 @@ class URLMap(pulumi.CustomResource):
         """
         return pulumi.get(self, "creation_timestamp")
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> pulumi.Output[Optional['outputs.URLMapDefaultCustomErrorResponsePolicy']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> pulumi.Output[Optional['outputs.URLMapDefaultRouteAction']]: