pulumi-aws-native 1.38.0a1761716526__py3-none-any.whl → 1.38.0a1761739268__py3-none-any.whl

pulumi_aws_native/ecs/_inputs.py

@@ -68,8 +68,12 @@ __all__ = [
     'ServiceAdvancedConfigurationArgsDict',
     'ServiceAwsVpcConfigurationArgs',
     'ServiceAwsVpcConfigurationArgsDict',
+    'ServiceCanaryConfigurationArgs',
+    'ServiceCanaryConfigurationArgsDict',
     'ServiceCapacityProviderStrategyItemArgs',
     'ServiceCapacityProviderStrategyItemArgsDict',
+    'ServiceConnectAccessLogConfigurationArgs',
+    'ServiceConnectAccessLogConfigurationArgsDict',
     'ServiceConnectClientAliasArgs',
     'ServiceConnectClientAliasArgsDict',
     'ServiceConnectConfigurationArgs',
@@ -100,6 +104,8 @@ __all__ = [
     'ServiceEbsTagSpecificationArgsDict',
     'ServiceForceNewDeploymentArgs',
     'ServiceForceNewDeploymentArgsDict',
+    'ServiceLinearConfigurationArgs',
+    'ServiceLinearConfigurationArgsDict',
     'ServiceLoadBalancerArgs',
     'ServiceLoadBalancerArgsDict',
     'ServiceLogConfigurationArgs',
@@ -2508,6 +2514,42 @@ class ServiceAwsVpcConfigurationArgs:
         pulumi.set(self, "subnets", value)
 
 
+if not MYPY:
+    class ServiceCanaryConfigurationArgsDict(TypedDict):
+        canary_bake_time_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        canary_percent: NotRequired[pulumi.Input[_builtins.float]]
+elif False:
+    ServiceCanaryConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceCanaryConfigurationArgs:
+    def __init__(__self__, *,
+                 canary_bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 canary_percent: Optional[pulumi.Input[_builtins.float]] = None):
+        if canary_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "canary_bake_time_in_minutes", canary_bake_time_in_minutes)
+        if canary_percent is not None:
+            pulumi.set(__self__, "canary_percent", canary_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryBakeTimeInMinutes")
+    def canary_bake_time_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        return pulumi.get(self, "canary_bake_time_in_minutes")
+
+    @canary_bake_time_in_minutes.setter
+    def canary_bake_time_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "canary_bake_time_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryPercent")
+    def canary_percent(self) -> Optional[pulumi.Input[_builtins.float]]:
+        return pulumi.get(self, "canary_percent")
+
+    @canary_percent.setter
+    def canary_percent(self, value: Optional[pulumi.Input[_builtins.float]]):
+        pulumi.set(self, "canary_percent", value)
+
+
 if not MYPY:
     class ServiceCapacityProviderStrategyItemArgsDict(TypedDict):
         """
@@ -2650,6 +2692,41 @@ class ServiceCapacityProviderStrategyItemArgs:
         pulumi.set(self, "weight", value)
 
 
+if not MYPY:
+    class ServiceConnectAccessLogConfigurationArgsDict(TypedDict):
+        format: pulumi.Input['ServiceConnectAccessLogConfigurationFormat']
+        include_query_parameters: NotRequired[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]
+elif False:
+    ServiceConnectAccessLogConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceConnectAccessLogConfigurationArgs:
+    def __init__(__self__, *,
+                 format: pulumi.Input['ServiceConnectAccessLogConfigurationFormat'],
+                 include_query_parameters: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']] = None):
+        pulumi.set(__self__, "format", format)
+        if include_query_parameters is not None:
+            pulumi.set(__self__, "include_query_parameters", include_query_parameters)
+
+    @_builtins.property
+    @pulumi.getter
+    def format(self) -> pulumi.Input['ServiceConnectAccessLogConfigurationFormat']:
+        return pulumi.get(self, "format")
+
+    @format.setter
+    def format(self, value: pulumi.Input['ServiceConnectAccessLogConfigurationFormat']):
+        pulumi.set(self, "format", value)
+
+    @_builtins.property
+    @pulumi.getter(name="includeQueryParameters")
+    def include_query_parameters(self) -> Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]:
+        return pulumi.get(self, "include_query_parameters")
+
+    @include_query_parameters.setter
+    def include_query_parameters(self, value: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationIncludeQueryParameters']]):
+        pulumi.set(self, "include_query_parameters", value)
+
+
 if not MYPY:
     class ServiceConnectClientAliasArgsDict(TypedDict):
         """
@@ -2748,6 +2825,7 @@ if not MYPY:
         """
         Specifies whether to use Service Connect with this service.
         """
+        access_log_configuration: NotRequired[pulumi.Input['ServiceConnectAccessLogConfigurationArgsDict']]
         log_configuration: NotRequired[pulumi.Input['ServiceLogConfigurationArgsDict']]
         """
         The log configuration for the container. This parameter maps to ``LogConfig`` in the docker container create command and the ``--log-driver`` option to docker run.
@@ -2777,6 +2855,7 @@ elif False:
 class ServiceConnectConfigurationArgs:
     def __init__(__self__, *,
                  enabled: pulumi.Input[_builtins.bool],
+                 access_log_configuration: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']] = None,
                  log_configuration: Optional[pulumi.Input['ServiceLogConfigurationArgs']] = None,
                  namespace: Optional[pulumi.Input[_builtins.str]] = None,
                  services: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceConnectServiceArgs']]]] = None):
@@ -2799,6 +2878,8 @@ class ServiceConnectConfigurationArgs:
                 An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if access_log_configuration is not None:
+            pulumi.set(__self__, "access_log_configuration", access_log_configuration)
         if log_configuration is not None:
             pulumi.set(__self__, "log_configuration", log_configuration)
         if namespace is not None:
@@ -2818,6 +2899,15 @@ class ServiceConnectConfigurationArgs:
     def enabled(self, value: pulumi.Input[_builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @_builtins.property
+    @pulumi.getter(name="accessLogConfiguration")
+    def access_log_configuration(self) -> Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']]:
+        return pulumi.get(self, "access_log_configuration")
+
+    @access_log_configuration.setter
+    def access_log_configuration(self, value: Optional[pulumi.Input['ServiceConnectAccessLogConfigurationArgs']]):
+        pulumi.set(self, "access_log_configuration", value)
+
     @_builtins.property
     @pulumi.getter(name="logConfiguration")
     def log_configuration(self) -> Optional[pulumi.Input['ServiceLogConfigurationArgs']]:
@@ -3377,7 +3467,7 @@ if not MYPY:
           +  When you use an external deployment controller (``EXTERNAL``), or the ACD blue/green deployment controller (``CODE_DEPLOY``), the value is set to 3 hours (180 minutes).
           +  For all other cases, the value is set to 36 hours (2160 minutes).
         """
-        canary_configuration: NotRequired[Any]
+        canary_configuration: NotRequired[pulumi.Input['ServiceCanaryConfigurationArgsDict']]
         deployment_circuit_breaker: NotRequired[pulumi.Input['ServiceDeploymentCircuitBreakerArgsDict']]
         """
         The deployment circuit breaker can only be used for services using the rolling update (``ECS``) deployment type.
@@ -3387,7 +3477,7 @@ if not MYPY:
         """
         An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
         """
-        linear_configuration: NotRequired[Any]
+        linear_configuration: NotRequired[pulumi.Input['ServiceLinearConfigurationArgsDict']]
         maximum_percent: NotRequired[pulumi.Input[_builtins.int]]
         """
         If a service is using the rolling update (``ECS``) deployment type, the ``maximumPercent`` parameter represents an upper limit on the number of your service's tasks that are allowed in the ``RUNNING`` or ``PENDING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the ``REPLICA`` service scheduler and has a ``desiredCount`` of four tasks and a ``maximumPercent`` value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default ``maximumPercent`` value for a service using the ``REPLICA`` service scheduler is 200%.
@@ -3429,10 +3519,10 @@ class ServiceDeploymentConfigurationArgs:
     def __init__(__self__, *,
                  alarms: Optional[pulumi.Input['ServiceDeploymentAlarmsArgs']] = None,
                  bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
-                 canary_configuration: Optional[Any] = None,
+                 canary_configuration: Optional[pulumi.Input['ServiceCanaryConfigurationArgs']] = None,
                  deployment_circuit_breaker: Optional[pulumi.Input['ServiceDeploymentCircuitBreakerArgs']] = None,
                  lifecycle_hooks: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceDeploymentLifecycleHookArgs']]]] = None,
-                 linear_configuration: Optional[Any] = None,
+                 linear_configuration: Optional[pulumi.Input['ServiceLinearConfigurationArgs']] = None,
                  maximum_percent: Optional[pulumi.Input[_builtins.int]] = None,
                  minimum_healthy_percent: Optional[pulumi.Input[_builtins.int]] = None,
                  strategy: Optional[pulumi.Input['ServiceDeploymentConfigurationStrategy']] = None):
@@ -3521,11 +3611,11 @@ class ServiceDeploymentConfigurationArgs:
 
     @_builtins.property
     @pulumi.getter(name="canaryConfiguration")
-    def canary_configuration(self) -> Optional[Any]:
+    def canary_configuration(self) -> Optional[pulumi.Input['ServiceCanaryConfigurationArgs']]:
         return pulumi.get(self, "canary_configuration")
 
     @canary_configuration.setter
-    def canary_configuration(self, value: Optional[Any]):
+    def canary_configuration(self, value: Optional[pulumi.Input['ServiceCanaryConfigurationArgs']]):
         pulumi.set(self, "canary_configuration", value)
 
     @_builtins.property
@@ -3555,11 +3645,11 @@ class ServiceDeploymentConfigurationArgs:
 
     @_builtins.property
     @pulumi.getter(name="linearConfiguration")
-    def linear_configuration(self) -> Optional[Any]:
+    def linear_configuration(self) -> Optional[pulumi.Input['ServiceLinearConfigurationArgs']]:
         return pulumi.get(self, "linear_configuration")
 
     @linear_configuration.setter
-    def linear_configuration(self, value: Optional[Any]):
+    def linear_configuration(self, value: Optional[pulumi.Input['ServiceLinearConfigurationArgs']]):
         pulumi.set(self, "linear_configuration", value)
 
     @_builtins.property
@@ -4067,6 +4157,42 @@ class ServiceForceNewDeploymentArgs:
         pulumi.set(self, "force_new_deployment_nonce", value)
 
 
+if not MYPY:
+    class ServiceLinearConfigurationArgsDict(TypedDict):
+        step_bake_time_in_minutes: NotRequired[pulumi.Input[_builtins.int]]
+        step_percent: NotRequired[pulumi.Input[_builtins.float]]
+elif False:
+    ServiceLinearConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServiceLinearConfigurationArgs:
+    def __init__(__self__, *,
+                 step_bake_time_in_minutes: Optional[pulumi.Input[_builtins.int]] = None,
+                 step_percent: Optional[pulumi.Input[_builtins.float]] = None):
+        if step_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "step_bake_time_in_minutes", step_bake_time_in_minutes)
+        if step_percent is not None:
+            pulumi.set(__self__, "step_percent", step_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="stepBakeTimeInMinutes")
+    def step_bake_time_in_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
+        return pulumi.get(self, "step_bake_time_in_minutes")
+
+    @step_bake_time_in_minutes.setter
+    def step_bake_time_in_minutes(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "step_bake_time_in_minutes", value)
+
+    @_builtins.property
+    @pulumi.getter(name="stepPercent")
+    def step_percent(self) -> Optional[pulumi.Input[_builtins.float]]:
+        return pulumi.get(self, "step_percent")
+
+    @step_percent.setter
+    def step_percent(self, value: Optional[pulumi.Input[_builtins.float]]):
+        pulumi.set(self, "step_percent", value)
+
+
 if not MYPY:
     class ServiceLoadBalancerArgsDict(TypedDict):
         """

pulumi_aws_native/ecs/outputs.py

@@ -43,7 +43,9 @@ __all__ = [
     'ClusterSettings',
     'ServiceAdvancedConfiguration',
     'ServiceAwsVpcConfiguration',
+    'ServiceCanaryConfiguration',
     'ServiceCapacityProviderStrategyItem',
+    'ServiceConnectAccessLogConfiguration',
     'ServiceConnectClientAlias',
     'ServiceConnectConfiguration',
     'ServiceConnectService',
@@ -59,6 +61,7 @@ __all__ = [
     'ServiceDeploymentLifecycleHook',
     'ServiceEbsTagSpecification',
     'ServiceForceNewDeployment',
+    'ServiceLinearConfiguration',
     'ServiceLoadBalancer',
     'ServiceLogConfiguration',
     'ServiceManagedEbsVolumeConfiguration',
@@ -1858,6 +1861,46 @@ class ServiceAwsVpcConfiguration(dict):
         return pulumi.get(self, "subnets")
 
 
+@pulumi.output_type
+class ServiceCanaryConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "canaryBakeTimeInMinutes":
+            suggest = "canary_bake_time_in_minutes"
+        elif key == "canaryPercent":
+            suggest = "canary_percent"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceCanaryConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceCanaryConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceCanaryConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 canary_bake_time_in_minutes: Optional[_builtins.int] = None,
+                 canary_percent: Optional[_builtins.float] = None):
+        if canary_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "canary_bake_time_in_minutes", canary_bake_time_in_minutes)
+        if canary_percent is not None:
+            pulumi.set(__self__, "canary_percent", canary_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryBakeTimeInMinutes")
+    def canary_bake_time_in_minutes(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "canary_bake_time_in_minutes")
+
+    @_builtins.property
+    @pulumi.getter(name="canaryPercent")
+    def canary_percent(self) -> Optional[_builtins.float]:
+        return pulumi.get(self, "canary_percent")
+
+
 @pulumi.output_type
 class ServiceCapacityProviderStrategyItem(dict):
     """
