pulumi-aws-native 1.38.0a1761284362__py3-none-any.whl → 1.39.0a1762409198__py3-none-any.whl

pulumi_aws_native/elasticloadbalancingv2/outputs.py

@@ -37,10 +37,13 @@ __all__ = [
     'ListenerRuleQueryStringConfig',
     'ListenerRuleQueryStringKeyValue',
     'ListenerRuleRedirectConfig',
+    'ListenerRuleRewriteConfig',
+    'ListenerRuleRewriteConfigObject',
     'ListenerRuleRuleCondition',
     'ListenerRuleSourceIpConfig',
     'ListenerRuleTargetGroupStickinessConfig',
     'ListenerRuleTargetGroupTuple',
+    'ListenerRuleTransform',
     'ListenerTargetGroupStickinessConfig',
     'ListenerTargetGroupTuple',
     'LoadBalancerAttribute',
@@ -100,10 +103,11 @@ class ListenerAction(dict):
         :param 'ListenerAuthenticateCognitoConfig' authenticate_cognito_config: [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.
         :param 'ListenerAuthenticateOidcConfig' authenticate_oidc_config: [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.
         :param 'ListenerFixedResponseConfig' fixed_response_config: [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.
-        :param 'ListenerForwardConfig' forward_config: Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        :param 'ListenerForwardConfig' forward_config: Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+                If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         :param _builtins.int order: The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.
         :param 'ListenerRedirectConfig' redirect_config: [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.
-        :param _builtins.str target_group_arn: The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.
+        :param _builtins.str target_group_arn: The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to multiple target groups, you must use ``ForwardConfig`` instead.
         """
         pulumi.set(__self__, "type", type)
         if authenticate_cognito_config is not None:
@@ -157,7 +161,8 @@ class ListenerAction(dict):
     @pulumi.getter(name="forwardConfig")
     def forward_config(self) -> Optional['outputs.ListenerForwardConfig']:
         """
-        Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+         If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         """
         return pulumi.get(self, "forward_config")
 
@@ -181,7 +186,7 @@ class ListenerAction(dict):
     @pulumi.getter(name="targetGroupArn")
     def target_group_arn(self) -> Optional[_builtins.str]:
         """
-        The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.
+        The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to multiple target groups, you must use ``ForwardConfig`` instead.
         """
         return pulumi.get(self, "target_group_arn")
 
@@ -713,7 +718,8 @@ class ListenerFixedResponseConfig(dict):
 @pulumi.output_type
 class ListenerForwardConfig(dict):
     """
-    Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+    Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+     If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
     """
     @staticmethod
     def __key_warning(key: str):
@@ -738,7 +744,8 @@ class ListenerForwardConfig(dict):
                  target_group_stickiness_config: Optional['outputs.ListenerTargetGroupStickinessConfig'] = None,
                  target_groups: Optional[Sequence['outputs.ListenerTargetGroupTuple']] = None):
         """
-        Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+         If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         :param 'ListenerTargetGroupStickinessConfig' target_group_stickiness_config: Information about the target group stickiness for a rule.
         :param Sequence['ListenerTargetGroupTuple'] target_groups: Information about how traffic will be distributed between multiple target groups in a forward rule.
         """
@@ -1008,10 +1015,11 @@ class ListenerRuleAction(dict):
         :param 'ListenerRuleAuthenticateCognitoConfig' authenticate_cognito_config: [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.
         :param 'ListenerRuleAuthenticateOidcConfig' authenticate_oidc_config: [HTTPS listeners] Information about an identity provider that is compliant with OpenID Connect (OIDC). Specify only when ``Type`` is ``authenticate-oidc``.
         :param 'ListenerRuleFixedResponseConfig' fixed_response_config: [Application Load Balancer] Information for creating an action that returns a custom HTTP response. Specify only when ``Type`` is ``fixed-response``.
-        :param 'ListenerRuleForwardConfig' forward_config: Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        :param 'ListenerRuleForwardConfig' forward_config: Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+                If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         :param _builtins.int order: The order for the action. This value is required for rules with multiple actions. The action with the lowest value for order is performed first.
         :param 'ListenerRuleRedirectConfig' redirect_config: [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.
-        :param _builtins.str target_group_arn: The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.
+        :param _builtins.str target_group_arn: The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to multiple target groups, you must use ``ForwardConfig`` instead.
         """
         pulumi.set(__self__, "type", type)
         if authenticate_cognito_config is not None:
@@ -1065,7 +1073,8 @@ class ListenerRuleAction(dict):
     @pulumi.getter(name="forwardConfig")
     def forward_config(self) -> Optional['outputs.ListenerRuleForwardConfig']:
         """
-        Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+         If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         """
         return pulumi.get(self, "forward_config")
 
@@ -1089,7 +1098,7 @@ class ListenerRuleAction(dict):
     @pulumi.getter(name="targetGroupArn")
     def target_group_arn(self) -> Optional[_builtins.str]:
         """
-        The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to one or more target groups, use ``ForwardConfig`` instead.
+        The Amazon Resource Name (ARN) of the target group. Specify only when ``Type`` is ``forward`` and you want to route to a single target group. To route to multiple target groups, you must use ``ForwardConfig`` instead.
         """
         return pulumi.get(self, "target_group_arn")
 
@@ -1500,7 +1509,8 @@ class ListenerRuleFixedResponseConfig(dict):
 @pulumi.output_type
 class ListenerRuleForwardConfig(dict):
     """
-    Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+    Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+     If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
     """
     @staticmethod
     def __key_warning(key: str):
@@ -1525,7 +1535,8 @@ class ListenerRuleForwardConfig(dict):
                  target_group_stickiness_config: Optional['outputs.ListenerRuleTargetGroupStickinessConfig'] = None,
                  target_groups: Optional[Sequence['outputs.ListenerRuleTargetGroupTuple']] = None):
         """
-        Information for creating an action that distributes requests among one or more target groups. For Network Load Balancers, you can specify a single target group. Specify only when ``Type`` is ``forward``. If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
+        Information for creating an action that distributes requests among multiple target groups. Specify only when ``Type`` is ``forward``.
+         If you specify both ``ForwardConfig`` and ``TargetGroupArn``, you can specify only one target group using ``ForwardConfig`` and it must be the same target group specified in ``TargetGroupArn``.
         :param 'ListenerRuleTargetGroupStickinessConfig' target_group_stickiness_config: Information about the target group stickiness for a rule.
         :param Sequence['ListenerRuleTargetGroupTuple'] target_groups: Information about how traffic will be distributed between multiple target groups in a forward rule.
         """
@@ -1556,21 +1567,46 @@ class ListenerRuleHostHeaderConfig(dict):
     """
     Information about a host header condition.
     """
+    @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 ListenerRuleHostHeaderConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ListenerRuleHostHeaderConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ListenerRuleHostHeaderConfig.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
+                 regex_values: Optional[Sequence[_builtins.str]] = None,
                  values: Optional[Sequence[_builtins.str]] = None):
         """
         Information about a host header condition.
-        :param Sequence[_builtins.str] values: The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        :param Sequence[_builtins.str] values: The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
+        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]]:
+        return pulumi.get(self, "regex_values")
+
     @_builtins.property
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
         return pulumi.get(self, "values")
@@ -1587,6 +1623,8 @@ class ListenerRuleHttpHeaderConfig(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 ListenerRuleHttpHeaderConfig. Access the value via the '{suggest}' property getter instead.")
@@ -1601,17 +1639,20 @@ class ListenerRuleHttpHeaderConfig(dict):
 
     def __init__(__self__, *,
                  http_header_name: Optional[_builtins.str] = None,
+                 regex_values: Optional[Sequence[_builtins.str]] = None,
                  values: Optional[Sequence[_builtins.str]] = None):
         """
         Information about an HTTP header condition.
          There is a set of standard HTTP header fields. You can also define custom HTTP header fields.
         :param _builtins.str http_header_name: The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.
-        :param Sequence[_builtins.str] values: The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        :param Sequence[_builtins.str] values: The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
                 If the same header appears multiple times in the request, we search them in order until a match is found.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
         if http_header_name is not None:
             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)
 
@@ -1623,11 +1664,16 @@ class ListenerRuleHttpHeaderConfig(dict):
         """
         return pulumi.get(self, "http_header_name")
 
+    @_builtins.property
+    @pulumi.getter(name="regexValues")
+    def regex_values(self) -> Optional[Sequence[_builtins.str]]:
+        return pulumi.get(self, "regex_values")
+
     @_builtins.property
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
          If the same header appears multiple times in the request, we search them in order until a match is found.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -1645,7 +1691,7 @@ class ListenerRuleHttpRequestMethodConfig(dict):
         """
         Information about an HTTP method condition.
          HTTP defines a set of request methods, also referred to as HTTP verbs. For more information, see the [HTTP Method Registry](https://docs.aws.amazon.com/https://www.iana.org/assignments/http-methods/http-methods.xhtml). You can also define custom HTTP methods.
-        :param Sequence[_builtins.str] values: The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        :param Sequence[_builtins.str] values: The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         if values is not None:
@@ -1655,7 +1701,7 @@ class ListenerRuleHttpRequestMethodConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         return pulumi.get(self, "values")
@@ -1666,16 +1712,41 @@ class ListenerRulePathPatternConfig(dict):
     """
     Information about a path pattern condition.
     """
+    @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 ListenerRulePathPatternConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ListenerRulePathPatternConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ListenerRulePathPatternConfig.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
+                 regex_values: Optional[Sequence[_builtins.str]] = None,
                  values: Optional[Sequence[_builtins.str]] = None):
         """
         Information about a path pattern condition.
         :param Sequence[_builtins.str] values: The path patterns to compare against the request URL. The maximum size of each string is 128 characters. The comparison is case sensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
                 If you specify multiple strings, the condition is satisfied if one of them matches the request URL. The path pattern is compared only to the path of the URL, not to its query string.
         """
+        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]]:
+        return pulumi.get(self, "regex_values")
+
     @_builtins.property
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
@@ -1697,7 +1768,7 @@ class ListenerRuleQueryStringConfig(dict):
         """
         Information about a query string condition.
          The query string component of a URI starts after the first '?' character and is terminated by either a '#' character or the end of the URI. A typical query string contains key/value pairs separated by '&' characters. The allowed characters are specified by RFC 3986. Any character can be percentage encoded.
-        :param Sequence['ListenerRuleQueryStringKeyValue'] values: The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        :param Sequence['ListenerRuleQueryStringKeyValue'] values: The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
                 If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         if values is not None:
@@ -1707,7 +1778,7 @@ class ListenerRuleQueryStringConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence['outputs.ListenerRuleQueryStringKeyValue']]:
         """
