aws-cdk-lib 2.115.0__py3-none-any.whl → 2.116.1__py3-none-any.whl

aws_cdk/__init__.py

@@ -9971,48 +9971,12 @@ class CustomResourceProps:
         )
 
 
-class CustomResourceProvider(
+class CustomResourceProviderBase(
     _constructs_77d1e7e8.Construct,
-    metaclass=jsii.JSIIMeta,
-    jsii_type="aws-cdk-lib.CustomResourceProvider",
+    metaclass=jsii.JSIIAbstractClass,
+    jsii_type="aws-cdk-lib.CustomResourceProviderBase",
 ):
-    '''An AWS-Lambda backed custom resource provider, for CDK Construct Library constructs.
-
-    This is a provider for ``CustomResource`` constructs, backed by an AWS Lambda
-    Function. It only supports NodeJS runtimes.
-    .. epigraph::
-
-       **Application builders do not need to use this provider type**. This is not
-       a generic custom resource provider class. It is specifically
-       intended to be used only by constructs in the AWS CDK Construct Library, and
-       only exists here because of reverse dependency issues (for example, it cannot
-       use ``iam.PolicyStatement`` objects, since the ``iam`` library already depends on
-       the CDK ``core`` library and we cannot have cyclic dependencies).
-
-    If you are not writing constructs for the AWS Construct Library, you should
-    use the ``Provider`` class in the ``custom-resources`` module instead, which has
-    a better API and supports all Lambda runtimes, not just Node.
-
-    N.B.: When you are writing Custom Resource Providers, there are a number of
-    lifecycle events you have to pay attention to. These are documented in the
-    README of the ``custom-resources`` module. Be sure to give the documentation
-    in that module a read, regardless of whether you end up using the Provider
-    class in there or this one.
-
-    :exampleMetadata: infused
-
-    Example::
-
-        provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
-            code_directory=f"{__dirname}/my-handler",
-            runtime=CustomResourceProviderRuntime.NODEJS_18_X
-        )
-        provider.add_to_role_policy({
-            "Effect": "Allow",
-            "Action": "s3:GetObject",
-            "Resource": "*"
-        })
-    '''
+    '''Base class for creating a custom resource provider.'''
 
     def __init__(
         self,
@@ -10020,7 +9984,7 @@ class CustomResourceProvider(
         id: builtins.str,
         *,
         code_directory: builtins.str,
-        runtime: "CustomResourceProviderRuntime",
+        runtime_name: builtins.str,
         description: typing.Optional[builtins.str] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         memory_size: typing.Optional["Size"] = None,
@@ -10032,7 +9996,7 @@ class CustomResourceProvider(
         :param scope: -
         :param id: -
         :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
-        :param runtime: The AWS Lambda runtime and version to use for the provider.
+        :param runtime_name: The AWS Lambda runtime and version name to use for the provider.
         :param description: A description of the function. Default: - No description.
         :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
         :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
@@ -10041,12 +10005,12 @@ class CustomResourceProvider(
         :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__c9a6802d57ad9b69b2fa5290464f51a2a8623348c365289d64305245e073ef41)
+            type_hints = typing.get_type_hints(_typecheckingstub__b472990efe22be52456a5e812dc6396350b7010d1113310d62ef01f74c1769e1)
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
-        props = CustomResourceProviderProps(
+        props = CustomResourceProviderBaseProps(
             code_directory=code_directory,
-            runtime=runtime,
+            runtime_name=runtime_name,
             description=description,
             environment=environment,
             memory_size=memory_size,
@@ -10057,108 +10021,6 @@ class CustomResourceProvider(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
-    @jsii.member(jsii_name="getOrCreate")
-    @builtins.classmethod
-    def get_or_create(
-        cls,
-        scope: _constructs_77d1e7e8.Construct,
-        uniqueid: builtins.str,
-        *,
-        code_directory: builtins.str,
-        runtime: "CustomResourceProviderRuntime",
-        description: typing.Optional[builtins.str] = None,
-        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
-        memory_size: typing.Optional["Size"] = None,
-        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
-        timeout: typing.Optional["Duration"] = None,
-        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
-    ) -> builtins.str:
-        '''Returns a stack-level singleton ARN (service token) for the custom resource provider.
-
-        :param scope: Construct scope.
-        :param uniqueid: A globally unique id that will be used for the stack-level construct.
-        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
-        :param runtime: The AWS Lambda runtime and version to use for the provider.
-        :param description: A description of the function. Default: - No description.
-        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
-        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
-        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
-        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
-        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
-
-        :return:
-
-        the service token of the custom resource provider, which should be
-        used when defining a ``CustomResource``.
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__c1f95fb403ff0b28ac158a1e391fedc73bee20ded09963a1a66fabfcfe99d006)
-            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
-            check_type(argname="argument uniqueid", value=uniqueid, expected_type=type_hints["uniqueid"])
-        props = CustomResourceProviderProps(
-            code_directory=code_directory,
-            runtime=runtime,
-            description=description,
-            environment=environment,
-            memory_size=memory_size,
-            policy_statements=policy_statements,
-            timeout=timeout,
-            use_cfn_response_wrapper=use_cfn_response_wrapper,
-        )
-
-        return typing.cast(builtins.str, jsii.sinvoke(cls, "getOrCreate", [scope, uniqueid, props]))
-
-    @jsii.member(jsii_name="getOrCreateProvider")
-    @builtins.classmethod
-    def get_or_create_provider(
-        cls,
-        scope: _constructs_77d1e7e8.Construct,
-        uniqueid: builtins.str,
-        *,
-        code_directory: builtins.str,
-        runtime: "CustomResourceProviderRuntime",
-        description: typing.Optional[builtins.str] = None,
-        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
-        memory_size: typing.Optional["Size"] = None,
-        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
-        timeout: typing.Optional["Duration"] = None,
-        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
-    ) -> "CustomResourceProvider":
-        '''Returns a stack-level singleton for the custom resource provider.
-
-        :param scope: Construct scope.
-        :param uniqueid: A globally unique id that will be used for the stack-level construct.
-        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
-        :param runtime: The AWS Lambda runtime and version to use for the provider.
-        :param description: A description of the function. Default: - No description.
-        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
-        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
-        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
-        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
-        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
-
-        :return:
-
-        the service token of the custom resource provider, which should be
-        used when defining a ``CustomResource``.
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__0ccbce12d9e6f35bd2240da7f5c1900a1ff6b41588e9f31f4b76ecb707a6310f)
-            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
-            check_type(argname="argument uniqueid", value=uniqueid, expected_type=type_hints["uniqueid"])
-        props = CustomResourceProviderProps(
-            code_directory=code_directory,
-            runtime=runtime,
-            description=description,
-            environment=environment,
-            memory_size=memory_size,
-            policy_statements=policy_statements,
-            timeout=timeout,
-            use_cfn_response_wrapper=use_cfn_response_wrapper,
-        )
-
-        return typing.cast("CustomResourceProvider", jsii.sinvoke(cls, "getOrCreateProvider", [scope, uniqueid, props]))
-
     @jsii.member(jsii_name="addToRolePolicy")
     def add_to_role_policy(self, statement: typing.Any) -> None:
         '''Add an IAM policy statement to the inline policy of the provider's lambda function's role.
@@ -10180,7 +10042,7 @@ class CustomResourceProvider(
             })
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__b6bbb7ac438407b317f797bf320b11f8dee8e0222411b4590c1352b276e7f29c)
+            type_hints = typing.get_type_hints(_typecheckingstub__d7b4da0f6df59a6071a8ead45156197cdf0751659059c019b964df5f5dd58b9a)
             check_type(argname="argument statement", value=statement, expected_type=type_hints["statement"])
         return typing.cast(None, jsii.invoke(self, "addToRolePolicy", [statement]))
 
@@ -10203,30 +10065,21 @@ class CustomResourceProvider(
     @builtins.property
     @jsii.member(jsii_name="serviceToken")
     def service_token(self) -> builtins.str:
-        '''The ARN of the provider's AWS Lambda function which should be used as the ``serviceToken`` when defining a custom resource.
+        '''The ARN of the provider's AWS Lambda function which should be used as the ``serviceToken`` when defining a custom resource.'''
+        return typing.cast(builtins.str, jsii.get(self, "serviceToken"))
 
-        Example::
 
-            # my_provider: CustomResourceProvider
-            
-            
-            CustomResource(self, "MyCustomResource",
-                service_token=my_provider.service_token,
-                properties={
-                    "my_property_one": "one",
-                    "my_property_two": "two"
-                }
-            )
-        '''
-        return typing.cast(builtins.str, jsii.get(self, "serviceToken"))
+class _CustomResourceProviderBaseProxy(CustomResourceProviderBase):
+    pass
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
+typing.cast(typing.Any, CustomResourceProviderBase).__jsii_proxy_class__ = lambda : _CustomResourceProviderBaseProxy
 
 
 @jsii.data_type(
-    jsii_type="aws-cdk-lib.CustomResourceProviderProps",
+    jsii_type="aws-cdk-lib.CustomResourceProviderOptions",
     jsii_struct_bases=[],
     name_mapping={
-        "code_directory": "codeDirectory",
-        "runtime": "runtime",
         "description": "description",
         "environment": "environment",
         "memory_size": "memorySize",
@@ -10235,12 +10088,10 @@ class CustomResourceProvider(
         "use_cfn_response_wrapper": "useCfnResponseWrapper",
     },
 )
-class CustomResourceProviderProps:
+class CustomResourceProviderOptions:
     def __init__(
         self,
         *,
-        code_directory: builtins.str,
-        runtime: "CustomResourceProviderRuntime",
         description: typing.Optional[builtins.str] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         memory_size: typing.Optional["Size"] = None,
@@ -10248,10 +10099,8 @@ class CustomResourceProviderProps:
         timeout: typing.Optional["Duration"] = None,
         use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
     ) -> None:
-        '''Initialization properties for ``CustomResourceProvider``.
+        '''Initialization options for custom resource providers.
 
-        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
-        :param runtime: The AWS Lambda runtime and version to use for the provider.
         :param description: A description of the function. Default: - No description.
         :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
         :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
@@ -10259,34 +10108,37 @@ class CustomResourceProviderProps:
         :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
         :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
 
-        :exampleMetadata: infused
+        :exampleMetadata: fixture=_generated
 
         Example::
 
-            provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
-                code_directory=f"{__dirname}/my-handler",
-                runtime=CustomResourceProviderRuntime.NODEJS_18_X
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk as cdk
+            
+            # policy_statements: Any
+            # size: cdk.Size
+            
+            custom_resource_provider_options = cdk.CustomResourceProviderOptions(
+                description="description",
+                environment={
+                    "environment_key": "environment"
+                },
+                memory_size=size,
+                policy_statements=[policy_statements],
+                timeout=cdk.Duration.minutes(30),
+                use_cfn_response_wrapper=False
             )
-            provider.add_to_role_policy({
-                "Effect": "Allow",
-                "Action": "s3:GetObject",
-                "Resource": "*"
-            })
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__67b3f7332c978ef4e7c7aecd62d50434c044f1fb228ab5cf8711c9ad036743c1)
-            check_type(argname="argument code_directory", value=code_directory, expected_type=type_hints["code_directory"])
-            check_type(argname="argument runtime", value=runtime, expected_type=type_hints["runtime"])
+            type_hints = typing.get_type_hints(_typecheckingstub__7473e2978820a8ffdbda9b6e4ccae286256e80d7f830b3838e774e0dd9a8605f)
             check_type(argname="argument description", value=description, expected_type=type_hints["description"])
             check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
             check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
             check_type(argname="argument policy_statements", value=policy_statements, expected_type=type_hints["policy_statements"])
             check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
             check_type(argname="argument use_cfn_response_wrapper", value=use_cfn_response_wrapper, expected_type=type_hints["use_cfn_response_wrapper"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "code_directory": code_directory,
-            "runtime": runtime,
-        }
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
         if description is not None:
             self._values["description"] = description
         if environment is not None:
@@ -10300,24 +10152,6 @@ class CustomResourceProviderProps:
         if use_cfn_response_wrapper is not None:
             self._values["use_cfn_response_wrapper"] = use_cfn_response_wrapper
 
-    @builtins.property
-    def code_directory(self) -> builtins.str:
-        '''A local file system directory with the provider's code.
-
-        The code will be
-        bundled into a zip asset and wired to the provider's AWS Lambda function.
-        '''
-        result = self._values.get("code_directory")
-        assert result is not None, "Required property 'code_directory' is missing"
-        return typing.cast(builtins.str, result)
-
-    @builtins.property
-    def runtime(self) -> "CustomResourceProviderRuntime":
-        '''The AWS Lambda runtime and version to use for the provider.'''
-        result = self._values.get("runtime")
-        assert result is not None, "Required property 'runtime' is missing"
-        return typing.cast("CustomResourceProviderRuntime", result)
-
     @builtins.property
     def description(self) -> typing.Optional[builtins.str]:
         '''A description of the function.
@@ -10400,19 +10234,203 @@ class CustomResourceProviderProps:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "CustomResourceProviderProps(%s)" % ", ".join(
+        return "CustomResourceProviderOptions(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
 
-@jsii.enum(jsii_type="aws-cdk-lib.CustomResourceProviderRuntime")
-class CustomResourceProviderRuntime(enum.Enum):
-    '''The lambda runtime to use for the resource provider.
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.CustomResourceProviderProps",
+    jsii_struct_bases=[CustomResourceProviderOptions],
+    name_mapping={
+        "description": "description",
+        "environment": "environment",
+        "memory_size": "memorySize",
+        "policy_statements": "policyStatements",
+        "timeout": "timeout",
+        "use_cfn_response_wrapper": "useCfnResponseWrapper",
+        "code_directory": "codeDirectory",
+        "runtime": "runtime",
+    },
+)
+class CustomResourceProviderProps(CustomResourceProviderOptions):
+    def __init__(
+        self,
+        *,
+        description: typing.Optional[builtins.str] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        memory_size: typing.Optional["Size"] = None,
+        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+        timeout: typing.Optional["Duration"] = None,
+        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+        code_directory: builtins.str,
+        runtime: "CustomResourceProviderRuntime",
+    ) -> None:
+        '''Initialization properties for ``CustomResourceProvider``.
 
-    This also indicates
-    which language is used for the handler.
+        :param description: A description of the function. Default: - No description.
+        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
+        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
+        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
+        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
+        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
+        :param runtime: The AWS Lambda runtime and version to use for the provider.
 
-    :exampleMetadata: infused
+        :exampleMetadata: infused
+
+        Example::
+
+            provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
+                code_directory=f"{__dirname}/my-handler",
+                runtime=CustomResourceProviderRuntime.NODEJS_18_X
+            )
+            provider.add_to_role_policy({
+                "Effect": "Allow",
+                "Action": "s3:GetObject",
+                "Resource": "*"
+            })
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__67b3f7332c978ef4e7c7aecd62d50434c044f1fb228ab5cf8711c9ad036743c1)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
+            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
+            check_type(argname="argument policy_statements", value=policy_statements, expected_type=type_hints["policy_statements"])
+            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
+            check_type(argname="argument use_cfn_response_wrapper", value=use_cfn_response_wrapper, expected_type=type_hints["use_cfn_response_wrapper"])
+            check_type(argname="argument code_directory", value=code_directory, expected_type=type_hints["code_directory"])
+            check_type(argname="argument runtime", value=runtime, expected_type=type_hints["runtime"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "code_directory": code_directory,
+            "runtime": runtime,
+        }
+        if description is not None:
+            self._values["description"] = description
+        if environment is not None:
+            self._values["environment"] = environment
+        if memory_size is not None:
+            self._values["memory_size"] = memory_size
+        if policy_statements is not None:
+            self._values["policy_statements"] = policy_statements
+        if timeout is not None:
+            self._values["timeout"] = timeout
+        if use_cfn_response_wrapper is not None:
+            self._values["use_cfn_response_wrapper"] = use_cfn_response_wrapper
+
+    @builtins.property
+    def description(self) -> typing.Optional[builtins.str]:
+        '''A description of the function.
+
+        :default: - No description.
+        '''
+        result = self._values.get("description")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def environment(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''Key-value pairs that are passed to Lambda as Environment.
+
+        :default: - No environment variables.
+        '''
+        result = self._values.get("environment")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
+
+    @builtins.property
+    def memory_size(self) -> typing.Optional["Size"]:
+        '''The amount of memory that your function has access to.
+
+        Increasing the
+        function's memory also increases its CPU allocation.
+
+        :default: Size.mebibytes(128)
+        '''
+        result = self._values.get("memory_size")
+        return typing.cast(typing.Optional["Size"], result)
+
+    @builtins.property
+    def policy_statements(self) -> typing.Optional[typing.List[typing.Any]]:
+        '''A set of IAM policy statements to include in the inline policy of the provider's lambda function.
+
+        **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement``
+        objects like you will see in the rest of the CDK.
+
+        :default: - no additional inline policy
+
+        Example::
+
+            provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
+                code_directory=f"{__dirname}/my-handler",
+                runtime=CustomResourceProviderRuntime.NODEJS_18_X,
+                policy_statements=[{
+                    "Effect": "Allow",
+                    "Action": "s3:PutObject*",
+                    "Resource": "*"
+                }
+                ]
+            )
+        '''
+        result = self._values.get("policy_statements")
+        return typing.cast(typing.Optional[typing.List[typing.Any]], result)
+
+    @builtins.property
+    def timeout(self) -> typing.Optional["Duration"]:
+        '''AWS Lambda timeout for the provider.
+
+        :default: Duration.minutes(15)
+        '''
+        result = self._values.get("timeout")
+        return typing.cast(typing.Optional["Duration"], result)
+
+    @builtins.property
+    def use_cfn_response_wrapper(self) -> typing.Optional[builtins.bool]:
+        '''Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint.
+
+        :default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+        '''
+        result = self._values.get("use_cfn_response_wrapper")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def code_directory(self) -> builtins.str:
+        '''A local file system directory with the provider's code.
+
+        The code will be
+        bundled into a zip asset and wired to the provider's AWS Lambda function.
+        '''
+        result = self._values.get("code_directory")
+        assert result is not None, "Required property 'code_directory' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def runtime(self) -> "CustomResourceProviderRuntime":
+        '''The AWS Lambda runtime and version to use for the provider.'''
+        result = self._values.get("runtime")
+        assert result is not None, "Required property 'runtime' is missing"
+        return typing.cast("CustomResourceProviderRuntime", 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 "CustomResourceProviderProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.CustomResourceProviderRuntime")
+class CustomResourceProviderRuntime(enum.Enum):
+    '''The lambda runtime to use for the resource provider.
+
+    This also indicates
+    which language is used for the handler.
+
+    :exampleMetadata: infused
 
     Example::
 
@@ -11973,26 +11991,21 @@ class Duration(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.Duration"):
 
     Example::
 
-        import aws_cdk.aws_ecs as ecs
-        
-        # cluster: ecs.ICluster
-        # task_definition: ecs.TaskDefinition
+        # application: appconfig.Application
+        # bucket: s3.Bucket
         
         
-        rule = events.Rule(self, "Rule",
-            schedule=events.Schedule.rate(cdk.Duration.hours(1))
+        appconfig.SourcedConfiguration(self, "MySourcedConfiguration",
+            application=application,
+            location=appconfig.ConfigurationSource.from_bucket(bucket, "path/to/file.json"),
+            deployment_strategy=appconfig.DeploymentStrategy(self, "MyDeploymentStrategy",
+                rollout_strategy=appconfig.RolloutStrategy.linear(
+                    growth_factor=15,
+                    deployment_duration=Duration.minutes(30),
+                    final_bake_time=Duration.minutes(15)
+                )
+            )
         )
-        
-        rule.add_target(targets.EcsTask(
-            cluster=cluster,
-            task_definition=task_definition,
-            task_count=1,
-            container_overrides=[targets.ContainerOverride(
-                container_name="TheContainer",
-                command=["echo", events.EventField.from_path("$.detail.event")]
-            )],
-            enable_execute_command=True
-        ))
     '''
 
     @jsii.member(jsii_name="days")
@@ -31005,127 +31018,512 @@ class CfnWaitConditionHandle(
         return typing.cast(builtins.str, jsii.get(self, "attrId"))
 
     @builtins.property
-    @jsii.member(jsii_name="cfnProperties")
-    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
-        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
-
+    @jsii.member(jsii_name="cfnProperties")
+    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
+
+
+class CustomResource(
+    Resource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.CustomResource",
+):
+    '''Instantiation of a custom resource, whose implementation is provided a Provider.
+
+    This class is intended to be used by construct library authors. Application
+    builder should not be able to tell whether or not a construct is backed by
+    a custom resource, and so the use of this class should be invisible.
+
+    Instead, construct library authors declare a custom construct that hides the
+    choice of provider, and accepts a strongly-typed properties object with the
+    properties your provider accepts.
+
+    Your custom resource provider (identified by the ``serviceToken`` property)
+    can be one of 4 constructs:
+
+    - If you are authoring a construct library or application, we recommend you
+      use the ``Provider`` class in the ``custom-resources`` module.
+    - If you are authoring a construct for the CDK's AWS Construct Library,
+      you should use the ``CustomResourceProvider`` construct in this package.
+    - If you want full control over the provider, you can always directly use
+      a Lambda Function or SNS Topic by passing the ARN into ``serviceToken``.
+
+    :resource: AWS::CloudFormation::CustomResource
+    :exampleMetadata: infused
+
+    Example::
+
+        service_token = CustomResourceProvider.get_or_create(self, "Custom::MyCustomResourceType",
+            code_directory=f"{__dirname}/my-handler",
+            runtime=CustomResourceProviderRuntime.NODEJS_18_X,
+            description="Lambda function created by the custom resource provider"
+        )
+        
+        CustomResource(self, "MyResource",
+            resource_type="Custom::MyCustomResourceType",
+            service_token=service_token
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        service_token: builtins.str,
+        pascal_case_properties: typing.Optional[builtins.bool] = None,
+        properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
+        removal_policy: typing.Optional[RemovalPolicy] = None,
+        resource_type: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param service_token: The ARN of the provider which implements this custom resource type. You can implement a provider by listening to raw AWS CloudFormation events and specify the ARN of an SNS topic (``topic.topicArn``) or the ARN of an AWS Lambda function (``lambda.functionArn``) or use the CDK's custom `resource provider framework <https://docs.aws.amazon.com/cdk/api/latest/docs/custom-resources-readme.html>`_ which makes it easier to implement robust providers. Provider framework:: // use the provider framework from aws-cdk/custom-resources: const provider = new customresources.Provider(this, 'ResourceProvider', { onEventHandler, isCompleteHandler, // optional }); new CustomResource(this, 'MyResource', { serviceToken: provider.serviceToken, }); AWS Lambda function (not recommended to use AWS Lambda Functions directly, see the module README):: // invoke an AWS Lambda function when a lifecycle event occurs: new CustomResource(this, 'MyResource', { serviceToken: myFunction.functionArn, }); SNS topic (not recommended to use AWS Lambda Functions directly, see the module README):: // publish lifecycle events to an SNS topic: new CustomResource(this, 'MyResource', { serviceToken: myTopic.topicArn, });
+        :param pascal_case_properties: Convert all property keys to pascal case. Default: false
+        :param properties: Properties to pass to the Lambda. Default: - No properties.
+        :param removal_policy: The policy to apply when this resource is removed from the application. Default: cdk.RemovalPolicy.Destroy
+        :param resource_type: For custom resources, you can specify AWS::CloudFormation::CustomResource (the default) as the resource type, or you can specify your own resource type name. For example, you can use "Custom::MyCustomResourceTypeName". Custom resource type names must begin with "Custom::" and can include alphanumeric characters and the following characters: _@-. You can specify a custom resource type name up to a maximum length of 60 characters. You cannot change the type during an update. Using your own resource type names helps you quickly differentiate the types of custom resources in your stack. For example, if you had two custom resources that conduct two different ping tests, you could name their type as Custom::PingTester to make them easily identifiable as ping testers (instead of using AWS::CloudFormation::CustomResource). Default: - AWS::CloudFormation::CustomResource
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5c89cdcdef1901fae8effe187c732f9fbf4ec5793ae2938cebb924671df2c26f)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CustomResourceProps(
+            service_token=service_token,
+            pascal_case_properties=pascal_case_properties,
+            properties=properties,
+            removal_policy=removal_policy,
+            resource_type=resource_type,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="getAtt")
+    def get_att(self, attribute_name: builtins.str) -> Reference:
+        '''Returns the value of an attribute of the custom resource of an arbitrary type.
+
+        Attributes are returned from the custom resource provider through the
+        ``Data`` map where the key is the attribute name.
+
+        :param attribute_name: the name of the attribute.
+
+        :return:
+
+        a token for ``Fn::GetAtt``. Use ``Token.asXxx`` to encode the returned ``Reference`` as a specific type or
+        use the convenience ``getAttString`` for string attributes.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__df75eb9fc7a387097b40aeef3aed3b3a82fae9b826d9d79442f6256b53ffab19)
+            check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
+        return typing.cast(Reference, jsii.invoke(self, "getAtt", [attribute_name]))
+
+    @jsii.member(jsii_name="getAttString")
+    def get_att_string(self, attribute_name: builtins.str) -> builtins.str:
+        '''Returns the value of an attribute of the custom resource of type string.
+
+        Attributes are returned from the custom resource provider through the
+        ``Data`` map where the key is the attribute name.
+
+        :param attribute_name: the name of the attribute.
+
+        :return: a token for ``Fn::GetAtt`` encoded as a string.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f9a9f2fc767762d8005e1a5d920d5d4064d4ed7ec492ba4a20eb60182b0e11ba)
+            check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
+        return typing.cast(builtins.str, jsii.invoke(self, "getAttString", [attribute_name]))
+
+    @builtins.property
+    @jsii.member(jsii_name="ref")
+    def ref(self) -> builtins.str:
+        '''The physical name of this custom resource.'''
+        return typing.cast(builtins.str, jsii.get(self, "ref"))
+
+
+class CustomResourceProvider(
+    CustomResourceProviderBase,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.CustomResourceProvider",
+):
+    '''An AWS-Lambda backed custom resource provider, for CDK Construct Library constructs.
+
+    This is a provider for ``CustomResource`` constructs, backed by an AWS Lambda
+    Function. It only supports NodeJS runtimes.
+    .. epigraph::
+
+       **Application builders do not need to use this provider type**. This is not
+       a generic custom resource provider class. It is specifically
+       intended to be used only by constructs in the AWS CDK Construct Library, and
+       only exists here because of reverse dependency issues (for example, it cannot
+       use ``iam.PolicyStatement`` objects, since the ``iam`` library already depends on
+       the CDK ``core`` library and we cannot have cyclic dependencies).
+
+    If you are not writing constructs for the AWS Construct Library, you should
+    use the ``Provider`` class in the ``custom-resources`` module instead, which has
+    a better API and supports all Lambda runtimes, not just Node.
+
+    N.B.: When you are writing Custom Resource Providers, there are a number of
+    lifecycle events you have to pay attention to. These are documented in the
+    README of the ``custom-resources`` module. Be sure to give the documentation
+    in that module a read, regardless of whether you end up using the Provider
+    class in there or this one.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
+            code_directory=f"{__dirname}/my-handler",
+            runtime=CustomResourceProviderRuntime.NODEJS_18_X
+        )
+        provider.add_to_role_policy({
+            "Effect": "Allow",
+            "Action": "s3:GetObject",
+            "Resource": "*"
+        })
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        code_directory: builtins.str,
+        runtime: CustomResourceProviderRuntime,
+        description: typing.Optional[builtins.str] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        memory_size: typing.Optional[Size] = None,
+        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+        timeout: typing.Optional[Duration] = None,
+        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
+        :param runtime: The AWS Lambda runtime and version to use for the provider.
+        :param description: A description of the function. Default: - No description.
+        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
+        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
+        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
+        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
+        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c9a6802d57ad9b69b2fa5290464f51a2a8623348c365289d64305245e073ef41)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CustomResourceProviderProps(
+            code_directory=code_directory,
+            runtime=runtime,
+            description=description,
+            environment=environment,
+            memory_size=memory_size,
+            policy_statements=policy_statements,
+            timeout=timeout,
+            use_cfn_response_wrapper=use_cfn_response_wrapper,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="getOrCreate")
+    @builtins.classmethod
+    def get_or_create(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        uniqueid: builtins.str,
+        *,
+        code_directory: builtins.str,
+        runtime: CustomResourceProviderRuntime,
+        description: typing.Optional[builtins.str] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        memory_size: typing.Optional[Size] = None,
+        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+        timeout: typing.Optional[Duration] = None,
+        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+    ) -> builtins.str:
+        '''Returns a stack-level singleton ARN (service token) for the custom resource provider.
+
+        :param scope: Construct scope.
+        :param uniqueid: A globally unique id that will be used for the stack-level construct.
+        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
+        :param runtime: The AWS Lambda runtime and version to use for the provider.
+        :param description: A description of the function. Default: - No description.
+        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
+        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
+        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
+        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
+        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+
+        :return:
+
+        the service token of the custom resource provider, which should be
+        used when defining a ``CustomResource``.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c1f95fb403ff0b28ac158a1e391fedc73bee20ded09963a1a66fabfcfe99d006)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument uniqueid", value=uniqueid, expected_type=type_hints["uniqueid"])
+        props = CustomResourceProviderProps(
+            code_directory=code_directory,
+            runtime=runtime,
+            description=description,
+            environment=environment,
+            memory_size=memory_size,
+            policy_statements=policy_statements,
+            timeout=timeout,
+            use_cfn_response_wrapper=use_cfn_response_wrapper,
+        )
+
+        return typing.cast(builtins.str, jsii.sinvoke(cls, "getOrCreate", [scope, uniqueid, props]))
+
+    @jsii.member(jsii_name="getOrCreateProvider")
+    @builtins.classmethod
+    def get_or_create_provider(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        uniqueid: builtins.str,
+        *,
+        code_directory: builtins.str,
+        runtime: CustomResourceProviderRuntime,
+        description: typing.Optional[builtins.str] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        memory_size: typing.Optional[Size] = None,
+        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+        timeout: typing.Optional[Duration] = None,
+        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+    ) -> "CustomResourceProvider":
+        '''Returns a stack-level singleton for the custom resource provider.
+
+        :param scope: Construct scope.
+        :param uniqueid: A globally unique id that will be used for the stack-level construct.
+        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
+        :param runtime: The AWS Lambda runtime and version to use for the provider.
+        :param description: A description of the function. Default: - No description.
+        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
+        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
+        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
+        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
+        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+
+        :return:
+
+        the service token of the custom resource provider, which should be
+        used when defining a ``CustomResource``.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__0ccbce12d9e6f35bd2240da7f5c1900a1ff6b41588e9f31f4b76ecb707a6310f)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument uniqueid", value=uniqueid, expected_type=type_hints["uniqueid"])
+        props = CustomResourceProviderProps(
+            code_directory=code_directory,
+            runtime=runtime,
+            description=description,
+            environment=environment,
+            memory_size=memory_size,
+            policy_statements=policy_statements,
+            timeout=timeout,
+            use_cfn_response_wrapper=use_cfn_response_wrapper,
+        )
+
+        return typing.cast("CustomResourceProvider", jsii.sinvoke(cls, "getOrCreateProvider", [scope, uniqueid, props]))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.CustomResourceProviderBaseProps",
+    jsii_struct_bases=[CustomResourceProviderOptions],
+    name_mapping={
+        "description": "description",
+        "environment": "environment",
+        "memory_size": "memorySize",
+        "policy_statements": "policyStatements",
+        "timeout": "timeout",
+        "use_cfn_response_wrapper": "useCfnResponseWrapper",
+        "code_directory": "codeDirectory",
+        "runtime_name": "runtimeName",
+    },
+)
+class CustomResourceProviderBaseProps(CustomResourceProviderOptions):
+    def __init__(
+        self,
+        *,
+        description: typing.Optional[builtins.str] = None,
+        environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+        memory_size: typing.Optional[Size] = None,
+        policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+        timeout: typing.Optional[Duration] = None,
+        use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+        code_directory: builtins.str,
+        runtime_name: builtins.str,
+    ) -> None:
+        '''Initialization properties for ``CustomResourceProviderBase``.
+
+        :param description: A description of the function. Default: - No description.
+        :param environment: Key-value pairs that are passed to Lambda as Environment. Default: - No environment variables.
+        :param memory_size: The amount of memory that your function has access to. Increasing the function's memory also increases its CPU allocation. Default: Size.mebibytes(128)
+        :param policy_statements: A set of IAM policy statements to include in the inline policy of the provider's lambda function. **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement`` objects like you will see in the rest of the CDK. Default: - no additional inline policy
+        :param timeout: AWS Lambda timeout for the provider. Default: Duration.minutes(15)
+        :param use_cfn_response_wrapper: Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint. Default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+        :param code_directory: A local file system directory with the provider's code. The code will be bundled into a zip asset and wired to the provider's AWS Lambda function.
+        :param runtime_name: The AWS Lambda runtime and version name to use for the provider.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk as cdk
+            
+            # policy_statements: Any
+            # size: cdk.Size
+            
+            custom_resource_provider_base_props = cdk.CustomResourceProviderBaseProps(
+                code_directory="codeDirectory",
+                runtime_name="runtimeName",
+            
+                # the properties below are optional
+                description="description",
+                environment={
+                    "environment_key": "environment"
+                },
+                memory_size=size,
+                policy_statements=[policy_statements],
+                timeout=cdk.Duration.minutes(30),
+                use_cfn_response_wrapper=False
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a1ac82056ff309d22752667288bc14e4df222e4ef5faa80aa686251113655d12)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+            check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
+            check_type(argname="argument memory_size", value=memory_size, expected_type=type_hints["memory_size"])
+            check_type(argname="argument policy_statements", value=policy_statements, expected_type=type_hints["policy_statements"])
+            check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
+            check_type(argname="argument use_cfn_response_wrapper", value=use_cfn_response_wrapper, expected_type=type_hints["use_cfn_response_wrapper"])
+            check_type(argname="argument code_directory", value=code_directory, expected_type=type_hints["code_directory"])
+            check_type(argname="argument runtime_name", value=runtime_name, expected_type=type_hints["runtime_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "code_directory": code_directory,
+            "runtime_name": runtime_name,
+        }
+        if description is not None:
+            self._values["description"] = description
+        if environment is not None:
+            self._values["environment"] = environment
+        if memory_size is not None:
+            self._values["memory_size"] = memory_size
+        if policy_statements is not None:
+            self._values["policy_statements"] = policy_statements
+        if timeout is not None:
+            self._values["timeout"] = timeout
+        if use_cfn_response_wrapper is not None:
+            self._values["use_cfn_response_wrapper"] = use_cfn_response_wrapper
+
+    @builtins.property
+    def description(self) -> typing.Optional[builtins.str]:
+        '''A description of the function.
+
+        :default: - No description.
+        '''
+        result = self._values.get("description")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def environment(
+        self,
+    ) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''Key-value pairs that are passed to Lambda as Environment.
 
-class CustomResource(
-    Resource,
-    metaclass=jsii.JSIIMeta,
-    jsii_type="aws-cdk-lib.CustomResource",
-):
-    '''Instantiation of a custom resource, whose implementation is provided a Provider.
+        :default: - No environment variables.
+        '''
+        result = self._values.get("environment")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
 
-    This class is intended to be used by construct library authors. Application
-    builder should not be able to tell whether or not a construct is backed by
-    a custom resource, and so the use of this class should be invisible.
+    @builtins.property
+    def memory_size(self) -> typing.Optional[Size]:
+        '''The amount of memory that your function has access to.
 
-    Instead, construct library authors declare a custom construct that hides the
-    choice of provider, and accepts a strongly-typed properties object with the
-    properties your provider accepts.
+        Increasing the
+        function's memory also increases its CPU allocation.
 
-    Your custom resource provider (identified by the ``serviceToken`` property)
-    can be one of 4 constructs:
+        :default: Size.mebibytes(128)
+        '''
+        result = self._values.get("memory_size")
+        return typing.cast(typing.Optional[Size], result)
 
-    - If you are authoring a construct library or application, we recommend you
-      use the ``Provider`` class in the ``custom-resources`` module.
-    - If you are authoring a construct for the CDK's AWS Construct Library,
-      you should use the ``CustomResourceProvider`` construct in this package.
-    - If you want full control over the provider, you can always directly use
-      a Lambda Function or SNS Topic by passing the ARN into ``serviceToken``.
+    @builtins.property
+    def policy_statements(self) -> typing.Optional[typing.List[typing.Any]]:
+        '''A set of IAM policy statements to include in the inline policy of the provider's lambda function.
 
-    :resource: AWS::CloudFormation::CustomResource
-    :exampleMetadata: infused
+        **Please note**: these are direct IAM JSON policy blobs, *not* ``iam.PolicyStatement``
+        objects like you will see in the rest of the CDK.
 
-    Example::
+        :default: - no additional inline policy
 
-        service_token = CustomResourceProvider.get_or_create(self, "Custom::MyCustomResourceType",
-            code_directory=f"{__dirname}/my-handler",
-            runtime=CustomResourceProviderRuntime.NODEJS_18_X,
-            description="Lambda function created by the custom resource provider"
-        )
-        
-        CustomResource(self, "MyResource",
-            resource_type="Custom::MyCustomResourceType",
-            service_token=service_token
-        )
-    '''
+        Example::
 
-    def __init__(
-        self,
-        scope: _constructs_77d1e7e8.Construct,
-        id: builtins.str,
-        *,
-        service_token: builtins.str,
-        pascal_case_properties: typing.Optional[builtins.bool] = None,
-        properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-        removal_policy: typing.Optional[RemovalPolicy] = None,
-        resource_type: typing.Optional[builtins.str] = None,
-    ) -> None:
-        '''
-        :param scope: -
-        :param id: -
-        :param service_token: The ARN of the provider which implements this custom resource type. You can implement a provider by listening to raw AWS CloudFormation events and specify the ARN of an SNS topic (``topic.topicArn``) or the ARN of an AWS Lambda function (``lambda.functionArn``) or use the CDK's custom `resource provider framework <https://docs.aws.amazon.com/cdk/api/latest/docs/custom-resources-readme.html>`_ which makes it easier to implement robust providers. Provider framework:: // use the provider framework from aws-cdk/custom-resources: const provider = new customresources.Provider(this, 'ResourceProvider', { onEventHandler, isCompleteHandler, // optional }); new CustomResource(this, 'MyResource', { serviceToken: provider.serviceToken, }); AWS Lambda function (not recommended to use AWS Lambda Functions directly, see the module README):: // invoke an AWS Lambda function when a lifecycle event occurs: new CustomResource(this, 'MyResource', { serviceToken: myFunction.functionArn, }); SNS topic (not recommended to use AWS Lambda Functions directly, see the module README):: // publish lifecycle events to an SNS topic: new CustomResource(this, 'MyResource', { serviceToken: myTopic.topicArn, });
-        :param pascal_case_properties: Convert all property keys to pascal case. Default: false
-        :param properties: Properties to pass to the Lambda. Default: - No properties.
-        :param removal_policy: The policy to apply when this resource is removed from the application. Default: cdk.RemovalPolicy.Destroy
-        :param resource_type: For custom resources, you can specify AWS::CloudFormation::CustomResource (the default) as the resource type, or you can specify your own resource type name. For example, you can use "Custom::MyCustomResourceTypeName". Custom resource type names must begin with "Custom::" and can include alphanumeric characters and the following characters: _@-. You can specify a custom resource type name up to a maximum length of 60 characters. You cannot change the type during an update. Using your own resource type names helps you quickly differentiate the types of custom resources in your stack. For example, if you had two custom resources that conduct two different ping tests, you could name their type as Custom::PingTester to make them easily identifiable as ping testers (instead of using AWS::CloudFormation::CustomResource). Default: - AWS::CloudFormation::CustomResource
+            provider = CustomResourceProvider.get_or_create_provider(self, "Custom::MyCustomResourceType",
+                code_directory=f"{__dirname}/my-handler",
+                runtime=CustomResourceProviderRuntime.NODEJS_18_X,
+                policy_statements=[{
+                    "Effect": "Allow",
+                    "Action": "s3:PutObject*",
+                    "Resource": "*"
+                }
+                ]
+            )
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__5c89cdcdef1901fae8effe187c732f9fbf4ec5793ae2938cebb924671df2c26f)
-            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
-            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
-        props = CustomResourceProps(
-            service_token=service_token,
-            pascal_case_properties=pascal_case_properties,
-            properties=properties,
-            removal_policy=removal_policy,
-            resource_type=resource_type,
-        )
+        result = self._values.get("policy_statements")
+        return typing.cast(typing.Optional[typing.List[typing.Any]], result)
 
-        jsii.create(self.__class__, self, [scope, id, props])
+    @builtins.property
+    def timeout(self) -> typing.Optional[Duration]:
+        '''AWS Lambda timeout for the provider.
 
-    @jsii.member(jsii_name="getAtt")
-    def get_att(self, attribute_name: builtins.str) -> Reference:
-        '''Returns the value of an attribute of the custom resource of an arbitrary type.
+        :default: Duration.minutes(15)
+        '''
+        result = self._values.get("timeout")
+        return typing.cast(typing.Optional[Duration], result)
 
-        Attributes are returned from the custom resource provider through the
-        ``Data`` map where the key is the attribute name.
+    @builtins.property
+    def use_cfn_response_wrapper(self) -> typing.Optional[builtins.bool]:
+        '''Whether or not the cloudformation response wrapper (``nodejs-entrypoint.ts``) is used. If set to ``true``, ``nodejs-entrypoint.js`` is bundled in the same asset as the custom resource and set as the entrypoint. If set to ``false``, the custom resource provided is the entrypoint.
 
-        :param attribute_name: the name of the attribute.
+        :default: - ``true`` if ``inlineCode: false`` and ``false`` otherwise.
+        '''
+        result = self._values.get("use_cfn_response_wrapper")
+        return typing.cast(typing.Optional[builtins.bool], result)
 
-        :return:
+    @builtins.property
+    def code_directory(self) -> builtins.str:
+        '''A local file system directory with the provider's code.
 
-        a token for ``Fn::GetAtt``. Use ``Token.asXxx`` to encode the returned ``Reference`` as a specific type or
-        use the convenience ``getAttString`` for string attributes.
+        The code will be
+        bundled into a zip asset and wired to the provider's AWS Lambda function.
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__df75eb9fc7a387097b40aeef3aed3b3a82fae9b826d9d79442f6256b53ffab19)
-            check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
-        return typing.cast(Reference, jsii.invoke(self, "getAtt", [attribute_name]))
-
-    @jsii.member(jsii_name="getAttString")
-    def get_att_string(self, attribute_name: builtins.str) -> builtins.str:
-        '''Returns the value of an attribute of the custom resource of type string.
+        result = self._values.get("code_directory")
+        assert result is not None, "Required property 'code_directory' is missing"
+        return typing.cast(builtins.str, result)
 
-        Attributes are returned from the custom resource provider through the
-        ``Data`` map where the key is the attribute name.
+    @builtins.property
+    def runtime_name(self) -> builtins.str:
+        '''The AWS Lambda runtime and version name to use for the provider.'''
+        result = self._values.get("runtime_name")
+        assert result is not None, "Required property 'runtime_name' is missing"
+        return typing.cast(builtins.str, result)
 
-        :param attribute_name: the name of the attribute.
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
 
-        :return: a token for ``Fn::GetAtt`` encoded as a string.
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__f9a9f2fc767762d8005e1a5d920d5d4064d4ed7ec492ba4a20eb60182b0e11ba)
-            check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
-        return typing.cast(builtins.str, jsii.invoke(self, "getAttString", [attribute_name]))
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
 
-    @builtins.property
-    @jsii.member(jsii_name="ref")
-    def ref(self) -> builtins.str:
-        '''The physical name of this custom resource.'''
-        return typing.cast(builtins.str, jsii.get(self, "ref"))
+    def __repr__(self) -> str:
+        return "CustomResourceProviderBaseProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
 
 
 @jsii.implements(ITokenResolver)
@@ -33066,6 +33464,9 @@ __all__ = [
     "CustomResource",
     "CustomResourceProps",
     "CustomResourceProvider",
+    "CustomResourceProviderBase",
+    "CustomResourceProviderBaseProps",
+    "CustomResourceProviderOptions",
     "CustomResourceProviderProps",
     "CustomResourceProviderRuntime",
     "DefaultStackSynthesizer",
@@ -33224,6 +33625,7 @@ __all__ = [
     "aws_autoscaling_common",
     "aws_autoscaling_hooktargets",
     "aws_autoscalingplans",
+    "aws_b2bi",
     "aws_backup",
     "aws_backupgateway",
     "aws_batch",
@@ -33496,6 +33898,7 @@ from . import aws_autoscaling
 from . import aws_autoscaling_common
 from . import aws_autoscaling_hooktargets
 from . import aws_autoscalingplans
+from . import aws_b2bi
 from . import aws_backup
 from . import aws_backupgateway
 from . import aws_batch
@@ -34750,12 +35153,12 @@ def _typecheckingstub__9dc07c260551c6e828a1b20303b5a44e226e85166f6249c94e31d0271
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__c9a6802d57ad9b69b2fa5290464f51a2a8623348c365289d64305245e073ef41(
+def _typecheckingstub__b472990efe22be52456a5e812dc6396350b7010d1113310d62ef01f74c1769e1(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
     code_directory: builtins.str,
-    runtime: CustomResourceProviderRuntime,
+    runtime_name: builtins.str,
     description: typing.Optional[builtins.str] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     memory_size: typing.Optional[Size] = None,
@@ -34766,28 +35169,14 @@ def _typecheckingstub__c9a6802d57ad9b69b2fa5290464f51a2a8623348c365289d64305245e
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__c1f95fb403ff0b28ac158a1e391fedc73bee20ded09963a1a66fabfcfe99d006(
-    scope: _constructs_77d1e7e8.Construct,
-    uniqueid: builtins.str,
-    *,
-    code_directory: builtins.str,
-    runtime: CustomResourceProviderRuntime,
-    description: typing.Optional[builtins.str] = None,
-    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
-    memory_size: typing.Optional[Size] = None,
-    policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
-    timeout: typing.Optional[Duration] = None,
-    use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+def _typecheckingstub__d7b4da0f6df59a6071a8ead45156197cdf0751659059c019b964df5f5dd58b9a(
+    statement: typing.Any,
 ) -> None:
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__0ccbce12d9e6f35bd2240da7f5c1900a1ff6b41588e9f31f4b76ecb707a6310f(
-    scope: _constructs_77d1e7e8.Construct,
-    uniqueid: builtins.str,
+def _typecheckingstub__7473e2978820a8ffdbda9b6e4ccae286256e80d7f830b3838e774e0dd9a8605f(
     *,
-    code_directory: builtins.str,
-    runtime: CustomResourceProviderRuntime,
     description: typing.Optional[builtins.str] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     memory_size: typing.Optional[Size] = None,
@@ -34798,22 +35187,16 @@ def _typecheckingstub__0ccbce12d9e6f35bd2240da7f5c1900a1ff6b41588e9f31f4b76ecb70
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__b6bbb7ac438407b317f797bf320b11f8dee8e0222411b4590c1352b276e7f29c(
-    statement: typing.Any,
-) -> None:
-    """Type checking stubs"""
-    pass
-
 def _typecheckingstub__67b3f7332c978ef4e7c7aecd62d50434c044f1fb228ab5cf8711c9ad036743c1(
     *,
-    code_directory: builtins.str,
-    runtime: CustomResourceProviderRuntime,
     description: typing.Optional[builtins.str] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     memory_size: typing.Optional[Size] = None,
     policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
     timeout: typing.Optional[Duration] = None,
     use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+    code_directory: builtins.str,
+    runtime: CustomResourceProviderRuntime,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -37755,6 +38138,68 @@ def _typecheckingstub__f9a9f2fc767762d8005e1a5d920d5d4064d4ed7ec492ba4a20eb60182
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c9a6802d57ad9b69b2fa5290464f51a2a8623348c365289d64305245e073ef41(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    code_directory: builtins.str,
+    runtime: CustomResourceProviderRuntime,
+    description: typing.Optional[builtins.str] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    memory_size: typing.Optional[Size] = None,
+    policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+    timeout: typing.Optional[Duration] = None,
+    use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c1f95fb403ff0b28ac158a1e391fedc73bee20ded09963a1a66fabfcfe99d006(
+    scope: _constructs_77d1e7e8.Construct,
+    uniqueid: builtins.str,
+    *,
+    code_directory: builtins.str,
+    runtime: CustomResourceProviderRuntime,
+    description: typing.Optional[builtins.str] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    memory_size: typing.Optional[Size] = None,
+    policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+    timeout: typing.Optional[Duration] = None,
+    use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__0ccbce12d9e6f35bd2240da7f5c1900a1ff6b41588e9f31f4b76ecb707a6310f(
+    scope: _constructs_77d1e7e8.Construct,
+    uniqueid: builtins.str,
+    *,
+    code_directory: builtins.str,
+    runtime: CustomResourceProviderRuntime,
+    description: typing.Optional[builtins.str] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    memory_size: typing.Optional[Size] = None,
+    policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+    timeout: typing.Optional[Duration] = None,
+    use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a1ac82056ff309d22752667288bc14e4df222e4ef5faa80aa686251113655d12(
+    *,
+    description: typing.Optional[builtins.str] = None,
+    environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    memory_size: typing.Optional[Size] = None,
+    policy_statements: typing.Optional[typing.Sequence[typing.Any]] = None,
+    timeout: typing.Optional[Duration] = None,
+    use_cfn_response_wrapper: typing.Optional[builtins.bool] = None,
+    code_directory: builtins.str,
+    runtime_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__782d46d699e89fd2df9c165498a60efbd310f2edb56c287f4b79e6ceed5a9ecb(
     concat: IFragmentConcatenator,
 ) -> None: