aws-cdk-lib 2.127.0__py3-none-any.whl → 2.129.0__py3-none-any.whl

aws_cdk/aws_codepipeline/__init__.py

@@ -360,7 +360,16 @@ replication_bucket = s3.Bucket(replication_stack, "ReplicationBucket",
 
 ## Variables
 
-The library supports the CodePipeline Variables feature.
+Variables are key-value pairs that can be used to dynamically configure actions in your pipeline.
+
+There are two types of variables, Action-level variables and Pipeline-level variables. Action-level
+variables are produced when an action is executed. Pipeline-level variables are defined when the
+pipeline is created and resolved at pipeline run time. You specify the Pipeline-level variables
+when the pipeline is created, and you can provide values at the time of the pipeline execution.
+
+### Action-level variables
+
+The library supports action-level variables.
 Each action class that emits variables has a separate variables interface,
 accessed as a property of the action instance called `variables`.
 You instantiate the action class and assign it to a local variable;
@@ -408,12 +417,99 @@ OtherAction(
 )
 ```
 
+The following is an actual code example.
+
+```python
+# source_action: codepipeline_actions.S3SourceAction
+# source_output: codepipeline.Artifact
+# deploy_bucket: s3.Bucket
+
+
+codepipeline.Pipeline(self, "Pipeline",
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        stage_name="Deploy",
+        actions=[
+            codepipeline_actions.S3DeployAction(
+                action_name="DeployAction",
+                # can reference the variables
+                object_key=f"{sourceAction.variables.versionId}.txt",
+                input=source_output,
+                bucket=deploy_bucket
+            )
+        ]
+    )
+    ]
+)
+```
+
 Check the documentation of the `aws-cdk-lib/aws-codepipeline-actions`
 for details on how to use the variables for each action class.
 
 See the [CodePipeline documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-variables.html)
 for more details on how to use the variables feature.
 
+### Pipeline-level variables
+
+You can add one or more variables at the pipeline level. You can reference
+this value in the configuration of CodePipeline actions. You can add the
+variable names, default values, and descriptions when you create the pipeline.
+Variables are resolved at the time of execution.
+
+Note that using pipeline-level variables in any kind of Source action is not supported.
+Also, the variables can only be used with pipeline type V2.
+
+```python
+# source_action: codepipeline_actions.S3SourceAction
+# source_output: codepipeline.Artifact
+# deploy_bucket: s3.Bucket
+
+
+# Pipeline-level variable
+variable = codepipeline.Variable(
+    variable_name="bucket-var",
+    description="description",
+    default_value="sample"
+)
+
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2,
+    variables=[variable],
+    stages=[codepipeline.StageProps(
+        stage_name="Source",
+        actions=[source_action]
+    ), codepipeline.StageProps(
+        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
+            )
+        ]
+    )
+    ]
+)
+```
+
+Or append a variable to an existing pipeline:
+
+```python
+# pipeline: codepipeline.Pipeline
+
+
+variable = codepipeline.Variable(
+    variable_name="bucket-var",
+    description="description",
+    default_value="sample"
+)
+pipeline.add_variable(variable)
+```
+
 ## Events
 
 ### Using a pipeline as an event target
@@ -477,6 +573,75 @@ target = chatbot.SlackChannelConfiguration(self, "MySlackChannel",
 )
 rule = pipeline.notify_on_execution_state_change("NotifyOnExecutionStateChange", target)
 ```
+
+## Trigger
+
+To trigger a pipeline with Git tags, specify the `triggers` property. When a Git tag is pushed,
+your pipeline starts. You can filter with glob patterns. The `tagsExcludes` takes priority over
+the `tagsIncludes`.
+
+The triggers can only be used with pipeline type V2.
+
+```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(
+                tags_excludes=["exclude1", "exclude2"],
+                tags_includes=["include*"]
+            )]
+        )
+    )]
+)
+```
+
+Or append a trigger to an existing pipeline:
+
+```python
+# pipeline: codepipeline.Pipeline
+# source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+
+
+pipeline.add_trigger(
+    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*"]
+        )]
+    )
+)
+```
+
+## 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`.
+This migration does not cause replacement of your pipeline.
+
+```python
+codepipeline.Pipeline(self, "Pipeline",
+    pipeline_type=codepipeline.PipelineType.V2
+)
+```
+
+See the [CodePipeline documentation](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html)
+for more details on the differences between each type.
 '''
 import abc
 import builtins
@@ -2138,7 +2303,9 @@ class CfnPipeline(
 ):
     '''The ``AWS::CodePipeline::Pipeline`` resource creates a CodePipeline pipeline that describes how software changes go through a release process.
 
-    For more information, see `What Is CodePipeline? <https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html>`_ in the *AWS CodePipeline User Guide* .
+    For more information, see `What Is CodePipeline? <https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html>`_ in the *CodePipeline User Guide* .
+
+    For an example in YAML and JSON that contains the parameters in this reference, see `Examples <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#aws-resource-codepipeline-pipeline--examples>`_ .
 
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html
     :cloudformationResource: AWS::CodePipeline::Pipeline
@@ -2214,6 +2381,7 @@ class CfnPipeline(
                 reason="reason",
                 stage_name="stageName"
             )],
+            execution_mode="executionMode",
             name="name",
             pipeline_type="pipelineType",
             restart_execution_on_update=False,
@@ -2229,7 +2397,26 @@ class CfnPipeline(
                     source_action_name="sourceActionName",
         
                     # the properties below are optional
+                    pull_request=[codepipeline.CfnPipeline.GitPullRequestFilterProperty(
+                        branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
+                        events=["events"],
+                        file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        )
+                    )],
                     push=[codepipeline.CfnPipeline.GitPushFilterProperty(
+                        branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
+                        file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
                         tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
                             excludes=["excludes"],
                             includes=["includes"]
@@ -2257,6 +2444,7 @@ class CfnPipeline(
         artifact_store: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.ArtifactStoreProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         artifact_stores: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.ArtifactStoreMapProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         disable_inbound_stage_transitions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.StageTransitionProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        execution_mode: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
         pipeline_type: typing.Optional[builtins.str] = None,
         restart_execution_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
@@ -2272,8 +2460,9 @@ class CfnPipeline(
         :param artifact_store: The S3 bucket where artifacts for the pipeline are stored. .. epigraph:: You must include either ``artifactStore`` or ``artifactStores`` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use ``artifactStores`` .
         :param artifact_stores: A mapping of ``artifactStore`` objects and their corresponding AWS Regions. There must be an artifact store for the pipeline Region and for each cross-region action in the pipeline. .. epigraph:: You must include either ``artifactStore`` or ``artifactStores`` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use ``artifactStores`` .
         :param disable_inbound_stage_transitions: Represents the input of a ``DisableStageTransition`` action.
+        :param execution_mode: The method that the pipeline will use to handle multiple executions. The default mode is SUPERSEDED.
         :param name: The name of the pipeline.
-        :param pipeline_type: CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications. - V1 type pipelines have a JSON structure that contains standard pipeline, stage, and action-level parameters. - V2 type pipelines have the same structure as a V1 type, along with additional parameters for release safety and trigger configuration. .. epigraph:: Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs. For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/https://aws.amazon.com/codepipeline/pricing/>`_ . For information about which type of pipeline to choose, see `What type of pipeline is right for me? <https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html>`_ .
+        :param pipeline_type: CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications. - V1 type pipelines have a JSON structure that contains standard pipeline, stage, and action-level parameters. - V2 type pipelines have the same structure as a V1 type, along with additional parameters for release safety and trigger configuration. .. epigraph:: Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs. For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/codepipeline/pricing/>`_ . For information about which type of pipeline to choose, see `What type of pipeline is right for me? <https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html>`_ .
         :param restart_execution_on_update: Indicates whether to rerun the CodePipeline pipeline after you update it.
         :param tags: Specifies the tags applied to the pipeline.
         :param triggers: The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline. .. epigraph:: When a trigger configuration is specified, default change detection for repository and branch commits is disabled.
@@ -2289,6 +2478,7 @@ class CfnPipeline(
             artifact_store=artifact_store,
             artifact_stores=artifact_stores,
             disable_inbound_stage_transitions=disable_inbound_stage_transitions,
+            execution_mode=execution_mode,
             name=name,
             pipeline_type=pipeline_type,
             restart_execution_on_update=restart_execution_on_update,
@@ -2446,6 +2636,19 @@ class CfnPipeline(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "disableInboundStageTransitions", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="executionMode")
+    def execution_mode(self) -> typing.Optional[builtins.str]:
+        '''The method that the pipeline will use to handle multiple executions.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "executionMode"))
+
+    @execution_mode.setter
+    def execution_mode(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__472d85ae1c4eb5d13c62e60f6347b15da6be45b950e9ce0ab0c5a3d67951fda0)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "executionMode", value)
+
     @builtins.property
     @jsii.member(jsii_name="name")
     def name(self) -> typing.Optional[builtins.str]:
@@ -2570,6 +2773,10 @@ class CfnPipeline(
         ) -> None:
             '''Represents information about an action declaration.
 
+            .. epigraph::
+
+               Documentation for the ``timeoutInMinutes`` parameter in the ``ActionDeclaration`` is not yet available for CloudFormation and CDK resources in CodePipeline. For more information about the configurable timeout for manual approval actions, see the `ActionDeclaration <https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionDeclaration.html>`_ in the CodePipeline API Reference.
+
             :param action_type_id: Specifies the action type and the provider of the action.
             :param name: The action declaration's name.
             :param configuration: The action's configuration. These are key-value pairs that specify input values for an action. For more information, see `Action Structure Requirements in CodePipeline <https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements>`_ . For the list of configuration properties for the AWS CloudFormation action type in CodePipeline, see `Configuration Properties Reference <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html>`_ in the *AWS CloudFormation User Guide* . For template snippets with examples, see `Using Parameter Override Functions with CodePipeline Pipelines <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html>`_ in the *AWS CloudFormation User Guide* . The values can be represented in either JSON or YAML format. For example, the JSON configuration item format is as follows: *JSON:* ``"Configuration" : { Key : Value },``
@@ -3219,16 +3426,91 @@ class CfnPipeline(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty",
+        jsii_struct_bases=[],
+        name_mapping={"excludes": "excludes", "includes": "includes"},
+    )
+    class GitBranchFilterCriteriaProperty:
+        def __init__(
+            self,
+            *,
+            excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+            includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        ) -> None:
+            '''The Git repository branches specified as filter criteria to start the pipeline.
+
+            :param excludes: The list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
+            :param includes: The list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html
+            :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
+                
+                git_branch_filter_criteria_property = codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                    excludes=["excludes"],
+                    includes=["includes"]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__1d236727cda322520f3a703d9e848a434f71ca107e953aec5359ac063333d29b)
+                check_type(argname="argument excludes", value=excludes, expected_type=type_hints["excludes"])
+                check_type(argname="argument includes", value=includes, expected_type=type_hints["includes"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if excludes is not None:
+                self._values["excludes"] = excludes
+            if includes is not None:
+                self._values["includes"] = includes
+
+        @builtins.property
+        def excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html#cfn-codepipeline-pipeline-gitbranchfiltercriteria-excludes
+            '''
+            result = self._values.get("excludes")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def includes(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html#cfn-codepipeline-pipeline-gitbranchfiltercriteria-includes
+            '''
+            result = self._values.get("includes")
+            return typing.cast(typing.Optional[typing.List[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 "GitBranchFilterCriteriaProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitConfigurationProperty",
         jsii_struct_bases=[],
-        name_mapping={"source_action_name": "sourceActionName", "push": "push"},
+        name_mapping={
+            "source_action_name": "sourceActionName",
+            "pull_request": "pullRequest",
+            "push": "push",
+        },
     )
     class GitConfigurationProperty:
         def __init__(
             self,
             *,
             source_action_name: builtins.str,
+            pull_request: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitPullRequestFilterProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             push: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitPushFilterProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         ) -> None:
             '''A type of trigger configuration for Git-based source actions.
@@ -3238,7 +3520,8 @@ class CfnPipeline(
                You can specify the Git configuration trigger type for all third-party Git-based source actions that are supported by the ``CodeStarSourceConnection`` action type.
 
             :param source_action_name: The name of the pipeline source action where the trigger configuration, such as Git tags, is specified. The trigger configuration will start the pipeline upon the specified change only. .. epigraph:: You can only specify one trigger configuration per source action.
-            :param push: The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details. .. epigraph:: Git tags is the only supported event type.
+            :param pull_request: The field where the repository event that will start the pipeline is specified as pull requests.
+            :param push: The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -3253,7 +3536,26 @@ class CfnPipeline(
                     source_action_name="sourceActionName",
                 
                     # the properties below are optional
+                    pull_request=[codepipeline.CfnPipeline.GitPullRequestFilterProperty(
+                        branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
+                        events=["events"],
+                        file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        )
+                    )],
                     push=[codepipeline.CfnPipeline.GitPushFilterProperty(
+                        branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
+                        file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                            excludes=["excludes"],
+                            includes=["includes"]
+                        ),
                         tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
                             excludes=["excludes"],
                             includes=["includes"]
@@ -3264,10 +3566,13 @@ class CfnPipeline(
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__76ac16c602eb78041b136170e0877a83865ceb0c0c451b7e61c00366edce50a8)
                 check_type(argname="argument source_action_name", value=source_action_name, expected_type=type_hints["source_action_name"])
+                check_type(argname="argument pull_request", value=pull_request, expected_type=type_hints["pull_request"])
                 check_type(argname="argument push", value=push, expected_type=type_hints["push"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
                 "source_action_name": source_action_name,
             }
+            if pull_request is not None:
+                self._values["pull_request"] = pull_request
             if push is not None:
                 self._values["push"] = push
 
@@ -3286,16 +3591,23 @@ class CfnPipeline(
             assert result is not None, "Required property 'source_action_name' is missing"
             return typing.cast(builtins.str, result)
 
+        @builtins.property
+        def pull_request(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitPullRequestFilterProperty"]]]]:
+            '''The field where the repository event that will start the pipeline is specified as pull requests.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html#cfn-codepipeline-pipeline-gitconfiguration-pullrequest
+            '''
+            result = self._values.get("pull_request")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitPullRequestFilterProperty"]]]], result)
+
         @builtins.property
         def push(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitPushFilterProperty"]]]]:
             '''The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
 
-            .. epigraph::
-
-               Git tags is the only supported event type.
-
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html#cfn-codepipeline-pipeline-gitconfiguration-push
             '''
             result = self._values.get("push")
@@ -3313,21 +3625,23 @@ class CfnPipeline(
             )
 
     @jsii.data_type(
-        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitPushFilterProperty",
+        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty",
         jsii_struct_bases=[],
-        name_mapping={"tags": "tags"},
+        name_mapping={"excludes": "excludes", "includes": "includes"},
     )
-    class GitPushFilterProperty:
+    class GitFilePathFilterCriteriaProperty:
         def __init__(
             self,
             *,
-            tags: typing.Optional[typing.Union["CfnPipeline.GitTagFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]] = None,
+            excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+            includes: typing.Optional[typing.Sequence[builtins.str]] = None,
         ) -> None:
-            '''The event criteria that specify when a specified repository event will start the pipeline for the specified trigger configuration, such as the lists of Git tags to include and exclude.
+            '''The Git repository file paths specified as filter criteria to start the pipeline.
 
-            :param tags: The field that contains the details for the Git tags trigger configuration.
+            :param excludes: The list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
+            :param includes: The list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html
             :exampleMetadata: fixture=_generated
 
             Example::
@@ -3336,30 +3650,38 @@ class CfnPipeline(
                 # The values are placeholders you should change.
                 from aws_cdk import aws_codepipeline as codepipeline
                 
-                git_push_filter_property = codepipeline.CfnPipeline.GitPushFilterProperty(
-                    tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
-                        excludes=["excludes"],
-                        includes=["includes"]
-                    )
+                git_file_path_filter_criteria_property = codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                    excludes=["excludes"],
+                    includes=["includes"]
                 )
             '''
-            if isinstance(tags, dict):
-                tags = CfnPipeline.GitTagFilterCriteriaProperty(**tags)
             if __debug__:
-                type_hints = typing.get_type_hints(_typecheckingstub__aace18192e6436301eeae21b4cd59bd8cb01b53eb17f6fcb74599b2f74f9ebd0)
-                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+                type_hints = typing.get_type_hints(_typecheckingstub__6e825f3cafba918e1c84a158f90d3bcbd543fab5a2e3990e2677d0de4ad794df)
+                check_type(argname="argument excludes", value=excludes, expected_type=type_hints["excludes"])
+                check_type(argname="argument includes", value=includes, expected_type=type_hints["includes"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
-            if tags is not None:
-                self._values["tags"] = tags
+            if excludes is not None:
+                self._values["excludes"] = excludes
+            if includes is not None:
+                self._values["includes"] = includes
 
         @builtins.property
-        def tags(self) -> typing.Optional["CfnPipeline.GitTagFilterCriteriaProperty"]:
-            '''The field that contains the details for the Git tags trigger configuration.
+        def excludes(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-tags
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html#cfn-codepipeline-pipeline-gitfilepathfiltercriteria-excludes
             '''
-            result = self._values.get("tags")
-            return typing.cast(typing.Optional["CfnPipeline.GitTagFilterCriteriaProperty"], result)
+            result = self._values.get("excludes")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def includes(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html#cfn-codepipeline-pipeline-gitfilepathfiltercriteria-includes
+            '''
+            result = self._values.get("includes")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -3368,28 +3690,34 @@ class CfnPipeline(
             return not (rhs == self)
 
         def __repr__(self) -> str:
-            return "GitPushFilterProperty(%s)" % ", ".join(
+            return "GitFilePathFilterCriteriaProperty(%s)" % ", ".join(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
     @jsii.data_type(
-        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitTagFilterCriteriaProperty",
+        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitPullRequestFilterProperty",
         jsii_struct_bases=[],
-        name_mapping={"excludes": "excludes", "includes": "includes"},
+        name_mapping={
+            "branches": "branches",
+            "events": "events",
+            "file_paths": "filePaths",
+        },
     )
-    class GitTagFilterCriteriaProperty:
+    class GitPullRequestFilterProperty:
         def __init__(
             self,
             *,
-            excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
-            includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+            branches: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitBranchFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            events: typing.Optional[typing.Sequence[builtins.str]] = None,
+            file_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitFilePathFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         ) -> None:
-            '''The Git tags specified as filter criteria for whether a Git tag repository event will start the pipeline.
+            '''The event criteria for the pull request trigger configuration, such as the lists of branches or file paths to include and exclude.
 
-            :param excludes: The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
-            :param includes: The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
+            :param branches: The field that specifies to filter on branches for the pull request trigger configuration.
+            :param events: The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration.
+            :param file_paths: The field that specifies to filter on file paths for the pull request trigger configuration.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html
             :exampleMetadata: fixture=_generated
 
             Example::
@@ -3398,41 +3726,238 @@ class CfnPipeline(
                 # The values are placeholders you should change.
                 from aws_cdk import aws_codepipeline as codepipeline
                 
-                git_tag_filter_criteria_property = codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
-                    excludes=["excludes"],
-                    includes=["includes"]
+                git_pull_request_filter_property = codepipeline.CfnPipeline.GitPullRequestFilterProperty(
+                    branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                        excludes=["excludes"],
+                        includes=["includes"]
+                    ),
+                    events=["events"],
+                    file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                        excludes=["excludes"],
+                        includes=["includes"]
+                    )
                 )
             '''
             if __debug__:
-                type_hints = typing.get_type_hints(_typecheckingstub__0011c01a814174b9712d97ce1aa7e9a05579a8de4bb3a1cdb0910216a0f71485)
-                check_type(argname="argument excludes", value=excludes, expected_type=type_hints["excludes"])
-                check_type(argname="argument includes", value=includes, expected_type=type_hints["includes"])
+                type_hints = typing.get_type_hints(_typecheckingstub__bd17e19e4fde95da653023de121d5f908ce71830fcd4cd84611c860dd5585932)
+                check_type(argname="argument branches", value=branches, expected_type=type_hints["branches"])
+                check_type(argname="argument events", value=events, expected_type=type_hints["events"])
+                check_type(argname="argument file_paths", value=file_paths, expected_type=type_hints["file_paths"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
-            if excludes is not None:
-                self._values["excludes"] = excludes
-            if includes is not None:
-                self._values["includes"] = includes
+            if branches is not None:
+                self._values["branches"] = branches
+            if events is not None:
+                self._values["events"] = events
+            if file_paths is not None:
+                self._values["file_paths"] = file_paths
 
         @builtins.property
-        def 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.
+        def branches(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitBranchFilterCriteriaProperty"]]:
+            '''The field that specifies to filter on branches for the pull request trigger configuration.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-excludes
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-branches
             '''
-            result = self._values.get("excludes")
-            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+            result = self._values.get("branches")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitBranchFilterCriteriaProperty"]], result)
 
         @builtins.property
-        def includes(self) -> typing.Optional[typing.List[builtins.str]]:
-            '''The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
+        def events(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-includes
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-events
             '''
-            result = self._values.get("includes")
+            result = self._values.get("events")
             return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
-        def __eq__(self, rhs: typing.Any) -> builtins.bool:
-            return isinstance(rhs, self.__class__) and rhs._values == self._values
+        @builtins.property
+        def file_paths(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitFilePathFilterCriteriaProperty"]]:
+            '''The field that specifies to filter on file paths for the pull request trigger configuration.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-filepaths
+            '''
+            result = self._values.get("file_paths")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitFilePathFilterCriteriaProperty"]], 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 "GitPullRequestFilterProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitPushFilterProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "branches": "branches",
+            "file_paths": "filePaths",
+            "tags": "tags",
+        },
+    )
+    class GitPushFilterProperty:
+        def __init__(
+            self,
+            *,
+            branches: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitBranchFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            file_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnPipeline.GitFilePathFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            tags: typing.Optional[typing.Union["CfnPipeline.GitTagFilterCriteriaProperty", typing.Dict[builtins.str, typing.Any]]] = None,
+        ) -> None:
+            '''The event criteria that specify when a specified repository event will start the pipeline for the specified trigger configuration, such as the lists of Git tags to include and exclude.
+
+            :param branches: The field that specifies to filter on branches for the push trigger configuration.
+            :param file_paths: The field that specifies to filter on file paths for the push trigger configuration.
+            :param tags: The field that contains the details for the Git tags trigger configuration.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html
+            :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
+                
+                git_push_filter_property = codepipeline.CfnPipeline.GitPushFilterProperty(
+                    branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                        excludes=["excludes"],
+                        includes=["includes"]
+                    ),
+                    file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                        excludes=["excludes"],
+                        includes=["includes"]
+                    ),
+                    tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
+                        excludes=["excludes"],
+                        includes=["includes"]
+                    )
+                )
+            '''
+            if isinstance(tags, dict):
+                tags = CfnPipeline.GitTagFilterCriteriaProperty(**tags)
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__aace18192e6436301eeae21b4cd59bd8cb01b53eb17f6fcb74599b2f74f9ebd0)
+                check_type(argname="argument branches", value=branches, expected_type=type_hints["branches"])
+                check_type(argname="argument file_paths", value=file_paths, expected_type=type_hints["file_paths"])
+                check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if branches is not None:
+                self._values["branches"] = branches
+            if file_paths is not None:
+                self._values["file_paths"] = file_paths
+            if tags is not None:
+                self._values["tags"] = tags
+
+        @builtins.property
+        def branches(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitBranchFilterCriteriaProperty"]]:
+            '''The field that specifies to filter on branches for the push trigger configuration.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-branches
+            '''
+            result = self._values.get("branches")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitBranchFilterCriteriaProperty"]], result)
+
+        @builtins.property
+        def file_paths(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitFilePathFilterCriteriaProperty"]]:
+            '''The field that specifies to filter on file paths for the push trigger configuration.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-filepaths
+            '''
+            result = self._values.get("file_paths")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnPipeline.GitFilePathFilterCriteriaProperty"]], result)
+
+        @builtins.property
+        def tags(self) -> typing.Optional["CfnPipeline.GitTagFilterCriteriaProperty"]:
+            '''The field that contains the details for the Git tags trigger configuration.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-tags
+            '''
+            result = self._values.get("tags")
+            return typing.cast(typing.Optional["CfnPipeline.GitTagFilterCriteriaProperty"], 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 "GitPushFilterProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_codepipeline.CfnPipeline.GitTagFilterCriteriaProperty",
+        jsii_struct_bases=[],
+        name_mapping={"excludes": "excludes", "includes": "includes"},
+    )
+    class GitTagFilterCriteriaProperty:
+        def __init__(
+            self,
+            *,
+            excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+            includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+        ) -> None:
+            '''The Git tags specified as filter criteria for whether a Git tag repository event will start the pipeline.
+
+            :param excludes: The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
+            :param includes: The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html
+            :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
+                
+                git_tag_filter_criteria_property = codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
+                    excludes=["excludes"],
+                    includes=["includes"]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__0011c01a814174b9712d97ce1aa7e9a05579a8de4bb3a1cdb0910216a0f71485)
+                check_type(argname="argument excludes", value=excludes, expected_type=type_hints["excludes"])
+                check_type(argname="argument includes", value=includes, expected_type=type_hints["includes"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if excludes is not None:
+                self._values["excludes"] = excludes
+            if includes is not None:
+                self._values["includes"] = includes
+
+        @builtins.property
+        def 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.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-excludes
+            '''
+            result = self._values.get("excludes")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def includes(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-includes
+            '''
+            result = self._values.get("includes")
+            return typing.cast(typing.Optional[typing.List[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)
@@ -3595,7 +4120,26 @@ class CfnPipeline(
                         source_action_name="sourceActionName",
                 
                         # the properties below are optional
+                        pull_request=[codepipeline.CfnPipeline.GitPullRequestFilterProperty(
+                            branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
+                            events=["events"],
+                            file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            )
+                        )],
                         push=[codepipeline.CfnPipeline.GitPushFilterProperty(
+                            branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
+                            file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
                             tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
                                 excludes=["excludes"],
                                 includes=["includes"]
@@ -3936,6 +4480,7 @@ class CfnPipeline(
         "artifact_store": "artifactStore",
         "artifact_stores": "artifactStores",
         "disable_inbound_stage_transitions": "disableInboundStageTransitions",
+        "execution_mode": "executionMode",
         "name": "name",
         "pipeline_type": "pipelineType",
         "restart_execution_on_update": "restartExecutionOnUpdate",
@@ -3953,6 +4498,7 @@ class CfnPipelineProps:
         artifact_store: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         artifact_stores: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreMapProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         disable_inbound_stage_transitions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.StageTransitionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        execution_mode: typing.Optional[builtins.str] = None,
         name: typing.Optional[builtins.str] = None,
         pipeline_type: typing.Optional[builtins.str] = None,
         restart_execution_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
@@ -3967,8 +4513,9 @@ class CfnPipelineProps:
         :param artifact_store: The S3 bucket where artifacts for the pipeline are stored. .. epigraph:: You must include either ``artifactStore`` or ``artifactStores`` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use ``artifactStores`` .
         :param artifact_stores: A mapping of ``artifactStore`` objects and their corresponding AWS Regions. There must be an artifact store for the pipeline Region and for each cross-region action in the pipeline. .. epigraph:: You must include either ``artifactStore`` or ``artifactStores`` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use ``artifactStores`` .
         :param disable_inbound_stage_transitions: Represents the input of a ``DisableStageTransition`` action.
+        :param execution_mode: The method that the pipeline will use to handle multiple executions. The default mode is SUPERSEDED.
         :param name: The name of the pipeline.
-        :param pipeline_type: CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications. - V1 type pipelines have a JSON structure that contains standard pipeline, stage, and action-level parameters. - V2 type pipelines have the same structure as a V1 type, along with additional parameters for release safety and trigger configuration. .. epigraph:: Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs. For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/https://aws.amazon.com/codepipeline/pricing/>`_ . For information about which type of pipeline to choose, see `What type of pipeline is right for me? <https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html>`_ .
+        :param pipeline_type: CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications. - V1 type pipelines have a JSON structure that contains standard pipeline, stage, and action-level parameters. - V2 type pipelines have the same structure as a V1 type, along with additional parameters for release safety and trigger configuration. .. epigraph:: Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs. For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/codepipeline/pricing/>`_ . For information about which type of pipeline to choose, see `What type of pipeline is right for me? <https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html>`_ .
         :param restart_execution_on_update: Indicates whether to rerun the CodePipeline pipeline after you update it.
         :param tags: Specifies the tags applied to the pipeline.
         :param triggers: The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline. .. epigraph:: When a trigger configuration is specified, default change detection for repository and branch commits is disabled.
@@ -4047,6 +4594,7 @@ class CfnPipelineProps:
                     reason="reason",
                     stage_name="stageName"
                 )],
+                execution_mode="executionMode",
                 name="name",
                 pipeline_type="pipelineType",
                 restart_execution_on_update=False,
@@ -4062,7 +4610,26 @@ class CfnPipelineProps:
                         source_action_name="sourceActionName",
             
                         # the properties below are optional
+                        pull_request=[codepipeline.CfnPipeline.GitPullRequestFilterProperty(
+                            branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
+                            events=["events"],
+                            file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            )
+                        )],
                         push=[codepipeline.CfnPipeline.GitPushFilterProperty(
+                            branches=codepipeline.CfnPipeline.GitBranchFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
+                            file_paths=codepipeline.CfnPipeline.GitFilePathFilterCriteriaProperty(
+                                excludes=["excludes"],
+                                includes=["includes"]
+                            ),
                             tags=codepipeline.CfnPipeline.GitTagFilterCriteriaProperty(
                                 excludes=["excludes"],
                                 includes=["includes"]
@@ -4086,6 +4653,7 @@ class CfnPipelineProps:
             check_type(argname="argument artifact_store", value=artifact_store, expected_type=type_hints["artifact_store"])
             check_type(argname="argument artifact_stores", value=artifact_stores, expected_type=type_hints["artifact_stores"])
             check_type(argname="argument disable_inbound_stage_transitions", value=disable_inbound_stage_transitions, expected_type=type_hints["disable_inbound_stage_transitions"])
+            check_type(argname="argument execution_mode", value=execution_mode, expected_type=type_hints["execution_mode"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument pipeline_type", value=pipeline_type, expected_type=type_hints["pipeline_type"])
             check_type(argname="argument restart_execution_on_update", value=restart_execution_on_update, expected_type=type_hints["restart_execution_on_update"])
@@ -4102,6 +4670,8 @@ class CfnPipelineProps:
             self._values["artifact_stores"] = artifact_stores
         if disable_inbound_stage_transitions is not None:
             self._values["disable_inbound_stage_transitions"] = disable_inbound_stage_transitions
+        if execution_mode is not None:
+            self._values["execution_mode"] = execution_mode
         if name is not None:
             self._values["name"] = name
         if pipeline_type is not None:
@@ -4179,6 +4749,17 @@ class CfnPipelineProps:
         result = self._values.get("disable_inbound_stage_transitions")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnPipeline.StageTransitionProperty]]]], result)
 
+    @builtins.property
+    def execution_mode(self) -> typing.Optional[builtins.str]:
+        '''The method that the pipeline will use to handle multiple executions.
+
+        The default mode is SUPERSEDED.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-executionmode
+        '''
+        result = self._values.get("execution_mode")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
         '''The name of the pipeline.
@@ -4199,7 +4780,7 @@ class CfnPipelineProps:
 
            Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs.
 
-        For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/https://aws.amazon.com/codepipeline/pricing/>`_ .
+        For information about pricing for CodePipeline, see `Pricing <https://docs.aws.amazon.com/codepipeline/pricing/>`_ .
 
         For information about which type of pipeline to choose, see `What type of pipeline is right for me? <https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html>`_ .
 
@@ -5596,65 +6177,241 @@ class CustomActionRegistrationProps:
         )
 
 
-class GlobalVariables(
-    metaclass=jsii.JSIIMeta,
-    jsii_type="aws-cdk-lib.aws_codepipeline.GlobalVariables",
-):
-    '''The CodePipeline variables that are global, not bound to a specific action.
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.GitConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={"source_action": "sourceAction", "push_filter": "pushFilter"},
+)
+class GitConfiguration:
+    def __init__(
+        self,
+        *,
+        source_action: "IAction",
+        push_filter: typing.Optional[typing.Sequence[typing.Union["GitPushFilter", typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
+        '''Git configuration for trigger.
 
-    This class defines a bunch of static fields that represent the different variables.
-    These can be used can be used in any action configuration.
+        :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 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.
 
-    :exampleMetadata: fixture=action infused
+        :exampleMetadata: infused
 
-    Example::
+        Example::
 
-        # OtherAction is some action type that produces variables, like EcrSourceAction
-        OtherAction(
-            # ...
-            config=codepipeline.GlobalVariables.execution_id,
-            action_name="otherAction"
-        )
-    '''
+            # 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 push_filter", value=push_filter, expected_type=type_hints["push_filter"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "source_action": source_action,
+        }
+        if push_filter is not None:
+            self._values["push_filter"] = push_filter
 
-    def __init__(self) -> None:
-        jsii.create(self.__class__, self, [])
+    @builtins.property
+    def source_action(self) -> "IAction":
+        '''The pipeline source action where the trigger configuration, such as Git tags.
 
-    @jsii.python.classproperty
-    @jsii.member(jsii_name="executionId")
-    def EXECUTION_ID(cls) -> builtins.str:
-        '''The identifier of the current pipeline execution.'''
-        return typing.cast(builtins.str, jsii.sget(cls, "executionId"))
+        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)
 
-@jsii.interface(jsii_type="aws-cdk-lib.aws_codepipeline.IAction")
-class IAction(typing_extensions.Protocol):
-    '''A Pipeline Action.
+    @builtins.property
+    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.
 
-    If you want to implement this interface,
-    consider extending the ``Action`` class,
-    which contains some common logic.
-    '''
+        Git tags is the only supported event type.
 
-    @builtins.property
-    @jsii.member(jsii_name="actionProperties")
-    def action_properties(self) -> ActionProperties:
-        '''The simple properties of the Action, like its Owner, name, etc.
+        The length must be less than or equal to 3.
 
-        Note that this accessor will be called before the ``bind`` callback.
+        :default: - no filter.
         '''
-        ...
+        result = self._values.get("push_filter")
+        return typing.cast(typing.Optional[typing.List["GitPushFilter"]], result)
 
-    @jsii.member(jsii_name="bind")
-    def bind(
-        self,
-        scope: _constructs_77d1e7e8.Construct,
-        stage: "IStage",
-        *,
-        bucket: _IBucket_42e086fd,
-        role: _IRole_235f5d8e,
-    ) -> ActionConfig:
-        '''The callback invoked when this Action is added to a Pipeline.
+    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 "GitConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.GitPushFilter",
+    jsii_struct_bases=[],
+    name_mapping={"tags_excludes": "tagsExcludes", "tags_includes": "tagsIncludes"},
+)
+class GitPushFilter:
+    def __init__(
+        self,
+        *,
+        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 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.
+
+        :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
+            
+            git_push_filter = codepipeline.GitPushFilter(
+                tags_excludes=["tagsExcludes"],
+                tags_includes=["tagsIncludes"]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d2e5e6ae139c810aa752b8a8c7cd3040d883f9f3a67c8d3693f9ab842351804e)
+            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 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 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.
+
+        You can filter with glob patterns. The ``tagsExcludes`` takes priority
+        over the ``tagsIncludes``.
+
+        Maximum length of this array is 8.
+
+        :default: - no tags.
+        '''
+        result = self._values.get("tags_excludes")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def tags_includes(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''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.
+        '''
+        result = self._values.get("tags_includes")
+        return typing.cast(typing.Optional[typing.List[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 "GitPushFilter(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class GlobalVariables(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_codepipeline.GlobalVariables",
+):
+    '''The CodePipeline variables that are global, not bound to a specific action.
+
+    This class defines a bunch of static fields that represent the different variables.
+    These can be used can be used in any action configuration.
+
+    :exampleMetadata: fixture=action infused
+
+    Example::
+
+        # OtherAction is some action type that produces variables, like EcrSourceAction
+        OtherAction(
+            # ...
+            config=codepipeline.GlobalVariables.execution_id,
+            action_name="otherAction"
+        )
+    '''
+
+    def __init__(self) -> None:
+        jsii.create(self.__class__, self, [])
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="executionId")
+    def EXECUTION_ID(cls) -> builtins.str:
+        '''The identifier of the current pipeline execution.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "executionId"))
+
+
+@jsii.interface(jsii_type="aws-cdk-lib.aws_codepipeline.IAction")
+class IAction(typing_extensions.Protocol):
+    '''A Pipeline Action.
+
+    If you want to implement this interface,
+    consider extending the ``Action`` class,
+    which contains some common logic.
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="actionProperties")
+    def action_properties(self) -> ActionProperties:
+        '''The simple properties of the Action, like its Owner, name, etc.
+
+        Note that this accessor will be called before the ``bind`` callback.
+        '''
+        ...
+
+    @jsii.member(jsii_name="bind")
+    def bind(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        stage: "IStage",
+        *,
+        bucket: _IBucket_42e086fd,
+        role: _IRole_235f5d8e,
+    ) -> ActionConfig:
+        '''The callback invoked when this Action is added to a Pipeline.
 
         :param scope: the Construct tree scope the Action can use if it needs to create any resources.
         :param stage: the ``IStage`` this Action is being added to.
@@ -6421,10 +7178,13 @@ class Pipeline(
         cross_region_replication_buckets: typing.Optional[typing.Mapping[builtins.str, _IBucket_42e086fd]] = None,
         enable_key_rotation: typing.Optional[builtins.bool] = None,
         pipeline_name: typing.Optional[builtins.str] = None,
+        pipeline_type: typing.Optional["PipelineType"] = None,
         restart_execution_on_update: typing.Optional[builtins.bool] = None,
         reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
         stages: typing.Optional[typing.Sequence[typing.Union["StageProps", typing.Dict[builtins.str, typing.Any]]]] = None,
+        triggers: typing.Optional[typing.Sequence[typing.Union["TriggerProps", typing.Dict[builtins.str, typing.Any]]]] = None,
+        variables: typing.Optional[typing.Sequence["Variable"]] = None,
     ) -> None:
         '''
         :param scope: -
@@ -6434,10 +7194,13 @@ class Pipeline(
         :param cross_region_replication_buckets: A map of region to S3 bucket name used for cross-region CodePipeline. For every Action that you specify targeting a different region than the Pipeline itself, if you don't provide an explicit Bucket for that region using this property, the construct will automatically create a Stack containing an S3 Bucket in that region. Default: - None.
         :param enable_key_rotation: Enable KMS key rotation for the generated KMS keys. By default KMS key rotation is disabled, but will add an additional $1/month for each year the key exists when enabled. Default: - false (key rotation is disabled)
         :param pipeline_name: Name of the pipeline. Default: - AWS CloudFormation generates an ID and uses that for the pipeline name.
+        :param pipeline_type: Type of the pipeline. Default: - PipelineType.V1
         :param restart_execution_on_update: Indicates whether to rerun the AWS CodePipeline pipeline after you update it. Default: false
         :param reuse_cross_region_support_stacks: Reuse the same cross region support stack for all pipelines in the App. Default: - true (Use the same support stack for all pipelines in App)
         :param role: The IAM role to be assumed by this Pipeline. Default: a new IAM role will be created.
         :param stages: The list of Stages, in order, to create this Pipeline with. You can always add more Stages later by calling ``Pipeline#addStage``. Default: - None.
+        :param triggers: The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline. When a trigger configuration is specified, default change detection for repository and branch commits is disabled. ``triggers`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``. You can always add more triggers later by calling ``Pipeline#addTrigger``. Default: - No triggers
+        :param variables: A list that defines the pipeline variables for a pipeline resource. ``variables`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``. You can always add more variables later by calling ``Pipeline#addVariable``. Default: - No variables
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__dccc82ea9bcac61a3fb8c34055734a04a1bee7f59ee6675fdade2d8b59a1477e)
@@ -6449,10 +7212,13 @@ class Pipeline(
             cross_region_replication_buckets=cross_region_replication_buckets,
             enable_key_rotation=enable_key_rotation,
             pipeline_name=pipeline_name,
+            pipeline_type=pipeline_type,
             restart_execution_on_update=restart_execution_on_update,
             reuse_cross_region_support_stacks=reuse_cross_region_support_stacks,
             role=role,
             stages=stages,
+            triggers=triggers,
+            variables=variables,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -6519,6 +7285,39 @@ class Pipeline(
             check_type(argname="argument statement", value=statement, expected_type=type_hints["statement"])
         return typing.cast(None, jsii.invoke(self, "addToRolePolicy", [statement]))
 
+    @jsii.member(jsii_name="addTrigger")
+    def add_trigger(
+        self,
+        *,
+        provider_type: "ProviderType",
+        git_configuration: typing.Optional[typing.Union[GitConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> "Trigger":
+        '''Adds a new Trigger to this Pipeline.
+
+        :param provider_type: The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.
+        :param git_configuration: Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags. Default: - no configuration.
+
+        :return: the newly created trigger
+        '''
+        props = TriggerProps(
+            provider_type=provider_type, git_configuration=git_configuration
+        )
+
+        return typing.cast("Trigger", jsii.invoke(self, "addTrigger", [props]))
+
+    @jsii.member(jsii_name="addVariable")
+    def add_variable(self, variable: "Variable") -> "Variable":
+        '''Adds a new Variable to this Pipeline.
+
+        :param variable: Variable instance to add to this Pipeline.
+
+        :return: the newly created variable
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c66f0602ec2236194290f47b7ed526e674bccbeaddc91834fa37bdbea2e9dce2)
+            check_type(argname="argument variable", value=variable, expected_type=type_hints["variable"])
+        return typing.cast("Variable", jsii.invoke(self, "addVariable", [variable]))
+
     @jsii.member(jsii_name="bindAsNotificationRuleSource")
     def bind_as_notification_rule_source(
         self,
@@ -6997,10 +7796,13 @@ class PipelineNotifyOnOptions(_NotificationRuleOptions_dff73281):
         "cross_region_replication_buckets": "crossRegionReplicationBuckets",
         "enable_key_rotation": "enableKeyRotation",
         "pipeline_name": "pipelineName",
+        "pipeline_type": "pipelineType",
         "restart_execution_on_update": "restartExecutionOnUpdate",
         "reuse_cross_region_support_stacks": "reuseCrossRegionSupportStacks",
         "role": "role",
         "stages": "stages",
+        "triggers": "triggers",
+        "variables": "variables",
     },
 )
 class PipelineProps:
