aws-cdk-lib 2.168.0__py3-none-any.whl → 2.170.0__py3-none-any.whl

aws_cdk/aws_lambda_event_sources/__init__.py

@@ -407,6 +407,30 @@ my_function.add_event_source(ManagedKafkaEventSource(
 ))
 ```
 
+Set configuration for provisioned pollers that read from the event source.
+
+```python
+from aws_cdk.aws_lambda_event_sources import ManagedKafkaEventSource
+
+# Your MSK cluster arn
+# cluster_arn: str
+
+# my_function: lambda.Function
+
+
+# The Kafka topic you want to subscribe to
+topic = "some-cool-topic"
+my_function.add_event_source(ManagedKafkaEventSource(
+    cluster_arn=cluster_arn,
+    topic=topic,
+    starting_position=lambda_.StartingPosition.TRIM_HORIZON,
+    provisioned_poller_config=ProvisionedPollerConfig(
+        minimum_pollers=1,
+        maximum_pollers=3
+    )
+))
+```
+
 ## Roadmap
 
 Eventually, this module will support all the event sources described under
@@ -472,6 +496,7 @@ from ..aws_lambda import (
     IEventSourceMapping as _IEventSourceMapping_e216064e,
     IFunction as _IFunction_6adb0ab8,
     MetricsConfig as _MetricsConfig_48ab59c4,
+    ProvisionedPollerConfig as _ProvisionedPollerConfig_1025e063,
     SourceAccessConfiguration as _SourceAccessConfiguration_1926ff89,
     StartingPosition as _StartingPosition_c0a4852c,
 )
@@ -627,6 +652,7 @@ class AuthenticationMethod(enum.Enum):
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
     },
 )
 class BaseStreamEventSourceProps:
@@ -637,6 +663,7 @@ class BaseStreamEventSourceProps:
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union["ProvisionedPollerConfig", typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''The set of properties for streaming event sources shared by Dynamo, Kinesis and Kafka.
 
@@ -644,6 +671,7 @@ class BaseStreamEventSourceProps:
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
 
         :exampleMetadata: fixture=_generated
 
@@ -661,15 +689,22 @@ class BaseStreamEventSourceProps:
                 # the properties below are optional
                 batch_size=123,
                 enabled=False,
-                max_batching_window=cdk.Duration.minutes(30)
+                max_batching_window=cdk.Duration.minutes(30),
+                provisioned_poller_config=lambda_event_sources.ProvisionedPollerConfig(
+                    maximum_pollers=123,
+                    minimum_pollers=123
+                )
             )
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__49e8158c80bdc70be09102671a6e9cb783a1a28274da91874a575eeb7e7b4fc6)
             check_type(argname="argument starting_position", value=starting_position, expected_type=type_hints["starting_position"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "starting_position": starting_position,
         }
@@ -679,6 +714,8 @@ class BaseStreamEventSourceProps:
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
 
     @builtins.property
     def starting_position(self) -> _StartingPosition_c0a4852c:
@@ -729,6 +766,18 @@ class BaseStreamEventSourceProps:
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional["ProvisionedPollerConfig"]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional["ProvisionedPollerConfig"], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -749,6 +798,7 @@ class BaseStreamEventSourceProps:
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "topic": "topic",
         "consumer_group_id": "consumerGroupId",
         "filter_encryption": "filterEncryption",
@@ -765,6 +815,7 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union["ProvisionedPollerConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         topic: builtins.str,
         consumer_group_id: typing.Optional[builtins.str] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -778,6 +829,7 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param topic: The Kafka topic to subscribe to.
         :param consumer_group_id: The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. The value must have a lenght between 1 and 200 and full the pattern '[a-zA-Z0-9-/*:_+=.@-]*'. Default: - none
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
@@ -816,15 +868,22 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
                 }],
                 max_batching_window=cdk.Duration.minutes(30),
                 on_failure=event_source_dlq,
+                provisioned_poller_config=lambda_event_sources.ProvisionedPollerConfig(
+                    maximum_pollers=123,
+                    minimum_pollers=123
+                ),
                 secret=secret
             )
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__980041697091a50415a7444df02a046d910ddd83f1229789d80780bf7903633d)
             check_type(argname="argument starting_position", value=starting_position, expected_type=type_hints["starting_position"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
             check_type(argname="argument consumer_group_id", value=consumer_group_id, expected_type=type_hints["consumer_group_id"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
@@ -841,6 +900,8 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if consumer_group_id is not None:
             self._values["consumer_group_id"] = consumer_group_id
         if filter_encryption is not None:
@@ -901,6 +962,18 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional["ProvisionedPollerConfig"]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional["ProvisionedPollerConfig"], result)
+
     @builtins.property
     def topic(self) -> builtins.str:
         '''The Kafka topic to subscribe to.'''
@@ -985,6 +1058,7 @@ class KafkaEventSourceProps(BaseStreamEventSourceProps):
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "topic": "topic",
         "consumer_group_id": "consumerGroupId",
         "filter_encryption": "filterEncryption",
@@ -1002,6 +1076,7 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union["ProvisionedPollerConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         topic: builtins.str,
         consumer_group_id: typing.Optional[builtins.str] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -1016,6 +1091,7 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param topic: The Kafka topic to subscribe to.
         :param consumer_group_id: The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. The value must have a lenght between 1 and 200 and full the pattern '[a-zA-Z0-9-/*:_+=.@-]*'. Default: - none
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
@@ -1051,12 +1127,15 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
                 starting_position=lambda_.StartingPosition.TRIM_HORIZON
             ))
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__e930f585c1bae37174885c54f0f224909bfb0a75d9f1b652bbcf3346100e977e)
             check_type(argname="argument starting_position", value=starting_position, expected_type=type_hints["starting_position"])
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
             check_type(argname="argument consumer_group_id", value=consumer_group_id, expected_type=type_hints["consumer_group_id"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
@@ -1075,6 +1154,8 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if consumer_group_id is not None:
             self._values["consumer_group_id"] = consumer_group_id
         if filter_encryption is not None:
@@ -1135,6 +1216,18 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional["ProvisionedPollerConfig"]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional["ProvisionedPollerConfig"], result)
+
     @builtins.property
     def topic(self) -> builtins.str:
         '''The Kafka topic to subscribe to.'''
@@ -1218,6 +1311,90 @@ class ManagedKafkaEventSourceProps(KafkaEventSourceProps):
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_lambda_event_sources.ProvisionedPollerConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "maximum_pollers": "maximumPollers",
+        "minimum_pollers": "minimumPollers",
+    },
+)
+class ProvisionedPollerConfig:
+    def __init__(
+        self,
+        *,
+        maximum_pollers: jsii.Number,
+        minimum_pollers: jsii.Number,
+    ) -> None:
+        '''
+        :param maximum_pollers: The maximum number of pollers that can be provisioned. Default: 200
+        :param minimum_pollers: The minimum number of pollers that should be provisioned. Default: 1
+
+        :exampleMetadata: infused
+
+        Example::
+
+            from aws_cdk.aws_lambda_event_sources import ManagedKafkaEventSource
+            
+            # Your MSK cluster arn
+            # cluster_arn: str
+            
+            # my_function: lambda.Function
+            
+            
+            # The Kafka topic you want to subscribe to
+            topic = "some-cool-topic"
+            my_function.add_event_source(ManagedKafkaEventSource(
+                cluster_arn=cluster_arn,
+                topic=topic,
+                starting_position=lambda_.StartingPosition.TRIM_HORIZON,
+                provisioned_poller_config=ProvisionedPollerConfig(
+                    minimum_pollers=1,
+                    maximum_pollers=3
+                )
+            ))
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__52613c26f6551f26dae012e5cb997a9c6c981e7e4a8c59f252b025ef2acd28a7)
+            check_type(argname="argument maximum_pollers", value=maximum_pollers, expected_type=type_hints["maximum_pollers"])
+            check_type(argname="argument minimum_pollers", value=minimum_pollers, expected_type=type_hints["minimum_pollers"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "maximum_pollers": maximum_pollers,
+            "minimum_pollers": minimum_pollers,
+        }
+
+    @builtins.property
+    def maximum_pollers(self) -> jsii.Number:
+        '''The maximum number of pollers that can be provisioned.
+
+        :default: 200
+        '''
+        result = self._values.get("maximum_pollers")
+        assert result is not None, "Required property 'maximum_pollers' is missing"
+        return typing.cast(jsii.Number, result)
+
+    @builtins.property
+    def minimum_pollers(self) -> jsii.Number:
+        '''The minimum number of pollers that should be provisioned.
+
+        :default: 1
+        '''
+        result = self._values.get("minimum_pollers")
+        assert result is not None, "Required property 'minimum_pollers' is missing"
+        return typing.cast(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 "ProvisionedPollerConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(_IEventSource_3686b3f8)
 class S3EventSource(
     metaclass=jsii.JSIIMeta,
@@ -1473,6 +1650,7 @@ class S3OnFailureDestination(
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "topic": "topic",
         "consumer_group_id": "consumerGroupId",
         "filter_encryption": "filterEncryption",
@@ -1495,6 +1673,7 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         topic: builtins.str,
         consumer_group_id: typing.Optional[builtins.str] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -1516,6 +1695,7 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param topic: The Kafka topic to subscribe to.
         :param consumer_group_id: The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. The value must have a lenght between 1 and 200 and full the pattern '[a-zA-Z0-9-/*:_+=.@-]*'. Default: - none
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
@@ -1559,6 +1739,8 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
                 starting_position=lambda_.StartingPosition.TRIM_HORIZON
             ))
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if isinstance(vpc_subnets, dict):
             vpc_subnets = _SubnetSelection_e57d76df(**vpc_subnets)
         if __debug__:
@@ -1567,6 +1749,7 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
             check_type(argname="argument consumer_group_id", value=consumer_group_id, expected_type=type_hints["consumer_group_id"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
@@ -1590,6 +1773,8 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if consumer_group_id is not None:
             self._values["consumer_group_id"] = consumer_group_id
         if filter_encryption is not None:
@@ -1660,6 +1845,18 @@ class SelfManagedKafkaEventSourceProps(KafkaEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional[ProvisionedPollerConfig]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional[ProvisionedPollerConfig], result)
+
     @builtins.property
     def topic(self) -> builtins.str:
         '''The Kafka topic to subscribe to.'''
@@ -2364,6 +2561,7 @@ class StreamEventSource(
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param bisect_batch_on_error: If the function returns an error, split the batch in two and retry. Default: false
@@ -2380,6 +2578,7 @@ class StreamEventSource(
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         '''
         props = StreamEventSourceProps(
             bisect_batch_on_error=bisect_batch_on_error,
@@ -2396,6 +2595,7 @@ class StreamEventSource(
             batch_size=batch_size,
             enabled=enabled,
             max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
         )
 
         jsii.create(self.__class__, self, [props])
@@ -2428,6 +2628,7 @@ class StreamEventSource(
         metrics_config: typing.Optional[typing.Union[_MetricsConfig_48ab59c4, typing.Dict[builtins.str, typing.Any]]] = None,
         on_failure: typing.Optional[_IEventSourceDlq_5e2c6ad9] = None,
         parallelization_factor: typing.Optional[jsii.Number] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[_ProvisionedPollerConfig_1025e063, typing.Dict[builtins.str, typing.Any]]] = None,
         report_batch_item_failures: typing.Optional[builtins.bool] = None,
         retry_attempts: typing.Optional[jsii.Number] = None,
         source_access_configurations: typing.Optional[typing.Sequence[typing.Union[_SourceAccessConfiguration_1926ff89, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -2452,6 +2653,7 @@ class StreamEventSource(
         :param metrics_config: Configuration for enhanced monitoring metrics collection When specified, enables collection of additional metrics for the stream event source. Default: - Enhanced monitoring is disabled
         :param on_failure: An Amazon SQS queue or Amazon SNS topic destination for discarded records. Default: discarded records are ignored
         :param parallelization_factor: The number of batches to process from each shard concurrently. Valid Range: - Minimum value of 1 - Maximum value of 10 Default: 1
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param report_batch_item_failures: Allow functions to return partially successful responses for a batch of records. Default: false
         :param retry_attempts: The maximum number of times to retry when the function returns an error. Set to ``undefined`` if you want lambda to keep retrying infinitely or until the record expires. Valid Range: - Minimum value of 0 - Maximum value of 10000 Default: - infinite or until the record expires.
         :param source_access_configurations: Specific settings like the authentication protocol or the VPC components to secure access to your event source. Default: - none
@@ -2476,6 +2678,7 @@ class StreamEventSource(
             metrics_config=metrics_config,
             on_failure=on_failure,
             parallelization_factor=parallelization_factor,
+            provisioned_poller_config=provisioned_poller_config,
             report_batch_item_failures=report_batch_item_failures,
             retry_attempts=retry_attempts,
             source_access_configurations=source_access_configurations,
@@ -2517,6 +2720,7 @@ typing.cast(typing.Any, StreamEventSource).__jsii_proxy_class__ = lambda : _Stre
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "bisect_batch_on_error": "bisectBatchOnError",
         "filter_encryption": "filterEncryption",
         "filters": "filters",
@@ -2537,6 +2741,7 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         bisect_batch_on_error: typing.Optional[builtins.bool] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
         filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
@@ -2554,6 +2759,7 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param bisect_batch_on_error: If the function returns an error, split the batch in two and retry. Default: false
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
         :param filters: Add filter criteria option. Default: - None
@@ -2598,11 +2804,17 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
                 ),
                 on_failure=event_source_dlq,
                 parallelization_factor=123,
+                provisioned_poller_config=lambda_event_sources.ProvisionedPollerConfig(
+                    maximum_pollers=123,
+                    minimum_pollers=123
+                ),
                 report_batch_item_failures=False,
                 retry_attempts=123,
                 tumbling_window=cdk.Duration.minutes(30)
             )
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if isinstance(metrics_config, dict):
             metrics_config = _MetricsConfig_48ab59c4(**metrics_config)
         if __debug__:
@@ -2611,6 +2823,7 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument bisect_batch_on_error", value=bisect_batch_on_error, expected_type=type_hints["bisect_batch_on_error"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
             check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
@@ -2630,6 +2843,8 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if bisect_batch_on_error is not None:
             self._values["bisect_batch_on_error"] = bisect_batch_on_error
         if filter_encryption is not None:
@@ -2700,6 +2915,18 @@ class StreamEventSourceProps(BaseStreamEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional[ProvisionedPollerConfig]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional[ProvisionedPollerConfig], result)
+
     @builtins.property
     def bisect_batch_on_error(self) -> typing.Optional[builtins.bool]:
         '''If the function returns an error, split the batch in two and retry.
@@ -2876,6 +3103,7 @@ class DynamoEventSource(
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param table: -
@@ -2893,6 +3121,7 @@ class DynamoEventSource(
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__826ee32f5239c7c242a7200ffc24778bee01c1101c3cc939fed4a861510c8358)
@@ -2912,6 +3141,7 @@ class DynamoEventSource(
             batch_size=batch_size,
             enabled=enabled,
             max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
         )
 
         jsii.create(self.__class__, self, [table, props])
@@ -2948,6 +3178,7 @@ class DynamoEventSource(
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "bisect_batch_on_error": "bisectBatchOnError",
         "filter_encryption": "filterEncryption",
         "filters": "filters",
@@ -2968,6 +3199,7 @@ class DynamoEventSourceProps(StreamEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         bisect_batch_on_error: typing.Optional[builtins.bool] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
         filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
@@ -2984,6 +3216,7 @@ class DynamoEventSourceProps(StreamEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param bisect_batch_on_error: If the function returns an error, split the batch in two and retry. Default: false
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
         :param filters: Add filter criteria option. Default: - None
@@ -3019,6 +3252,8 @@ class DynamoEventSourceProps(StreamEventSourceProps):
                 )
             ))
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if isinstance(metrics_config, dict):
             metrics_config = _MetricsConfig_48ab59c4(**metrics_config)
         if __debug__:
@@ -3027,6 +3262,7 @@ class DynamoEventSourceProps(StreamEventSourceProps):
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument bisect_batch_on_error", value=bisect_batch_on_error, expected_type=type_hints["bisect_batch_on_error"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
             check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
@@ -3046,6 +3282,8 @@ class DynamoEventSourceProps(StreamEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if bisect_batch_on_error is not None:
             self._values["bisect_batch_on_error"] = bisect_batch_on_error
         if filter_encryption is not None:
@@ -3116,6 +3354,18 @@ class DynamoEventSourceProps(StreamEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional[ProvisionedPollerConfig]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional[ProvisionedPollerConfig], result)
+
     @builtins.property
     def bisect_batch_on_error(self) -> typing.Optional[builtins.bool]:
         '''If the function returns an error, split the batch in two and retry.
@@ -3285,6 +3535,7 @@ class KinesisEventSource(
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param stream: -
@@ -3303,6 +3554,7 @@ class KinesisEventSource(
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__9f81acc98c12b4967363bdd43130a7e674a566679a7b200f5ccd6a0ae313ad2e)
@@ -3323,6 +3575,7 @@ class KinesisEventSource(
             batch_size=batch_size,
             enabled=enabled,
             max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
         )
 
         jsii.create(self.__class__, self, [stream, props])
@@ -3364,6 +3617,7 @@ class KinesisEventSource(
         "batch_size": "batchSize",
         "enabled": "enabled",
         "max_batching_window": "maxBatchingWindow",
+        "provisioned_poller_config": "provisionedPollerConfig",
         "bisect_batch_on_error": "bisectBatchOnError",
         "filter_encryption": "filterEncryption",
         "filters": "filters",
@@ -3385,6 +3639,7 @@ class KinesisEventSourceProps(StreamEventSourceProps):
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         bisect_batch_on_error: typing.Optional[builtins.bool] = None,
         filter_encryption: typing.Optional[_IKey_5f11635f] = None,
         filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
@@ -3402,6 +3657,7 @@ class KinesisEventSourceProps(StreamEventSourceProps):
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         :param bisect_batch_on_error: If the function returns an error, split the batch in two and retry. Default: false
         :param filter_encryption: Add Customer managed KMS key to encrypt Filter Criteria. Default: - none
         :param filters: Add filter criteria option. Default: - None
@@ -3430,6 +3686,8 @@ class KinesisEventSourceProps(StreamEventSourceProps):
                 starting_position=lambda_.StartingPosition.TRIM_HORIZON
             ))
         '''
+        if isinstance(provisioned_poller_config, dict):
+            provisioned_poller_config = ProvisionedPollerConfig(**provisioned_poller_config)
         if isinstance(metrics_config, dict):
             metrics_config = _MetricsConfig_48ab59c4(**metrics_config)
         if __debug__:
@@ -3438,6 +3696,7 @@ class KinesisEventSourceProps(StreamEventSourceProps):
             check_type(argname="argument batch_size", value=batch_size, expected_type=type_hints["batch_size"])
             check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
             check_type(argname="argument max_batching_window", value=max_batching_window, expected_type=type_hints["max_batching_window"])
+            check_type(argname="argument provisioned_poller_config", value=provisioned_poller_config, expected_type=type_hints["provisioned_poller_config"])
             check_type(argname="argument bisect_batch_on_error", value=bisect_batch_on_error, expected_type=type_hints["bisect_batch_on_error"])
             check_type(argname="argument filter_encryption", value=filter_encryption, expected_type=type_hints["filter_encryption"])
             check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
@@ -3458,6 +3717,8 @@ class KinesisEventSourceProps(StreamEventSourceProps):
             self._values["enabled"] = enabled
         if max_batching_window is not None:
             self._values["max_batching_window"] = max_batching_window
+        if provisioned_poller_config is not None:
+            self._values["provisioned_poller_config"] = provisioned_poller_config
         if bisect_batch_on_error is not None:
             self._values["bisect_batch_on_error"] = bisect_batch_on_error
         if filter_encryption is not None:
@@ -3530,6 +3791,18 @@ class KinesisEventSourceProps(StreamEventSourceProps):
         result = self._values.get("max_batching_window")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def provisioned_poller_config(self) -> typing.Optional[ProvisionedPollerConfig]:
+        '''Configuration for provisioned pollers that read from the event source.
+
+        When specified, allows control over the minimum and maximum number of pollers
+        that can be provisioned to process events from the source.
+
+        :default: - no provisioned pollers
+        '''
+        result = self._values.get("provisioned_poller_config")
+        return typing.cast(typing.Optional[ProvisionedPollerConfig], result)
+
     @builtins.property
     def bisect_batch_on_error(self) -> typing.Optional[builtins.bool]:
         '''If the function returns an error, split the batch in two and retry.
@@ -3714,6 +3987,7 @@ class ManagedKafkaEventSource(
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param cluster_arn: An MSK cluster construct.
@@ -3727,6 +4001,7 @@ class ManagedKafkaEventSource(
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         '''
         props = ManagedKafkaEventSourceProps(
             cluster_arn=cluster_arn,
@@ -3740,6 +4015,7 @@ class ManagedKafkaEventSource(
             batch_size=batch_size,
             enabled=enabled,
             max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
         )
 
         jsii.create(self.__class__, self, [props])
@@ -3825,6 +4101,7 @@ class SelfManagedKafkaEventSource(
         batch_size: typing.Optional[jsii.Number] = None,
         enabled: typing.Optional[builtins.bool] = None,
         max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+        provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''
         :param bootstrap_servers: The list of host and port pairs that are the addresses of the Kafka brokers in a "bootstrap" Kafka cluster that a Kafka client connects to initially to bootstrap itself. They are in the format ``abc.xyz.com:xxxx``.
@@ -3843,6 +4120,7 @@ class SelfManagedKafkaEventSource(
         :param batch_size: The largest number of records that AWS Lambda will retrieve from your event source at the time of invoking your function. Your function receives an event with all the retrieved records. Valid Range: - Minimum value of 1 - Maximum value of: - 1000 for ``DynamoEventSource`` - 10000 for ``KinesisEventSource``, ``ManagedKafkaEventSource`` and ``SelfManagedKafkaEventSource`` Default: 100
         :param enabled: If the stream event source mapping should be enabled. Default: true
         :param max_batching_window: The maximum amount of time to gather records before invoking the function. Maximum of Duration.minutes(5). Default: - Duration.seconds(0) for Kinesis, DynamoDB, and SQS event sources, Duration.millis(500) for MSK, self-managed Kafka, and Amazon MQ.
+        :param provisioned_poller_config: Configuration for provisioned pollers that read from the event source. When specified, allows control over the minimum and maximum number of pollers that can be provisioned to process events from the source. Default: - no provisioned pollers
         '''
         props = SelfManagedKafkaEventSourceProps(
             bootstrap_servers=bootstrap_servers,
@@ -3861,6 +4139,7 @@ class SelfManagedKafkaEventSource(
             batch_size=batch_size,
             enabled=enabled,
             max_batching_window=max_batching_window,
+            provisioned_poller_config=provisioned_poller_config,
         )
 
         jsii.create(self.__class__, self, [props])
@@ -3888,6 +4167,7 @@ __all__ = [
     "KinesisEventSourceProps",
     "ManagedKafkaEventSource",
     "ManagedKafkaEventSourceProps",
+    "ProvisionedPollerConfig",
     "S3EventSource",
     "S3EventSourceProps",
     "S3EventSourceV2",
@@ -3936,6 +4216,7 @@ def _typecheckingstub__49e8158c80bdc70be09102671a6e9cb783a1a28274da91874a575eeb7
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -3946,6 +4227,7 @@ def _typecheckingstub__980041697091a50415a7444df02a046d910ddd83f1229789d80780bf7
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     topic: builtins.str,
     consumer_group_id: typing.Optional[builtins.str] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -3962,6 +4244,7 @@ def _typecheckingstub__e930f585c1bae37174885c54f0f224909bfb0a75d9f1b652bbcf33461
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     topic: builtins.str,
     consumer_group_id: typing.Optional[builtins.str] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -3973,6 +4256,14 @@ def _typecheckingstub__e930f585c1bae37174885c54f0f224909bfb0a75d9f1b652bbcf33461
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__52613c26f6551f26dae012e5cb997a9c6c981e7e4a8c59f252b025ef2acd28a7(
+    *,
+    maximum_pollers: jsii.Number,
+    minimum_pollers: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__f651835f5621f3e8376a1eb7f742b3f55035a565412de372e2e29a201c5b9347(
     bucket: _Bucket_2d22f22c,
     *,
@@ -4030,6 +4321,7 @@ def _typecheckingstub__0100a45aa91b9c2103378e2ba54dd41b054f1d6a50733797256d6971b
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     topic: builtins.str,
     consumer_group_id: typing.Optional[builtins.str] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
@@ -4144,6 +4436,7 @@ def _typecheckingstub__f846cf48a1cd8d8120ed4973fabeee827928eff2de72d372506124b7d
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     bisect_batch_on_error: typing.Optional[builtins.bool] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
     filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
@@ -4175,6 +4468,7 @@ def _typecheckingstub__826ee32f5239c7c242a7200ffc24778bee01c1101c3cc939fed4a8615
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4191,6 +4485,7 @@ def _typecheckingstub__ec371d5e4612e8923bbdcc024d90e26915d64be2dc40151f22fc41139
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     bisect_batch_on_error: typing.Optional[builtins.bool] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
     filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,
@@ -4223,6 +4518,7 @@ def _typecheckingstub__9f81acc98c12b4967363bdd43130a7e674a566679a7b200f5ccd6a0ae
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -4239,6 +4535,7 @@ def _typecheckingstub__a0e5c31953f1ef382a7863484f36982000428c40cc94325c4f41de1e3
     batch_size: typing.Optional[jsii.Number] = None,
     enabled: typing.Optional[builtins.bool] = None,
     max_batching_window: typing.Optional[_Duration_4839e8c3] = None,
+    provisioned_poller_config: typing.Optional[typing.Union[ProvisionedPollerConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     bisect_batch_on_error: typing.Optional[builtins.bool] = None,
     filter_encryption: typing.Optional[_IKey_5f11635f] = None,
     filters: typing.Optional[typing.Sequence[typing.Mapping[builtins.str, typing.Any]]] = None,