aws-cdk-lib 2.167.2__py3-none-any.whl → 2.169.0__py3-none-any.whl

aws_cdk/aws_sns/__init__.py

@@ -419,6 +419,45 @@ from ..aws_kms import IKey as _IKey_5f11635f
 from ..aws_sqs import IQueue as _IQueue_7ed6f679
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_sns.BackoffFunction")
+class BackoffFunction(enum.Enum):
+    '''Algorithms which can be used by SNS to calculate the delays associated with all of the retry attempts between the first and last retries in the backoff phase.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        my_topic = sns.Topic(self, "MyTopic")
+        
+        my_topic.add_subscription(
+            subscriptions.UrlSubscription("https://foobar.com/",
+                delivery_policy=sns.DeliveryPolicy(
+                    healthy_retry_policy=sns.HealthyRetryPolicy(
+                        min_delay_target=Duration.seconds(5),
+                        max_delay_target=Duration.seconds(10),
+                        num_retries=6,
+                        backoff_function=sns.BackoffFunction.EXPONENTIAL
+                    ),
+                    throttle_policy=sns.ThrottlePolicy(
+                        max_receives_per_second=10
+                    ),
+                    request_policy=sns.RequestPolicy(
+                        header_content_type="application/json"
+                    )
+                )
+            ))
+    '''
+
+    ARITHMETIC = "ARITHMETIC"
+    '''Arithmetic, see {@link https://docs.aws.amazon.com/images/sns/latest/dg/images/backoff-graph.png this image} for how this function compares to others.'''
+    EXPONENTIAL = "EXPONENTIAL"
+    '''Exponential, see {@link https://docs.aws.amazon.com/images/sns/latest/dg/images/backoff-graph.png this image} for how this function compares to others.'''
+    GEOMETRIC = "GEOMETRIC"
+    '''Geometric, see {@link https://docs.aws.amazon.com/images/sns/latest/dg/images/backoff-graph.png this image} for how this function compares to others.'''
+    LINEAR = "LINEAR"
+    '''Linear, see {@link https://docs.aws.amazon.com/images/sns/latest/dg/images/backoff-graph.png this image} for how this function compares to others.'''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_sns.BetweenCondition",
     jsii_struct_bases=[],
