pulumi-aws 7.11.0__py3-none-any.whl → 7.11.0a1761834890__py3-none-any.whl

pulumi_aws/lb/_inputs.py

@@ -63,16 +63,6 @@ __all__ = [
     'ListenerRuleConditionQueryStringArgsDict',
     'ListenerRuleConditionSourceIpArgs',
     'ListenerRuleConditionSourceIpArgsDict',
-    'ListenerRuleTransformArgs',
-    'ListenerRuleTransformArgsDict',
-    'ListenerRuleTransformHostHeaderRewriteConfigArgs',
-    'ListenerRuleTransformHostHeaderRewriteConfigArgsDict',
-    'ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs',
-    'ListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict',
-    'ListenerRuleTransformUrlRewriteConfigArgs',
-    'ListenerRuleTransformUrlRewriteConfigArgsDict',
-    'ListenerRuleTransformUrlRewriteConfigRewriteArgs',
-    'ListenerRuleTransformUrlRewriteConfigRewriteArgsDict',
     'LoadBalancerAccessLogsArgs',
     'LoadBalancerAccessLogsArgsDict',
     'LoadBalancerConnectionLogsArgs',
@@ -129,16 +119,6 @@ __all__ = [
     'GetListenerRuleConditionQueryStringValueArgsDict',
     'GetListenerRuleConditionSourceIpArgs',
     'GetListenerRuleConditionSourceIpArgsDict',
-    'GetListenerRuleTransformArgs',
-    'GetListenerRuleTransformArgsDict',
-    'GetListenerRuleTransformHostHeaderRewriteConfigArgs',
-    'GetListenerRuleTransformHostHeaderRewriteConfigArgsDict',
-    'GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs',
-    'GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict',
-    'GetListenerRuleTransformUrlRewriteConfigArgs',
-    'GetListenerRuleTransformUrlRewriteConfigArgsDict',
-    'GetListenerRuleTransformUrlRewriteConfigRewriteArgs',
-    'GetListenerRuleTransformUrlRewriteConfigRewriteArgsDict',
 ]
 
 MYPY = False
@@ -2155,7 +2135,7 @@ if not MYPY:
     class ListenerRuleConditionArgsDict(TypedDict):
         host_header: NotRequired[pulumi.Input['ListenerRuleConditionHostHeaderArgsDict']]
         """
-        Host header patterns to match. Host Header block fields documented below.
+        Contains a single `values` item which is a list of host header patterns to match. The maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied.
         """
         http_header: NotRequired[pulumi.Input['ListenerRuleConditionHttpHeaderArgsDict']]
         """
@@ -2167,7 +2147,7 @@ if not MYPY:
         """
         path_pattern: NotRequired[pulumi.Input['ListenerRuleConditionPathPatternArgsDict']]
         """
-        Path patterns to match against the request URL. Path Pattern block fields documented below.
+        Contains a single `values` item which is a list of path patterns to match against the request URL. Maximum size of each pattern is 128 characters. Comparison is case sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition.
         """
         query_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input['ListenerRuleConditionQueryStringArgsDict']]]]
         """
@@ -2192,10 +2172,10 @@ class ListenerRuleConditionArgs:
                  query_strings: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleConditionQueryStringArgs']]]] = None,
                  source_ip: Optional[pulumi.Input['ListenerRuleConditionSourceIpArgs']] = None):
         """
-        :param pulumi.Input['ListenerRuleConditionHostHeaderArgs'] host_header: Host header patterns to match. Host Header block fields documented below.
+        :param pulumi.Input['ListenerRuleConditionHostHeaderArgs'] host_header: Contains a single `values` item which is a list of host header patterns to match. The maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied.
         :param pulumi.Input['ListenerRuleConditionHttpHeaderArgs'] http_header: HTTP headers to match. HTTP Header block fields documented below.
         :param pulumi.Input['ListenerRuleConditionHttpRequestMethodArgs'] http_request_method: Contains a single `values` item which is a list of HTTP request methods or verbs to match. Maximum size is 40 characters. Only allowed characters are A-Z, hyphen (-) and underscore (\\_). Comparison is case sensitive. Wildcards are not supported. Only one needs to match for the condition to be satisfied. AWS recommends that GET and HEAD requests are routed in the same way because the response to a HEAD request may be cached.
-        :param pulumi.Input['ListenerRuleConditionPathPatternArgs'] path_pattern: Path patterns to match against the request URL. Path Pattern block fields documented below.
+        :param pulumi.Input['ListenerRuleConditionPathPatternArgs'] path_pattern: Contains a single `values` item which is a list of path patterns to match against the request URL. Maximum size of each pattern is 128 characters. Comparison is case sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition.
         :param pulumi.Input[Sequence[pulumi.Input['ListenerRuleConditionQueryStringArgs']]] query_strings: Query strings to match. Query String block fields documented below.
         :param pulumi.Input['ListenerRuleConditionSourceIpArgs'] source_ip: Contains a single `values` item which is a list of source IP CIDR notations to match. You can use both IPv4 and IPv6 addresses. Wildcards are not supported. Condition is satisfied if the source IP address of the request matches one of the CIDR blocks. Condition is not satisfied by the addresses in the `X-Forwarded-For` header, use `http_header` condition instead.
                
@@ -2218,7 +2198,7 @@ class ListenerRuleConditionArgs:
     @pulumi.getter(name="hostHeader")
     def host_header(self) -> Optional[pulumi.Input['ListenerRuleConditionHostHeaderArgs']]:
         """
-        Host header patterns to match. Host Header block fields documented below.
+        Contains a single `values` item which is a list of host header patterns to match. The maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied.
         """
         return pulumi.get(self, "host_header")
 
@@ -2254,7 +2234,7 @@ class ListenerRuleConditionArgs:
     @pulumi.getter(name="pathPattern")
     def path_pattern(self) -> Optional[pulumi.Input['ListenerRuleConditionPathPatternArgs']]:
         """
-        Path patterns to match against the request URL. Path Pattern block fields documented below.
+        Contains a single `values` item which is a list of path patterns to match against the request URL. Maximum size of each pattern is 128 characters. Comparison is case sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition.
         """
         return pulumi.get(self, "path_pattern")
 
@@ -2291,53 +2271,23 @@ class ListenerRuleConditionArgs:
 
 if not MYPY:
     class ListenerRuleConditionHostHeaderArgsDict(TypedDict):
-        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        List of regular expressions to compare against the host header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        List of host header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Conflicts with `regex_values`.
-        """
+        values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
 elif False:
     ListenerRuleConditionHostHeaderArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ListenerRuleConditionHostHeaderArgs:
     def __init__(__self__, *,
-                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
-                 values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regex_values: List of regular expressions to compare against the host header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: List of host header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Conflicts with `regex_values`.
-        """
-        if regex_values is not None:
-            pulumi.set(__self__, "regex_values", regex_values)
-        if values is not None:
-            pulumi.set(__self__, "values", values)
-
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        List of regular expressions to compare against the host header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "regex_values", value)
+                 values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(__self__, "values", values)
 
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        List of host header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Conflicts with `regex_values`.
-        """
+    def values(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         return pulumi.get(self, "values")
 
     @values.setter
-    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+    def values(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
         pulumi.set(self, "values", value)
 
 
@@ -2345,15 +2295,11 @@ if not MYPY:
     class ListenerRuleConditionHttpHeaderArgsDict(TypedDict):
         http_header_name: pulumi.Input[_builtins.str]
         """
-        Name of HTTP header to search. The maximum size is 40 characters. Comparison is case-insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
-        """
-        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        Name of HTTP header to search. The maximum size is 40 characters. Comparison is case insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
         """
-        List of regular expression to compare against the HTTP header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
         """
-        List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string. Conflicts with `regex_values`.
+        List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string.
         """
 elif False:
     ListenerRuleConditionHttpHeaderArgsDict: TypeAlias = Mapping[str, Any]
@@ -2362,24 +2308,19 @@ elif False:
 class ListenerRuleConditionHttpHeaderArgs:
     def __init__(__self__, *,
                  http_header_name: pulumi.Input[_builtins.str],
-                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
-                 values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+                 values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
         """
-        :param pulumi.Input[_builtins.str] http_header_name: Name of HTTP header to search. The maximum size is 40 characters. Comparison is case-insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regex_values: List of regular expression to compare against the HTTP header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string. Conflicts with `regex_values`.
+        :param pulumi.Input[_builtins.str] http_header_name: Name of HTTP header to search. The maximum size is 40 characters. Comparison is case insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string.
         """
         pulumi.set(__self__, "http_header_name", http_header_name)
-        if regex_values is not None:
-            pulumi.set(__self__, "regex_values", regex_values)
-        if values is not None:
-            pulumi.set(__self__, "values", values)
+        pulumi.set(__self__, "values", values)
 
     @_builtins.property
     @pulumi.getter(name="httpHeaderName")
     def http_header_name(self) -> pulumi.Input[_builtins.str]:
         """
-        Name of HTTP header to search. The maximum size is 40 characters. Comparison is case-insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
+        Name of HTTP header to search. The maximum size is 40 characters. Comparison is case insensitive. Only RFC7240 characters are supported. Wildcards are not supported. You cannot use HTTP header condition to specify the host header, use a `host-header` condition instead.
         """
         return pulumi.get(self, "http_header_name")
 
@@ -2387,28 +2328,16 @@ class ListenerRuleConditionHttpHeaderArgs:
     def http_header_name(self, value: pulumi.Input[_builtins.str]):
         pulumi.set(self, "http_header_name", value)
 
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        List of regular expression to compare against the HTTP header. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "regex_values", value)
-
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+    def values(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         """
-        List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case-insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string. Conflicts with `regex_values`.
+        List of header value patterns to match. Maximum size of each pattern is 128 characters. Comparison is case insensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). If the same header appears multiple times in the request they will be searched in order until a match is found. Only one pattern needs to match for the condition to be satisfied. To require that all of the strings are a match, create one condition block per string.
         """
         return pulumi.get(self, "values")
 
     @values.setter
-    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+    def values(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
         pulumi.set(self, "values", value)
 
 
@@ -2436,53 +2365,23 @@ class ListenerRuleConditionHttpRequestMethodArgs:
 
 if not MYPY:
     class ListenerRuleConditionPathPatternArgsDict(TypedDict):
-        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        List of regular expressions to compare against the request URL. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
-        """
-        List of path patterns to compare against the request URL. Maximum size of each pattern is 128 characters. Comparison is case-sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition. Conflicts with `regex_values`.
-        """
+        values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
 elif False:
     ListenerRuleConditionPathPatternArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ListenerRuleConditionPathPatternArgs:
     def __init__(__self__, *,
-                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
-                 values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regex_values: List of regular expressions to compare against the request URL. The maximum length of each string is 128 characters. Conflicts with `values`.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: List of path patterns to compare against the request URL. Maximum size of each pattern is 128 characters. Comparison is case-sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition. Conflicts with `regex_values`.
-        """
-        if regex_values is not None:
-            pulumi.set(__self__, "regex_values", regex_values)
-        if values is not None:
-            pulumi.set(__self__, "values", values)
-
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        List of regular expressions to compare against the request URL. The maximum length of each string is 128 characters. Conflicts with `values`.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
-        pulumi.set(self, "regex_values", value)
+                 values: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
+        pulumi.set(__self__, "values", values)
 
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
-        """
-        List of path patterns to compare against the request URL. Maximum size of each pattern is 128 characters. Comparison is case-sensitive. Wildcard characters supported: * (matches 0 or more characters) and ? (matches exactly 1 character). Only one pattern needs to match for the condition to be satisfied. Path pattern is compared only to the path of the URL, not to its query string. To compare against the query string, use a `query_string` condition. Conflicts with `regex_values`.
-        """
+    def values(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
         return pulumi.get(self, "values")
 
     @values.setter
-    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+    def values(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
         pulumi.set(self, "values", value)
 
 
@@ -2559,241 +2458,6 @@ class ListenerRuleConditionSourceIpArgs:
         pulumi.set(self, "values", value)
 
 
-if not MYPY:
-    class ListenerRuleTransformArgsDict(TypedDict):
-        type: pulumi.Input[_builtins.str]
-        """
-        Type of transform. Valid values are `host-header-rewrite` and `url-rewrite`.
-        """
-        host_header_rewrite_config: NotRequired[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigArgsDict']]
-        """
-        Configuration block for host header rewrite. Required if `type` is `host-header-rewrite`. See Host Header Rewrite Config Blocks below.
-        """
-        url_rewrite_config: NotRequired[pulumi.Input['ListenerRuleTransformUrlRewriteConfigArgsDict']]
-        """
-        Configuration block for URL rewrite. Required if `type` is `url-rewrite`. See URL Rewrite Config Blocks below.
-        """
-elif False:
-    ListenerRuleTransformArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ListenerRuleTransformArgs:
-    def __init__(__self__, *,
-                 type: pulumi.Input[_builtins.str],
-                 host_header_rewrite_config: Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigArgs']] = None,
-                 url_rewrite_config: Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigArgs']] = None):
-        """
-        :param pulumi.Input[_builtins.str] type: Type of transform. Valid values are `host-header-rewrite` and `url-rewrite`.
-        :param pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigArgs'] host_header_rewrite_config: Configuration block for host header rewrite. Required if `type` is `host-header-rewrite`. See Host Header Rewrite Config Blocks below.
-        :param pulumi.Input['ListenerRuleTransformUrlRewriteConfigArgs'] url_rewrite_config: Configuration block for URL rewrite. Required if `type` is `url-rewrite`. See URL Rewrite Config Blocks below.
-        """
-        pulumi.set(__self__, "type", type)
-        if host_header_rewrite_config is not None:
-            pulumi.set(__self__, "host_header_rewrite_config", host_header_rewrite_config)
-        if url_rewrite_config is not None:
-            pulumi.set(__self__, "url_rewrite_config", url_rewrite_config)
-
-    @_builtins.property
-    @pulumi.getter
-    def type(self) -> pulumi.Input[_builtins.str]:
-        """
-        Type of transform. Valid values are `host-header-rewrite` and `url-rewrite`.
-        """
-        return pulumi.get(self, "type")
-
-    @type.setter
-    def type(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "type", value)
-
-    @_builtins.property
-    @pulumi.getter(name="hostHeaderRewriteConfig")
-    def host_header_rewrite_config(self) -> Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigArgs']]:
-        """
-        Configuration block for host header rewrite. Required if `type` is `host-header-rewrite`. See Host Header Rewrite Config Blocks below.
-        """
-        return pulumi.get(self, "host_header_rewrite_config")
-
-    @host_header_rewrite_config.setter
-    def host_header_rewrite_config(self, value: Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigArgs']]):
-        pulumi.set(self, "host_header_rewrite_config", value)
-
-    @_builtins.property
-    @pulumi.getter(name="urlRewriteConfig")
-    def url_rewrite_config(self) -> Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigArgs']]:
-        """
-        Configuration block for URL rewrite. Required if `type` is `url-rewrite`. See URL Rewrite Config Blocks below.
-        """
-        return pulumi.get(self, "url_rewrite_config")
-
-    @url_rewrite_config.setter
-    def url_rewrite_config(self, value: Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigArgs']]):
-        pulumi.set(self, "url_rewrite_config", value)
-
-
-if not MYPY:
-    class ListenerRuleTransformHostHeaderRewriteConfigArgsDict(TypedDict):
-        rewrite: NotRequired[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict']]
-        """
-        Block for host header rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-elif False:
-    ListenerRuleTransformHostHeaderRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ListenerRuleTransformHostHeaderRewriteConfigArgs:
-    def __init__(__self__, *,
-                 rewrite: Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']] = None):
-        """
-        :param pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs'] rewrite: Block for host header rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        if rewrite is not None:
-            pulumi.set(__self__, "rewrite", rewrite)
-
-    @_builtins.property
-    @pulumi.getter
-    def rewrite(self) -> Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']]:
-        """
-        Block for host header rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        return pulumi.get(self, "rewrite")
-
-    @rewrite.setter
-    def rewrite(self, value: Optional[pulumi.Input['ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']]):
-        pulumi.set(self, "rewrite", value)
-
-
-if not MYPY:
-    class ListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict(TypedDict):
-        regex: pulumi.Input[_builtins.str]
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        replace: pulumi.Input[_builtins.str]
-        """
-        Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-elif False:
-    ListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ListenerRuleTransformHostHeaderRewriteConfigRewriteArgs:
-    def __init__(__self__, *,
-                 regex: pulumi.Input[_builtins.str],
-                 replace: pulumi.Input[_builtins.str]):
-        """
-        :param pulumi.Input[_builtins.str] regex: Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        :param pulumi.Input[_builtins.str] replace: Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-        pulumi.set(__self__, "regex", regex)
-        pulumi.set(__self__, "replace", replace)
-
-    @_builtins.property
-    @pulumi.getter
-    def regex(self) -> pulumi.Input[_builtins.str]:
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        return pulumi.get(self, "regex")
-
-    @regex.setter
-    def regex(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "regex", value)
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> pulumi.Input[_builtins.str]:
-        """
-        Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-        return pulumi.get(self, "replace")
-
-    @replace.setter
-    def replace(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "replace", value)
-
-
-if not MYPY:
-    class ListenerRuleTransformUrlRewriteConfigArgsDict(TypedDict):
-        rewrite: NotRequired[pulumi.Input['ListenerRuleTransformUrlRewriteConfigRewriteArgsDict']]
-        """
-        Block for URL rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-elif False:
-    ListenerRuleTransformUrlRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ListenerRuleTransformUrlRewriteConfigArgs:
-    def __init__(__self__, *,
-                 rewrite: Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigRewriteArgs']] = None):
-        """
-        :param pulumi.Input['ListenerRuleTransformUrlRewriteConfigRewriteArgs'] rewrite: Block for URL rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        if rewrite is not None:
-            pulumi.set(__self__, "rewrite", rewrite)
-
-    @_builtins.property
-    @pulumi.getter
-    def rewrite(self) -> Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigRewriteArgs']]:
-        """
-        Block for URL rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        return pulumi.get(self, "rewrite")
-
-    @rewrite.setter
-    def rewrite(self, value: Optional[pulumi.Input['ListenerRuleTransformUrlRewriteConfigRewriteArgs']]):
-        pulumi.set(self, "rewrite", value)
-
-
-if not MYPY:
-    class ListenerRuleTransformUrlRewriteConfigRewriteArgsDict(TypedDict):
-        regex: pulumi.Input[_builtins.str]
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        replace: pulumi.Input[_builtins.str]
-        """
-        Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-elif False:
-    ListenerRuleTransformUrlRewriteConfigRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ListenerRuleTransformUrlRewriteConfigRewriteArgs:
-    def __init__(__self__, *,
-                 regex: pulumi.Input[_builtins.str],
-                 replace: pulumi.Input[_builtins.str]):
-        """
-        :param pulumi.Input[_builtins.str] regex: Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        :param pulumi.Input[_builtins.str] replace: Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-        pulumi.set(__self__, "regex", regex)
-        pulumi.set(__self__, "replace", replace)
-
-    @_builtins.property
-    @pulumi.getter
-    def regex(self) -> pulumi.Input[_builtins.str]:
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        return pulumi.get(self, "regex")
-
-    @regex.setter
-    def regex(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "regex", value)
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> pulumi.Input[_builtins.str]:
-        """
-        Replacement string to use when rewriting the matched input. Capture groups in the regular expression (for example, `$1` and `$2`) can be specified. Length constraints: Between 0 and 1024 characters.
-        """
-        return pulumi.get(self, "replace")
-
-    @replace.setter
-    def replace(self, value: pulumi.Input[_builtins.str]):
-        pulumi.set(self, "replace", value)
-
-
 if not MYPY:
     class LoadBalancerAccessLogsArgsDict(TypedDict):
         bucket: pulumi.Input[_builtins.str]
@@ -3692,7 +3356,7 @@ if not MYPY:
         """
         type: _builtins.str
         """
-        Type of transform.
+        The type of the action, indicates which sub-block will be populated.
         """
         authenticate_cognitos: NotRequired[Sequence['GetListenerRuleActionAuthenticateCognitoArgsDict']]
         """
@@ -3734,7 +3398,7 @@ class GetListenerRuleActionArgs:
                  redirects: Optional[Sequence['GetListenerRuleActionRedirectArgs']] = None):
         """
         :param _builtins.int order: The evaluation order of the action.
-        :param _builtins.str type: Type of transform.
+        :param _builtins.str type: The type of the action, indicates which sub-block will be populated.
         :param Sequence['GetListenerRuleActionAuthenticateCognitoArgs'] authenticate_cognitos: An action to authenticate using Amazon Cognito.
                Detailed below.
         :param Sequence['GetListenerRuleActionAuthenticateOidcArgs'] authenticate_oidcs: An action to authenticate using OIDC.
@@ -3775,7 +3439,7 @@ class GetListenerRuleActionArgs:
     @pulumi.getter
     def type(self) -> _builtins.str:
         """
-        Type of transform.
+        The type of the action, indicates which sub-block will be populated.
         """
         return pulumi.get(self, "type")
 
@@ -4581,8 +4245,7 @@ if not MYPY:
     class GetListenerRuleConditionArgsDict(TypedDict):
         host_headers: NotRequired[Sequence['GetListenerRuleConditionHostHeaderArgsDict']]
         """
-        Host header patterns to match.
-        Detailed below.
+        Contains a single attribute `values`, which contains a set of host names.
         """
         http_headers: NotRequired[Sequence['GetListenerRuleConditionHttpHeaderArgsDict']]
         """
@@ -4595,8 +4258,7 @@ if not MYPY:
         """
         path_patterns: NotRequired[Sequence['GetListenerRuleConditionPathPatternArgsDict']]
         """
-        Path patterns to compare against the request URL.
-        Detailed below.
+        Contains a single attribute `values`, which contains a set of path patterns to compare against the request URL.
         """
         query_strings: NotRequired[Sequence['GetListenerRuleConditionQueryStringArgsDict']]
         """
@@ -4620,13 +4282,11 @@ class GetListenerRuleConditionArgs:
                  query_strings: Optional[Sequence['GetListenerRuleConditionQueryStringArgs']] = None,
                  source_ips: Optional[Sequence['GetListenerRuleConditionSourceIpArgs']] = None):
         """
-        :param Sequence['GetListenerRuleConditionHostHeaderArgs'] host_headers: Host header patterns to match.
-               Detailed below.
+        :param Sequence['GetListenerRuleConditionHostHeaderArgs'] host_headers: Contains a single attribute `values`, which contains a set of host names.
         :param Sequence['GetListenerRuleConditionHttpHeaderArgs'] http_headers: HTTP header and values to match.
                Detailed below.
         :param Sequence['GetListenerRuleConditionHttpRequestMethodArgs'] http_request_methods: Contains a single attribute `values`, which contains a set of HTTP request methods.
-        :param Sequence['GetListenerRuleConditionPathPatternArgs'] path_patterns: Path patterns to compare against the request URL.
-               Detailed below.
+        :param Sequence['GetListenerRuleConditionPathPatternArgs'] path_patterns: Contains a single attribute `values`, which contains a set of path patterns to compare against the request URL.
         :param Sequence['GetListenerRuleConditionQueryStringArgs'] query_strings: Query string parameters to match.
                Detailed below.
         :param Sequence['GetListenerRuleConditionSourceIpArgs'] source_ips: Contains a single attribute `values`, which contains a set of source IPs in CIDR notation.
@@ -4648,8 +4308,7 @@ class GetListenerRuleConditionArgs:
     @pulumi.getter(name="hostHeaders")
     def host_headers(self) -> Optional[Sequence['GetListenerRuleConditionHostHeaderArgs']]:
         """
-        Host header patterns to match.
-        Detailed below.
+        Contains a single attribute `values`, which contains a set of host names.
         """
         return pulumi.get(self, "host_headers")
 
@@ -4686,8 +4345,7 @@ class GetListenerRuleConditionArgs:
     @pulumi.getter(name="pathPatterns")
     def path_patterns(self) -> Optional[Sequence['GetListenerRuleConditionPathPatternArgs']]:
         """
-        Path patterns to compare against the request URL.
-        Detailed below.
+        Contains a single attribute `values`, which contains a set of path patterns to compare against the request URL.
         """
         return pulumi.get(self, "path_patterns")
 
@@ -4723,10 +4381,6 @@ class GetListenerRuleConditionArgs:
 
 if not MYPY:
     class GetListenerRuleConditionHostHeaderArgsDict(TypedDict):
-        regex_values: Sequence[_builtins.str]
-        """
-        Set of regular expressions to compare against the request URL.
-        """
         values: Sequence[_builtins.str]
         """
         Set of `key`-`value` pairs indicating the query string parameters to match.
@@ -4737,27 +4391,12 @@ elif False:
 @pulumi.input_type
 class GetListenerRuleConditionHostHeaderArgs:
     def __init__(__self__, *,
-                 regex_values: Sequence[_builtins.str],
                  values: Sequence[_builtins.str]):
         """
-        :param Sequence[_builtins.str] regex_values: Set of regular expressions to compare against the request URL.
         :param Sequence[_builtins.str] values: Set of `key`-`value` pairs indicating the query string parameters to match.
         """
-        pulumi.set(__self__, "regex_values", regex_values)
         pulumi.set(__self__, "values", values)
 
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Sequence[_builtins.str]:
-        """
-        Set of regular expressions to compare against the request URL.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Sequence[_builtins.str]):
-        pulumi.set(self, "regex_values", value)
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -4777,10 +4416,6 @@ if not MYPY:
         """
         Name of the HTTP header to match.
         """
-        regex_values: Sequence[_builtins.str]
-        """
-        Set of regular expressions to compare against the request URL.
-        """
         values: Sequence[_builtins.str]
         """
         Set of `key`-`value` pairs indicating the query string parameters to match.
@@ -4792,15 +4427,12 @@ elif False:
 class GetListenerRuleConditionHttpHeaderArgs:
     def __init__(__self__, *,
                  http_header_name: _builtins.str,
-                 regex_values: Sequence[_builtins.str],
                  values: Sequence[_builtins.str]):
         """
         :param _builtins.str http_header_name: Name of the HTTP header to match.
-        :param Sequence[_builtins.str] regex_values: Set of regular expressions to compare against the request URL.
         :param Sequence[_builtins.str] values: Set of `key`-`value` pairs indicating the query string parameters to match.
         """
         pulumi.set(__self__, "http_header_name", http_header_name)
-        pulumi.set(__self__, "regex_values", regex_values)
         pulumi.set(__self__, "values", values)
 
     @_builtins.property
@@ -4815,18 +4447,6 @@ class GetListenerRuleConditionHttpHeaderArgs:
     def http_header_name(self, value: _builtins.str):
         pulumi.set(self, "http_header_name", value)
 
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Sequence[_builtins.str]:
-        """
-        Set of regular expressions to compare against the request URL.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Sequence[_builtins.str]):
-        pulumi.set(self, "regex_values", value)
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -4873,10 +4493,6 @@ class GetListenerRuleConditionHttpRequestMethodArgs:
 
 if not MYPY:
     class GetListenerRuleConditionPathPatternArgsDict(TypedDict):
-        regex_values: Sequence[_builtins.str]
-        """
-        Set of regular expressions to compare against the request URL.
-        """
         values: Sequence[_builtins.str]
         """
         Set of `key`-`value` pairs indicating the query string parameters to match.
@@ -4887,27 +4503,12 @@ elif False:
 @pulumi.input_type
 class GetListenerRuleConditionPathPatternArgs:
     def __init__(__self__, *,
-                 regex_values: Sequence[_builtins.str],
                  values: Sequence[_builtins.str]):
         """
-        :param Sequence[_builtins.str] regex_values: Set of regular expressions to compare against the request URL.
         :param Sequence[_builtins.str] values: Set of `key`-`value` pairs indicating the query string parameters to match.
         """
-        pulumi.set(__self__, "regex_values", regex_values)
         pulumi.set(__self__, "values", values)
 
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Sequence[_builtins.str]:
-        """
-        Set of regular expressions to compare against the request URL.
-        """
-        return pulumi.get(self, "regex_values")
-
-    @regex_values.setter
-    def regex_values(self, value: Sequence[_builtins.str]):
-        pulumi.set(self, "regex_values", value)
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -5034,238 +4635,3 @@ class GetListenerRuleConditionSourceIpArgs:
         pulumi.set(self, "values", value)
 
 
-if not MYPY:
-    class GetListenerRuleTransformArgsDict(TypedDict):
-        type: _builtins.str
-        """
-        Type of transform.
-        """
-        host_header_rewrite_configs: NotRequired[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigArgsDict']]
-        """
-        Block for host header rewrite. Detailed below.
-        """
-        url_rewrite_configs: NotRequired[Sequence['GetListenerRuleTransformUrlRewriteConfigArgsDict']]
-        """
-        Block for URL rewrite. Detailed below.
-        """
-elif False:
-    GetListenerRuleTransformArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class GetListenerRuleTransformArgs:
-    def __init__(__self__, *,
-                 type: _builtins.str,
-                 host_header_rewrite_configs: Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigArgs']] = None,
-                 url_rewrite_configs: Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigArgs']] = None):
-        """
-        :param _builtins.str type: Type of transform.
-        :param Sequence['GetListenerRuleTransformHostHeaderRewriteConfigArgs'] host_header_rewrite_configs: Block for host header rewrite. Detailed below.
-        :param Sequence['GetListenerRuleTransformUrlRewriteConfigArgs'] url_rewrite_configs: Block for URL rewrite. Detailed below.
-        """
-        pulumi.set(__self__, "type", type)
-        if host_header_rewrite_configs is not None:
-            pulumi.set(__self__, "host_header_rewrite_configs", host_header_rewrite_configs)
-        if url_rewrite_configs is not None:
-            pulumi.set(__self__, "url_rewrite_configs", url_rewrite_configs)
-
-    @_builtins.property
-    @pulumi.getter
-    def type(self) -> _builtins.str:
-        """
-        Type of transform.
-        """
-        return pulumi.get(self, "type")
-
-    @type.setter
-    def type(self, value: _builtins.str):
-        pulumi.set(self, "type", value)
-
-    @_builtins.property
-    @pulumi.getter(name="hostHeaderRewriteConfigs")
-    def host_header_rewrite_configs(self) -> Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigArgs']]:
-        """
-        Block for host header rewrite. Detailed below.
-        """
-        return pulumi.get(self, "host_header_rewrite_configs")
-
-    @host_header_rewrite_configs.setter
-    def host_header_rewrite_configs(self, value: Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigArgs']]):
-        pulumi.set(self, "host_header_rewrite_configs", value)
-
-    @_builtins.property
-    @pulumi.getter(name="urlRewriteConfigs")
-    def url_rewrite_configs(self) -> Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigArgs']]:
-        """
-        Block for URL rewrite. Detailed below.
-        """
-        return pulumi.get(self, "url_rewrite_configs")
-
-    @url_rewrite_configs.setter
-    def url_rewrite_configs(self, value: Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigArgs']]):
-        pulumi.set(self, "url_rewrite_configs", value)
-
-
-if not MYPY:
-    class GetListenerRuleTransformHostHeaderRewriteConfigArgsDict(TypedDict):
-        rewrites: NotRequired[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict']]
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-elif False:
-    GetListenerRuleTransformHostHeaderRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class GetListenerRuleTransformHostHeaderRewriteConfigArgs:
-    def __init__(__self__, *,
-                 rewrites: Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']] = None):
-        """
-        :param Sequence['GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs'] rewrites: Block for URL rewrite configuration. Detailed below.
-        """
-        if rewrites is not None:
-            pulumi.set(__self__, "rewrites", rewrites)
-
-    @_builtins.property
-    @pulumi.getter
-    def rewrites(self) -> Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']]:
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-        return pulumi.get(self, "rewrites")
-
-    @rewrites.setter
-    def rewrites(self, value: Optional[Sequence['GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs']]):
-        pulumi.set(self, "rewrites", value)
-
-
-if not MYPY:
-    class GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict(TypedDict):
-        regex: _builtins.str
-        """
-        Regular expression to match in the input string.
-        """
-        replace: _builtins.str
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-elif False:
-    GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class GetListenerRuleTransformHostHeaderRewriteConfigRewriteArgs:
-    def __init__(__self__, *,
-                 regex: _builtins.str,
-                 replace: _builtins.str):
-        """
-        :param _builtins.str regex: Regular expression to match in the input string.
-        :param _builtins.str replace: Replacement string to use when rewriting the matched input.
-        """
-        pulumi.set(__self__, "regex", regex)
-        pulumi.set(__self__, "replace", replace)
-
-    @_builtins.property
-    @pulumi.getter
-    def regex(self) -> _builtins.str:
-        """
-        Regular expression to match in the input string.
-        """
-        return pulumi.get(self, "regex")
-
-    @regex.setter
-    def regex(self, value: _builtins.str):
-        pulumi.set(self, "regex", value)
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _builtins.str:
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-        return pulumi.get(self, "replace")
-
-    @replace.setter
-    def replace(self, value: _builtins.str):
-        pulumi.set(self, "replace", value)
-
-
-if not MYPY:
-    class GetListenerRuleTransformUrlRewriteConfigArgsDict(TypedDict):
-        rewrites: NotRequired[Sequence['GetListenerRuleTransformUrlRewriteConfigRewriteArgsDict']]
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-elif False:
-    GetListenerRuleTransformUrlRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class GetListenerRuleTransformUrlRewriteConfigArgs:
-    def __init__(__self__, *,
-                 rewrites: Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigRewriteArgs']] = None):
-        """
-        :param Sequence['GetListenerRuleTransformUrlRewriteConfigRewriteArgs'] rewrites: Block for URL rewrite configuration. Detailed below.
-        """
-        if rewrites is not None:
-            pulumi.set(__self__, "rewrites", rewrites)
-
-    @_builtins.property
-    @pulumi.getter
-    def rewrites(self) -> Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigRewriteArgs']]:
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-        return pulumi.get(self, "rewrites")
-
-    @rewrites.setter
-    def rewrites(self, value: Optional[Sequence['GetListenerRuleTransformUrlRewriteConfigRewriteArgs']]):
-        pulumi.set(self, "rewrites", value)
-
-
-if not MYPY:
-    class GetListenerRuleTransformUrlRewriteConfigRewriteArgsDict(TypedDict):
-        regex: _builtins.str
-        """
-        Regular expression to match in the input string.
-        """
-        replace: _builtins.str
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-elif False:
-    GetListenerRuleTransformUrlRewriteConfigRewriteArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class GetListenerRuleTransformUrlRewriteConfigRewriteArgs:
-    def __init__(__self__, *,
-                 regex: _builtins.str,
-                 replace: _builtins.str):
-        """
-        :param _builtins.str regex: Regular expression to match in the input string.
-        :param _builtins.str replace: Replacement string to use when rewriting the matched input.
-        """
-        pulumi.set(__self__, "regex", regex)
-        pulumi.set(__self__, "replace", replace)
-
-    @_builtins.property
-    @pulumi.getter
-    def regex(self) -> _builtins.str:
-        """
-        Regular expression to match in the input string.
-        """
-        return pulumi.get(self, "regex")
-
-    @regex.setter
-    def regex(self, value: _builtins.str):
-        pulumi.set(self, "regex", value)
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _builtins.str:
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-        return pulumi.get(self, "replace")
-
-    @replace.setter
-    def replace(self, value: _builtins.str):
-        pulumi.set(self, "replace", value)
-
-