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

pulumi_aws/lb/outputs.py

@@ -40,11 +40,6 @@ __all__ = [
     'ListenerRuleConditionPathPattern',
     'ListenerRuleConditionQueryString',
     'ListenerRuleConditionSourceIp',
-    'ListenerRuleTransform',
-    'ListenerRuleTransformHostHeaderRewriteConfig',
-    'ListenerRuleTransformHostHeaderRewriteConfigRewrite',
-    'ListenerRuleTransformUrlRewriteConfig',
-    'ListenerRuleTransformUrlRewriteConfigRewrite',
     'LoadBalancerAccessLogs',
     'LoadBalancerConnectionLogs',
     'LoadBalancerIpamPools',
@@ -82,11 +77,6 @@ __all__ = [
     'GetListenerRuleConditionQueryStringResult',
     'GetListenerRuleConditionQueryStringValueResult',
     'GetListenerRuleConditionSourceIpResult',
-    'GetListenerRuleTransformResult',
-    'GetListenerRuleTransformHostHeaderRewriteConfigResult',
-    'GetListenerRuleTransformHostHeaderRewriteConfigRewriteResult',
-    'GetListenerRuleTransformUrlRewriteConfigResult',
-    'GetListenerRuleTransformUrlRewriteConfigRewriteResult',
     'GetLoadBalancerAccessLogsResult',
     'GetLoadBalancerConnectionLogResult',
     'GetLoadBalancerIpamPoolResult',
@@ -1627,10 +1617,10 @@ class ListenerRuleCondition(dict):
                  query_strings: Optional[Sequence['outputs.ListenerRuleConditionQueryString']] = None,
                  source_ip: Optional['outputs.ListenerRuleConditionSourceIp'] = None):
         """
-        :param 'ListenerRuleConditionHostHeaderArgs' host_header: Host header patterns to match. Host Header block fields documented below.
+        :param '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 'ListenerRuleConditionHttpHeaderArgs' http_header: HTTP headers to match. HTTP Header block fields documented below.
         :param '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 'ListenerRuleConditionPathPatternArgs' path_pattern: Path patterns to match against the request URL. Path Pattern block fields documented below.
+        :param '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 Sequence['ListenerRuleConditionQueryStringArgs'] query_strings: Query strings to match. Query String block fields documented below.
         :param '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.
                
@@ -1653,7 +1643,7 @@ class ListenerRuleCondition(dict):
     @pulumi.getter(name="hostHeader")
     def host_header(self) -> Optional['outputs.ListenerRuleConditionHostHeader']:
         """
-        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")
 
@@ -1677,7 +1667,7 @@ class ListenerRuleCondition(dict):
     @pulumi.getter(name="pathPattern")
     def path_pattern(self) -> Optional['outputs.ListenerRuleConditionPathPattern']:
         """
-        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")
 
@@ -1702,49 +1692,13 @@ class ListenerRuleCondition(dict):
 
 @pulumi.output_type
 class ListenerRuleConditionHostHeader(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "regexValues":
-            suggest = "regex_values"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ListenerRuleConditionHostHeader. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ListenerRuleConditionHostHeader.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ListenerRuleConditionHostHeader.__key_warning(key)
-        return super().get(key, default)
-
     def __init__(__self__, *,
-                 regex_values: Optional[Sequence[_builtins.str]] = None,
-                 values: Optional[Sequence[_builtins.str]] = None):
-        """
-        :param Sequence[_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 Sequence[_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[Sequence[_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")
+                 values: Sequence[_builtins.str]):
+        pulumi.set(__self__, "values", values)
 
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[Sequence[_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) -> Sequence[_builtins.str]:
         return pulumi.get(self, "values")
 
 
@@ -1755,8 +1709,6 @@ class ListenerRuleConditionHttpHeader(dict):
         suggest = None
         if key == "httpHeaderName":
             suggest = "http_header_name"
-        elif key == "regexValues":
-            suggest = "regex_values"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ListenerRuleConditionHttpHeader. Access the value via the '{suggest}' property getter instead.")
@@ -1771,40 +1723,27 @@ class ListenerRuleConditionHttpHeader(dict):
 
     def __init__(__self__, *,
                  http_header_name: _builtins.str,
-                 regex_values: Optional[Sequence[_builtins.str]] = None,
-                 values: Optional[Sequence[_builtins.str]] = None):
+                 values: Sequence[_builtins.str]):
         """
-        :param _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 Sequence[_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 Sequence[_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 _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 Sequence[_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) -> _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")
 
-    @_builtins.property
-    @pulumi.getter(name="regexValues")
-    def regex_values(self) -> Optional[Sequence[_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")
-
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[Sequence[_builtins.str]]:
+    def values(self) -> Sequence[_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")
 
@@ -1823,49 +1762,13 @@ class ListenerRuleConditionHttpRequestMethod(dict):
 
 @pulumi.output_type
 class ListenerRuleConditionPathPattern(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "regexValues":
-            suggest = "regex_values"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ListenerRuleConditionPathPattern. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ListenerRuleConditionPathPattern.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ListenerRuleConditionPathPattern.__key_warning(key)
-        return super().get(key, default)
-
     def __init__(__self__, *,
-                 regex_values: Optional[Sequence[_builtins.str]] = None,
-                 values: Optional[Sequence[_builtins.str]] = None):
-        """
-        :param Sequence[_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 Sequence[_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[Sequence[_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")
+                 values: Sequence[_builtins.str]):
+        pulumi.set(__self__, "values", values)
 
     @_builtins.property
     @pulumi.getter
-    def values(self) -> Optional[Sequence[_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) -> Sequence[_builtins.str]:
         return pulumi.get(self, "values")
 
 
@@ -1911,163 +1814,6 @@ class ListenerRuleConditionSourceIp(dict):
         return pulumi.get(self, "values")
 
 
-@pulumi.output_type
-class ListenerRuleTransform(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "hostHeaderRewriteConfig":
-            suggest = "host_header_rewrite_config"
-        elif key == "urlRewriteConfig":
-            suggest = "url_rewrite_config"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ListenerRuleTransform. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ListenerRuleTransform.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ListenerRuleTransform.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 type: _builtins.str,
-                 host_header_rewrite_config: Optional['outputs.ListenerRuleTransformHostHeaderRewriteConfig'] = None,
-                 url_rewrite_config: Optional['outputs.ListenerRuleTransformUrlRewriteConfig'] = None):
-        """
-        :param _builtins.str type: Type of transform. Valid values are `host-header-rewrite` and `url-rewrite`.
-        :param '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 '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) -> _builtins.str:
-        """
-        Type of transform. Valid values are `host-header-rewrite` and `url-rewrite`.
-        """
-        return pulumi.get(self, "type")
-
-    @_builtins.property
-    @pulumi.getter(name="hostHeaderRewriteConfig")
-    def host_header_rewrite_config(self) -> Optional['outputs.ListenerRuleTransformHostHeaderRewriteConfig']:
-        """
-        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")
-
-    @_builtins.property
-    @pulumi.getter(name="urlRewriteConfig")
-    def url_rewrite_config(self) -> Optional['outputs.ListenerRuleTransformUrlRewriteConfig']:
-        """
-        Configuration block for URL rewrite. Required if `type` is `url-rewrite`. See URL Rewrite Config Blocks below.
-        """
-        return pulumi.get(self, "url_rewrite_config")
-
-
-@pulumi.output_type
-class ListenerRuleTransformHostHeaderRewriteConfig(dict):
-    def __init__(__self__, *,
-                 rewrite: Optional['outputs.ListenerRuleTransformHostHeaderRewriteConfigRewrite'] = None):
-        """
-        :param '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['outputs.ListenerRuleTransformHostHeaderRewriteConfigRewrite']:
-        """
-        Block for host header rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        return pulumi.get(self, "rewrite")
-
-
-@pulumi.output_type
-class ListenerRuleTransformHostHeaderRewriteConfigRewrite(dict):
-    def __init__(__self__, *,
-                 regex: _builtins.str,
-                 replace: _builtins.str):
-        """
-        :param _builtins.str regex: Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        :param _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) -> _builtins.str:
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        return pulumi.get(self, "regex")
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _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")
-
-
-@pulumi.output_type
-class ListenerRuleTransformUrlRewriteConfig(dict):
-    def __init__(__self__, *,
-                 rewrite: Optional['outputs.ListenerRuleTransformUrlRewriteConfigRewrite'] = None):
-        """
-        :param '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['outputs.ListenerRuleTransformUrlRewriteConfigRewrite']:
-        """
-        Block for URL rewrite configuration. Only one block is accepted. See Rewrite Blocks below.
-        """
-        return pulumi.get(self, "rewrite")
-
-
-@pulumi.output_type
-class ListenerRuleTransformUrlRewriteConfigRewrite(dict):
-    def __init__(__self__, *,
-                 regex: _builtins.str,
-                 replace: _builtins.str):
-        """
-        :param _builtins.str regex: Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        :param _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) -> _builtins.str:
-        """
-        Regular expression to match in the input string. Length constraints: Between 1 and 1024 characters.
-        """
-        return pulumi.get(self, "regex")
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _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")
-
-
 @pulumi.output_type
 class LoadBalancerAccessLogs(dict):
     def __init__(__self__, *,
@@ -3182,7 +2928,7 @@ class GetListenerRuleActionResult(dict):
                  redirects: Optional[Sequence['outputs.GetListenerRuleActionRedirectResult']] = 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.
@@ -3219,7 +2965,7 @@ class GetListenerRuleActionResult(dict):
     @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")
 
@@ -3703,13 +3449,11 @@ class GetListenerRuleConditionResult(dict):
                  query_strings: Optional[Sequence['outputs.GetListenerRuleConditionQueryStringResult']] = None,
                  source_ips: Optional[Sequence['outputs.GetListenerRuleConditionSourceIpResult']] = 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.
@@ -3731,8 +3475,7 @@ class GetListenerRuleConditionResult(dict):
     @pulumi.getter(name="hostHeaders")
     def host_headers(self) -> Optional[Sequence['outputs.GetListenerRuleConditionHostHeaderResult']]:
         """
-        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")
 
@@ -3757,8 +3500,7 @@ class GetListenerRuleConditionResult(dict):
     @pulumi.getter(name="pathPatterns")
     def path_patterns(self) -> Optional[Sequence['outputs.GetListenerRuleConditionPathPatternResult']]:
         """
-        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")
 
@@ -3783,23 +3525,12 @@ class GetListenerRuleConditionResult(dict):
 @pulumi.output_type
 class GetListenerRuleConditionHostHeaderResult(dict):
     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")
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -3813,15 +3544,12 @@ class GetListenerRuleConditionHostHeaderResult(dict):
 class GetListenerRuleConditionHttpHeaderResult(dict):
     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
@@ -3832,14 +3560,6 @@ class GetListenerRuleConditionHttpHeaderResult(dict):
         """
         return pulumi.get(self, "http_header_name")
 
-    @_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")
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -3870,23 +3590,12 @@ class GetListenerRuleConditionHttpRequestMethodResult(dict):
 @pulumi.output_type
 class GetListenerRuleConditionPathPatternResult(dict):
     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")
-
     @_builtins.property
     @pulumi.getter
     def values(self) -> Sequence[_builtins.str]:
@@ -3962,144 +3671,6 @@ class GetListenerRuleConditionSourceIpResult(dict):
         return pulumi.get(self, "values")
 
 
-@pulumi.output_type
-class GetListenerRuleTransformResult(dict):
-    def __init__(__self__, *,
-                 type: _builtins.str,
-                 host_header_rewrite_configs: Optional[Sequence['outputs.GetListenerRuleTransformHostHeaderRewriteConfigResult']] = None,
-                 url_rewrite_configs: Optional[Sequence['outputs.GetListenerRuleTransformUrlRewriteConfigResult']] = 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")
-
-    @_builtins.property
-    @pulumi.getter(name="hostHeaderRewriteConfigs")
-    def host_header_rewrite_configs(self) -> Optional[Sequence['outputs.GetListenerRuleTransformHostHeaderRewriteConfigResult']]:
-        """
-        Block for host header rewrite. Detailed below.
-        """
-        return pulumi.get(self, "host_header_rewrite_configs")
-
-    @_builtins.property
-    @pulumi.getter(name="urlRewriteConfigs")
-    def url_rewrite_configs(self) -> Optional[Sequence['outputs.GetListenerRuleTransformUrlRewriteConfigResult']]:
-        """
-        Block for URL rewrite. Detailed below.
-        """
-        return pulumi.get(self, "url_rewrite_configs")
-
-
-@pulumi.output_type
-class GetListenerRuleTransformHostHeaderRewriteConfigResult(dict):
-    def __init__(__self__, *,
-                 rewrites: Optional[Sequence['outputs.GetListenerRuleTransformHostHeaderRewriteConfigRewriteResult']] = 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['outputs.GetListenerRuleTransformHostHeaderRewriteConfigRewriteResult']]:
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-        return pulumi.get(self, "rewrites")
-
-
-@pulumi.output_type
-class GetListenerRuleTransformHostHeaderRewriteConfigRewriteResult(dict):
-    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")
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _builtins.str:
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-        return pulumi.get(self, "replace")
-
-
-@pulumi.output_type
-class GetListenerRuleTransformUrlRewriteConfigResult(dict):
-    def __init__(__self__, *,
-                 rewrites: Optional[Sequence['outputs.GetListenerRuleTransformUrlRewriteConfigRewriteResult']] = 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['outputs.GetListenerRuleTransformUrlRewriteConfigRewriteResult']]:
-        """
-        Block for URL rewrite configuration. Detailed below.
-        """
-        return pulumi.get(self, "rewrites")
-
-
-@pulumi.output_type
-class GetListenerRuleTransformUrlRewriteConfigRewriteResult(dict):
-    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")
-
-    @_builtins.property
-    @pulumi.getter
-    def replace(self) -> _builtins.str:
-        """
-        Replacement string to use when rewriting the matched input.
-        """
-        return pulumi.get(self, "replace")
-
-
 @pulumi.output_type
 class GetLoadBalancerAccessLogsResult(dict):
     def __init__(__self__, *,