@@ -2257,6 +2296,111 @@ class CfnTopicProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_sns.DeliveryPolicy",
+    jsii_struct_bases=[],
+    name_mapping={
+        "healthy_retry_policy": "healthyRetryPolicy",
+        "request_policy": "requestPolicy",
+        "throttle_policy": "throttlePolicy",
+    },
+)
+class DeliveryPolicy:
+    def __init__(
+        self,
+        *,
+        healthy_retry_policy: typing.Optional[typing.Union["HealthyRetryPolicy", typing.Dict[builtins.str, typing.Any]]] = None,
+        request_policy: typing.Optional[typing.Union["RequestPolicy", typing.Dict[builtins.str, typing.Any]]] = None,
+        throttle_policy: typing.Optional[typing.Union["ThrottlePolicy", typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Options for customising the delivery of SNS messages to HTTP/S endpoints.
+
+        :param healthy_retry_policy: The retry policy of the delivery of SNS messages to HTTP/S endpoints. Default: - Amazon SNS attempts up to three retries with a delay between failed attempts set at 20 seconds
+        :param request_policy: The request of the content sent in AWS SNS HTTP/S requests. Default: - The content type is set to 'text/plain; charset=UTF-8'
+        :param throttle_policy: The throttling policy of the delivery of SNS messages to HTTP/S endpoints. Default: - No throttling
+
+        :exampleMetadata: infused
+
+        Example::
+
+            my_topic = sns.Topic(self, "MyTopic")
+            
+            my_topic.add_subscription(
+                subscriptions.UrlSubscription("https://foobar.com/",
+                    delivery_policy=sns.DeliveryPolicy(
+                        healthy_retry_policy=sns.HealthyRetryPolicy(
+                            min_delay_target=Duration.seconds(5),
+                            max_delay_target=Duration.seconds(10),
+                            num_retries=6,
+                            backoff_function=sns.BackoffFunction.EXPONENTIAL
+                        ),
+                        throttle_policy=sns.ThrottlePolicy(
+                            max_receives_per_second=10
+                        ),
+                        request_policy=sns.RequestPolicy(
+                            header_content_type="application/json"
+                        )
+                    )
+                ))
+        '''
+        if isinstance(healthy_retry_policy, dict):
+            healthy_retry_policy = HealthyRetryPolicy(**healthy_retry_policy)
+        if isinstance(request_policy, dict):
+            request_policy = RequestPolicy(**request_policy)
+        if isinstance(throttle_policy, dict):
+            throttle_policy = ThrottlePolicy(**throttle_policy)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4b77bc2bacea1b5a536852c018892cbf213e209fa1462f79eed79e56c3588546)
+            check_type(argname="argument healthy_retry_policy", value=healthy_retry_policy, expected_type=type_hints["healthy_retry_policy"])
+            check_type(argname="argument request_policy", value=request_policy, expected_type=type_hints["request_policy"])
+            check_type(argname="argument throttle_policy", value=throttle_policy, expected_type=type_hints["throttle_policy"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if healthy_retry_policy is not None:
+            self._values["healthy_retry_policy"] = healthy_retry_policy
+        if request_policy is not None:
+            self._values["request_policy"] = request_policy
+        if throttle_policy is not None:
+            self._values["throttle_policy"] = throttle_policy
+
+    @builtins.property
+    def healthy_retry_policy(self) -> typing.Optional["HealthyRetryPolicy"]:
+        '''The retry policy of the delivery of SNS messages to HTTP/S endpoints.
+
+        :default: - Amazon SNS attempts up to three retries with a delay between failed attempts set at 20 seconds
+        '''
+        result = self._values.get("healthy_retry_policy")
+        return typing.cast(typing.Optional["HealthyRetryPolicy"], result)
+
+    @builtins.property
+    def request_policy(self) -> typing.Optional["RequestPolicy"]:
+        '''The request of the content sent in AWS SNS HTTP/S requests.
+
+        :default: - The content type is set to 'text/plain; charset=UTF-8'
+        '''
+        result = self._values.get("request_policy")
+        return typing.cast(typing.Optional["RequestPolicy"], result)
+
+    @builtins.property
+    def throttle_policy(self) -> typing.Optional["ThrottlePolicy"]:
+        '''The throttling policy of the delivery of SNS messages to HTTP/S endpoints.
+
+        :default: - No throttling
+        '''
+        result = self._values.get("throttle_policy")
+        return typing.cast(typing.Optional["ThrottlePolicy"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DeliveryPolicy(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class FilterOrPolicy(
     metaclass=jsii.JSIIAbstractClass,
     jsii_type="aws-cdk-lib.aws_sns.FilterOrPolicy",
@@ -2352,6 +2496,177 @@ class FilterOrPolicyType(enum.Enum):
     '''A nested key of the MessageBody.'''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_sns.HealthyRetryPolicy",
+    jsii_struct_bases=[],
+    name_mapping={
+        "backoff_function": "backoffFunction",
+        "max_delay_target": "maxDelayTarget",
+        "min_delay_target": "minDelayTarget",
+        "num_max_delay_retries": "numMaxDelayRetries",
+        "num_min_delay_retries": "numMinDelayRetries",
+        "num_no_delay_retries": "numNoDelayRetries",
+        "num_retries": "numRetries",
+    },
+)
+class HealthyRetryPolicy:
+    def __init__(
+        self,
+        *,
+        backoff_function: typing.Optional[BackoffFunction] = None,
+        max_delay_target: typing.Optional[_Duration_4839e8c3] = None,
+        min_delay_target: typing.Optional[_Duration_4839e8c3] = None,
+        num_max_delay_retries: typing.Optional[jsii.Number] = None,
+        num_min_delay_retries: typing.Optional[jsii.Number] = None,
+        num_no_delay_retries: typing.Optional[jsii.Number] = None,
+        num_retries: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''Options for customising the retry policy of the delivery of SNS messages to HTTP/S endpoints.
+
+        :param backoff_function: The model for backoff between retries. Default: - linear
+        :param max_delay_target: The maximum delay for a retry. Must be at least ``minDelayTarget`` less than 3,600 seconds, and correspond to a whole number of seconds, Default: - 20 seconds
+        :param min_delay_target: The minimum delay for a retry. Must be at least one second, not exceed ``maxDelayTarget``, and correspond to a whole number of seconds. Default: - 20 seconds
+        :param num_max_delay_retries: The number of retries in the post-backoff phase, with the maximum delay between them. Must be zero or greater Default: 0
+        :param num_min_delay_retries: The number of retries in the pre-backoff phase, with the specified minimum delay between them. Must be zero or greater Default: 0
+        :param num_no_delay_retries: The number of retries to be done immediately, with no delay between them. Must be zero or greater. Default: 0
+        :param num_retries: The total number of retries, including immediate, pre-backoff, backoff, and post-backoff retries. Must be greater than or equal to zero and not exceed 100. Default: 3
+
+        :exampleMetadata: infused
+
+        Example::
+
+            my_topic = sns.Topic(self, "MyTopic")
+            
+            my_topic.add_subscription(
+                subscriptions.UrlSubscription("https://foobar.com/",
+                    delivery_policy=sns.DeliveryPolicy(
+                        healthy_retry_policy=sns.HealthyRetryPolicy(
+                            min_delay_target=Duration.seconds(5),
+                            max_delay_target=Duration.seconds(10),
+                            num_retries=6,
+                            backoff_function=sns.BackoffFunction.EXPONENTIAL
+                        ),
+                        throttle_policy=sns.ThrottlePolicy(
+                            max_receives_per_second=10
+                        ),
+                        request_policy=sns.RequestPolicy(
+                            header_content_type="application/json"
+                        )
+                    )
+                ))
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__7048a9fbd5081ad0f7c8324f945c1b50c0d35cd8d4656a13c6ebdbe87c3749c2)
+            check_type(argname="argument backoff_function", value=backoff_function, expected_type=type_hints["backoff_function"])
+            check_type(argname="argument max_delay_target", value=max_delay_target, expected_type=type_hints["max_delay_target"])
+            check_type(argname="argument min_delay_target", value=min_delay_target, expected_type=type_hints["min_delay_target"])
+            check_type(argname="argument num_max_delay_retries", value=num_max_delay_retries, expected_type=type_hints["num_max_delay_retries"])
+            check_type(argname="argument num_min_delay_retries", value=num_min_delay_retries, expected_type=type_hints["num_min_delay_retries"])
+            check_type(argname="argument num_no_delay_retries", value=num_no_delay_retries, expected_type=type_hints["num_no_delay_retries"])
+            check_type(argname="argument num_retries", value=num_retries, expected_type=type_hints["num_retries"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if backoff_function is not None:
+            self._values["backoff_function"] = backoff_function
+        if max_delay_target is not None:
+            self._values["max_delay_target"] = max_delay_target
+        if min_delay_target is not None:
+            self._values["min_delay_target"] = min_delay_target
+        if num_max_delay_retries is not None:
+            self._values["num_max_delay_retries"] = num_max_delay_retries
+        if num_min_delay_retries is not None:
+            self._values["num_min_delay_retries"] = num_min_delay_retries
+        if num_no_delay_retries is not None:
+            self._values["num_no_delay_retries"] = num_no_delay_retries
+        if num_retries is not None:
+            self._values["num_retries"] = num_retries
+
+    @builtins.property
+    def backoff_function(self) -> typing.Optional[BackoffFunction]:
+        '''The model for backoff between retries.
+
+        :default: - linear
+        '''
+        result = self._values.get("backoff_function")
+        return typing.cast(typing.Optional[BackoffFunction], result)
+
+    @builtins.property
+    def max_delay_target(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The maximum delay for a retry.
+
+        Must be at least ``minDelayTarget`` less than 3,600 seconds, and correspond to a whole number of seconds,
+
+        :default: - 20 seconds
+        '''
+        result = self._values.get("max_delay_target")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def min_delay_target(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The minimum delay for a retry.
+
+        Must be at least one second, not exceed ``maxDelayTarget``, and correspond to a whole number of seconds.
+
+        :default: - 20 seconds
+        '''
+        result = self._values.get("min_delay_target")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def num_max_delay_retries(self) -> typing.Optional[jsii.Number]:
+        '''The number of retries in the post-backoff phase, with the maximum delay between them.
+
+        Must be zero or greater
+
+        :default: 0
+        '''
+        result = self._values.get("num_max_delay_retries")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def num_min_delay_retries(self) -> typing.Optional[jsii.Number]:
+        '''The number of retries in the pre-backoff phase, with the specified minimum delay between them.
+
+        Must be zero or greater
+
+        :default: 0
+        '''
+        result = self._values.get("num_min_delay_retries")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def num_no_delay_retries(self) -> typing.Optional[jsii.Number]:
+        '''The number of retries to be done immediately, with no delay between them.
+
+        Must be zero or greater.
+
+        :default: 0
+        '''
+        result = self._values.get("num_no_delay_retries")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def num_retries(self) -> typing.Optional[jsii.Number]:
+        '''The total number of retries, including immediate, pre-backoff, backoff, and post-backoff retries.
+
+        Must be greater than or equal to zero and not exceed 100.
+
+        :default: 3
+        '''
+        result = self._values.get("num_retries")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "HealthyRetryPolicy(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.interface(jsii_type="aws-cdk-lib.aws_sns.ITopic")
 class ITopic(
     _IResource_c80c4260,
@@ -3604,6 +3919,73 @@ class Policy(
         return typing.cast(FilterOrPolicyType, jsii.get(self, "type"))
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_sns.RequestPolicy",
+    jsii_struct_bases=[],
+    name_mapping={"header_content_type": "headerContentType"},
+)
+class RequestPolicy:
+    def __init__(
+        self,
+        *,
+        header_content_type: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Options for customising aspects of the content sent in AWS SNS HTTP/S requests.
+
+        :param header_content_type: The content type of the notification being sent to HTTP/S endpoints. Default: - text/plain; charset=UTF-8
+
+        :exampleMetadata: infused
+
+        Example::
+
+            my_topic = sns.Topic(self, "MyTopic")
+            
+            my_topic.add_subscription(
+                subscriptions.UrlSubscription("https://foobar.com/",
+                    delivery_policy=sns.DeliveryPolicy(
+                        healthy_retry_policy=sns.HealthyRetryPolicy(
+                            min_delay_target=Duration.seconds(5),
+                            max_delay_target=Duration.seconds(10),
+                            num_retries=6,
+                            backoff_function=sns.BackoffFunction.EXPONENTIAL
+                        ),
+                        throttle_policy=sns.ThrottlePolicy(
+                            max_receives_per_second=10
+                        ),
+                        request_policy=sns.RequestPolicy(
+                            header_content_type="application/json"
+                        )
+                    )
+                ))
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__86e9fa22eec2ba0cf8286f32e79e7bcd2d6d2dc454a8253571ffcff32c198ecd)
+            check_type(argname="argument header_content_type", value=header_content_type, expected_type=type_hints["header_content_type"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if header_content_type is not None:
+            self._values["header_content_type"] = header_content_type
+
+    @builtins.property
+    def header_content_type(self) -> typing.Optional[builtins.str]:
+        '''The content type of the notification being sent to HTTP/S endpoints.
+
+        :default: - text/plain; charset=UTF-8
+        '''
+        result = self._values.get("header_content_type")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RequestPolicy(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_sns.StringConditions",
     jsii_struct_bases=[],
@@ -3764,6 +4146,7 @@ class Subscription(
         endpoint: builtins.str,
         protocol: "SubscriptionProtocol",
         dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
         filter_policy: typing.Optional[typing.Mapping[builtins.str, "SubscriptionFilter"]] = None,
         filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
         raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -3777,6 +4160,7 @@ class Subscription(
         :param endpoint: The subscription endpoint. The meaning of this value depends on the value for 'protocol'.
         :param protocol: What type of subscription to add.
         :param dead_letter_queue: Queue to be used as dead letter queue. If not passed no dead letter queue is enabled. Default: - No dead letter queue enabled.
+        :param delivery_policy: The delivery policy. Default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
         :param filter_policy: The filter policy. Default: - all messages are delivered
         :param filter_policy_with_message_body: The filter policy that is applied on the message body. To apply a filter policy to the message attributes, use ``filterPolicy``. A maximum of one of ``filterPolicyWithMessageBody`` and ``filterPolicy`` may be used. Default: - all messages are delivered
         :param raw_message_delivery: true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple Notification Service API Reference. Default: false
@@ -3792,6 +4176,7 @@ class Subscription(
             endpoint=endpoint,
             protocol=protocol,
             dead_letter_queue=dead_letter_queue,
+            delivery_policy=delivery_policy,
             filter_policy=filter_policy,
             filter_policy_with_message_body=filter_policy_with_message_body,
             raw_message_delivery=raw_message_delivery,
@@ -3941,6 +4326,7 @@ class SubscriptionFilter(
         "endpoint": "endpoint",
         "protocol": "protocol",
         "dead_letter_queue": "deadLetterQueue",
+        "delivery_policy": "deliveryPolicy",
         "filter_policy": "filterPolicy",
         "filter_policy_with_message_body": "filterPolicyWithMessageBody",
         "raw_message_delivery": "rawMessageDelivery",
@@ -3955,6 +4341,7 @@ class SubscriptionOptions:
         endpoint: builtins.str,
         protocol: "SubscriptionProtocol",
         dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
         filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
         filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
         raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -3966,6 +4353,7 @@ class SubscriptionOptions:
         :param endpoint: The subscription endpoint. The meaning of this value depends on the value for 'protocol'.
         :param protocol: What type of subscription to add.
         :param dead_letter_queue: Queue to be used as dead letter queue. If not passed no dead letter queue is enabled. Default: - No dead letter queue enabled.
+        :param delivery_policy: The delivery policy. Default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
         :param filter_policy: The filter policy. Default: - all messages are delivered
         :param filter_policy_with_message_body: The filter policy that is applied on the message body. To apply a filter policy to the message attributes, use ``filterPolicy``. A maximum of one of ``filterPolicyWithMessageBody`` and ``filterPolicy`` may be used. Default: - all messages are delivered
         :param raw_message_delivery: true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple Notification Service API Reference. Default: false
@@ -3978,6 +4366,7 @@ class SubscriptionOptions:
 
             # The code below shows an example of how to instantiate this type.
             # The values are placeholders you should change.
+            import aws_cdk as cdk
             from aws_cdk import aws_sns as sns
             from aws_cdk import aws_sqs as sqs
             
@@ -3991,6 +4380,23 @@ class SubscriptionOptions:
             
                 # the properties below are optional
                 dead_letter_queue=queue,
+                delivery_policy=sns.DeliveryPolicy(
+                    healthy_retry_policy=sns.HealthyRetryPolicy(
+                        backoff_function=sns.BackoffFunction.ARITHMETIC,
+                        max_delay_target=cdk.Duration.minutes(30),
+                        min_delay_target=cdk.Duration.minutes(30),
+                        num_max_delay_retries=123,
+                        num_min_delay_retries=123,
+                        num_no_delay_retries=123,
+                        num_retries=123
+                    ),
+                    request_policy=sns.RequestPolicy(
+                        header_content_type="headerContentType"
+                    ),
+                    throttle_policy=sns.ThrottlePolicy(
+                        max_receives_per_second=123
+                    )
+                ),
                 filter_policy={
                     "filter_policy_key": subscription_filter
                 },
@@ -4002,11 +4408,14 @@ class SubscriptionOptions:
                 subscription_role_arn="subscriptionRoleArn"
             )
         '''
+        if isinstance(delivery_policy, dict):
+            delivery_policy = DeliveryPolicy(**delivery_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bce75a2ad593ea78ce07c3bf1cbe6c0262cc48f6f133af363ca95a0cadfb6008)
             check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
             check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
             check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
+            check_type(argname="argument delivery_policy", value=delivery_policy, expected_type=type_hints["delivery_policy"])
             check_type(argname="argument filter_policy", value=filter_policy, expected_type=type_hints["filter_policy"])
             check_type(argname="argument filter_policy_with_message_body", value=filter_policy_with_message_body, expected_type=type_hints["filter_policy_with_message_body"])
             check_type(argname="argument raw_message_delivery", value=raw_message_delivery, expected_type=type_hints["raw_message_delivery"])
@@ -4018,6 +4427,8 @@ class SubscriptionOptions:
         }
         if dead_letter_queue is not None:
             self._values["dead_letter_queue"] = dead_letter_queue
+        if delivery_policy is not None:
+            self._values["delivery_policy"] = delivery_policy
         if filter_policy is not None:
             self._values["filter_policy"] = filter_policy
         if filter_policy_with_message_body is not None:
@@ -4057,6 +4468,15 @@ class SubscriptionOptions:
         result = self._values.get("dead_letter_queue")
         return typing.cast(typing.Optional[_IQueue_7ed6f679], result)
 
+    @builtins.property
+    def delivery_policy(self) -> typing.Optional[DeliveryPolicy]:
+        '''The delivery policy.
+
+        :default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
+        '''
+        result = self._values.get("delivery_policy")
+        return typing.cast(typing.Optional[DeliveryPolicy], result)
+
     @builtins.property
     def filter_policy(
         self,
@@ -4135,6 +4555,7 @@ class SubscriptionOptions:
         "endpoint": "endpoint",
         "protocol": "protocol",
         "dead_letter_queue": "deadLetterQueue",
+        "delivery_policy": "deliveryPolicy",
         "filter_policy": "filterPolicy",
         "filter_policy_with_message_body": "filterPolicyWithMessageBody",
         "raw_message_delivery": "rawMessageDelivery",
@@ -4150,6 +4571,7 @@ class SubscriptionProps(SubscriptionOptions):
         endpoint: builtins.str,
         protocol: "SubscriptionProtocol",
         dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
         filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
         filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
         raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -4162,6 +4584,7 @@ class SubscriptionProps(SubscriptionOptions):
         :param endpoint: The subscription endpoint. The meaning of this value depends on the value for 'protocol'.
         :param protocol: What type of subscription to add.
         :param dead_letter_queue: Queue to be used as dead letter queue. If not passed no dead letter queue is enabled. Default: - No dead letter queue enabled.
+        :param delivery_policy: The delivery policy. Default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
         :param filter_policy: The filter policy. Default: - all messages are delivered
         :param filter_policy_with_message_body: The filter policy that is applied on the message body. To apply a filter policy to the message attributes, use ``filterPolicy``. A maximum of one of ``filterPolicyWithMessageBody`` and ``filterPolicy`` may be used. Default: - all messages are delivered
         :param raw_message_delivery: true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple Notification Service API Reference. Default: false
@@ -4186,11 +4609,14 @@ class SubscriptionProps(SubscriptionOptions):
                 subscription_role_arn="SAMPLE_ARN"
             )
         '''
+        if isinstance(delivery_policy, dict):
+            delivery_policy = DeliveryPolicy(**delivery_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__ca027bfed18b17f0f94ff71f11bf24813f4ec24f9b1029e73d8da4ef880e57a4)
             check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
             check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
             check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
+            check_type(argname="argument delivery_policy", value=delivery_policy, expected_type=type_hints["delivery_policy"])
             check_type(argname="argument filter_policy", value=filter_policy, expected_type=type_hints["filter_policy"])
             check_type(argname="argument filter_policy_with_message_body", value=filter_policy_with_message_body, expected_type=type_hints["filter_policy_with_message_body"])
             check_type(argname="argument raw_message_delivery", value=raw_message_delivery, expected_type=type_hints["raw_message_delivery"])
@@ -4204,6 +4630,8 @@ class SubscriptionProps(SubscriptionOptions):
         }
         if dead_letter_queue is not None:
             self._values["dead_letter_queue"] = dead_letter_queue
+        if delivery_policy is not None:
+            self._values["delivery_policy"] = delivery_policy
         if filter_policy is not None:
             self._values["filter_policy"] = filter_policy
         if filter_policy_with_message_body is not None:
@@ -4243,6 +4671,15 @@ class SubscriptionProps(SubscriptionOptions):
         result = self._values.get("dead_letter_queue")
         return typing.cast(typing.Optional[_IQueue_7ed6f679], result)
 
+    @builtins.property
+    def delivery_policy(self) -> typing.Optional[DeliveryPolicy]:
+        '''The delivery policy.
+
+        :default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
+        '''
+        result = self._values.get("delivery_policy")
+        return typing.cast(typing.Optional[DeliveryPolicy], result)
+
     @builtins.property
     def filter_policy(
         self,
@@ -4363,6 +4800,73 @@ class SubscriptionProtocol(enum.Enum):
     '''Notifications put records into a firehose delivery stream.'''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_sns.ThrottlePolicy",
+    jsii_struct_bases=[],
+    name_mapping={"max_receives_per_second": "maxReceivesPerSecond"},
+)
+class ThrottlePolicy:
+    def __init__(
+        self,
+        *,
+        max_receives_per_second: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''Options for customising AWS SNS HTTP/S delivery throttling.
+
+        :param max_receives_per_second: The maximum number of deliveries per second, per subscription. Default: - no throttling
+
+        :exampleMetadata: infused
+
+        Example::
+
+            my_topic = sns.Topic(self, "MyTopic")
+            
+            my_topic.add_subscription(
+                subscriptions.UrlSubscription("https://foobar.com/",
+                    delivery_policy=sns.DeliveryPolicy(
+                        healthy_retry_policy=sns.HealthyRetryPolicy(
+                            min_delay_target=Duration.seconds(5),
+                            max_delay_target=Duration.seconds(10),
+                            num_retries=6,
+                            backoff_function=sns.BackoffFunction.EXPONENTIAL
+                        ),
+                        throttle_policy=sns.ThrottlePolicy(
+                            max_receives_per_second=10
+                        ),
+                        request_policy=sns.RequestPolicy(
+                            header_content_type="application/json"
+                        )
+                    )
+                ))
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a26bd7e7a2d13b89f16f82c085347a85549066b76cb0e201a2ac60f8b28f60fb)
+            check_type(argname="argument max_receives_per_second", value=max_receives_per_second, expected_type=type_hints["max_receives_per_second"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if max_receives_per_second is not None:
+            self._values["max_receives_per_second"] = max_receives_per_second
+
+    @builtins.property
+    def max_receives_per_second(self) -> typing.Optional[jsii.Number]:
+        '''The maximum number of deliveries per second, per subscription.
+
+        :default: - no throttling
+        '''
+        result = self._values.get("max_receives_per_second")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ThrottlePolicy(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_sns.TopicAttributes",
     jsii_struct_bases=[],
@@ -5441,6 +5945,7 @@ class TopicProps:
         "endpoint": "endpoint",
         "protocol": "protocol",
         "dead_letter_queue": "deadLetterQueue",
+        "delivery_policy": "deliveryPolicy",
         "filter_policy": "filterPolicy",
         "filter_policy_with_message_body": "filterPolicyWithMessageBody",
         "raw_message_delivery": "rawMessageDelivery",
@@ -5458,6 +5963,7 @@ class TopicSubscriptionConfig(SubscriptionOptions):
         endpoint: builtins.str,
         protocol: SubscriptionProtocol,
         dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+        delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
         filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
         filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
         raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -5472,6 +5978,7 @@ class TopicSubscriptionConfig(SubscriptionOptions):
         :param endpoint: The subscription endpoint. The meaning of this value depends on the value for 'protocol'.
         :param protocol: What type of subscription to add.
         :param dead_letter_queue: Queue to be used as dead letter queue. If not passed no dead letter queue is enabled. Default: - No dead letter queue enabled.
+        :param delivery_policy: The delivery policy. Default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
         :param filter_policy: The filter policy. Default: - all messages are delivered
         :param filter_policy_with_message_body: The filter policy that is applied on the message body. To apply a filter policy to the message attributes, use ``filterPolicy``. A maximum of one of ``filterPolicyWithMessageBody`` and ``filterPolicy`` may be used. Default: - all messages are delivered
         :param raw_message_delivery: true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple Notification Service API Reference. Default: false
@@ -5487,6 +5994,7 @@ class TopicSubscriptionConfig(SubscriptionOptions):
 
             # The code below shows an example of how to instantiate this type.
             # The values are placeholders you should change.
+            import aws_cdk as cdk
             from aws_cdk import aws_sns as sns
             from aws_cdk import aws_sqs as sqs
             import constructs as constructs
@@ -5504,6 +6012,23 @@ class TopicSubscriptionConfig(SubscriptionOptions):
             
                 # the properties below are optional
                 dead_letter_queue=queue,
+                delivery_policy=sns.DeliveryPolicy(
+                    healthy_retry_policy=sns.HealthyRetryPolicy(
+                        backoff_function=sns.BackoffFunction.ARITHMETIC,
+                        max_delay_target=cdk.Duration.minutes(30),
+                        min_delay_target=cdk.Duration.minutes(30),
+                        num_max_delay_retries=123,
+                        num_min_delay_retries=123,
+                        num_no_delay_retries=123,
+                        num_retries=123
+                    ),
+                    request_policy=sns.RequestPolicy(
+                        header_content_type="headerContentType"
+                    ),
+                    throttle_policy=sns.ThrottlePolicy(
+                        max_receives_per_second=123
+                    )
+                ),
                 filter_policy={
                     "filter_policy_key": subscription_filter
                 },
@@ -5517,11 +6042,14 @@ class TopicSubscriptionConfig(SubscriptionOptions):
                 subscription_role_arn="subscriptionRoleArn"
             )
         '''
+        if isinstance(delivery_policy, dict):
+            delivery_policy = DeliveryPolicy(**delivery_policy)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bd56ac6d2cb8c4c70278e4ea1ea1a8ca0d0a6de563f2be0fe02916900d9f0d01)
             check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
             check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
             check_type(argname="argument dead_letter_queue", value=dead_letter_queue, expected_type=type_hints["dead_letter_queue"])
+            check_type(argname="argument delivery_policy", value=delivery_policy, expected_type=type_hints["delivery_policy"])
             check_type(argname="argument filter_policy", value=filter_policy, expected_type=type_hints["filter_policy"])
             check_type(argname="argument filter_policy_with_message_body", value=filter_policy_with_message_body, expected_type=type_hints["filter_policy_with_message_body"])
             check_type(argname="argument raw_message_delivery", value=raw_message_delivery, expected_type=type_hints["raw_message_delivery"])
@@ -5537,6 +6065,8 @@ class TopicSubscriptionConfig(SubscriptionOptions):
         }
         if dead_letter_queue is not None:
             self._values["dead_letter_queue"] = dead_letter_queue
+        if delivery_policy is not None:
+            self._values["delivery_policy"] = delivery_policy
         if filter_policy is not None:
             self._values["filter_policy"] = filter_policy
         if filter_policy_with_message_body is not None:
@@ -5580,6 +6110,15 @@ class TopicSubscriptionConfig(SubscriptionOptions):
         result = self._values.get("dead_letter_queue")
         return typing.cast(typing.Optional[_IQueue_7ed6f679], result)
 
+    @builtins.property
+    def delivery_policy(self) -> typing.Optional[DeliveryPolicy]:
+        '''The delivery policy.
+
+        :default: - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
+        '''
+        result = self._values.get("delivery_policy")
+        return typing.cast(typing.Optional[DeliveryPolicy], result)
+
     @builtins.property
     def filter_policy(
         self,
@@ -5762,17 +6301,18 @@ class Topic(TopicBase, metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_sns.T
 
     Example::
 
-        from aws_cdk.aws_kinesisfirehose_alpha import DeliveryStream
-        # stream: DeliveryStream
+        import aws_cdk.aws_sns as sns
         
         
-        topic = sns.Topic(self, "Topic")
+        topic = sns.Topic(self, "MyTopic")
         
-        sns.Subscription(self, "Subscription",
-            topic=topic,
-            endpoint=stream.delivery_stream_arn,
-            protocol=sns.SubscriptionProtocol.FIREHOSE,
-            subscription_role_arn="SAMPLE_ARN"
+        topic_rule = iot.TopicRule(self, "TopicRule",
+            sql=iot.IotSql.from_string_as_ver20160323("SELECT topic(2) as device_id, year, month, day FROM 'device/+/data'"),
+            actions=[
+                actions.SnsTopicAction(topic,
+                    message_format=actions.SnsActionMessageFormat.JSON
+                )
+            ]
         )
     '''
 
@@ -5937,6 +6477,7 @@ class Topic(TopicBase, metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_sns.T
 
 
 __all__ = [
+    "BackoffFunction",
     "BetweenCondition",
     "CfnSubscription",
     "CfnSubscriptionProps",
@@ -5946,21 +6487,25 @@ __all__ = [
     "CfnTopicPolicy",
     "CfnTopicPolicyProps",
     "CfnTopicProps",
+    "DeliveryPolicy",
     "Filter",
     "FilterOrPolicy",
     "FilterOrPolicyType",
+    "HealthyRetryPolicy",
     "ITopic",
     "ITopicSubscription",
     "LoggingConfig",
     "LoggingProtocol",
     "NumericConditions",
     "Policy",
+    "RequestPolicy",
     "StringConditions",
     "Subscription",
     "SubscriptionFilter",
     "SubscriptionOptions",
     "SubscriptionProps",
     "SubscriptionProtocol",
+    "ThrottlePolicy",
     "Topic",
     "TopicAttributes",
     "TopicBase",
@@ -6319,6 +6864,15 @@ def _typecheckingstub__39eaeffb1fed865d99c7cf51cdf720d8471aec20b2163161ef50035fb
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4b77bc2bacea1b5a536852c018892cbf213e209fa1462f79eed79e56c3588546(
+    *,
+    healthy_retry_policy: typing.Optional[typing.Union[HealthyRetryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
+    request_policy: typing.Optional[typing.Union[RequestPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
+    throttle_policy: typing.Optional[typing.Union[ThrottlePolicy, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__48b960a8d07778472d280833dc7671d5e58991a28e7dd556c9d0aaf7509fb28e(
     filter: SubscriptionFilter,
 ) -> None:
@@ -6331,6 +6885,19 @@ def _typecheckingstub__3bfe2da643ae34d8de4bb104c40157d580fd7cce715aa1fe916f39f19
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__7048a9fbd5081ad0f7c8324f945c1b50c0d35cd8d4656a13c6ebdbe87c3749c2(
+    *,
+    backoff_function: typing.Optional[BackoffFunction] = None,
+    max_delay_target: typing.Optional[_Duration_4839e8c3] = None,
+    min_delay_target: typing.Optional[_Duration_4839e8c3] = None,
+    num_max_delay_retries: typing.Optional[jsii.Number] = None,
+    num_min_delay_retries: typing.Optional[jsii.Number] = None,
+    num_no_delay_retries: typing.Optional[jsii.Number] = None,
+    num_retries: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__3254ccc49f43f33130f11f9db98dd8a000762fcec4aeed1d0e619180d6590c66(
     subscription: ITopicSubscription,
 ) -> None:
@@ -6405,6 +6972,13 @@ def _typecheckingstub__83467db20c58c3a233e8e98fe95c435848f7d6f585004282a53542710
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__86e9fa22eec2ba0cf8286f32e79e7bcd2d6d2dc454a8253571ffcff32c198ecd(
+    *,
+    header_content_type: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__608bd3c9ae19b496ea71293f19119c75ba12a13947777e25f50e21d76ee1afa9(
     *,
     allowlist: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -6423,6 +6997,7 @@ def _typecheckingstub__8ba93ce15c8c35d2f3ef25181ab5de6aae90de3adaf596e2b2f2e51f9
     endpoint: builtins.str,
     protocol: SubscriptionProtocol,
     dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+    delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
     filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
     filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
     raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -6443,6 +7018,7 @@ def _typecheckingstub__bce75a2ad593ea78ce07c3bf1cbe6c0262cc48f6f133af363ca95a0ca
     endpoint: builtins.str,
     protocol: SubscriptionProtocol,
     dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+    delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
     filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
     filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
     raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -6457,6 +7033,7 @@ def _typecheckingstub__ca027bfed18b17f0f94ff71f11bf24813f4ec24f9b1029e73d8da4ef8
     endpoint: builtins.str,
     protocol: SubscriptionProtocol,
     dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+    delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
     filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
     filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
     raw_message_delivery: typing.Optional[builtins.bool] = None,
@@ -6467,6 +7044,13 @@ def _typecheckingstub__ca027bfed18b17f0f94ff71f11bf24813f4ec24f9b1029e73d8da4ef8
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a26bd7e7a2d13b89f16f82c085347a85549066b76cb0e201a2ac60f8b28f60fb(
+    *,
+    max_receives_per_second: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b8362e16cf38fb93899cf1443c05ea87f926cf385d45c4f25eb95067bff9642a(
     *,
     topic_arn: builtins.str,
@@ -6585,6 +7169,7 @@ def _typecheckingstub__bd56ac6d2cb8c4c70278e4ea1ea1a8ca0d0a6de563f2be0fe02916900
     endpoint: builtins.str,
     protocol: SubscriptionProtocol,
     dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
+    delivery_policy: typing.Optional[typing.Union[DeliveryPolicy, typing.Dict[builtins.str, typing.Any]]] = None,
     filter_policy: typing.Optional[typing.Mapping[builtins.str, SubscriptionFilter]] = None,
     filter_policy_with_message_body: typing.Optional[typing.Mapping[builtins.str, FilterOrPolicy]] = None,
     raw_message_delivery: typing.Optional[builtins.bool] = None,