-        The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
          If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         return pulumi.get(self, "values")
@@ -1865,6 +1936,37 @@ class ListenerRuleRedirectConfig(dict):
         return pulumi.get(self, "query")
 
 
+@pulumi.output_type
+class ListenerRuleRewriteConfig(dict):
+    def __init__(__self__, *,
+                 regex: _builtins.str,
+                 replace: _builtins.str):
+        pulumi.set(__self__, "regex", regex)
+        pulumi.set(__self__, "replace", replace)
+
+    @_builtins.property
+    @pulumi.getter
+    def regex(self) -> _builtins.str:
+        return pulumi.get(self, "regex")
+
+    @_builtins.property
+    @pulumi.getter
+    def replace(self) -> _builtins.str:
+        return pulumi.get(self, "replace")
+
+
+@pulumi.output_type
+class ListenerRuleRewriteConfigObject(dict):
+    def __init__(__self__, *,
+                 rewrites: Sequence['outputs.ListenerRuleRewriteConfig']):
+        pulumi.set(__self__, "rewrites", rewrites)
+
+    @_builtins.property
+    @pulumi.getter
+    def rewrites(self) -> Sequence['outputs.ListenerRuleRewriteConfig']:
+        return pulumi.get(self, "rewrites")
+
+
 @pulumi.output_type
 class ListenerRuleRuleCondition(dict):
     """
@@ -1883,6 +1985,8 @@ class ListenerRuleRuleCondition(dict):
             suggest = "path_pattern_config"
         elif key == "queryStringConfig":
             suggest = "query_string_config"
+        elif key == "regexValues":
+            suggest = "regex_values"
         elif key == "sourceIpConfig":
             suggest = "source_ip_config"
 
@@ -1904,6 +2008,7 @@ class ListenerRuleRuleCondition(dict):
                  http_request_method_config: Optional['outputs.ListenerRuleHttpRequestMethodConfig'] = None,
                  path_pattern_config: Optional['outputs.ListenerRulePathPatternConfig'] = None,
                  query_string_config: Optional['outputs.ListenerRuleQueryStringConfig'] = None,
+                 regex_values: Optional[Sequence[_builtins.str]] = None,
                  source_ip_config: Optional['outputs.ListenerRuleSourceIpConfig'] = None,
                  values: Optional[Sequence[_builtins.str]] = None):
         """