@@ -7012,10 +7814,13 @@ class PipelineProps:
         cross_region_replication_buckets: typing.Optional[typing.Mapping[builtins.str, _IBucket_42e086fd]] = None,
         enable_key_rotation: typing.Optional[builtins.bool] = None,
         pipeline_name: typing.Optional[builtins.str] = None,
+        pipeline_type: typing.Optional["PipelineType"] = None,
         restart_execution_on_update: typing.Optional[builtins.bool] = None,
         reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
         stages: typing.Optional[typing.Sequence[typing.Union["StageProps", typing.Dict[builtins.str, typing.Any]]]] = None,
+        triggers: typing.Optional[typing.Sequence[typing.Union["TriggerProps", typing.Dict[builtins.str, typing.Any]]]] = None,
+        variables: typing.Optional[typing.Sequence["Variable"]] = None,
     ) -> None:
         '''
         :param artifact_bucket: The S3 bucket used by this Pipeline to store artifacts. Default: - A new S3 bucket will be created.
@@ -7023,10 +7828,13 @@ class PipelineProps:
         :param cross_region_replication_buckets: A map of region to S3 bucket name used for cross-region CodePipeline. For every Action that you specify targeting a different region than the Pipeline itself, if you don't provide an explicit Bucket for that region using this property, the construct will automatically create a Stack containing an S3 Bucket in that region. Default: - None.
         :param enable_key_rotation: Enable KMS key rotation for the generated KMS keys. By default KMS key rotation is disabled, but will add an additional $1/month for each year the key exists when enabled. Default: - false (key rotation is disabled)
         :param pipeline_name: Name of the pipeline. Default: - AWS CloudFormation generates an ID and uses that for the pipeline name.
+        :param pipeline_type: Type of the pipeline. Default: - PipelineType.V1
         :param restart_execution_on_update: Indicates whether to rerun the AWS CodePipeline pipeline after you update it. Default: false
         :param reuse_cross_region_support_stacks: Reuse the same cross region support stack for all pipelines in the App. Default: - true (Use the same support stack for all pipelines in App)
         :param role: The IAM role to be assumed by this Pipeline. Default: a new IAM role will be created.
         :param stages: The list of Stages, in order, to create this Pipeline with. You can always add more Stages later by calling ``Pipeline#addStage``. Default: - None.
+        :param triggers: The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline. When a trigger configuration is specified, default change detection for repository and branch commits is disabled. ``triggers`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``. You can always add more triggers later by calling ``Pipeline#addTrigger``. Default: - No triggers
+        :param variables: A list that defines the pipeline variables for a pipeline resource. ``variables`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``. You can always add more variables later by calling ``Pipeline#addVariable``. Default: - No variables
 
         :exampleMetadata: infused
 
@@ -7072,10 +7880,13 @@ class PipelineProps:
             check_type(argname="argument cross_region_replication_buckets", value=cross_region_replication_buckets, expected_type=type_hints["cross_region_replication_buckets"])
             check_type(argname="argument enable_key_rotation", value=enable_key_rotation, expected_type=type_hints["enable_key_rotation"])
             check_type(argname="argument pipeline_name", value=pipeline_name, expected_type=type_hints["pipeline_name"])
+            check_type(argname="argument pipeline_type", value=pipeline_type, expected_type=type_hints["pipeline_type"])
             check_type(argname="argument restart_execution_on_update", value=restart_execution_on_update, expected_type=type_hints["restart_execution_on_update"])
             check_type(argname="argument reuse_cross_region_support_stacks", value=reuse_cross_region_support_stacks, expected_type=type_hints["reuse_cross_region_support_stacks"])
             check_type(argname="argument role", value=role, expected_type=type_hints["role"])
             check_type(argname="argument stages", value=stages, expected_type=type_hints["stages"])
+            check_type(argname="argument triggers", value=triggers, expected_type=type_hints["triggers"])
+            check_type(argname="argument variables", value=variables, expected_type=type_hints["variables"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if artifact_bucket is not None:
             self._values["artifact_bucket"] = artifact_bucket
@@ -7087,6 +7898,8 @@ class PipelineProps:
             self._values["enable_key_rotation"] = enable_key_rotation
         if pipeline_name is not None:
             self._values["pipeline_name"] = pipeline_name
+        if pipeline_type is not None:
+            self._values["pipeline_type"] = pipeline_type
         if restart_execution_on_update is not None:
             self._values["restart_execution_on_update"] = restart_execution_on_update
         if reuse_cross_region_support_stacks is not None:
@@ -7095,6 +7908,10 @@ class PipelineProps:
             self._values["role"] = role
         if stages is not None:
             self._values["stages"] = stages
+        if triggers is not None:
+            self._values["triggers"] = triggers
+        if variables is not None:
+            self._values["variables"] = variables
 
     @builtins.property
     def artifact_bucket(self) -> typing.Optional[_IBucket_42e086fd]:
@@ -7163,6 +7980,17 @@ class PipelineProps:
         result = self._values.get("pipeline_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def pipeline_type(self) -> typing.Optional["PipelineType"]:
+        '''Type of the pipeline.
+
+        :default: - PipelineType.V1
+
+        :see: https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html
+        '''
+        result = self._values.get("pipeline_type")
+        return typing.cast(typing.Optional["PipelineType"], result)
+
     @builtins.property
     def restart_execution_on_update(self) -> typing.Optional[builtins.bool]:
         '''Indicates whether to rerun the AWS CodePipeline pipeline after you update it.