@@ -1968,6 +2011,43 @@ class ServiceCapacityProviderStrategyItem(dict):
         return pulumi.get(self, "weight")
 
 
+@pulumi.output_type
+class ServiceConnectAccessLogConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "includeQueryParameters":
+            suggest = "include_query_parameters"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceConnectAccessLogConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceConnectAccessLogConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceConnectAccessLogConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 format: 'ServiceConnectAccessLogConfigurationFormat',
+                 include_query_parameters: Optional['ServiceConnectAccessLogConfigurationIncludeQueryParameters'] = None):
+        pulumi.set(__self__, "format", format)
+        if include_query_parameters is not None:
+            pulumi.set(__self__, "include_query_parameters", include_query_parameters)
+
+    @_builtins.property
+    @pulumi.getter
+    def format(self) -> 'ServiceConnectAccessLogConfigurationFormat':
+        return pulumi.get(self, "format")
+
+    @_builtins.property
+    @pulumi.getter(name="includeQueryParameters")
+    def include_query_parameters(self) -> Optional['ServiceConnectAccessLogConfigurationIncludeQueryParameters']:
+        return pulumi.get(self, "include_query_parameters")
+
+
 @pulumi.output_type
 class ServiceConnectClientAlias(dict):
     """
@@ -2052,7 +2132,9 @@ class ServiceConnectConfiguration(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "logConfiguration":
+        if key == "accessLogConfiguration":
+            suggest = "access_log_configuration"
+        elif key == "logConfiguration":
             suggest = "log_configuration"
 
         if suggest:
@@ -2068,6 +2150,7 @@ class ServiceConnectConfiguration(dict):
 
     def __init__(__self__, *,
                  enabled: _builtins.bool,
+                 access_log_configuration: Optional['outputs.ServiceConnectAccessLogConfiguration'] = None,
                  log_configuration: Optional['outputs.ServiceLogConfiguration'] = None,
                  namespace: Optional[_builtins.str] = None,
                  services: Optional[Sequence['outputs.ServiceConnectService']] = None):
@@ -2090,6 +2173,8 @@ class ServiceConnectConfiguration(dict):
                 An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if access_log_configuration is not None:
+            pulumi.set(__self__, "access_log_configuration", access_log_configuration)
         if log_configuration is not None:
             pulumi.set(__self__, "log_configuration", log_configuration)
         if namespace is not None:
@@ -2105,6 +2190,11 @@ class ServiceConnectConfiguration(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="accessLogConfiguration")
+    def access_log_configuration(self) -> Optional['outputs.ServiceConnectAccessLogConfiguration']:
+        return pulumi.get(self, "access_log_configuration")
+
     @_builtins.property
     @pulumi.getter(name="logConfiguration")
     def log_configuration(self) -> Optional['outputs.ServiceLogConfiguration']:
@@ -2561,10 +2651,10 @@ class ServiceDeploymentConfiguration(dict):
     def __init__(__self__, *,
                  alarms: Optional['outputs.ServiceDeploymentAlarms'] = None,
                  bake_time_in_minutes: Optional[_builtins.int] = None,
-                 canary_configuration: Optional[Any] = None,
+                 canary_configuration: Optional['outputs.ServiceCanaryConfiguration'] = None,
                  deployment_circuit_breaker: Optional['outputs.ServiceDeploymentCircuitBreaker'] = None,
                  lifecycle_hooks: Optional[Sequence['outputs.ServiceDeploymentLifecycleHook']] = None,
-                 linear_configuration: Optional[Any] = None,
+                 linear_configuration: Optional['outputs.ServiceLinearConfiguration'] = None,
                  maximum_percent: Optional[_builtins.int] = None,
                  minimum_healthy_percent: Optional[_builtins.int] = None,
                  strategy: Optional['ServiceDeploymentConfigurationStrategy'] = None):
@@ -2645,7 +2735,7 @@ class ServiceDeploymentConfiguration(dict):
 
     @_builtins.property
     @pulumi.getter(name="canaryConfiguration")
-    def canary_configuration(self) -> Optional[Any]:
+    def canary_configuration(self) -> Optional['outputs.ServiceCanaryConfiguration']:
         return pulumi.get(self, "canary_configuration")
 
     @_builtins.property
@@ -2667,7 +2757,7 @@ class ServiceDeploymentConfiguration(dict):
 
     @_builtins.property
     @pulumi.getter(name="linearConfiguration")
-    def linear_configuration(self) -> Optional[Any]:
+    def linear_configuration(self) -> Optional['outputs.ServiceLinearConfiguration']:
         return pulumi.get(self, "linear_configuration")
 
     @_builtins.property
@@ -3062,6 +3152,46 @@ class ServiceForceNewDeployment(dict):
         return pulumi.get(self, "force_new_deployment_nonce")
 
 
+@pulumi.output_type
+class ServiceLinearConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "stepBakeTimeInMinutes":
+            suggest = "step_bake_time_in_minutes"
+        elif key == "stepPercent":
+            suggest = "step_percent"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceLinearConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceLinearConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceLinearConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 step_bake_time_in_minutes: Optional[_builtins.int] = None,
+                 step_percent: Optional[_builtins.float] = None):
+        if step_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "step_bake_time_in_minutes", step_bake_time_in_minutes)
+        if step_percent is not None:
+            pulumi.set(__self__, "step_percent", step_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="stepBakeTimeInMinutes")
+    def step_bake_time_in_minutes(self) -> Optional[_builtins.int]:
+        return pulumi.get(self, "step_bake_time_in_minutes")
+
+    @_builtins.property
+    @pulumi.getter(name="stepPercent")
+    def step_percent(self) -> Optional[_builtins.float]:
+        return pulumi.get(self, "step_percent")
+
+
 @pulumi.output_type
 class ServiceLoadBalancer(dict):
     """

pulumi_aws_native/elasticloadbalancingv2/_inputs.py

@@ -2035,7 +2035,7 @@ if not MYPY:
         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.
+        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.
         """
 elif False:
@@ -2048,7 +2048,7 @@ class ListenerRuleHostHeaderConfigArgs:
                  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.
+        :param pulumi.Input[Sequence[pulumi.Input[_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:
@@ -2069,7 +2069,7 @@ class ListenerRuleHostHeaderConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[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.
+        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")
@@ -2092,7 +2092,7 @@ if not MYPY:
         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).
+        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.
         """
@@ -2109,7 +2109,7 @@ class ListenerRuleHttpHeaderConfigArgs:
         Information about an HTTP header condition.
          There is a set of standard HTTP header fields. You can also define custom HTTP header fields.
         :param pulumi.Input[_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 pulumi.Input[Sequence[pulumi.Input[_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 pulumi.Input[Sequence[pulumi.Input[_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.
         """
@@ -2145,7 +2145,7 @@ class ListenerRuleHttpHeaderConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[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).
+        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.
         """
@@ -2164,7 +2164,7 @@ if not MYPY:
         """
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_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.
         """
 elif False:
@@ -2177,7 +2177,7 @@ class ListenerRuleHttpRequestMethodConfigArgs:
         """
         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 pulumi.Input[Sequence[pulumi.Input[_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 pulumi.Input[Sequence[pulumi.Input[_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:
@@ -2187,7 +2187,7 @@ class ListenerRuleHttpRequestMethodConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_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")
@@ -2257,7 +2257,7 @@ if not MYPY:
         """
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgsDict']]]]
         """
-        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.
         """
 elif False:
@@ -2270,7 +2270,7 @@ class ListenerRuleQueryStringConfigArgs:
         """
         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 pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]] 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 pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]] 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:
@@ -2280,7 +2280,7 @@ class ListenerRuleQueryStringConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]]]:
         """
-        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")

pulumi_aws_native/elasticloadbalancingv2/load_balancer.py

@@ -39,7 +39,7 @@ class LoadBalancerArgs:
                  type: Optional[pulumi.Input[_builtins.str]] = None):
         """
         The set of arguments for constructing a LoadBalancer resource.
-        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         :param pulumi.Input[_builtins.str] enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.
         :param pulumi.Input[_builtins.str] enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.
                 You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
@@ -104,7 +104,7 @@ class LoadBalancerArgs:
     @pulumi.getter(name="enableCapacityReservationProvisionStabilize")
     def enable_capacity_reservation_provision_stabilize(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         """
         return pulumi.get(self, "enable_capacity_reservation_provision_stabilize")
 
@@ -312,7 +312,7 @@ class LoadBalancer(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         :param pulumi.Input[_builtins.str] enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.
         :param pulumi.Input[_builtins.str] enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.
                 You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
@@ -475,7 +475,7 @@ class LoadBalancer(pulumi.CustomResource):
     @pulumi.getter(name="enableCapacityReservationProvisionStabilize")
     def enable_capacity_reservation_provision_stabilize(self) -> pulumi.Output[Optional[_builtins.bool]]:
         """
-        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         """
         return pulumi.get(self, "enable_capacity_reservation_provision_stabilize")