pulumi-aws-native 1.38.0a1761286050__py3-none-any.whl → 1.38.0a1761329030__py3-none-any.whl

pulumi_aws_native/elasticloadbalancingv2/_inputs.py

@@ -57,6 +57,10 @@ __all__ = [
     'ListenerRuleQueryStringKeyValueArgsDict',
     'ListenerRuleRedirectConfigArgs',
     'ListenerRuleRedirectConfigArgsDict',
+    'ListenerRuleRewriteConfigObjectArgs',
+    'ListenerRuleRewriteConfigObjectArgsDict',
+    'ListenerRuleRewriteConfigArgs',
+    'ListenerRuleRewriteConfigArgsDict',
     'ListenerRuleRuleConditionArgs',
     'ListenerRuleRuleConditionArgsDict',
     'ListenerRuleSourceIpConfigArgs',
@@ -65,6 +69,8 @@ __all__ = [
     'ListenerRuleTargetGroupStickinessConfigArgsDict',
     'ListenerRuleTargetGroupTupleArgs',
     'ListenerRuleTargetGroupTupleArgsDict',
+    'ListenerRuleTransformArgs',
+    'ListenerRuleTransformArgsDict',
     'ListenerTargetGroupStickinessConfigArgs',
     'ListenerTargetGroupStickinessConfigArgsDict',
     'ListenerTargetGroupTupleArgs',
@@ -110,7 +116,8 @@ if not MYPY:
         """
         forward_config: NotRequired[pulumi.Input['ListenerForwardConfigArgsDict']]
         """
-        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``.
         """
         order: NotRequired[pulumi.Input[_builtins.int]]
         """
@@ -122,7 +129,7 @@ if not MYPY:
         """
         target_group_arn: NotRequired[pulumi.Input[_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.
         """
 elif False:
     ListenerActionArgsDict: TypeAlias = Mapping[str, Any]
@@ -144,10 +151,11 @@ class ListenerActionArgs:
         :param pulumi.Input['ListenerAuthenticateCognitoConfigArgs'] authenticate_cognito_config: [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.
         :param pulumi.Input['ListenerAuthenticateOidcConfigArgs'] 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 pulumi.Input['ListenerFixedResponseConfigArgs'] 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 pulumi.Input['ListenerForwardConfigArgs'] 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 pulumi.Input['ListenerForwardConfigArgs'] 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 pulumi.Input[_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 pulumi.Input['ListenerRedirectConfigArgs'] redirect_config: [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.
-        :param pulumi.Input[_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 pulumi.Input[_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:
@@ -217,7 +225,8 @@ class ListenerActionArgs:
     @pulumi.getter(name="forwardConfig")
     def forward_config(self) -> Optional[pulumi.Input['ListenerForwardConfigArgs']]:
         """
-        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")
 
@@ -253,7 +262,7 @@ class ListenerActionArgs:
     @pulumi.getter(name="targetGroupArn")
     def target_group_arn(self) -> Optional[pulumi.Input[_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")
 
@@ -952,7 +961,8 @@ class ListenerFixedResponseConfigArgs:
 if not MYPY:
     class ListenerForwardConfigArgsDict(TypedDict):
         """
-        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``.
         """
         target_group_stickiness_config: NotRequired[pulumi.Input['ListenerTargetGroupStickinessConfigArgsDict']]
         """
@@ -971,7 +981,8 @@ class ListenerForwardConfigArgs:
                  target_group_stickiness_config: Optional[pulumi.Input['ListenerTargetGroupStickinessConfigArgs']] = None,
                  target_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerTargetGroupTupleArgs']]]] = 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 pulumi.Input['ListenerTargetGroupStickinessConfigArgs'] target_group_stickiness_config: Information about the target group stickiness for a rule.
         :param pulumi.Input[Sequence[pulumi.Input['ListenerTargetGroupTupleArgs']]] target_groups: Information about how traffic will be distributed between multiple target groups in a forward rule.
         """
@@ -1277,7 +1288,8 @@ if not MYPY:
         """
         forward_config: NotRequired[pulumi.Input['ListenerRuleForwardConfigArgsDict']]
         """
-        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``.
         """
         order: NotRequired[pulumi.Input[_builtins.int]]
         """
@@ -1289,7 +1301,7 @@ if not MYPY:
         """
         target_group_arn: NotRequired[pulumi.Input[_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.
         """
 elif False:
     ListenerRuleActionArgsDict: TypeAlias = Mapping[str, Any]
@@ -1311,10 +1323,11 @@ class ListenerRuleActionArgs:
         :param pulumi.Input['ListenerRuleAuthenticateCognitoConfigArgs'] authenticate_cognito_config: [HTTPS listeners] Information for using Amazon Cognito to authenticate users. Specify only when ``Type`` is ``authenticate-cognito``.
         :param pulumi.Input['ListenerRuleAuthenticateOidcConfigArgs'] 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 pulumi.Input['ListenerRuleFixedResponseConfigArgs'] 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 pulumi.Input['ListenerRuleForwardConfigArgs'] 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 pulumi.Input['ListenerRuleForwardConfigArgs'] 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 pulumi.Input[_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 pulumi.Input['ListenerRuleRedirectConfigArgs'] redirect_config: [Application Load Balancer] Information for creating a redirect action. Specify only when ``Type`` is ``redirect``.
-        :param pulumi.Input[_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 pulumi.Input[_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:
@@ -1384,7 +1397,8 @@ class ListenerRuleActionArgs:
     @pulumi.getter(name="forwardConfig")
     def forward_config(self) -> Optional[pulumi.Input['ListenerRuleForwardConfigArgs']]:
         """
-        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")
 
@@ -1420,7 +1434,7 @@ class ListenerRuleActionArgs:
     @pulumi.getter(name="targetGroupArn")
     def target_group_arn(self) -> Optional[pulumi.Input[_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")
 
@@ -1958,7 +1972,8 @@ class ListenerRuleFixedResponseConfigArgs:
 if not MYPY:
     class ListenerRuleForwardConfigArgsDict(TypedDict):
         """
-        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``.
         """
         target_group_stickiness_config: NotRequired[pulumi.Input['ListenerRuleTargetGroupStickinessConfigArgsDict']]
         """
@@ -1977,7 +1992,8 @@ class ListenerRuleForwardConfigArgs:
                  target_group_stickiness_config: Optional[pulumi.Input['ListenerRuleTargetGroupStickinessConfigArgs']] = None,
                  target_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleTargetGroupTupleArgs']]]] = 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 pulumi.Input['ListenerRuleTargetGroupStickinessConfigArgs'] target_group_stickiness_config: Information about the target group stickiness for a rule.
         :param pulumi.Input[Sequence[pulumi.Input['ListenerRuleTargetGroupTupleArgs']]] target_groups: Information about how traffic will be distributed between multiple target groups in a forward rule.
         """
@@ -2016,6 +2032,7 @@ if not MYPY:
         """
         Information about a host header condition.
         """
+        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_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.
@@ -2027,15 +2044,27 @@ elif False:
 @pulumi.input_type
 class ListenerRuleHostHeaderConfigArgs:
     def __init__(__self__, *,
+                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         Information about a host header condition.
         :param pulumi.Input[Sequence[pulumi.Input[_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.
                 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[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        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]]]]:
@@ -2060,6 +2089,7 @@ if not MYPY:
         """
         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.
         """
+        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_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).
@@ -2073,6 +2103,7 @@ elif False:
 class ListenerRuleHttpHeaderConfigArgs:
     def __init__(__self__, *,
                  http_header_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         Information about an HTTP header condition.
@@ -2084,6 +2115,8 @@ class ListenerRuleHttpHeaderConfigArgs:
         """
         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)
 
@@ -2099,6 +2132,15 @@ class ListenerRuleHttpHeaderConfigArgs:
     def http_header_name(self, value: Optional[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]]]]:
+        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]]]]:
@@ -2160,6 +2202,7 @@ if not MYPY:
         """
         Information about a path pattern condition.
         """
+        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
         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).
@@ -2171,15 +2214,27 @@ elif False:
 @pulumi.input_type
 class ListenerRulePathPatternConfigArgs:
     def __init__(__self__, *,
+                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         Information about a path pattern condition.
         :param pulumi.Input[Sequence[pulumi.Input[_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[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        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]]]]:
@@ -2444,6 +2499,62 @@ class ListenerRuleRedirectConfigArgs:
         pulumi.set(self, "query", value)
 
 
+if not MYPY:
+    class ListenerRuleRewriteConfigObjectArgsDict(TypedDict):
+        rewrites: pulumi.Input[Sequence[pulumi.Input['ListenerRuleRewriteConfigArgsDict']]]
+elif False:
+    ListenerRuleRewriteConfigObjectArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ListenerRuleRewriteConfigObjectArgs:
+    def __init__(__self__, *,
+                 rewrites: pulumi.Input[Sequence[pulumi.Input['ListenerRuleRewriteConfigArgs']]]):
+        pulumi.set(__self__, "rewrites", rewrites)
+
+    @_builtins.property
+    @pulumi.getter
+    def rewrites(self) -> pulumi.Input[Sequence[pulumi.Input['ListenerRuleRewriteConfigArgs']]]:
+        return pulumi.get(self, "rewrites")
+
+    @rewrites.setter
+    def rewrites(self, value: pulumi.Input[Sequence[pulumi.Input['ListenerRuleRewriteConfigArgs']]]):
+        pulumi.set(self, "rewrites", value)
+
+
+if not MYPY:
+    class ListenerRuleRewriteConfigArgsDict(TypedDict):
+        regex: pulumi.Input[_builtins.str]
+        replace: pulumi.Input[_builtins.str]
+elif False:
+    ListenerRuleRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ListenerRuleRewriteConfigArgs:
+    def __init__(__self__, *,
+                 regex: pulumi.Input[_builtins.str],
+                 replace: pulumi.Input[_builtins.str]):
+        pulumi.set(__self__, "regex", regex)
+        pulumi.set(__self__, "replace", replace)
+
+    @_builtins.property
+    @pulumi.getter
+    def regex(self) -> pulumi.Input[_builtins.str]:
+        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]:
+        return pulumi.get(self, "replace")
+
+    @replace.setter
+    def replace(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "replace", value)
+
+
 if not MYPY:
     class ListenerRuleRuleConditionArgsDict(TypedDict):
         """
@@ -2479,6 +2590,10 @@ if not MYPY:
         """
         Information for a query string condition. Specify only when ``Field`` is ``query-string``.
         """
+        regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_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` .
+        """
         source_ip_config: NotRequired[pulumi.Input['ListenerRuleSourceIpConfigArgsDict']]
         """
         Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
@@ -2511,6 +2626,7 @@ class ListenerRuleRuleConditionArgs:
                  http_request_method_config: Optional[pulumi.Input['ListenerRuleHttpRequestMethodConfigArgs']] = None,
                  path_pattern_config: Optional[pulumi.Input['ListenerRulePathPatternConfigArgs']] = None,
                  query_string_config: Optional[pulumi.Input['ListenerRuleQueryStringConfigArgs']] = None,
+                 regex_values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                  source_ip_config: Optional[pulumi.Input['ListenerRuleSourceIpConfigArgs']] = None,
                  values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
@@ -2527,6 +2643,7 @@ class ListenerRuleRuleConditionArgs:
         :param pulumi.Input['ListenerRuleHttpRequestMethodConfigArgs'] http_request_method_config: Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.
         :param pulumi.Input['ListenerRulePathPatternConfigArgs'] path_pattern_config: Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.
         :param pulumi.Input['ListenerRuleQueryStringConfigArgs'] query_string_config: Information for a query string condition. Specify only when ``Field`` is ``query-string``.
+        :param pulumi.Input[Sequence[pulumi.Input[_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 pulumi.Input['ListenerRuleSourceIpConfigArgs'] source_ip_config: Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
         :param pulumi.Input[Sequence[pulumi.Input[_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.
@@ -2554,6 +2671,8 @@ class ListenerRuleRuleConditionArgs:
             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:
@@ -2637,6 +2756,18 @@ class ListenerRuleRuleConditionArgs:
     def query_string_config(self, value: Optional[pulumi.Input['ListenerRuleQueryStringConfigArgs']]):
         pulumi.set(self, "query_string_config", value)
 
+    @_builtins.property
+    @pulumi.getter(name="regexValues")
+    def regex_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_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")
+
+    @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(name="sourceIpConfig")
     def source_ip_config(self) -> Optional[pulumi.Input['ListenerRuleSourceIpConfigArgs']]:
@@ -2722,7 +2853,7 @@ if not MYPY:
         """
         duration_seconds: NotRequired[pulumi.Input[_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.
         """
         enabled: NotRequired[pulumi.Input[_builtins.bool]]
         """
@@ -2738,7 +2869,7 @@ class ListenerRuleTargetGroupStickinessConfigArgs:
                  enabled: Optional[pulumi.Input[_builtins.bool]] = None):
         """
         Information about the target group stickiness for a rule.
-        :param pulumi.Input[_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 pulumi.Input[_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 pulumi.Input[_builtins.bool] enabled: Indicates whether target group stickiness is enabled.
         """
         if duration_seconds is not None:
@@ -2750,7 +2881,7 @@ class ListenerRuleTargetGroupStickinessConfigArgs:
     @pulumi.getter(name="durationSeconds")
     def duration_seconds(self) -> Optional[pulumi.Input[_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")
 
@@ -2827,6 +2958,54 @@ class ListenerRuleTargetGroupTupleArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class ListenerRuleTransformArgsDict(TypedDict):
+        type: pulumi.Input[_builtins.str]
+        host_header_rewrite_config: NotRequired[pulumi.Input['ListenerRuleRewriteConfigObjectArgsDict']]
+        url_rewrite_config: NotRequired[pulumi.Input['ListenerRuleRewriteConfigObjectArgsDict']]
+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['ListenerRuleRewriteConfigObjectArgs']] = None,
+                 url_rewrite_config: Optional[pulumi.Input['ListenerRuleRewriteConfigObjectArgs']] = 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) -> pulumi.Input[_builtins.str]:
+        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['ListenerRuleRewriteConfigObjectArgs']]:
+        return pulumi.get(self, "host_header_rewrite_config")
+
+    @host_header_rewrite_config.setter
+    def host_header_rewrite_config(self, value: Optional[pulumi.Input['ListenerRuleRewriteConfigObjectArgs']]):
+        pulumi.set(self, "host_header_rewrite_config", value)
+
+    @_builtins.property
+    @pulumi.getter(name="urlRewriteConfig")
+    def url_rewrite_config(self) -> Optional[pulumi.Input['ListenerRuleRewriteConfigObjectArgs']]:
+        return pulumi.get(self, "url_rewrite_config")
+
+    @url_rewrite_config.setter
+    def url_rewrite_config(self, value: Optional[pulumi.Input['ListenerRuleRewriteConfigObjectArgs']]):
+        pulumi.set(self, "url_rewrite_config", value)
+
+
 if not MYPY:
     class ListenerTargetGroupStickinessConfigArgsDict(TypedDict):
         """
@@ -2834,7 +3013,7 @@ if not MYPY:
         """
         duration_seconds: NotRequired[pulumi.Input[_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.
         """
         enabled: NotRequired[pulumi.Input[_builtins.bool]]
         """
@@ -2850,7 +3029,7 @@ class ListenerTargetGroupStickinessConfigArgs:
                  enabled: Optional[pulumi.Input[_builtins.bool]] = None):
         """
         Information about the target group stickiness for a rule.
-        :param pulumi.Input[_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 pulumi.Input[_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 pulumi.Input[_builtins.bool] enabled: Indicates whether target group stickiness is enabled.
         """
         if duration_seconds is not None:
@@ -2862,7 +3041,7 @@ class ListenerTargetGroupStickinessConfigArgs:
     @pulumi.getter(name="durationSeconds")
     def duration_seconds(self) -> Optional[pulumi.Input[_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/elasticloadbalancingv2/get_listener_rule.py

@@ -24,7 +24,7 @@ __all__ = [
 
 @pulumi.output_type
 class GetListenerRuleResult:
-    def __init__(__self__, actions=None, conditions=None, is_default=None, priority=None, rule_arn=None):
+    def __init__(__self__, actions=None, conditions=None, is_default=None, priority=None, rule_arn=None, transforms=None):
         if actions and not isinstance(actions, list):
             raise TypeError("Expected argument 'actions' to be a list")
         pulumi.set(__self__, "actions", actions)
@@ -40,6 +40,9 @@ class GetListenerRuleResult:
         if rule_arn and not isinstance(rule_arn, str):
             raise TypeError("Expected argument 'rule_arn' to be a str")
         pulumi.set(__self__, "rule_arn", rule_arn)
+        if transforms and not isinstance(transforms, list):
+            raise TypeError("Expected argument 'transforms' to be a list")
+        pulumi.set(__self__, "transforms", transforms)
 
     @_builtins.property
     @pulumi.getter
@@ -84,6 +87,11 @@ class GetListenerRuleResult:
         """
         return pulumi.get(self, "rule_arn")
 
+    @_builtins.property
+    @pulumi.getter
+    def transforms(self) -> Optional[Sequence['outputs.ListenerRuleTransform']]:
+        return pulumi.get(self, "transforms")
+
 
 class AwaitableGetListenerRuleResult(GetListenerRuleResult):
     # pylint: disable=using-constant-test
@@ -95,7 +103,8 @@ class AwaitableGetListenerRuleResult(GetListenerRuleResult):
             conditions=self.conditions,
             is_default=self.is_default,
             priority=self.priority,
-            rule_arn=self.rule_arn)
+            rule_arn=self.rule_arn,
+            transforms=self.transforms)
 
 
 def get_listener_rule(rule_arn: Optional[_builtins.str] = None,
@@ -117,7 +126,8 @@ def get_listener_rule(rule_arn: Optional[_builtins.str] = None,
         conditions=pulumi.get(__ret__, 'conditions'),
         is_default=pulumi.get(__ret__, 'is_default'),
         priority=pulumi.get(__ret__, 'priority'),
-        rule_arn=pulumi.get(__ret__, 'rule_arn'))
+        rule_arn=pulumi.get(__ret__, 'rule_arn'),
+        transforms=pulumi.get(__ret__, 'transforms'))
 def get_listener_rule_output(rule_arn: Optional[pulumi.Input[_builtins.str]] = None,
                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetListenerRuleResult]:
     """
@@ -136,4 +146,5 @@ def get_listener_rule_output(rule_arn: Optional[pulumi.Input[_builtins.str]] = N
         conditions=pulumi.get(__response__, 'conditions'),
         is_default=pulumi.get(__response__, 'is_default'),
         priority=pulumi.get(__response__, 'priority'),
-        rule_arn=pulumi.get(__response__, 'rule_arn')))
+        rule_arn=pulumi.get(__response__, 'rule_arn'),
+        transforms=pulumi.get(__response__, 'transforms')))

pulumi_aws_native/elasticloadbalancingv2/listener_rule.py

@@ -24,7 +24,8 @@ class ListenerRuleArgs:
                  actions: pulumi.Input[Sequence[pulumi.Input['ListenerRuleActionArgs']]],
                  conditions: pulumi.Input[Sequence[pulumi.Input['ListenerRuleRuleConditionArgs']]],
                  priority: pulumi.Input[_builtins.int],
-                 listener_arn: Optional[pulumi.Input[_builtins.str]] = None):
+                 listener_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 transforms: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleTransformArgs']]]] = None):
         """
         The set of arguments for constructing a ListenerRule resource.
         :param pulumi.Input[Sequence[pulumi.Input['ListenerRuleActionArgs']]] actions: The actions.
@@ -40,6 +41,8 @@ class ListenerRuleArgs:
         pulumi.set(__self__, "priority", priority)
         if listener_arn is not None:
             pulumi.set(__self__, "listener_arn", listener_arn)
+        if transforms is not None:
+            pulumi.set(__self__, "transforms", transforms)
 
     @_builtins.property
     @pulumi.getter
@@ -92,6 +95,15 @@ class ListenerRuleArgs:
     def listener_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
         pulumi.set(self, "listener_arn", value)
 
+    @_builtins.property
+    @pulumi.getter
+    def transforms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleTransformArgs']]]]:
+        return pulumi.get(self, "transforms")
+
+    @transforms.setter
+    def transforms(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleTransformArgs']]]]):
+        pulumi.set(self, "transforms", value)
+
 
 @pulumi.type_token("aws-native:elasticloadbalancingv2:ListenerRule")
 class ListenerRule(pulumi.CustomResource):
@@ -103,6 +115,7 @@ class ListenerRule(pulumi.CustomResource):
                  conditions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ListenerRuleRuleConditionArgs', 'ListenerRuleRuleConditionArgsDict']]]]] = None,
                  listener_arn: Optional[pulumi.Input[_builtins.str]] = None,
                  priority: Optional[pulumi.Input[_builtins.int]] = None,
+                 transforms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ListenerRuleTransformArgs', 'ListenerRuleTransformArgsDict']]]]] = None,
                  __props__=None):
         """
         Specifies a listener rule. The listener must be associated with an Application Load Balancer. Each rule consists of a priority, one or more actions, and one or more conditions.
@@ -147,6 +160,7 @@ class ListenerRule(pulumi.CustomResource):
                  conditions: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ListenerRuleRuleConditionArgs', 'ListenerRuleRuleConditionArgsDict']]]]] = None,
                  listener_arn: Optional[pulumi.Input[_builtins.str]] = None,
                  priority: Optional[pulumi.Input[_builtins.int]] = None,
+                 transforms: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ListenerRuleTransformArgs', 'ListenerRuleTransformArgsDict']]]]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
         if not isinstance(opts, pulumi.ResourceOptions):
@@ -166,6 +180,7 @@ class ListenerRule(pulumi.CustomResource):
             if priority is None and not opts.urn:
                 raise TypeError("Missing required property 'priority'")
             __props__.__dict__["priority"] = priority
+            __props__.__dict__["transforms"] = transforms
             __props__.__dict__["is_default"] = None
             __props__.__dict__["rule_arn"] = None
         replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["listenerArn"])
@@ -198,6 +213,7 @@ class ListenerRule(pulumi.CustomResource):
         __props__.__dict__["listener_arn"] = None
         __props__.__dict__["priority"] = None
         __props__.__dict__["rule_arn"] = None
+        __props__.__dict__["transforms"] = None
         return ListenerRule(resource_name, opts=opts, __props__=__props__)
 
     @_builtins.property
@@ -251,3 +267,8 @@ class ListenerRule(pulumi.CustomResource):
         """
         return pulumi.get(self, "rule_arn")
 
+    @_builtins.property
+    @pulumi.getter
+    def transforms(self) -> pulumi.Output[Optional[Sequence['outputs.ListenerRuleTransform']]]:
+        return pulumi.get(self, "transforms")
+