@@ -7201,6 +8029,33 @@ class PipelineProps:
         result = self._values.get("stages")
         return typing.cast(typing.Optional[typing.List["StageProps"]], result)
 
+    @builtins.property
+    def triggers(self) -> typing.Optional[typing.List["TriggerProps"]]:
+        '''The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline.
+
+        When a trigger configuration is specified, default change detection for repository
+        and branch commits is disabled.
+
+        ``triggers`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``.
+        You can always add more triggers later by calling ``Pipeline#addTrigger``.
+
+        :default: - No triggers
+        '''
+        result = self._values.get("triggers")
+        return typing.cast(typing.Optional[typing.List["TriggerProps"]], result)
+
+    @builtins.property
+    def variables(self) -> typing.Optional[typing.List["Variable"]]:
+        '''A list that defines the pipeline variables for a pipeline resource.
+
+        ``variables`` can only be used when ``pipelineType`` is set to ``PipelineType.V2``.
+        You can always add more variables later by calling ``Pipeline#addVariable``.
+
+        :default: - No variables
+        '''
+        result = self._values.get("variables")
+        return typing.cast(typing.Optional[typing.List["Variable"]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -7213,6 +8068,86 @@ class PipelineProps:
         )
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codepipeline.PipelineType")
+class PipelineType(enum.Enum):
+    '''Pipeline types.
+
+    :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*"]
+                    )]
+                )
+            )]
+        )
+    '''
+
+    V1 = "V1"
+    '''V1 type.'''
+    V2 = "V2"
+    '''V2 type.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codepipeline.ProviderType")
+class ProviderType(enum.Enum):
+    '''Provider type for trigger.
+
+    :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*"]
+                    )]
+                )
+            )]
+        )
+    '''
+
+    CODE_STAR_SOURCE_CONNECTION = "CODE_STAR_SOURCE_CONNECTION"
+    '''CodeStarSourceConnection.'''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_codepipeline.StagePlacement",
     jsii_struct_bases=[],
@@ -7397,6 +8332,332 @@ class StageProps:
         )
 
 
+class Trigger(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_codepipeline.Trigger",
+):
+    '''Trigger.
+
+    :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
+        
+        # action: codepipeline.Action
+        
+        trigger = codepipeline.Trigger(
+            provider_type=codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+        
+            # the properties below are optional
+            git_configuration=codepipeline.GitConfiguration(
+                source_action=action,
+        
+                # the properties below are optional
+                push_filter=[codepipeline.GitPushFilter(
+                    tags_excludes=["tagsExcludes"],
+                    tags_includes=["tagsIncludes"]
+                )]
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        *,
+        provider_type: ProviderType,
+        git_configuration: typing.Optional[typing.Union[GitConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''
+        :param provider_type: The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.
+        :param git_configuration: Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags. Default: - no configuration.
+        '''
+        props = TriggerProps(
+            provider_type=provider_type, git_configuration=git_configuration
+        )
+
+        jsii.create(self.__class__, self, [props])
+
+    @builtins.property
+    @jsii.member(jsii_name="sourceAction")
+    def source_action(self) -> typing.Optional[IAction]:
+        '''The pipeline source action where the trigger configuration.'''
+        return typing.cast(typing.Optional[IAction], jsii.get(self, "sourceAction"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.TriggerProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "provider_type": "providerType",
+        "git_configuration": "gitConfiguration",
+    },
+)
+class TriggerProps:
+    def __init__(
+        self,
+        *,
+        provider_type: ProviderType,
+        git_configuration: typing.Optional[typing.Union[GitConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+    ) -> None:
+        '''Properties of trigger.
+
+        :param provider_type: The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.
+        :param git_configuration: Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags. Default: - no configuration.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # pipeline: codepipeline.Pipeline
+            # source_action: codepipeline_actions.CodeStarConnectionsSourceAction
+            
+            
+            pipeline.add_trigger(
+                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 isinstance(git_configuration, dict):
+            git_configuration = GitConfiguration(**git_configuration)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__0e77c8b9601fdd47bfd2d43819e8d9a90e923d90d1d79bc31317a9a7e0dee535)
+            check_type(argname="argument provider_type", value=provider_type, expected_type=type_hints["provider_type"])
+            check_type(argname="argument git_configuration", value=git_configuration, expected_type=type_hints["git_configuration"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "provider_type": provider_type,
+        }
+        if git_configuration is not None:
+            self._values["git_configuration"] = git_configuration
+
+    @builtins.property
+    def provider_type(self) -> ProviderType:
+        '''The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.'''
+        result = self._values.get("provider_type")
+        assert result is not None, "Required property 'provider_type' is missing"
+        return typing.cast(ProviderType, result)
+
+    @builtins.property
+    def git_configuration(self) -> typing.Optional[GitConfiguration]:
+        '''Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags.
+
+        :default: - no configuration.
+        '''
+        result = self._values.get("git_configuration")
+        return typing.cast(typing.Optional[GitConfiguration], 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 "TriggerProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+class Variable(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_codepipeline.Variable",
+):
+    '''Pipeline-Level variable.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # source_action: codepipeline_actions.S3SourceAction
+        # source_output: codepipeline.Artifact
+        # deploy_bucket: s3.Bucket
+        
+        
+        # Pipeline-level variable
+        variable = codepipeline.Variable(
+            variable_name="bucket-var",
+            description="description",
+            default_value="sample"
+        )
+        
+        codepipeline.Pipeline(self, "Pipeline",
+            pipeline_type=codepipeline.PipelineType.V2,
+            variables=[variable],
+            stages=[codepipeline.StageProps(
+                stage_name="Source",
+                actions=[source_action]
+            ), codepipeline.StageProps(
+                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
+                    )
+                ]
+            )
+            ]
+        )
+    '''
+
+    def __init__(
+        self,
+        *,
+        variable_name: builtins.str,
+        default_value: typing.Optional[builtins.str] = None,
+        description: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''
+        :param variable_name: The name of a pipeline-level variable.
+        :param default_value: The default value of a pipeline-level variable. Default: - No default value.
+        :param description: The description of a pipeline-level variable. It's used to add additional context about the variable, and not being used at time when pipeline executes. Default: - No description.
+        '''
+        props = VariableProps(
+            variable_name=variable_name,
+            default_value=default_value,
+            description=description,
+        )
+
+        jsii.create(self.__class__, self, [props])
+
+    @jsii.member(jsii_name="reference")
+    def reference(self) -> builtins.str:
+        '''Reference the variable name at Pipeline actions.
+
+        :return: The variable name in a format that can be referenced at Pipeline actions
+        '''
+        return typing.cast(builtins.str, jsii.invoke(self, "reference", []))
+
+    @builtins.property
+    @jsii.member(jsii_name="variableName")
+    def variable_name(self) -> builtins.str:
+        '''The name of a pipeline-level variable.'''
+        return typing.cast(builtins.str, jsii.get(self, "variableName"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codepipeline.VariableProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "variable_name": "variableName",
+        "default_value": "defaultValue",
+        "description": "description",
+    },
+)
+class VariableProps:
+    def __init__(
+        self,
+        *,
+        variable_name: builtins.str,
+        default_value: typing.Optional[builtins.str] = None,
+        description: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Properties of pipeline-level variable.
+
+        :param variable_name: The name of a pipeline-level variable.
+        :param default_value: The default value of a pipeline-level variable. Default: - No default value.
+        :param description: The description of a pipeline-level variable. It's used to add additional context about the variable, and not being used at time when pipeline executes. Default: - No description.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # source_action: codepipeline_actions.S3SourceAction
+            # source_output: codepipeline.Artifact
+            # deploy_bucket: s3.Bucket
+            
+            
+            # Pipeline-level variable
+            variable = codepipeline.Variable(
+                variable_name="bucket-var",
+                description="description",
+                default_value="sample"
+            )
+            
+            codepipeline.Pipeline(self, "Pipeline",
+                pipeline_type=codepipeline.PipelineType.V2,
+                variables=[variable],
+                stages=[codepipeline.StageProps(
+                    stage_name="Source",
+                    actions=[source_action]
+                ), codepipeline.StageProps(
+                    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
+                        )
+                    ]
+                )
+                ]
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a98b171eab4c5eaadb5c59d8cb50bc5cfedba458e43c6e91a962ebcc7aa7cdb6)
+            check_type(argname="argument variable_name", value=variable_name, expected_type=type_hints["variable_name"])
+            check_type(argname="argument default_value", value=default_value, expected_type=type_hints["default_value"])
+            check_type(argname="argument description", value=description, expected_type=type_hints["description"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "variable_name": variable_name,
+        }
+        if default_value is not None:
+            self._values["default_value"] = default_value
+        if description is not None:
+            self._values["description"] = description
+
+    @builtins.property
+    def variable_name(self) -> builtins.str:
+        '''The name of a pipeline-level variable.'''
+        result = self._values.get("variable_name")
+        assert result is not None, "Required property 'variable_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def default_value(self) -> typing.Optional[builtins.str]:
+        '''The default value of a pipeline-level variable.
+
+        :default: - No default value.
+        '''
+        result = self._values.get("default_value")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def description(self) -> typing.Optional[builtins.str]:
+        '''The description of a pipeline-level variable.
+
+        It's used to add additional context
+        about the variable, and not being used at time when pipeline executes.
+
+        :default: - No description.
+        '''
+        result = self._values.get("description")
+        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 "VariableProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(IAction)
 class Action(
     metaclass=jsii.JSIIAbstractClass,
@@ -7707,6 +8968,8 @@ __all__ = [
     "CustomActionProperty",
     "CustomActionRegistration",
     "CustomActionRegistrationProps",
+    "GitConfiguration",
+    "GitPushFilter",
     "GlobalVariables",
     "IAction",
     "IPipeline",
@@ -7715,9 +8978,15 @@ __all__ = [
     "PipelineNotificationEvents",
     "PipelineNotifyOnOptions",
     "PipelineProps",
+    "PipelineType",
+    "ProviderType",
     "StageOptions",
     "StagePlacement",
     "StageProps",
+    "Trigger",
+    "TriggerProps",
+    "Variable",
+    "VariableProps",
 ]
 
 publication.publish()
@@ -7949,6 +9218,7 @@ def _typecheckingstub__43ae22b404f50a75462f3d5423718be3ca300d4e4e15354489d856039
     artifact_store: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     artifact_stores: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreMapProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     disable_inbound_stage_transitions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.StageTransitionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    execution_mode: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
     pipeline_type: typing.Optional[builtins.str] = None,
     restart_execution_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
@@ -8001,6 +9271,12 @@ def _typecheckingstub__a8171e6979490d73c864965d74418184aa66850b94084357d00f5bac7
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__472d85ae1c4eb5d13c62e60f6347b15da6be45b950e9ce0ab0c5a3d67951fda0(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2b2610baf2075574499b5c3a30d307e832f359e9aa154becdcd51b0b886e97cf(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -8095,16 +9371,44 @@ def _typecheckingstub__947de613103ce26163068b14d3b93b5c2d7f86d29fa6fc5cbd1509b11
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__1d236727cda322520f3a703d9e848a434f71ca107e953aec5359ac063333d29b(
+    *,
+    excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__76ac16c602eb78041b136170e0877a83865ceb0c0c451b7e61c00366edce50a8(
     *,
     source_action_name: builtins.str,
+    pull_request: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitPullRequestFilterProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     push: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitPushFilterProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__6e825f3cafba918e1c84a158f90d3bcbd543fab5a2e3990e2677d0de4ad794df(
+    *,
+    excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__bd17e19e4fde95da653023de121d5f908ce71830fcd4cd84611c860dd5585932(
+    *,
+    branches: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitBranchFilterCriteriaProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    events: typing.Optional[typing.Sequence[builtins.str]] = None,
+    file_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitFilePathFilterCriteriaProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__aace18192e6436301eeae21b4cd59bd8cb01b53eb17f6fcb74599b2f74f9ebd0(
     *,
+    branches: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitBranchFilterCriteriaProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    file_paths: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.GitFilePathFilterCriteriaProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Union[CfnPipeline.GitTagFilterCriteriaProperty, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -8173,6 +9477,7 @@ def _typecheckingstub__34b7cf6aaa1cc98db41892b9b8499f74092bf6b5f7f4050d1bd7642f7
     artifact_store: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     artifact_stores: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.ArtifactStoreMapProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     disable_inbound_stage_transitions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnPipeline.StageTransitionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    execution_mode: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
     pipeline_type: typing.Optional[builtins.str] = None,
     restart_execution_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
@@ -8357,6 +9662,22 @@ def _typecheckingstub__65e227e2024e22ec4a8340ba1d5e7057772fcde85f4031d00361f79aa
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9bf0379bb3fa72f7dc00a45de6a383d19d18294c73d73dabcbdb7240e76832bf(
+    *,
+    source_action: IAction,
+    push_filter: typing.Optional[typing.Sequence[typing.Union[GitPushFilter, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d2e5e6ae139c810aa752b8a8c7cd3040d883f9f3a67c8d3693f9ab842351804e(
+    *,
+    tags_excludes: typing.Optional[typing.Sequence[builtins.str]] = None,
+    tags_includes: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5ac49c0e0a6597fa486597c011a67a04f9a1915fcc8f997bb6e6c4b0af2ee57d(
     scope: _constructs_77d1e7e8.Construct,
     stage: IStage,
@@ -8494,10 +9815,13 @@ def _typecheckingstub__dccc82ea9bcac61a3fb8c34055734a04a1bee7f59ee6675fdade2d8b5
     cross_region_replication_buckets: typing.Optional[typing.Mapping[builtins.str, _IBucket_42e086fd]] = None,
     enable_key_rotation: typing.Optional[builtins.bool] = None,
     pipeline_name: typing.Optional[builtins.str] = None,
+    pipeline_type: typing.Optional[PipelineType] = None,
     restart_execution_on_update: typing.Optional[builtins.bool] = None,
     reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,
     stages: typing.Optional[typing.Sequence[typing.Union[StageProps, typing.Dict[builtins.str, typing.Any]]]] = None,
+    triggers: typing.Optional[typing.Sequence[typing.Union[TriggerProps, typing.Dict[builtins.str, typing.Any]]]] = None,
+    variables: typing.Optional[typing.Sequence[Variable]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -8516,6 +9840,12 @@ def _typecheckingstub__7e85fb888993feed0e311ee7eff01c41ae2b8d2c859471c3e8abd51dd
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__c66f0602ec2236194290f47b7ed526e674bccbeaddc91834fa37bdbea2e9dce2(
+    variable: Variable,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__426062ddd10eb07a3be4ad55dd0fe3c2b81732bcdb5a244b2ec7d40db4605efc(
     _scope: _constructs_77d1e7e8.Construct,
 ) -> None:
@@ -8625,10 +9955,13 @@ def _typecheckingstub__22f00fc379808105702c3f59369205afd36025a51e45bcaf5d1cec0a3
     cross_region_replication_buckets: typing.Optional[typing.Mapping[builtins.str, _IBucket_42e086fd]] = None,
     enable_key_rotation: typing.Optional[builtins.bool] = None,
     pipeline_name: typing.Optional[builtins.str] = None,
+    pipeline_type: typing.Optional[PipelineType] = None,
     restart_execution_on_update: typing.Optional[builtins.bool] = None,
     reuse_cross_region_support_stacks: typing.Optional[builtins.bool] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,
     stages: typing.Optional[typing.Sequence[typing.Union[StageProps, typing.Dict[builtins.str, typing.Any]]]] = None,
+    triggers: typing.Optional[typing.Sequence[typing.Union[TriggerProps, typing.Dict[builtins.str, typing.Any]]]] = None,
+    variables: typing.Optional[typing.Sequence[Variable]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -8651,6 +9984,23 @@ def _typecheckingstub__6abc7556098f83ba3d73e92b8d6098aeb43f50e6fc7a58af7d194bb4f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__0e77c8b9601fdd47bfd2d43819e8d9a90e923d90d1d79bc31317a9a7e0dee535(
+    *,
+    provider_type: ProviderType,
+    git_configuration: typing.Optional[typing.Union[GitConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a98b171eab4c5eaadb5c59d8cb50bc5cfedba458e43c6e91a962ebcc7aa7cdb6(
+    *,
+    variable_name: builtins.str,
+    default_value: typing.Optional[builtins.str] = None,
+    description: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__74f62b0d88fd176d196b7a472610f641266a6df9a34453a50f26d3e0e2424260(
     scope: _constructs_77d1e7e8.Construct,
     stage: IStage,