aws-cdk-lib 2.185.0__py3-none-any.whl → 2.187.0__py3-none-any.whl

aws_cdk/aws_codepipeline/__init__.py

@@ -582,7 +582,7 @@ The triggers can only be used with pipeline type V2.
 ### Push filter
 
 Pipelines can be started based on push events. You can specify the `pushFilter` property to
-filter the push events. The `pushFilter` can specify Git tags.
+filter the push events. The `pushFilter` can specify Git tags and branches.
 
 In the case of Git tags, your pipeline starts when a Git tag is pushed.
 You can filter with glob patterns. The `tagsExcludes` takes priority over the `tagsIncludes`.
@@ -615,6 +615,70 @@ codepipeline.Pipeline(self, "Pipeline",
 )
 ```
 
+In the case of branches, your pipeline starts when a commit is pushed on the specified branches.
+You can filter with glob patterns. The `branchesExcludes` takes priority over the `branchesIncludes`.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action]
+    )
+    ],
+    triggers=[codepipeline.TriggerProps(
+        provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        git_configuration=codepipeline.GitConfiguration(
+            source_action=source_action,
+            push_filter=[codepipeline.GitPushFilter(
+                branches_excludes=["exclude1", "exclude2"],
+                branches_includes=["include*"]
+            )]
+        )
+    )]
+)
+```
+
+File paths can also be specified along with the branches to start the pipeline.
+You can filter with glob patterns. The `filePathsExcludes` takes priority over the `filePathsIncludes`.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action]
+    )
+    ],
+    triggers=[codepipeline.TriggerProps(
+        provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        git_configuration=codepipeline.GitConfiguration(
+            source_action=source_action,
+            push_filter=[codepipeline.GitPushFilter(
+                branches_excludes=["exclude1", "exclude2"],
+                branches_includes=["include1", "include2"],
+                file_paths_excludes=["/path/to/exclude1", "/path/to/exclude2"],
+                file_paths_includes=["/path/to/include1", "/path/to/include1"]
+            )]
+        )
+    )]
+)
+```
+
 ### Pull request filter
 
 Pipelines can be started based on pull request events. You can specify the `pullRequestFilter` property to
@@ -750,6 +814,86 @@ codepipeline.Pipeline(self, "Pipeline",
 )
 ```
 
+## Stage Level Condition
+
+Conditions are used for specific types of expressions and each has specific options for results available as follows:
+
+```
+Entry - The conditions for making checks that, if met, allow entry to a stage. Rules are engaged with the following result options: Fail or Skip
+
+On Failure - The conditions for making checks for the stage when it fails. Rules are engaged with the following result option: Rollback
+
+On Success - The conditions for making checks for the stage when it succeeds. Rules are engaged with the following result options: Rollback or Fail
+```
+
+Conditions are supported by a set of rules for each type of condition.
+
+For each type of condition, there are specific actions that are set up by the condition. The action is the result of the succeeded or failed condition check. For example, the condition for entry (entry condition) encounters an alarm (rule), then the check is successful and the result (action) is that the stage entry is blocked.
+
+```python
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+# build_action: codepipeline_actions.CodeBuildAction
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Build",
+        actions=[build_action],
+        # BeforeEntry condition - checks before entering the stage
+        before_entry=codepipeline.Conditions(
+            conditions=[codepipeline.Condition(
+                rules=[codepipeline.Rule(
+                    name="LambdaCheck",
+                    provider="LambdaInvoke",
+                    version="1",
+                    configuration={
+                        "FunctionName": "LambdaFunctionName"
+                    }
+                )],
+                result=codepipeline.Result.FAIL
+            )]
+        ),
+        # OnSuccess condition - checks after successful stage completion
+        on_success=codepipeline.Conditions(
+            conditions=[codepipeline.Condition(
+                result=codepipeline.Result.FAIL,
+                rules=[codepipeline.Rule(
+                    name="CloudWatchCheck",
+                    provider="LambdaInvoke",
+                    version="1",
+                    configuration={
+                        "AlarmName": "AlarmName1",
+                        "WaitTime": "300",  # 5 minutes
+                        "FunctionName": "funcName2"
+                    }
+                )]
+            )]
+        ),
+        # OnFailure condition - handles stage failure
+        on_failure=codepipeline.FailureConditions(
+            conditions=[codepipeline.Condition(
+                result=codepipeline.Result.ROLLBACK,
+                rules=[codepipeline.Rule(
+                    name="RollBackOnFailure",
+                    provider="LambdaInvoke",
+                    version="1",
+                    configuration={
+                        "AlarmName": "Alarm",
+                        "WaitTime": "300",  # 5 minutes
+                        "FunctionName": "funcName1"
+                    }
+                )]
+            )]
+        )
+    )
+    ]
+)
+```
+
 ## Migrating a pipeline type from V1 to V2
 
 To migrate your pipeline type from V1 to V2, you just need to update the `pipelineType` property to `PipelineType.V2`.
@@ -831,7 +975,9 @@ from ..aws_events import (
     Schedule as _Schedule_c151d01f,
 )
 from ..aws_iam import (
-    IRole as _IRole_235f5d8e, PolicyStatement as _PolicyStatement_0fe33853
+    IRole as _IRole_235f5d8e,
+    PolicyStatement as _PolicyStatement_0fe33853,
+    Role as _Role_e8c6e11f,
 )
 from ..aws_s3 import IBucket as _IBucket_42e086fd, Location as _Location_0948fa7f
 
@@ -6986,6 +7132,189 @@ class CommonAwsActionProps(CommonActionProps):
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.Condition",
+    jsii_struct_bases=[],
+    name_mapping={"result": "result", "rules": "rules"},
+)
+class Condition:
+    def __init__(
+        self,
+        *,
+        result: typing.Optional["Result"] = None,
+        rules: typing.Optional[typing.Sequence["Rule"]] = None,
+    ) -> None:
+        '''The condition for the stage.
+
+        A condition is made up of the rules and the result for the condition.
+
+        :param result: The action to be done when the condition is met. Default: - No result action is taken
+        :param rules: The rules that make up the condition. Default: - No rules are applied
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_codepipeline as codepipeline
+            
+            # rule: codepipeline.Rule
+            
+            condition = codepipeline.Condition(
+                result=codepipeline.Result.ROLLBACK,
+                rules=[rule]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f9d3d585d6146668bf50fd9ef4e444521a4def40f934c6c42bb219a9816ffc01)
+            check_type(argname="argument result", value=result, expected_type=type_hints["result"])
+            check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if result is not None:
+            self._values["result"] = result
+        if rules is not None:
+            self._values["rules"] = rules
+
+    @builtins.property
+    def result(self) -> typing.Optional["Result"]:
+        '''The action to be done when the condition is met.
+
+        :default: - No result action is taken
+        '''
+        result = self._values.get("result")
+        return typing.cast(typing.Optional["Result"], result)
+
+    @builtins.property
+    def rules(self) -> typing.Optional[typing.List["Rule"]]:
+        '''The rules that make up the condition.
+
+        :default: - No rules are applied
+        '''
+        result = self._values.get("rules")
+        return typing.cast(typing.Optional[typing.List["Rule"]], 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 "Condition(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.Conditions",
+    jsii_struct_bases=[],
+    name_mapping={"conditions": "conditions"},
+)
+class Conditions:
+    def __init__(
+        self,
+        *,
+        conditions: typing.Optional[typing.Sequence[typing.Union[Condition, typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
+        '''The conditions for making checks for the stage.
+
+        :param conditions: The conditions that are configured as entry conditions, making check to succeed the stage, or fail the stage. Default: - No conditions are configured
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+            # build_action: codepipeline_actions.CodeBuildAction
+            
+            
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                stages=[codepipeline.StageProps(
+                    stage_name="Source",
+                    actions=[source_action]
+                ), codepipeline.StageProps(
+                    stage_name="Build",
+                    actions=[build_action],
+                    # BeforeEntry condition - checks before entering the stage
+                    before_entry=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            rules=[codepipeline.Rule(
+                                name="LambdaCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "FunctionName": "LambdaFunctionName"
+                                }
+                            )],
+                            result=codepipeline.Result.FAIL
+                        )]
+                    ),
+                    # OnSuccess condition - checks after successful stage completion
+                    on_success=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.FAIL,
+                            rules=[codepipeline.Rule(
+                                name="CloudWatchCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "AlarmName1",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName2"
+                                }
+                            )]
+                        )]
+                    ),
+                    # OnFailure condition - handles stage failure
+                    on_failure=codepipeline.FailureConditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.ROLLBACK,
+                            rules=[codepipeline.Rule(
+                                name="RollBackOnFailure",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "Alarm",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName1"
+                                }
+                            )]
+                        )]
+                    )
+                )
+                ]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__b1d234052e60461c20b06295a40d2efb73b7297f0a204252511a0083c29daef9)
+            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if conditions is not None:
+            self._values["conditions"] = conditions
+
+    @builtins.property
+    def conditions(self) -> typing.Optional[typing.List[Condition]]:
+        '''The conditions that are configured as entry conditions, making check to succeed the stage, or fail the stage.
+
+        :default: - No conditions are configured
+        '''
+        result = self._values.get("conditions")
+        return typing.cast(typing.Optional[typing.List[Condition]], 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 "Conditions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_codepipeline.CrossRegionSupport",
     jsii_struct_bases=[],
@@ -7510,27 +7839,27 @@ class ExecutionMode(enum.Enum):
 
 
 @jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_codepipeline.GitConfiguration",
-    jsii_struct_bases=[],
+    jsii_type="aws-cdk-lib.aws_codepipeline.FailureConditions",
+    jsii_struct_bases=[Conditions],
     name_mapping={
-        "source_action": "sourceAction",
-        "pull_request_filter": "pullRequestFilter",
-        "push_filter": "pushFilter",
+        "conditions": "conditions",
+        "result": "result",
+        "retry_mode": "retryMode",
     },
 )
-class GitConfiguration:
+class FailureConditions(Conditions):
     def __init__(
         self,
         *,
-        source_action: "IAction",
-        pull_request_filter: typing.Optional[typing.Sequence[typing.Union["GitPullRequestFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
-        push_filter: typing.Optional[typing.Sequence[typing.Union["GitPushFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
+        conditions: typing.Optional[typing.Sequence[typing.Union[Condition, typing.Dict[builtins.str, typing.Any]]]] = None,
+        result: typing.Optional["Result"] = None,
+        retry_mode: typing.Optional["RetryMode"] = None,
     ) -> None:
-        '''Git configuration for trigger.
+        '''The configuration that specifies the result, such as rollback, to occur upon stage failure.
 
-        :param source_action: The pipeline source action where the trigger configuration, such as Git tags. The trigger configuration will start the pipeline upon the specified change only. You can only specify one trigger configuration per source action. Since the provider for ``sourceAction`` must be ``CodeStarSourceConnection``, you can use ``CodeStarConnectionsSourceAction`` construct in ``aws-codepipeline-actions`` module.
-        :param pull_request_filter: The field where the repository event that will start the pipeline is specified as pull requests. The length must be less than or equal to 3. Default: - no filter.
-        :param push_filter: The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. Git tags is the only supported event type. The length must be less than or equal to 3. Default: - no filter.
+        :param conditions: The conditions that are configured as entry conditions, making check to succeed the stage, or fail the stage. Default: - No conditions are configured
+        :param result: The specified result for when the failure conditions are met, such as rolling back the stage. Default: FAIL
+        :param retry_mode: The method that you want to configure for automatic stage retry on stage failure. Default: ALL_ACTIONS
 
         :exampleMetadata: infused
 
@@ -7547,55 +7876,196 @@ class GitConfiguration:
                     actions=[source_action]
                 ), codepipeline.StageProps(
                     stage_name="Build",
-                    actions=[build_action]
-                )
-                ],
-                triggers=[codepipeline.TriggerProps(
-                    provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
-                    git_configuration=codepipeline.GitConfiguration(
-                        source_action=source_action,
-                        push_filter=[codepipeline.GitPushFilter(
-                            tags_excludes=["exclude1", "exclude2"],
-                            tags_includes=["include*"]
+                    actions=[build_action],
+                    # BeforeEntry condition - checks before entering the stage
+                    before_entry=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            rules=[codepipeline.Rule(
+                                name="LambdaCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "FunctionName": "LambdaFunctionName"
+                                }
+                            )],
+                            result=codepipeline.Result.FAIL
+                        )]
+                    ),
+                    # OnSuccess condition - checks after successful stage completion
+                    on_success=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.FAIL,
+                            rules=[codepipeline.Rule(
+                                name="CloudWatchCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "AlarmName1",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName2"
+                                }
+                            )]
+                        )]
+                    ),
+                    # OnFailure condition - handles stage failure
+                    on_failure=codepipeline.FailureConditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.ROLLBACK,
+                            rules=[codepipeline.Rule(
+                                name="RollBackOnFailure",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "Alarm",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName1"
+                                }
+                            )]
                         )]
                     )
-                )]
+                )
+                ]
             )
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf)
-            check_type(argname="argument source_action", value=source_action, expected_type=type_hints["source_action"])
-            check_type(argname="argument pull_request_filter", value=pull_request_filter, expected_type=type_hints["pull_request_filter"])
-            check_type(argname="argument push_filter", value=push_filter, expected_type=type_hints["push_filter"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "source_action": source_action,
-        }
-        if pull_request_filter is not None:
-            self._values["pull_request_filter"] = pull_request_filter
-        if push_filter is not None:
-            self._values["push_filter"] = push_filter
+            type_hints = typing.get_type_hints(_typecheckingstub__5c4e44cde413d4a9db86d96fc9c455622d0585f9fb8a399e230a3e6f73163569)
+            check_type(argname="argument conditions", value=conditions, expected_type=type_hints["conditions"])
+            check_type(argname="argument result", value=result, expected_type=type_hints["result"])
+            check_type(argname="argument retry_mode", value=retry_mode, expected_type=type_hints["retry_mode"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if conditions is not None:
+            self._values["conditions"] = conditions
+        if result is not None:
+            self._values["result"] = result
+        if retry_mode is not None:
+            self._values["retry_mode"] = retry_mode
 
     @builtins.property
-    def source_action(self) -> "IAction":
-        '''The pipeline source action where the trigger configuration, such as Git tags.
+    def conditions(self) -> typing.Optional[typing.List[Condition]]:
+        '''The conditions that are configured as entry conditions, making check to succeed the stage, or fail the stage.
 
-        The trigger configuration will start the pipeline upon the specified change only.
-        You can only specify one trigger configuration per source action.
+        :default: - No conditions are configured
+        '''
+        result = self._values.get("conditions")
+        return typing.cast(typing.Optional[typing.List[Condition]], result)
 
-        Since the provider for ``sourceAction`` must be ``CodeStarSourceConnection``, you can use
-        ``CodeStarConnectionsSourceAction`` construct in ``aws-codepipeline-actions`` module.
+    @builtins.property
+    def result(self) -> typing.Optional["Result"]:
+        '''The specified result for when the failure conditions are met, such as rolling back the stage.
+
+        :default: FAIL
         '''
-        result = self._values.get("source_action")
-        assert result is not None, "Required property 'source_action' is missing"
-        return typing.cast("IAction", result)
+        result = self._values.get("result")
+        return typing.cast(typing.Optional["Result"], result)
 
     @builtins.property
-    def pull_request_filter(
-        self,
-    ) -> typing.Optional[typing.List["GitPullRequestFilter"]]:
-        '''The field where the repository event that will start the pipeline is specified as pull requests.
+    def retry_mode(self) -> typing.Optional["RetryMode"]:
+        '''The method that you want to configure for automatic stage retry on stage failure.
 
-        The length must be less than or equal to 3.
+        :default: ALL_ACTIONS
+        '''
+        result = self._values.get("retry_mode")
+        return typing.cast(typing.Optional["RetryMode"], 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 "FailureConditions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.GitConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={
+        "source_action": "sourceAction",
+        "pull_request_filter": "pullRequestFilter",
+        "push_filter": "pushFilter",
+    },
+)
+class GitConfiguration:
+    def __init__(
+        self,
+        *,
+        source_action: "IAction",
+        pull_request_filter: typing.Optional[typing.Sequence[typing.Union["GitPullRequestFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
+        push_filter: typing.Optional[typing.Sequence[typing.Union["GitPushFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
+        '''Git configuration for trigger.
+
+        :param source_action: The pipeline source action where the trigger configuration, such as Git tags. The trigger configuration will start the pipeline upon the specified change only. You can only specify one trigger configuration per source action. Since the provider for ``sourceAction`` must be ``CodeStarSourceConnection``, you can use ``CodeStarConnectionsSourceAction`` construct in ``aws-codepipeline-actions`` module.
+        :param pull_request_filter: The field where the repository event that will start the pipeline is specified as pull requests. The length must be less than or equal to 3. Default: - no filter.
+        :param push_filter: The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. Git tags, file paths and branches are supported event type. The length must be less than or equal to 3. Default: - no filter.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+            # build_action: codepipeline_actions.CodeBuildAction
+            
+            
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                stages=[codepipeline.StageProps(
+                    stage_name="Source",
+                    actions=[source_action]
+                ), codepipeline.StageProps(
+                    stage_name="Build",
+                    actions=[build_action]
+                )
+                ],
+                triggers=[codepipeline.TriggerProps(
+                    provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+                    git_configuration=codepipeline.GitConfiguration(
+                        source_action=source_action,
+                        push_filter=[codepipeline.GitPushFilter(
+                            tags_excludes=["exclude1", "exclude2"],
+                            tags_includes=["include*"]
+                        )]
+                    )
+                )]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf)
+            check_type(argname="argument source_action", value=source_action, expected_type=type_hints["source_action"])
+            check_type(argname="argument pull_request_filter", value=pull_request_filter, expected_type=type_hints["pull_request_filter"])
+            check_type(argname="argument push_filter", value=push_filter, expected_type=type_hints["push_filter"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "source_action": source_action,
+        }
+        if pull_request_filter is not None:
+            self._values["pull_request_filter"] = pull_request_filter
+        if push_filter is not None:
+            self._values["push_filter"] = push_filter
+
+    @builtins.property
+    def source_action(self) -> "IAction":
+        '''The pipeline source action where the trigger configuration, such as Git tags.
+
+        The trigger configuration will start the pipeline upon the specified change only.
+        You can only specify one trigger configuration per source action.
+
+        Since the provider for ``sourceAction`` must be ``CodeStarSourceConnection``, you can use
+        ``CodeStarConnectionsSourceAction`` construct in ``aws-codepipeline-actions`` module.
+        '''
+        result = self._values.get("source_action")
+        assert result is not None, "Required property 'source_action' is missing"
+        return typing.cast("IAction", result)
+
+    @builtins.property
+    def pull_request_filter(
+        self,
+    ) -> typing.Optional[typing.List["GitPullRequestFilter"]]:
+        '''The field where the repository event that will start the pipeline is specified as pull requests.
+
+        The length must be less than or equal to 3.
 
         :default: - no filter.
         '''
@@ -7606,7 +8076,7 @@ class GitConfiguration:
     def push_filter(self) -> typing.Optional[typing.List["GitPushFilter"]]:
         '''The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
 
-        Git tags is the only supported event type.
+        Git tags, file paths and branches are supported event type.
 
         The length must be less than or equal to 3.
 
@@ -7816,17 +8286,32 @@ class GitPullRequestFilter:
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_codepipeline.GitPushFilter",
     jsii_struct_bases=[],
-    name_mapping={"tags_excludes": "tagsExcludes", "tags_includes": "tagsIncludes"},
+    name_mapping={
+        "branches_excludes": "branchesExcludes",
+        "branches_includes": "branchesIncludes",
+        "file_paths_excludes": "filePathsExcludes",
+        "file_paths_includes": "filePathsIncludes",
+        "tags_excludes": "tagsExcludes",
+        "tags_includes": "tagsIncludes",
+    },
 )
 class GitPushFilter:
     def __init__(
         self,
         *,
+        branches_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        branches_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        file_paths_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        file_paths_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
         tags_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
         tags_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
     ) -> None:
         '''Git push filter for trigger.
 
+        :param branches_excludes: The list of patterns of Git branches that, when pull request events occurs, are to be excluded from starting the pipeline. You can filter with glob patterns. The ``branchesExcludes`` takes priority over the ``branchesIncludes``. Maximum length of this array is 8. Default: - no branches.
+        :param branches_includes: The list of patterns of Git branches that, when pull request events occurs, are to be included as criteria that starts the pipeline. You can filter with glob patterns. The ``branchesExcludes`` takes priority over the ``branchesIncludes``. Maximum length of this array is 8. Default: - no branches.
+        :param file_paths_excludes: The list of patterns of Git repository file paths that, when pull request events occurs, are to be excluded from starting the pipeline. You can filter with glob patterns. The ``filePathsExcludes`` takes priority over the ``filePathsIncludes``. Maximum length of this array is 8. Default: - no filePaths.
+        :param file_paths_includes: The list of patterns of Git repository file paths that, when pull request events occurs, are to be included as criteria that starts the pipeline. You can filter with glob patterns. The ``filePathsExcludes`` takes priority over the ``filePathsIncludes``. Maximum length of this array is 8. Default: - no filePaths.
         :param tags_excludes: The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline. You can filter with glob patterns. The ``tagsExcludes`` takes priority over the ``tagsIncludes``. Maximum length of this array is 8. Default: - no tags.
         :param tags_includes: The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline. You can filter with glob patterns. The ``tagsExcludes`` takes priority over the ``tagsIncludes``. Maximum length of this array is 8. Default: - no tags.
 
@@ -7839,20 +8324,92 @@ class GitPushFilter:
             from aws_cdk import aws_codepipeline as codepipeline
             
             git_push_filter = codepipeline.GitPushFilter(
+                branches_excludes=["branchesExcludes"],
+                branches_includes=["branchesIncludes"],
+                file_paths_excludes=["filePathsExcludes"],
+                file_paths_includes=["filePathsIncludes"],
                 tags_excludes=["tagsExcludes"],
                 tags_includes=["tagsIncludes"]
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d2e5e6ae139c810aa752b8a8c7cd3040d883f9f3a67c8d3693f9ab842351804e)
+            check_type(argname="argument branches_excludes", value=branches_excludes, expected_type=type_hints["branches_excludes"])
+            check_type(argname="argument branches_includes", value=branches_includes, expected_type=type_hints["branches_includes"])
+            check_type(argname="argument file_paths_excludes", value=file_paths_excludes, expected_type=type_hints["file_paths_excludes"])
+            check_type(argname="argument file_paths_includes", value=file_paths_includes, expected_type=type_hints["file_paths_includes"])
             check_type(argname="argument tags_excludes", value=tags_excludes, expected_type=type_hints["tags_excludes"])
             check_type(argname="argument tags_includes", value=tags_includes, expected_type=type_hints["tags_includes"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if branches_excludes is not None:
+            self._values["branches_excludes"] = branches_excludes
+        if branches_includes is not None:
+            self._values["branches_includes"] = branches_includes
+        if file_paths_excludes is not None:
+            self._values["file_paths_excludes"] = file_paths_excludes
+        if file_paths_includes is not None:
+            self._values["file_paths_includes"] = file_paths_includes
         if tags_excludes is not None:
             self._values["tags_excludes"] = tags_excludes
         if tags_includes is not None:
             self._values["tags_includes"] = tags_includes
 
+    @builtins.property
+    def branches_excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git branches that, when pull request events occurs, are to be excluded from starting the pipeline.
+
+        You can filter with glob patterns. The ``branchesExcludes`` takes priority
+        over the ``branchesIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no branches.
+        '''
+        result = self._values.get("branches_excludes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def branches_includes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git branches that, when pull request events occurs, are to be included as criteria that starts the pipeline.
+
+        You can filter with glob patterns. The ``branchesExcludes`` takes priority
+        over the ``branchesIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no branches.
+        '''
+        result = self._values.get("branches_includes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def file_paths_excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git repository file paths that, when pull request events occurs, are to be excluded from starting the pipeline.
+
+        You can filter with glob patterns. The ``filePathsExcludes`` takes priority
+        over the ``filePathsIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no filePaths.
+        '''
+        result = self._values.get("file_paths_excludes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def file_paths_includes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The list of patterns of Git repository file paths that, when pull request events occurs, are to be included as criteria that starts the pipeline.
+
+        You can filter with glob patterns. The ``filePathsExcludes`` takes priority
+        over the ``filePathsIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no filePaths.
+        '''
+        result = self._values.get("file_paths_includes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     @builtins.property
     def tags_excludes(self) -> typing.Optional[typing.List[builtins.str]]:
         '''The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
@@ -8819,6 +9376,9 @@ class Pipeline(
         placement: typing.Optional[typing.Union["StagePlacement", typing.Dict[builtins.str, typing.Any]]] = None,
         stage_name: builtins.str,
         actions: typing.Optional[typing.Sequence[IAction]] = None,
+        before_entry: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_failure: typing.Optional[typing.Union[FailureConditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_success: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
         transition_disabled_reason: typing.Optional[builtins.str] = None,
         transition_to_enabled: typing.Optional[builtins.bool] = None,
     ) -> IStage:
@@ -8827,6 +9387,9 @@ class Pipeline(
         :param placement: 
         :param stage_name: The physical, human-readable name to assign to this Pipeline Stage.
         :param actions: The list of Actions to create this Stage with. You can always add more Actions later by calling ``IStage#addAction``.
+        :param before_entry: The method to use when a stage allows entry. Default: - No conditions are applied before stage entry
+        :param on_failure: The method to use when a stage has not completed successfully. Default: - No failure conditions are applied
+        :param on_success: The method to use when a stage has succeeded. Default: - No success conditions are applied
         :param transition_disabled_reason: The reason for disabling transition to this stage. Only applicable if ``transitionToEnabled`` is set to ``false``. Default: 'Transition disabled'
         :param transition_to_enabled: Whether to enable transition to this stage. Default: true
 
@@ -8836,6 +9399,9 @@ class Pipeline(
             placement=placement,
             stage_name=stage_name,
             actions=actions,
+            before_entry=before_entry,
+            on_failure=on_failure,
+            on_success=on_success,
             transition_disabled_reason=transition_disabled_reason,
             transition_to_enabled=transition_to_enabled,
         )
@@ -9444,35 +10010,35 @@ class PipelineProps:
 
         Example::
 
-            # Source action
-            bucket = s3.Bucket(self, "SourceBucket",
-                versioned=True
-            )
-            source_artifact = codepipeline.Artifact("SourceArtifact")
-            source_action = codepipeline_actions.S3SourceAction(
-                action_name="Source",
-                output=source_artifact,
-                bucket=bucket,
-                bucket_key="my.zip"
-            )
+            # source_action: codepipeline_actions.S3SourceAction
+            # source_output: codepipeline.Artifact
+            # deploy_bucket: s3.Bucket
             
-            # Commands action
-            output_artifact = codepipeline.Artifact("OutputArtifact")
-            commands_action = codepipeline_actions.CommandsAction(
-                action_name="Commands",
-                commands=["echo \"some commands\""
-                ],
-                input=source_artifact,
-                output=output_artifact
+            
+            # Pipeline-level variable
+            variable = codepipeline.Variable(
+                variable_name="bucket-var",
+                description="description",
+                default_value="sample"
             )
             
-            pipeline = codepipeline.Pipeline(self, "Pipeline",
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                variables=[variable],
                 stages=[codepipeline.StageProps(
                     stage_name="Source",
                     actions=[source_action]
                 ), codepipeline.StageProps(
-                    stage_name="Commands",
-                    actions=[commands_action]
+                    stage_name="Deploy",
+                    actions=[
+                        codepipeline_actions.S3DeployAction(
+                            action_name="DeployAction",
+                            # can reference the variables
+                            object_key=f"{variable.reference()}.txt",
+                            input=source_output,
+                            bucket=deploy_bucket
+                        )
+                    ]
                 )
                 ]
             )
@@ -9767,54 +10333,514 @@ class ProviderType(enum.Enum):
     '''CodeStarSourceConnection.'''
 
 
-@jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_codepipeline.StagePlacement",
-    jsii_struct_bases=[],
-    name_mapping={"just_after": "justAfter", "right_before": "rightBefore"},
-)
-class StagePlacement:
-    def __init__(
-        self,
-        *,
-        just_after: typing.Optional[IStage] = None,
-        right_before: typing.Optional[IStage] = None,
-    ) -> None:
-        '''Allows you to control where to place a new Stage when it's added to the Pipeline.
-
-        Note that you can provide only one of the below properties -
-        specifying more than one will result in a validation error.
-
-        :param just_after: Inserts the new Stage as a child of the given Stage (changing its current child Stage, if it had one).
-        :param right_before: Inserts the new Stage as a parent of the given Stage (changing its current parent Stage, if it had one).
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codepipeline.Result")
+class Result(enum.Enum):
+    '''The action to be done when the condition is met.
 
-        :see: #justAfter
-        :exampleMetadata: infused
+    :exampleMetadata: infused
 
-        Example::
+    Example::
 
-            # Insert a new Stage at an arbitrary point
-            # pipeline: codepipeline.Pipeline
-            # another_stage: codepipeline.IStage
-            # yet_another_stage: codepipeline.IStage
-            
-            
-            some_stage = pipeline.add_stage(
-                stage_name="SomeStage",
-                placement=codepipeline.StagePlacement(
-                    # note: you can only specify one of the below properties
-                    right_before=another_stage,
-                    just_after=yet_another_stage
-                )
-            )
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__c178aee5c43b367dd6efb72d92b210fe5967b9817ff84698c049986838c0cf39)
-            check_type(argname="argument just_after", value=just_after, expected_type=type_hints["just_after"])
-            check_type(argname="argument right_before", value=right_before, expected_type=type_hints["right_before"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {}
-        if just_after is not None:
-            self._values["just_after"] = just_after
-        if right_before is not None:
+        # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+        # build_action: codepipeline_actions.CodeBuildAction
+        
+        
+        codepipeline.Pipeline(self, "Pipeline",
+            pipeline_type=codepipeline.PipelineType.V2,
+            stages=[codepipeline.StageProps(
+                stage_name="Source",
+                actions=[source_action]
+            ), codepipeline.StageProps(
+                stage_name="Build",
+                actions=[build_action],
+                # BeforeEntry condition - checks before entering the stage
+                before_entry=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        rules=[codepipeline.Rule(
+                            name="LambdaCheck",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "FunctionName": "LambdaFunctionName"
+                            }
+                        )],
+                        result=codepipeline.Result.FAIL
+                    )]
+                ),
+                # OnSuccess condition - checks after successful stage completion
+                on_success=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.FAIL,
+                        rules=[codepipeline.Rule(
+                            name="CloudWatchCheck",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "AlarmName": "AlarmName1",
+                                "WaitTime": "300",  # 5 minutes
+                                "FunctionName": "funcName2"
+                            }
+                        )]
+                    )]
+                ),
+                # OnFailure condition - handles stage failure
+                on_failure=codepipeline.FailureConditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.ROLLBACK,
+                        rules=[codepipeline.Rule(
+                            name="RollBackOnFailure",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "AlarmName": "Alarm",
+                                "WaitTime": "300",  # 5 minutes
+                                "FunctionName": "funcName1"
+                            }
+                        )]
+                    )]
+                )
+            )
+            ]
+        )
+    '''
+
+    ROLLBACK = "ROLLBACK"
+    '''Rollback.'''
+    FAIL = "FAIL"
+    '''Failure.'''
+    RETRY = "RETRY"
+    '''Retry.'''
+    SKIP = "SKIP"
+    '''Skip.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codepipeline.RetryMode")
+class RetryMode(enum.Enum):
+    '''The method that you want to configure for automatic stage retry on stage failure.
+
+    You can specify to retry only failed action in the stage or all actions in the stage.
+    '''
+
+    ALL_ACTIONS = "ALL_ACTIONS"
+    '''Retry all actions under this stage.'''
+    FAILED_ACTIONS = "FAILED_ACTIONS"
+    '''Only retry failed actions.'''
+
+
+class Rule(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.aws_codepipeline.Rule"):
+    '''Represents a rule in AWS CodePipeline that can be used to add conditions and controls to pipeline execution.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+        # build_action: codepipeline_actions.CodeBuildAction
+        
+        
+        codepipeline.Pipeline(self, "Pipeline",
+            pipeline_type=codepipeline.PipelineType.V2,
+            stages=[codepipeline.StageProps(
+                stage_name="Source",
+                actions=[source_action]
+            ), codepipeline.StageProps(
+                stage_name="Build",
+                actions=[build_action],
+                # BeforeEntry condition - checks before entering the stage
+                before_entry=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        rules=[codepipeline.Rule(
+                            name="LambdaCheck",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "FunctionName": "LambdaFunctionName"
+                            }
+                        )],
+                        result=codepipeline.Result.FAIL
+                    )]
+                ),
+                # OnSuccess condition - checks after successful stage completion
+                on_success=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.FAIL,
+                        rules=[codepipeline.Rule(
+                            name="CloudWatchCheck",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "AlarmName": "AlarmName1",
+                                "WaitTime": "300",  # 5 minutes
+                                "FunctionName": "funcName2"
+                            }
+                        )]
+                    )]
+                ),
+                # OnFailure condition - handles stage failure
+                on_failure=codepipeline.FailureConditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.ROLLBACK,
+                        rules=[codepipeline.Rule(
+                            name="RollBackOnFailure",
+                            provider="LambdaInvoke",
+                            version="1",
+                            configuration={
+                                "AlarmName": "Alarm",
+                                "WaitTime": "300",  # 5 minutes
+                                "FunctionName": "funcName1"
+                            }
+                        )]
+                    )]
+                )
+            )
+            ]
+        )
+    '''
+
+    def __init__(
+        self,
+        *,
+        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
+        configuration: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None,
+        input_artifacts: typing.Optional[typing.Sequence[builtins.str]] = None,
+        name: typing.Optional[builtins.str] = None,
+        provider: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        role: typing.Optional[_Role_e8c6e11f] = None,
+        version: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Creates a new Rule instance.
+
+        :param commands: The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats. While CodeBuild logs and permissions are used, you do not need to create any resources in CodeBuild. Default: - No commands
+        :param configuration: The action configuration fields for the rule. This can include custom parameters specific to the rule type. Default: - No configuration
+        :param input_artifacts: The input artifacts fields for the rule, such as specifying an input file for the rule. Each string in the array represents an artifact name that this rule will use as input. Default: - No input artifacts
+        :param name: The name of the rule that is created for the condition. Must be unique within the pipeline. Default: - A unique name will be generated
+        :param provider: The rule provider that implements the rule's functionality. Default: - No provider, must be specified if rule is used
+        :param region: The AWS Region for the condition associated with the rule. If not specified, uses the pipeline's region. Default: - Pipeline's region
+        :param role: The IAM role that the rule will use to execute its actions. The role must have sufficient permissions to perform the rule's tasks. Default: - A new role will be created
+        :param version: The version of the rule to use. Different versions may have different features or behaviors. Default: '1'
+
+        :throws: {Error} If the rule name is invalid
+        '''
+        props = RuleProps(
+            commands=commands,
+            configuration=configuration,
+            input_artifacts=input_artifacts,
+            name=name,
+            provider=provider,
+            region=region,
+            role=role,
+            version=version,
+        )
+
+        jsii.create(self.__class__, self, [props])
+
+    @jsii.member(jsii_name="reference")
+    def reference(self) -> builtins.str:
+        '''Returns a reference to the rule that can be used in pipeline stage conditions.
+
+        :return: A string in the format "#{rule.ruleName}" that can be used to reference this rule
+        '''
+        return typing.cast(builtins.str, jsii.invoke(self, "reference", []))
+
+    @builtins.property
+    @jsii.member(jsii_name="ruleName")
+    def rule_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the rule, if specified in the properties.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "ruleName"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.RuleProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "commands": "commands",
+        "configuration": "configuration",
+        "input_artifacts": "inputArtifacts",
+        "name": "name",
+        "provider": "provider",
+        "region": "region",
+        "role": "role",
+        "version": "version",
+    },
+)
+class RuleProps:
+    def __init__(
+        self,
+        *,
+        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
+        configuration: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None,
+        input_artifacts: typing.Optional[typing.Sequence[builtins.str]] = None,
+        name: typing.Optional[builtins.str] = None,
+        provider: typing.Optional[builtins.str] = None,
+        region: typing.Optional[builtins.str] = None,
+        role: typing.Optional[_Role_e8c6e11f] = None,
+        version: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Properties for defining a CodePipeline Rule.
+
+        :param commands: The shell commands to run with your commands rule in CodePipeline. All commands are supported except multi-line formats. While CodeBuild logs and permissions are used, you do not need to create any resources in CodeBuild. Default: - No commands
+        :param configuration: The action configuration fields for the rule. This can include custom parameters specific to the rule type. Default: - No configuration
+        :param input_artifacts: The input artifacts fields for the rule, such as specifying an input file for the rule. Each string in the array represents an artifact name that this rule will use as input. Default: - No input artifacts
+        :param name: The name of the rule that is created for the condition. Must be unique within the pipeline. Default: - A unique name will be generated
+        :param provider: The rule provider that implements the rule's functionality. Default: - No provider, must be specified if rule is used
+        :param region: The AWS Region for the condition associated with the rule. If not specified, uses the pipeline's region. Default: - Pipeline's region
+        :param role: The IAM role that the rule will use to execute its actions. The role must have sufficient permissions to perform the rule's tasks. Default: - A new role will be created
+        :param version: The version of the rule to use. Different versions may have different features or behaviors. Default: '1'
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+            # build_action: codepipeline_actions.CodeBuildAction
+            
+            
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                stages=[codepipeline.StageProps(
+                    stage_name="Source",
+                    actions=[source_action]
+                ), codepipeline.StageProps(
+                    stage_name="Build",
+                    actions=[build_action],
+                    # BeforeEntry condition - checks before entering the stage
+                    before_entry=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            rules=[codepipeline.Rule(
+                                name="LambdaCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "FunctionName": "LambdaFunctionName"
+                                }
+                            )],
+                            result=codepipeline.Result.FAIL
+                        )]
+                    ),
+                    # OnSuccess condition - checks after successful stage completion
+                    on_success=codepipeline.Conditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.FAIL,
+                            rules=[codepipeline.Rule(
+                                name="CloudWatchCheck",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "AlarmName1",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName2"
+                                }
+                            )]
+                        )]
+                    ),
+                    # OnFailure condition - handles stage failure
+                    on_failure=codepipeline.FailureConditions(
+                        conditions=[codepipeline.Condition(
+                            result=codepipeline.Result.ROLLBACK,
+                            rules=[codepipeline.Rule(
+                                name="RollBackOnFailure",
+                                provider="LambdaInvoke",
+                                version="1",
+                                configuration={
+                                    "AlarmName": "Alarm",
+                                    "WaitTime": "300",  # 5 minutes
+                                    "FunctionName": "funcName1"
+                                }
+                            )]
+                        )]
+                    )
+                )
+                ]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__04d67752f5c1682591306a9c0ca45eff53409b418ee518ef81598208bfeca4a0)
+            check_type(argname="argument commands", value=commands, expected_type=type_hints["commands"])
+            check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
+            check_type(argname="argument input_artifacts", value=input_artifacts, expected_type=type_hints["input_artifacts"])
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
+            check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+            check_type(argname="argument version", value=version, expected_type=type_hints["version"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if commands is not None:
+            self._values["commands"] = commands
+        if configuration is not None:
+            self._values["configuration"] = configuration
+        if input_artifacts is not None:
+            self._values["input_artifacts"] = input_artifacts
+        if name is not None:
+            self._values["name"] = name
+        if provider is not None:
+            self._values["provider"] = provider
+        if region is not None:
+            self._values["region"] = region
+        if role is not None:
+            self._values["role"] = role
+        if version is not None:
+            self._values["version"] = version
+
+    @builtins.property
+    def commands(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The shell commands to run with your commands rule in CodePipeline.
+
+        All commands are supported except multi-line formats. While CodeBuild logs and permissions are used,
+        you do not need to create any resources in CodeBuild.
+
+        :default: - No commands
+
+        :remarks: Using compute time for this action will incur separate charges in AWS CodeBuild.
+        '''
+        result = self._values.get("commands")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def configuration(self) -> typing.Optional[typing.Mapping[typing.Any, typing.Any]]:
+        '''The action configuration fields for the rule.
+
+        This can include custom parameters specific to the rule type.
+
+        :default: - No configuration
+        '''
+        result = self._values.get("configuration")
+        return typing.cast(typing.Optional[typing.Mapping[typing.Any, typing.Any]], result)
+
+    @builtins.property
+    def input_artifacts(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The input artifacts fields for the rule, such as specifying an input file for the rule.
+
+        Each string in the array represents an artifact name that this rule will use as input.
+
+        :default: - No input artifacts
+        '''
+        result = self._values.get("input_artifacts")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def name(self) -> typing.Optional[builtins.str]:
+        '''The name of the rule that is created for the condition.
+
+        Must be unique within the pipeline.
+
+        :default: - A unique name will be generated
+
+        Example::
+
+            "VariableCheck"
+        '''
+        result = self._values.get("name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def provider(self) -> typing.Optional[builtins.str]:
+        '''The rule provider that implements the rule's functionality.
+
+        :default: - No provider, must be specified if rule is used
+
+        :see: AWS CodePipeline rule reference for available providers
+
+        Example::
+
+            "DeploymentWindow"
+        '''
+        result = self._values.get("provider")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def region(self) -> typing.Optional[builtins.str]:
+        '''The AWS Region for the condition associated with the rule.
+
+        If not specified, uses the pipeline's region.
+
+        :default: - Pipeline's region
+        '''
+        result = self._values.get("region")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def role(self) -> typing.Optional[_Role_e8c6e11f]:
+        '''The IAM role that the rule will use to execute its actions.
+
+        The role must have sufficient permissions to perform the rule's tasks.
+
+        :default: - A new role will be created
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_Role_e8c6e11f], result)
+
+    @builtins.property
+    def version(self) -> typing.Optional[builtins.str]:
+        '''The version of the rule to use.
+
+        Different versions may have different features or behaviors.
+
+        :default: '1'
+        '''
+        result = self._values.get("version")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "RuleProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.StagePlacement",
+    jsii_struct_bases=[],
+    name_mapping={"just_after": "justAfter", "right_before": "rightBefore"},
+)
+class StagePlacement:
+    def __init__(
+        self,
+        *,
+        just_after: typing.Optional[IStage] = None,
+        right_before: typing.Optional[IStage] = None,
+    ) -> None:
+        '''Allows you to control where to place a new Stage when it's added to the Pipeline.
+
+        Note that you can provide only one of the below properties -
+        specifying more than one will result in a validation error.
+
+        :param just_after: Inserts the new Stage as a child of the given Stage (changing its current child Stage, if it had one).
+        :param right_before: Inserts the new Stage as a parent of the given Stage (changing its current parent Stage, if it had one).
+
+        :see: #justAfter
+        :exampleMetadata: infused
+
+        Example::
+
+            # Insert a new Stage at an arbitrary point
+            # pipeline: codepipeline.Pipeline
+            # another_stage: codepipeline.IStage
+            # yet_another_stage: codepipeline.IStage
+            
+            
+            some_stage = pipeline.add_stage(
+                stage_name="SomeStage",
+                placement=codepipeline.StagePlacement(
+                    # note: you can only specify one of the below properties
+                    right_before=another_stage,
+                    just_after=yet_another_stage
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c178aee5c43b367dd6efb72d92b210fe5967b9817ff84698c049986838c0cf39)
+            check_type(argname="argument just_after", value=just_after, expected_type=type_hints["just_after"])
+            check_type(argname="argument right_before", value=right_before, expected_type=type_hints["right_before"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if just_after is not None:
+            self._values["just_after"] = just_after
+        if right_before is not None:
             self._values["right_before"] = right_before
 
     @builtins.property
@@ -9847,6 +10873,9 @@ class StagePlacement:
     name_mapping={
         "stage_name": "stageName",
         "actions": "actions",
+        "before_entry": "beforeEntry",
+        "on_failure": "onFailure",
+        "on_success": "onSuccess",
         "transition_disabled_reason": "transitionDisabledReason",
         "transition_to_enabled": "transitionToEnabled",
     },
@@ -9857,6 +10886,9 @@ class StageProps:
         *,
         stage_name: builtins.str,
         actions: typing.Optional[typing.Sequence[IAction]] = None,
+        before_entry: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_failure: typing.Optional[typing.Union[FailureConditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_success: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
         transition_disabled_reason: typing.Optional[builtins.str] = None,
         transition_to_enabled: typing.Optional[builtins.bool] = None,
     ) -> None:
@@ -9864,6 +10896,9 @@ class StageProps:
 
         :param stage_name: The physical, human-readable name to assign to this Pipeline Stage.
         :param actions: The list of Actions to create this Stage with. You can always add more Actions later by calling ``IStage#addAction``.
+        :param before_entry: The method to use when a stage allows entry. Default: - No conditions are applied before stage entry
+        :param on_failure: The method to use when a stage has not completed successfully. Default: - No failure conditions are applied
+        :param on_success: The method to use when a stage has succeeded. Default: - No success conditions are applied
         :param transition_disabled_reason: The reason for disabling transition to this stage. Only applicable if ``transitionToEnabled`` is set to ``false``. Default: 'Transition disabled'
         :param transition_to_enabled: Whether to enable transition to this stage. Default: true
 
@@ -9876,20 +10911,50 @@ class StageProps:
             from aws_cdk import aws_codepipeline as codepipeline
             
             # action: codepipeline.Action
+            # rule: codepipeline.Rule
             
             stage_props = codepipeline.StageProps(
                 stage_name="stageName",
             
                 # the properties below are optional
                 actions=[action],
+                before_entry=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.ROLLBACK,
+                        rules=[rule]
+                    )]
+                ),
+                on_failure=codepipeline.FailureConditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.ROLLBACK,
+                        rules=[rule]
+                    )],
+                    result=codepipeline.Result.ROLLBACK,
+                    retry_mode=codepipeline.RetryMode.ALL_ACTIONS
+                ),
+                on_success=codepipeline.Conditions(
+                    conditions=[codepipeline.Condition(
+                        result=codepipeline.Result.ROLLBACK,
+                        rules=[rule]
+                    )]
+                ),
                 transition_disabled_reason="transitionDisabledReason",
                 transition_to_enabled=False
             )
         '''
+        if isinstance(before_entry, dict):
+            before_entry = Conditions(**before_entry)
+        if isinstance(on_failure, dict):
+            on_failure = FailureConditions(**on_failure)
+        if isinstance(on_success, dict):
+            on_success = Conditions(**on_success)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__6abc7556098f83ba3d73e92b8d6098aeb43f50e6fc7a58af7d194bb4ffc1f646)
             check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
             check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
+            check_type(argname="argument before_entry", value=before_entry, expected_type=type_hints["before_entry"])
+            check_type(argname="argument on_failure", value=on_failure, expected_type=type_hints["on_failure"])
+            check_type(argname="argument on_success", value=on_success, expected_type=type_hints["on_success"])
             check_type(argname="argument transition_disabled_reason", value=transition_disabled_reason, expected_type=type_hints["transition_disabled_reason"])
             check_type(argname="argument transition_to_enabled", value=transition_to_enabled, expected_type=type_hints["transition_to_enabled"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
@@ -9897,6 +10962,12 @@ class StageProps:
         }
         if actions is not None:
             self._values["actions"] = actions
+        if before_entry is not None:
+            self._values["before_entry"] = before_entry
+        if on_failure is not None:
+            self._values["on_failure"] = on_failure
+        if on_success is not None:
+            self._values["on_success"] = on_success
         if transition_disabled_reason is not None:
             self._values["transition_disabled_reason"] = transition_disabled_reason
         if transition_to_enabled is not None:
@@ -9918,6 +10989,33 @@ class StageProps:
         result = self._values.get("actions")
         return typing.cast(typing.Optional[typing.List[IAction]], result)
 
+    @builtins.property
+    def before_entry(self) -> typing.Optional[Conditions]:
+        '''The method to use when a stage allows entry.
+
+        :default: - No conditions are applied before stage entry
+        '''
+        result = self._values.get("before_entry")
+        return typing.cast(typing.Optional[Conditions], result)
+
+    @builtins.property
+    def on_failure(self) -> typing.Optional[FailureConditions]:
+        '''The method to use when a stage has not completed successfully.
+
+        :default: - No failure conditions are applied
+        '''
+        result = self._values.get("on_failure")
+        return typing.cast(typing.Optional[FailureConditions], result)
+
+    @builtins.property
+    def on_success(self) -> typing.Optional[Conditions]:
+        '''The method to use when a stage has succeeded.
+
+        :default: - No success conditions are applied
+        '''
+        result = self._values.get("on_success")
+        return typing.cast(typing.Optional[Conditions], result)
+
     @builtins.property
     def transition_disabled_reason(self) -> typing.Optional[builtins.str]:
         '''The reason for disabling transition to this stage.
@@ -9983,6 +11081,10 @@ class Trigger(
                     file_paths_includes=["filePathsIncludes"]
                 )],
                 push_filter=[codepipeline.GitPushFilter(
+                    branches_excludes=["branchesExcludes"],
+                    branches_includes=["branchesIncludes"],
+                    file_paths_excludes=["filePathsExcludes"],
+                    file_paths_includes=["filePathsIncludes"],
                     tags_excludes=["tagsExcludes"],
                     tags_includes=["tagsIncludes"]
                 )]
@@ -10455,6 +11557,9 @@ typing.cast(typing.Any, Action).__jsii_proxy_class__ = lambda : _ActionProxy
     name_mapping={
         "stage_name": "stageName",
         "actions": "actions",
+        "before_entry": "beforeEntry",
+        "on_failure": "onFailure",
+        "on_success": "onSuccess",
         "transition_disabled_reason": "transitionDisabledReason",
         "transition_to_enabled": "transitionToEnabled",
         "placement": "placement",
@@ -10466,6 +11571,9 @@ class StageOptions(StageProps):
         *,
         stage_name: builtins.str,
         actions: typing.Optional[typing.Sequence[IAction]] = None,
+        before_entry: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_failure: typing.Optional[typing.Union[FailureConditions, typing.Dict[builtins.str, typing.Any]]] = None,
+        on_success: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
         transition_disabled_reason: typing.Optional[builtins.str] = None,
         transition_to_enabled: typing.Optional[builtins.bool] = None,
         placement: typing.Optional[typing.Union[StagePlacement, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -10473,6 +11581,9 @@ class StageOptions(StageProps):
         '''
         :param stage_name: The physical, human-readable name to assign to this Pipeline Stage.
         :param actions: The list of Actions to create this Stage with. You can always add more Actions later by calling ``IStage#addAction``.
+        :param before_entry: The method to use when a stage allows entry. Default: - No conditions are applied before stage entry
+        :param on_failure: The method to use when a stage has not completed successfully. Default: - No failure conditions are applied
+        :param on_success: The method to use when a stage has succeeded. Default: - No success conditions are applied
         :param transition_disabled_reason: The reason for disabling transition to this stage. Only applicable if ``transitionToEnabled`` is set to ``false``. Default: 'Transition disabled'
         :param transition_to_enabled: Whether to enable transition to this stage. Default: true
         :param placement: 
@@ -10498,12 +11609,21 @@ class StageOptions(StageProps):
                 actions=[step_function_action]
             )
         '''
+        if isinstance(before_entry, dict):
+            before_entry = Conditions(**before_entry)
+        if isinstance(on_failure, dict):
+            on_failure = FailureConditions(**on_failure)
+        if isinstance(on_success, dict):
+            on_success = Conditions(**on_success)
         if isinstance(placement, dict):
             placement = StagePlacement(**placement)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__92727a684e79c716bbbda8d093b76a8cb689c53237b1b129e655150ce80272df)
             check_type(argname="argument stage_name", value=stage_name, expected_type=type_hints["stage_name"])
             check_type(argname="argument actions", value=actions, expected_type=type_hints["actions"])
+            check_type(argname="argument before_entry", value=before_entry, expected_type=type_hints["before_entry"])
+            check_type(argname="argument on_failure", value=on_failure, expected_type=type_hints["on_failure"])
+            check_type(argname="argument on_success", value=on_success, expected_type=type_hints["on_success"])
             check_type(argname="argument transition_disabled_reason", value=transition_disabled_reason, expected_type=type_hints["transition_disabled_reason"])
             check_type(argname="argument transition_to_enabled", value=transition_to_enabled, expected_type=type_hints["transition_to_enabled"])
             check_type(argname="argument placement", value=placement, expected_type=type_hints["placement"])
@@ -10512,6 +11632,12 @@ class StageOptions(StageProps):
         }
         if actions is not None:
             self._values["actions"] = actions
+        if before_entry is not None:
+            self._values["before_entry"] = before_entry
+        if on_failure is not None:
+            self._values["on_failure"] = on_failure
+        if on_success is not None:
+            self._values["on_success"] = on_success
         if transition_disabled_reason is not None:
             self._values["transition_disabled_reason"] = transition_disabled_reason
         if transition_to_enabled is not None:
@@ -10535,6 +11661,33 @@ class StageOptions(StageProps):
         result = self._values.get("actions")
         return typing.cast(typing.Optional[typing.List[IAction]], result)
 
+    @builtins.property
+    def before_entry(self) -> typing.Optional[Conditions]:
+        '''The method to use when a stage allows entry.
+
+        :default: - No conditions are applied before stage entry
+        '''
+        result = self._values.get("before_entry")
+        return typing.cast(typing.Optional[Conditions], result)
+
+    @builtins.property
+    def on_failure(self) -> typing.Optional[FailureConditions]:
+        '''The method to use when a stage has not completed successfully.
+
+        :default: - No failure conditions are applied
+        '''
+        result = self._values.get("on_failure")
+        return typing.cast(typing.Optional[FailureConditions], result)
+
+    @builtins.property
+    def on_success(self) -> typing.Optional[Conditions]:
+        '''The method to use when a stage has succeeded.
+
+        :default: - No success conditions are applied
+        '''
+        result = self._values.get("on_success")
+        return typing.cast(typing.Optional[Conditions], result)
+
     @builtins.property
     def transition_disabled_reason(self) -> typing.Optional[builtins.str]:
         '''The reason for disabling transition to this stage.
@@ -10590,11 +11743,14 @@ __all__ = [
     "CfnWebhookProps",
     "CommonActionProps",
     "CommonAwsActionProps",
+    "Condition",
+    "Conditions",
     "CrossRegionSupport",
     "CustomActionProperty",
     "CustomActionRegistration",
     "CustomActionRegistrationProps",
     "ExecutionMode",
+    "FailureConditions",
     "GitConfiguration",
     "GitPullRequestEvent",
     "GitPullRequestFilter",
@@ -10609,6 +11765,10 @@ __all__ = [
     "PipelineProps",
     "PipelineType",
     "ProviderType",
+    "Result",
+    "RetryMode",
+    "Rule",
+    "RuleProps",
     "StageOptions",
     "StagePlacement",
     "StageProps",
@@ -11315,6 +12475,21 @@ def _typecheckingstub__b783a63e8d6c7172676968c2e23c558eb0d0f2b7f7bcc22e469d596ee
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__f9d3d585d6146668bf50fd9ef4e444521a4def40f934c6c42bb219a9816ffc01(
+    *,
+    result: typing.Optional[Result] = None,
+    rules: typing.Optional[typing.Sequence[Rule]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__b1d234052e60461c20b06295a40d2efb73b7297f0a204252511a0083c29daef9(
+    *,
+    conditions: typing.Optional[typing.Sequence[typing.Union[Condition, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__d001dfd3e83aa31d0adf70e4d5aba4e4d34063bfb876bb5ad39b788c9e458e0c(
     *,
     replication_bucket: _IBucket_42e086fd,
@@ -11364,6 +12539,15 @@ def _typecheckingstub__65e227e2024e22ec4a8340ba1d5e7057772fcde85f4031d00361f79aa
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5c4e44cde413d4a9db86d96fc9c455622d0585f9fb8a399e230a3e6f73163569(
+    *,
+    conditions: typing.Optional[typing.Sequence[typing.Union[Condition, typing.Dict[builtins.str, typing.Any]]]] = None,
+    result: typing.Optional[Result] = None,
+    retry_mode: typing.Optional[RetryMode] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf(
     *,
     source_action: IAction,
@@ -11386,6 +12570,10 @@ def _typecheckingstub__cd84a4c10c68eec597c7c17a163a758ee28d398b585c996c44eba7fd9
 
 def _typecheckingstub__d2e5e6ae139c810aa752b8a8c7cd3040d883f9f3a67c8d3693f9ab842351804e(
     *,
+    branches_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    branches_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    file_paths_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    file_paths_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
     tags_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
     tags_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
@@ -11693,6 +12881,20 @@ def _typecheckingstub__22f00fc379808105702c3f59369205afd36025a51e45bcaf5d1cec0a3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__04d67752f5c1682591306a9c0ca45eff53409b418ee518ef81598208bfeca4a0(
+    *,
+    commands: typing.Optional[typing.Sequence[builtins.str]] = None,
+    configuration: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None,
+    input_artifacts: typing.Optional[typing.Sequence[builtins.str]] = None,
+    name: typing.Optional[builtins.str] = None,
+    provider: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
+    role: typing.Optional[_Role_e8c6e11f] = None,
+    version: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c178aee5c43b367dd6efb72d92b210fe5967b9817ff84698c049986838c0cf39(
     *,
     just_after: typing.Optional[IStage] = None,
@@ -11705,6 +12907,9 @@ def _typecheckingstub__6abc7556098f83ba3d73e92b8d6098aeb43f50e6fc7a58af7d194bb4f
     *,
     stage_name: builtins.str,
     actions: typing.Optional[typing.Sequence[IAction]] = None,
+    before_entry: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
+    on_failure: typing.Optional[typing.Union[FailureConditions, typing.Dict[builtins.str, typing.Any]]] = None,
+    on_success: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
     transition_disabled_reason: typing.Optional[builtins.str] = None,
     transition_to_enabled: typing.Optional[builtins.bool] = None,
 ) -> None:
@@ -11774,6 +12979,9 @@ def _typecheckingstub__92727a684e79c716bbbda8d093b76a8cb689c53237b1b129e655150ce
     *,
     stage_name: builtins.str,
     actions: typing.Optional[typing.Sequence[IAction]] = None,
+    before_entry: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
+    on_failure: typing.Optional[typing.Union[FailureConditions, typing.Dict[builtins.str, typing.Any]]] = None,
+    on_success: typing.Optional[typing.Union[Conditions, typing.Dict[builtins.str, typing.Any]]] = None,
     transition_disabled_reason: typing.Optional[builtins.str] = None,
     transition_to_enabled: typing.Optional[builtins.bool] = None,
     placement: typing.Optional[typing.Union[StagePlacement, typing.Dict[builtins.str, typing.Any]]] = None,