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

pulumi_gcp/compute/target_https_proxy.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
 
 __all__ = ['TargetHttpsProxyArgs', 'TargetHttpsProxy']
@@ -30,8 +25,7 @@ class TargetHttpsProxyArgs:
                  quic_override: Optional[pulumi.Input[str]] = None,
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None):
+                 ssl_policy: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a TargetHttpsProxy resource.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
@@ -87,11 +81,6 @@ class TargetHttpsProxyArgs:
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         """
         pulumi.set(__self__, "url_map", url_map)
         if certificate_manager_certificates is not None:
@@ -116,8 +105,6 @@ class TargetHttpsProxyArgs:
             pulumi.set(__self__, "ssl_certificates", ssl_certificates)
         if ssl_policy is not None:
             pulumi.set(__self__, "ssl_policy", ssl_policy)
-        if tls_early_data is not None:
-            pulumi.set(__self__, "tls_early_data", tls_early_data)
 
     @property
     @pulumi.getter(name="urlMap")
@@ -304,22 +291,6 @@ class TargetHttpsProxyArgs:
     def ssl_policy(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ssl_policy", value)
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> Optional[pulumi.Input[str]]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
-    @tls_early_data.setter
-    def tls_early_data(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "tls_early_data", value)
-
 
 @pulumi.input_type
 class _TargetHttpsProxyState:
@@ -338,7 +309,6 @@ class _TargetHttpsProxyState:
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering TargetHttpsProxy resources.
@@ -393,11 +363,6 @@ class _TargetHttpsProxyState:
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -432,8 +397,6 @@ class _TargetHttpsProxyState:
             pulumi.set(__self__, "ssl_certificates", ssl_certificates)
         if ssl_policy is not None:
             pulumi.set(__self__, "ssl_policy", ssl_policy)
-        if tls_early_data is not None:
-            pulumi.set(__self__, "tls_early_data", tls_early_data)
         if url_map is not None:
             pulumi.set(__self__, "url_map", url_map)
 
@@ -642,22 +605,6 @@ class _TargetHttpsProxyState:
     def ssl_policy(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ssl_policy", value)
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> Optional[pulumi.Input[str]]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
-    @tls_early_data.setter
-    def tls_early_data(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "tls_early_data", value)
-
     @property
     @pulumi.getter(name="urlMap")
     def url_map(self) -> Optional[pulumi.Input[str]]:
@@ -691,7 +638,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
@@ -732,18 +678,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-proxy",
             url_map=default_url_map.id,
@@ -776,18 +722,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-http-keep-alive-timeout-proxy",
             http_keep_alive_timeout_sec=610,
@@ -806,14 +752,14 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="my-trust-config",
             description="sample description for the trust config",
             location="global",
-            trust_stores=[{
-                "trustAnchors": [{
-                    "pemCertificate": std.file(input="test-fixtures/ca_cert.pem").result,
-                }],
-                "intermediateCas": [{
-                    "pemCertificate": std.file(input="test-fixtures/ca_cert.pem").result,
-                }],
-            }],
+            trust_stores=[gcp.certificatemanager.TrustConfigTrustStoreArgs(
+                trust_anchors=[gcp.certificatemanager.TrustConfigTrustStoreTrustAnchorArgs(
+                    pem_certificate=std.file(input="test-fixtures/ca_cert.pem").result,
+                )],
+                intermediate_cas=[gcp.certificatemanager.TrustConfigTrustStoreIntermediateCaArgs(
+                    pem_certificate=std.file(input="test-fixtures/ca_cert.pem").result,
+                )],
+            )],
             labels={
                 "foo": "bar",
             })
@@ -822,10 +768,10 @@ class TargetHttpsProxy(pulumi.CustomResource):
             description="my description",
             location="global",
             allow_open=False,
-            mtls_policy={
-                "clientValidationMode": "ALLOW_INVALID_OR_MISSING_CLIENT_CERT",
-                "clientValidationTrustConfig": default_trust_config.name.apply(lambda name: f"projects/{project.number}/locations/global/trustConfigs/{name}"),
-            })
+            mtls_policy=gcp.networksecurity.ServerTlsPolicyMtlsPolicyArgs(
+                client_validation_mode="ALLOW_INVALID_OR_MISSING_CLIENT_CERT",
+                client_validation_trust_config=default_trust_config.name.apply(lambda name: f"projects/{project.number}/locations/global/trustConfigs/{name}"),
+            ))
         default_ssl_certificate = gcp.compute.SSLCertificate("default",
             name="my-certificate",
             private_key=std.file(input="path/to/private.key").result,
@@ -845,18 +791,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-mtls-proxy",
             url_map=default_url_map.id,
@@ -873,10 +819,10 @@ class TargetHttpsProxy(pulumi.CustomResource):
         default_certificate = gcp.certificatemanager.Certificate("default",
             name="my-certificate",
             scope="ALL_REGIONS",
-            self_managed={
-                "pemCertificate": std.file(input="test-fixtures/cert.pem").result,
-                "pemPrivateKey": std.file(input="test-fixtures/private-key.pem").result,
-            })
+            self_managed=gcp.certificatemanager.CertificateSelfManagedArgs(
+                pem_certificate=std.file(input="test-fixtures/cert.pem").result,
+                pem_private_key=std.file(input="test-fixtures/private-key.pem").result,
+            ))
         default_backend_service = gcp.compute.BackendService("default",
             name="backend-service",
             port_name="http",
@@ -887,18 +833,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="target-http-proxy",
             url_map=default_url_map.id,
@@ -979,11 +925,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1034,18 +975,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-proxy",
             url_map=default_url_map.id,
@@ -1078,18 +1019,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-http-keep-alive-timeout-proxy",
             http_keep_alive_timeout_sec=610,
@@ -1108,14 +1049,14 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="my-trust-config",
             description="sample description for the trust config",
             location="global",
-            trust_stores=[{
-                "trustAnchors": [{
-                    "pemCertificate": std.file(input="test-fixtures/ca_cert.pem").result,
-                }],
-                "intermediateCas": [{
-                    "pemCertificate": std.file(input="test-fixtures/ca_cert.pem").result,
-                }],
-            }],
+            trust_stores=[gcp.certificatemanager.TrustConfigTrustStoreArgs(
+                trust_anchors=[gcp.certificatemanager.TrustConfigTrustStoreTrustAnchorArgs(
+                    pem_certificate=std.file(input="test-fixtures/ca_cert.pem").result,
+                )],
+                intermediate_cas=[gcp.certificatemanager.TrustConfigTrustStoreIntermediateCaArgs(
+                    pem_certificate=std.file(input="test-fixtures/ca_cert.pem").result,
+                )],
+            )],
             labels={
                 "foo": "bar",
             })
@@ -1124,10 +1065,10 @@ class TargetHttpsProxy(pulumi.CustomResource):
             description="my description",
             location="global",
             allow_open=False,
-            mtls_policy={
-                "clientValidationMode": "ALLOW_INVALID_OR_MISSING_CLIENT_CERT",
-                "clientValidationTrustConfig": default_trust_config.name.apply(lambda name: f"projects/{project.number}/locations/global/trustConfigs/{name}"),
-            })
+            mtls_policy=gcp.networksecurity.ServerTlsPolicyMtlsPolicyArgs(
+                client_validation_mode="ALLOW_INVALID_OR_MISSING_CLIENT_CERT",
+                client_validation_trust_config=default_trust_config.name.apply(lambda name: f"projects/{project.number}/locations/global/trustConfigs/{name}"),
+            ))
         default_ssl_certificate = gcp.compute.SSLCertificate("default",
             name="my-certificate",
             private_key=std.file(input="path/to/private.key").result,
@@ -1147,18 +1088,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="test-mtls-proxy",
             url_map=default_url_map.id,
@@ -1175,10 +1116,10 @@ class TargetHttpsProxy(pulumi.CustomResource):
         default_certificate = gcp.certificatemanager.Certificate("default",
             name="my-certificate",
             scope="ALL_REGIONS",
-            self_managed={
-                "pemCertificate": std.file(input="test-fixtures/cert.pem").result,
-                "pemPrivateKey": std.file(input="test-fixtures/private-key.pem").result,
-            })
+            self_managed=gcp.certificatemanager.CertificateSelfManagedArgs(
+                pem_certificate=std.file(input="test-fixtures/cert.pem").result,
+                pem_private_key=std.file(input="test-fixtures/private-key.pem").result,
+            ))
         default_backend_service = gcp.compute.BackendService("default",
             name="backend-service",
             port_name="http",
@@ -1189,18 +1130,18 @@ class TargetHttpsProxy(pulumi.CustomResource):
             name="url-map",
             description="a description",
             default_service=default_backend_service.id,
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "allpaths",
-            }],
-            path_matchers=[{
-                "name": "allpaths",
-                "defaultService": default_backend_service.id,
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": default_backend_service.id,
-                }],
-            }])
+            host_rules=[gcp.compute.URLMapHostRuleArgs(
+                hosts=["mysite.com"],
+                path_matcher="allpaths",
+            )],
+            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
+                name="allpaths",
+                default_service=default_backend_service.id,
+                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
+                    paths=["/*"],
+                    service=default_backend_service.id,
+                )],
+            )])
         default = gcp.compute.TargetHttpsProxy("default",
             name="target-http-proxy",
             url_map=default_url_map.id,
@@ -1257,7 +1198,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -1279,7 +1219,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
             __props__.__dict__["server_tls_policy"] = server_tls_policy
             __props__.__dict__["ssl_certificates"] = ssl_certificates
             __props__.__dict__["ssl_policy"] = ssl_policy
-            __props__.__dict__["tls_early_data"] = tls_early_data
             if url_map is None and not opts.urn:
                 raise TypeError("Missing required property 'url_map'")
             __props__.__dict__["url_map"] = url_map
@@ -1310,7 +1249,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
             server_tls_policy: Optional[pulumi.Input[str]] = None,
             ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             ssl_policy: Optional[pulumi.Input[str]] = None,
-            tls_early_data: Optional[pulumi.Input[str]] = None,
             url_map: Optional[pulumi.Input[str]] = None) -> 'TargetHttpsProxy':
         """
         Get an existing TargetHttpsProxy resource's state with the given name, id, and optional extra
@@ -1370,11 +1308,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1399,7 +1332,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         __props__.__dict__["server_tls_policy"] = server_tls_policy
         __props__.__dict__["ssl_certificates"] = ssl_certificates
         __props__.__dict__["ssl_policy"] = ssl_policy
-        __props__.__dict__["tls_early_data"] = tls_early_data
         __props__.__dict__["url_map"] = url_map
         return TargetHttpsProxy(resource_name, opts=opts, __props__=__props__)
 
@@ -1552,18 +1484,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         """
         return pulumi.get(self, "ssl_policy")
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> pulumi.Output[str]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
     @property
     @pulumi.getter(name="urlMap")
     def url_map(self) -> pulumi.Output[str]: