aws-cdk-lib 2.130.0__py3-none-any.whl → 2.131.0__py3-none-any.whl

aws_cdk/__init__.py

@@ -12613,12 +12613,18 @@ class Expiration(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.Expiration"):
 @jsii.data_type(
     jsii_type="aws-cdk-lib.ExportValueOptions",
     jsii_struct_bases=[],
-    name_mapping={"name": "name"},
+    name_mapping={"description": "description", "name": "name"},
 )
 class ExportValueOptions:
-    def __init__(self, *, name: typing.Optional[builtins.str] = None) -> None:
+    def __init__(
+        self,
+        *,
+        description: typing.Optional[builtins.str] = None,
+        name: typing.Optional[builtins.str] = None,
+    ) -> None:
         '''Options for the ``stack.exportValue()`` method.
 
+        :param description: The description of the outputs. Default: - No description
         :param name: The name of the export to create. Default: - A name is automatically chosen
 
         :exampleMetadata: fixture=_generated
@@ -12630,16 +12636,29 @@ class ExportValueOptions:
             import aws_cdk as cdk
             
             export_value_options = cdk.ExportValueOptions(
+                description="description",
                 name="name"
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__03cd5df1b4b793501aa18abc1ba0ae9423e6661d00a8437be18434d086a1ba09)
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if description is not None:
+            self._values["description"] = description
         if name is not None:
             self._values["name"] = name
 
+    @builtins.property
+    def description(self) -> typing.Optional[builtins.str]:
+        '''The description of the outputs.
+
+        :default: - No description
+        '''
+        result = self._values.get("description")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
         '''The name of the export to create.
@@ -18032,25 +18051,19 @@ class RemovalPolicy(enum.Enum):
 
     Example::
 
-        import aws_cdk as cdk
-        
-        
-        app = cdk.App()
-        stack = cdk.Stack(app, "Stack", env=cdk.Environment(region="us-west-2"))
+        # my_role: iam.Role
         
-        global_table = dynamodb.TableV2(stack, "GlobalTable",
-            partition_key=dynamodb.Attribute(name="pk", type=dynamodb.AttributeType.STRING),
-            removal_policy=cdk.RemovalPolicy.DESTROY,
-            deletion_protection=True,
-            # only the replica in us-east-1 will be deleted during stack deletion
-            replicas=[dynamodb.ReplicaTableProps(
-                region="us-east-1",
-                deletion_protection=False
-            ), dynamodb.ReplicaTableProps(
-                region="us-east-2",
-                deletion_protection=True
+        cr.AwsCustomResource(self, "Customized",
+            role=my_role,  # must be assumable by the `lambda.amazonaws.com` service principal
+            timeout=Duration.minutes(10),  # defaults to 2 minutes
+            log_group=logs.LogGroup(self, "AwsCustomResourceLogs",
+                retention=logs.RetentionDays.ONE_DAY
+            ),
+            function_name="my-custom-name",  # defaults to a CloudFormation generated name
+            removal_policy=RemovalPolicy.RETAIN,  # defaults to `RemovalPolicy.DESTROY`
+            policy=cr.AwsCustomResourcePolicy.from_sdk_calls(
+                resources=cr.AwsCustomResourcePolicy.ANY_RESOURCE
             )
-            ]
         )
     '''
 
@@ -19920,6 +19933,7 @@ class Stack(
         self,
         exported_value: typing.Any,
         *,
+        description: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
     ) -> typing.List[builtins.str]:
         '''Create a CloudFormation Export for a string list value.
@@ -19943,12 +19957,13 @@ class Stack(
         See ``exportValue`` for an example of this process.
 
         :param exported_value: -
+        :param description: The description of the outputs. Default: - No description
         :param name: The name of the export to create. Default: - A name is automatically chosen
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__faa2c6c50018e9e3d11357c477c01bc5738821f06996cbccc7f4742576fd0bc6)
             check_type(argname="argument exported_value", value=exported_value, expected_type=type_hints["exported_value"])
-        options = ExportValueOptions(name=name)
+        options = ExportValueOptions(description=description, name=name)
 
         return typing.cast(typing.List[builtins.str], jsii.invoke(self, "exportStringListValue", [exported_value, options]))
 
@@ -19957,6 +19972,7 @@ class Stack(
         self,
         exported_value: typing.Any,
         *,
+        description: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
     ) -> builtins.str:
         '''Create a CloudFormation Export for a string value.
@@ -20009,12 +20025,13 @@ class Stack(
         - Deploy again (this time only the ``producerStack`` will be changed -- the bucket will be deleted).
 
         :param exported_value: -
+        :param description: The description of the outputs. Default: - No description
         :param name: The name of the export to create. Default: - A name is automatically chosen
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bdfd896d61326907c01ae729a53da036fa27f4187a875c48919eebc0badd0cd0)
             check_type(argname="argument exported_value", value=exported_value, expected_type=type_hints["exported_value"])
-        options = ExportValueOptions(name=name)
+        options = ExportValueOptions(description=description, name=name)
 
         return typing.cast(builtins.str, jsii.invoke(self, "exportValue", [exported_value, options]))
 
@@ -35618,6 +35635,7 @@ def _typecheckingstub__dc6818df505088eacca22c0f0266f3c1617959e13b5241f901c71411d
 
 def _typecheckingstub__03cd5df1b4b793501aa18abc1ba0ae9423e6661d00a8437be18434d086a1ba09(
     *,
+    description: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -36747,6 +36765,7 @@ def _typecheckingstub__235fe1ed5ac633557e7613d012412725b6f4766ba2e38556a0731a6f0
 def _typecheckingstub__faa2c6c50018e9e3d11357c477c01bc5738821f06996cbccc7f4742576fd0bc6(
     exported_value: typing.Any,
     *,
+    description: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -36755,6 +36774,7 @@ def _typecheckingstub__faa2c6c50018e9e3d11357c477c01bc5738821f06996cbccc7f474257
 def _typecheckingstub__bdfd896d61326907c01ae729a53da036fa27f4187a875c48919eebc0badd0cd0(
     exported_value: typing.Any,
     *,
+    description: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""

aws_cdk/_jsii/__init__.py

@@ -16,7 +16,7 @@ import aws_cdk.asset_node_proxy_agent_v6._jsii
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "aws-cdk-lib", "2.130.0", __name__[0:-6], "aws-cdk-lib@2.130.0.jsii.tgz"
+    "aws-cdk-lib", "2.131.0", __name__[0:-6], "aws-cdk-lib@2.131.0.jsii.tgz"
 )
 
 __all__ = [

aws_cdk/aws_apigatewayv2/__init__.py

@@ -9558,6 +9558,45 @@ class HttpIntegrationSubtype(enum.Enum):
     '''Supported integration subtypes.
 
     :see: https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html
+    :exampleMetadata: infused
+
+    Example::
+
+        from aws_cdk.aws_apigatewayv2_integrations import HttpStepFunctionsIntegration
+        import aws_cdk.aws_stepfunctions as sfn
+        
+        # state_machine: sfn.StateMachine
+        # http_api: apigwv2.HttpApi
+        
+        
+        http_api.add_routes(
+            path="/start",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StartExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+            )
+        )
+        
+        http_api.add_routes(
+            path="/start-sync",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StartSyncExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_SYNC_EXECUTION
+            )
+        )
+        
+        http_api.add_routes(
+            path="/stop",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StopExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_STOP_EXECUTION,
+                # For the `STOP_EXECUTION` subtype, it is necessary to specify the `executionArn`.
+                parameter_mapping=apigwv2.ParameterMapping().custom("ExecutionArn", "$request.querystring.executionArn")
+            )
+        )
     '''
 
     EVENTBRIDGE_PUT_EVENTS = "EVENTBRIDGE_PUT_EVENTS"
@@ -15176,23 +15215,25 @@ class AddRoutesOptions(BatchHttpRouteOptions):
 
         Example::
 
-            from aws_cdk.aws_apigatewayv2_authorizers import HttpLambdaAuthorizer, HttpLambdaResponseType
-            from aws_cdk.aws_apigatewayv2_integrations import HttpUrlIntegration
+            from aws_cdk.aws_apigatewayv2_integrations import HttpUrlIntegration, HttpLambdaIntegration
             
-            # This function handles your auth logic
-            # auth_handler: lambda.Function
+            # book_store_default_fn: lambda.Function
             
             
-            authorizer = HttpLambdaAuthorizer("BooksAuthorizer", auth_handler,
-                response_types=[HttpLambdaResponseType.SIMPLE]
-            )
+            get_books_integration = HttpUrlIntegration("GetBooksIntegration", "https://get-books-proxy.example.com")
+            book_store_default_integration = HttpLambdaIntegration("BooksIntegration", book_store_default_fn)
             
-            api = apigwv2.HttpApi(self, "HttpApi")
+            http_api = apigwv2.HttpApi(self, "HttpApi")
             
-            api.add_routes(
-                integration=HttpUrlIntegration("BooksIntegration", "https://get-books-proxy.example.com"),
+            http_api.add_routes(
+                path="/books",
+                methods=[apigwv2.HttpMethod.GET],
+                integration=get_books_integration
+            )
+            http_api.add_routes(
                 path="/books",
-                authorizer=authorizer
+                methods=[apigwv2.HttpMethod.ANY],
+                integration=book_store_default_integration
             )
         '''
         if __debug__:

aws_cdk/aws_apigatewayv2_integrations/__init__.py

@@ -70,6 +70,58 @@ http_api.add_routes(
 )
 ```
 
+### StepFunctions Integration
+
+Step Functions integrations enable integrating an HTTP API route with AWS Step Functions.
+This allows the HTTP API to start state machine executions synchronously or asynchronously, or to stop executions.
+
+When a client invokes the route configured with a Step Functions integration, the API Gateway service interacts with the specified state machine according to the integration subtype (e.g., starts a new execution, synchronously starts an execution, or stops an execution) and returns the response to the client.
+
+The following code configures a Step Functions integrations:
+
+```python
+from aws_cdk.aws_apigatewayv2_integrations import HttpStepFunctionsIntegration
+import aws_cdk.aws_stepfunctions as sfn
+
+# state_machine: sfn.StateMachine
+# http_api: apigwv2.HttpApi
+
+
+http_api.add_routes(
+    path="/start",
+    methods=[apigwv2.HttpMethod.POST],
+    integration=HttpStepFunctionsIntegration("StartExecutionIntegration",
+        state_machine=state_machine,
+        subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+    )
+)
+
+http_api.add_routes(
+    path="/start-sync",
+    methods=[apigwv2.HttpMethod.POST],
+    integration=HttpStepFunctionsIntegration("StartSyncExecutionIntegration",
+        state_machine=state_machine,
+        subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_SYNC_EXECUTION
+    )
+)
+
+http_api.add_routes(
+    path="/stop",
+    methods=[apigwv2.HttpMethod.POST],
+    integration=HttpStepFunctionsIntegration("StopExecutionIntegration",
+        state_machine=state_machine,
+        subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_STOP_EXECUTION,
+        # For the `STOP_EXECUTION` subtype, it is necessary to specify the `executionArn`.
+        parameter_mapping=apigwv2.ParameterMapping().custom("ExecutionArn", "$request.querystring.executionArn")
+    )
+)
+```
+
+**Note**:
+
+* The `executionArn` parameter is required for the `STOP_EXECUTION` subtype. It is necessary to specify the `executionArn` in the `parameterMapping` property of the `HttpStepFunctionsIntegration` object.
+* `START_SYNC_EXECUTION` subtype is only supported for EXPRESS type state machine.
+
 ### Private Integration
 
 Private integrations enable integrating an HTTP API route with private resources in a VPC, such as Application Load Balancers or
@@ -279,6 +331,7 @@ from .._jsii import *
 import constructs as _constructs_77d1e7e8
 from ..aws_apigatewayv2 import (
     HttpConnectionType as _HttpConnectionType_02a8b6fb,
+    HttpIntegrationSubtype as _HttpIntegrationSubtype_beb63b59,
     HttpIntegrationType as _HttpIntegrationType_aee0d440,
     HttpMethod as _HttpMethod_4c4f3090,
     HttpRouteIntegration as _HttpRouteIntegration_d3ee7c34,
@@ -301,6 +354,7 @@ from ..aws_elasticloadbalancingv2 import (
 from ..aws_iam import IRole as _IRole_235f5d8e
 from ..aws_lambda import IFunction as _IFunction_6adb0ab8
 from ..aws_servicediscovery import IService as _IService_46860ae1
+from ..aws_stepfunctions import StateMachine as _StateMachine_a256d24f
 
 
 class HttpAlbIntegration(
@@ -1074,6 +1128,217 @@ class HttpServiceDiscoveryIntegrationProps(HttpPrivateIntegrationOptions):
         )
 
 
+class HttpStepFunctionsIntegration(
+    _HttpRouteIntegration_d3ee7c34,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_apigatewayv2_integrations.HttpStepFunctionsIntegration",
+):
+    '''The StepFunctions integration resource for HTTP API.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        from aws_cdk.aws_apigatewayv2_integrations import HttpStepFunctionsIntegration
+        import aws_cdk.aws_stepfunctions as sfn
+        
+        # state_machine: sfn.StateMachine
+        # http_api: apigwv2.HttpApi
+        
+        
+        http_api.add_routes(
+            path="/start",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StartExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+            )
+        )
+        
+        http_api.add_routes(
+            path="/start-sync",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StartSyncExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_SYNC_EXECUTION
+            )
+        )
+        
+        http_api.add_routes(
+            path="/stop",
+            methods=[apigwv2.HttpMethod.POST],
+            integration=HttpStepFunctionsIntegration("StopExecutionIntegration",
+                state_machine=state_machine,
+                subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_STOP_EXECUTION,
+                # For the `STOP_EXECUTION` subtype, it is necessary to specify the `executionArn`.
+                parameter_mapping=apigwv2.ParameterMapping().custom("ExecutionArn", "$request.querystring.executionArn")
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        id: builtins.str,
+        *,
+        state_machine: _StateMachine_a256d24f,
+        parameter_mapping: typing.Optional[_ParameterMapping_c11a48e0] = None,
+        subtype: typing.Optional[_HttpIntegrationSubtype_beb63b59] = None,
+    ) -> None:
+        '''
+        :param id: id of the underlying integration construct.
+        :param state_machine: Statemachine that Integrates with API Gateway.
+        :param parameter_mapping: Specifies how to transform HTTP requests before sending them to the backend. When the subtype is either ``START_EXECUTION`` or ``START_SYNC_EXECUTION``, it is necessary to specify the ``StateMachineArn``. Conversely, when the subtype is ``STOP_EXECUTION``, the ``ExecutionArn`` must be specified. Default: - specify only ``StateMachineArn``
+        :param subtype: The subtype of the HTTP integration. Only subtypes starting with STEPFUNCTIONS_ can be specified. Default: HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__76518171338936bd0fbff4054b2b72b876355e21b6eef931d4dd4f111fc7889f)
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = HttpStepFunctionsIntegrationProps(
+            state_machine=state_machine,
+            parameter_mapping=parameter_mapping,
+            subtype=subtype,
+        )
+
+        jsii.create(self.__class__, self, [id, props])
+
+    @jsii.member(jsii_name="bind")
+    def bind(
+        self,
+        *,
+        route: _IHttpRoute_2fbc6171,
+        scope: _constructs_77d1e7e8.Construct,
+    ) -> _HttpRouteIntegrationConfig_aafc4b76:
+        '''Bind this integration to the route.
+
+        :param route: The route to which this is being bound.
+        :param scope: The current scope in which the bind is occurring. If the ``HttpRouteIntegration`` being bound creates additional constructs, this will be used as their parent scope.
+        '''
+        options = _HttpRouteIntegrationBindOptions_f870a39e(route=route, scope=scope)
+
+        return typing.cast(_HttpRouteIntegrationConfig_aafc4b76, jsii.invoke(self, "bind", [options]))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_apigatewayv2_integrations.HttpStepFunctionsIntegrationProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "state_machine": "stateMachine",
+        "parameter_mapping": "parameterMapping",
+        "subtype": "subtype",
+    },
+)
+class HttpStepFunctionsIntegrationProps:
+    def __init__(
+        self,
+        *,
+        state_machine: _StateMachine_a256d24f,
+        parameter_mapping: typing.Optional[_ParameterMapping_c11a48e0] = None,
+        subtype: typing.Optional[_HttpIntegrationSubtype_beb63b59] = None,
+    ) -> None:
+        '''Properties to initialize ``HttpStepFunctionsIntegration``.
+
+        :param state_machine: Statemachine that Integrates with API Gateway.
+        :param parameter_mapping: Specifies how to transform HTTP requests before sending them to the backend. When the subtype is either ``START_EXECUTION`` or ``START_SYNC_EXECUTION``, it is necessary to specify the ``StateMachineArn``. Conversely, when the subtype is ``STOP_EXECUTION``, the ``ExecutionArn`` must be specified. Default: - specify only ``StateMachineArn``
+        :param subtype: The subtype of the HTTP integration. Only subtypes starting with STEPFUNCTIONS_ can be specified. Default: HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+
+        :exampleMetadata: infused
+
+        Example::
+
+            from aws_cdk.aws_apigatewayv2_integrations import HttpStepFunctionsIntegration
+            import aws_cdk.aws_stepfunctions as sfn
+            
+            # state_machine: sfn.StateMachine
+            # http_api: apigwv2.HttpApi
+            
+            
+            http_api.add_routes(
+                path="/start",
+                methods=[apigwv2.HttpMethod.POST],
+                integration=HttpStepFunctionsIntegration("StartExecutionIntegration",
+                    state_machine=state_machine,
+                    subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+                )
+            )
+            
+            http_api.add_routes(
+                path="/start-sync",
+                methods=[apigwv2.HttpMethod.POST],
+                integration=HttpStepFunctionsIntegration("StartSyncExecutionIntegration",
+                    state_machine=state_machine,
+                    subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_START_SYNC_EXECUTION
+                )
+            )
+            
+            http_api.add_routes(
+                path="/stop",
+                methods=[apigwv2.HttpMethod.POST],
+                integration=HttpStepFunctionsIntegration("StopExecutionIntegration",
+                    state_machine=state_machine,
+                    subtype=apigwv2.HttpIntegrationSubtype.STEPFUNCTIONS_STOP_EXECUTION,
+                    # For the `STOP_EXECUTION` subtype, it is necessary to specify the `executionArn`.
+                    parameter_mapping=apigwv2.ParameterMapping().custom("ExecutionArn", "$request.querystring.executionArn")
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a7072515a6bcc56ecf05d39b9b84f7dde9de04e9c2caf9ada206b863db8625ed)
+            check_type(argname="argument state_machine", value=state_machine, expected_type=type_hints["state_machine"])
+            check_type(argname="argument parameter_mapping", value=parameter_mapping, expected_type=type_hints["parameter_mapping"])
+            check_type(argname="argument subtype", value=subtype, expected_type=type_hints["subtype"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "state_machine": state_machine,
+        }
+        if parameter_mapping is not None:
+            self._values["parameter_mapping"] = parameter_mapping
+        if subtype is not None:
+            self._values["subtype"] = subtype
+
+    @builtins.property
+    def state_machine(self) -> _StateMachine_a256d24f:
+        '''Statemachine that Integrates with API Gateway.'''
+        result = self._values.get("state_machine")
+        assert result is not None, "Required property 'state_machine' is missing"
+        return typing.cast(_StateMachine_a256d24f, result)
+
+    @builtins.property
+    def parameter_mapping(self) -> typing.Optional[_ParameterMapping_c11a48e0]:
+        '''Specifies how to transform HTTP requests before sending them to the backend.
+
+        When the subtype is either ``START_EXECUTION`` or ``START_SYNC_EXECUTION``,
+        it is necessary to specify the ``StateMachineArn``.
+        Conversely, when the subtype is ``STOP_EXECUTION``, the ``ExecutionArn`` must be specified.
+
+        :default: - specify only ``StateMachineArn``
+
+        :see: https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-parameter-mapping.html
+        '''
+        result = self._values.get("parameter_mapping")
+        return typing.cast(typing.Optional[_ParameterMapping_c11a48e0], result)
+
+    @builtins.property
+    def subtype(self) -> typing.Optional[_HttpIntegrationSubtype_beb63b59]:
+        '''The subtype of the HTTP integration.
+
+        Only subtypes starting with STEPFUNCTIONS_ can be specified.
+
+        :default: HttpIntegrationSubtype.STEPFUNCTIONS_START_EXECUTION
+        '''
+        result = self._values.get("subtype")
+        return typing.cast(typing.Optional[_HttpIntegrationSubtype_beb63b59], 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 "HttpStepFunctionsIntegrationProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class HttpUrlIntegration(
     _HttpRouteIntegration_d3ee7c34,
     metaclass=jsii.JSIIMeta,
@@ -1840,6 +2105,8 @@ __all__ = [
     "HttpPrivateIntegrationOptions",
     "HttpServiceDiscoveryIntegration",
     "HttpServiceDiscoveryIntegrationProps",
+    "HttpStepFunctionsIntegration",
+    "HttpStepFunctionsIntegrationProps",
     "HttpUrlIntegration",
     "HttpUrlIntegrationProps",
     "WebSocketAwsIntegration",
@@ -1996,6 +2263,25 @@ def _typecheckingstub__8bbb857ee24522818d504a3830c65b95bbc66b9ef70c67fa5b85fbdca
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__76518171338936bd0fbff4054b2b72b876355e21b6eef931d4dd4f111fc7889f(
+    id: builtins.str,
+    *,
+    state_machine: _StateMachine_a256d24f,
+    parameter_mapping: typing.Optional[_ParameterMapping_c11a48e0] = None,
+    subtype: typing.Optional[_HttpIntegrationSubtype_beb63b59] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a7072515a6bcc56ecf05d39b9b84f7dde9de04e9c2caf9ada206b863db8625ed(
+    *,
+    state_machine: _StateMachine_a256d24f,
+    parameter_mapping: typing.Optional[_ParameterMapping_c11a48e0] = None,
+    subtype: typing.Optional[_HttpIntegrationSubtype_beb63b59] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__39ce64d79e6c4249c8c60321022b7721149966e379b0f947f602cb248aee9bce(
     id: builtins.str,
     url: builtins.str,