@@ -1920,6 +2025,7 @@ class ListenerRuleRuleCondition(dict):
         :param 'ListenerRuleHttpRequestMethodConfig' http_request_method_config: Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.
         :param 'ListenerRulePathPatternConfig' path_pattern_config: Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.
         :param 'ListenerRuleQueryStringConfig' query_string_config: Information for a query string condition. Specify only when ``Field`` is ``query-string``.
+        :param Sequence[_builtins.str] regex_values: The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
         :param 'ListenerRuleSourceIpConfig' source_ip_config: Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
         :param Sequence[_builtins.str] values: The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.
                 If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.
@@ -1947,6 +2053,8 @@ class ListenerRuleRuleCondition(dict):
             pulumi.set(__self__, "path_pattern_config", path_pattern_config)
         if query_string_config is not None:
             pulumi.set(__self__, "query_string_config", query_string_config)
+        if regex_values is not None:
+            pulumi.set(__self__, "regex_values", regex_values)
         if source_ip_config is not None:
             pulumi.set(__self__, "source_ip_config", source_ip_config)
         if values is not None:
@@ -2006,6 +2114,14 @@ class ListenerRuleRuleCondition(dict):
         """
         return pulumi.get(self, "query_string_config")
 
+    @_builtins.property
+    @pulumi.getter(name="regexValues")
+    def regex_values(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
+        """
+        return pulumi.get(self, "regex_values")
+
     @_builtins.property
     @pulumi.getter(name="sourceIpConfig")
     def source_ip_config(self) -> Optional['outputs.ListenerRuleSourceIpConfig']:
@@ -2089,7 +2205,7 @@ class ListenerRuleTargetGroupStickinessConfig(dict):
                  enabled: Optional[_builtins.bool] = None):
         """
         Information about the target group stickiness for a rule.
-        :param _builtins.int duration_seconds: The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
+        :param _builtins.int duration_seconds: [Application Load Balancers] The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
         :param _builtins.bool enabled: Indicates whether target group stickiness is enabled.
         """
         if duration_seconds is not None:
@@ -2101,7 +2217,7 @@ class ListenerRuleTargetGroupStickinessConfig(dict):
     @pulumi.getter(name="durationSeconds")
     def duration_seconds(self) -> Optional[_builtins.int]:
         """
-        The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
+        [Application Load Balancers] The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
         """
         return pulumi.get(self, "duration_seconds")
 
@@ -2166,6 +2282,53 @@ class ListenerRuleTargetGroupTuple(dict):
         return pulumi.get(self, "weight")
 
 
+@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.ListenerRuleRewriteConfigObject'] = None,
+                 url_rewrite_config: Optional['outputs.ListenerRuleRewriteConfigObject'] = None):
+        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:
+        return pulumi.get(self, "type")
+
+    @_builtins.property
+    @pulumi.getter(name="hostHeaderRewriteConfig")
+    def host_header_rewrite_config(self) -> Optional['outputs.ListenerRuleRewriteConfigObject']:
+        return pulumi.get(self, "host_header_rewrite_config")
+
+    @_builtins.property
+    @pulumi.getter(name="urlRewriteConfig")
+    def url_rewrite_config(self) -> Optional['outputs.ListenerRuleRewriteConfigObject']:
+        return pulumi.get(self, "url_rewrite_config")
+
+
 @pulumi.output_type
 class ListenerTargetGroupStickinessConfig(dict):
     """
@@ -2193,7 +2356,7 @@ class ListenerTargetGroupStickinessConfig(dict):
                  enabled: Optional[_builtins.bool] = None):
         """
         Information about the target group stickiness for a rule.
-        :param _builtins.int duration_seconds: The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
+        :param _builtins.int duration_seconds: [Application Load Balancers] The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
         :param _builtins.bool enabled: Indicates whether target group stickiness is enabled.
         """
         if duration_seconds is not None:
@@ -2205,7 +2368,7 @@ class ListenerTargetGroupStickinessConfig(dict):
     @pulumi.getter(name="durationSeconds")
     def duration_seconds(self) -> Optional[_builtins.int]:
         """
-        The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
+        [Application Load Balancers] The time period, in seconds, during which requests from a client should be routed to the same target group. The range is 1-604800 seconds (7 days). You must specify this value when enabling target group stickiness.
         """
         return pulumi.get(self, "duration_seconds")
 

pulumi_aws_native/events/__init__.py

@@ -12,11 +12,13 @@ from .archive import *
 from .connection import *
 from .endpoint import *
 from .event_bus import *
+from .event_bus_policy import *
 from .get_api_destination import *
 from .get_archive import *
 from .get_connection import *
 from .get_endpoint import *
 from .get_event_bus import *
+from .get_event_bus_policy import *
 from .get_rule import *
 from .rule import *
 from ._inputs import *

pulumi_aws_native/events/_inputs.py

@@ -48,6 +48,8 @@ __all__ = [
     'EndpointRoutingConfigArgsDict',
     'EndpointSecondaryArgs',
     'EndpointSecondaryArgsDict',
+    'EventBusPolicyConditionArgs',
+    'EventBusPolicyConditionArgsDict',
     'InvocationConnectivityParametersPropertiesArgs',
     'InvocationConnectivityParametersPropertiesArgsDict',
     'LogConfigPropertiesArgs',
@@ -921,6 +923,82 @@ class EndpointSecondaryArgs:
         pulumi.set(self, "route", value)
 
 
+if not MYPY:
+    class EventBusPolicyConditionArgsDict(TypedDict):
+        """
+        This parameter enables you to limit the permission to accounts that fulfill a certain condition, such as being a member of a certain AWS organization.
+        """
+        key: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the value for the key. Currently, this must be the ID of the organization.
+        """
+        type: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the type of condition. Currently the only supported value is StringEquals.
+        """
+        value: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specifies the key for the condition. Currently the only supported key is aws:PrincipalOrgID.
+        """
+elif False:
+    EventBusPolicyConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class EventBusPolicyConditionArgs:
+    def __init__(__self__, *,
+                 key: Optional[pulumi.Input[_builtins.str]] = None,
+                 type: Optional[pulumi.Input[_builtins.str]] = None,
+                 value: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        This parameter enables you to limit the permission to accounts that fulfill a certain condition, such as being a member of a certain AWS organization.
+        :param pulumi.Input[_builtins.str] key: Specifies the value for the key. Currently, this must be the ID of the organization.
+        :param pulumi.Input[_builtins.str] type: Specifies the type of condition. Currently the only supported value is StringEquals.
+        :param pulumi.Input[_builtins.str] value: Specifies the key for the condition. Currently the only supported key is aws:PrincipalOrgID.
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies the value for the key. Currently, this must be the ID of the organization.
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "key", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies the type of condition. Currently the only supported value is StringEquals.
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "type", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specifies the key for the condition. Currently the only supported key is aws:PrincipalOrgID.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class InvocationConnectivityParametersPropertiesArgsDict(TypedDict):
         """