agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-codepipeline/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.services.codepipeline"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.AWS.CodePipeline"
+    },
+    "python": {
+      "module": "aws_cdk.aws_codepipeline"
+    }
+  }
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/README.md

@@ -0,0 +1,925 @@
+# AWS CodePipeline Construct Library
+
+## Pipeline
+
+To construct an empty Pipeline:
+
+```ts
+// Construct an empty Pipeline
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline');
+```
+
+To give the Pipeline a nice, human-readable name:
+
+```ts
+// Give the Pipeline a nice, human-readable name
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline', {
+  pipelineName: 'MyPipeline',
+});
+```
+
+Be aware that in the default configuration, the `Pipeline` construct creates
+an AWS Key Management Service (AWS KMS) Customer Master Key (CMK) for you to
+encrypt the artifacts in the artifact bucket, which incurs a cost of
+**$1/month**. This default configuration is necessary to allow cross-account
+actions.
+
+If you do not intend to perform cross-account deployments, you can disable
+the creation of the Customer Master Keys by passing `crossAccountKeys: false`
+when defining the Pipeline:
+
+```ts
+// Don't create Customer Master Keys
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline', {
+  crossAccountKeys: false,
+});
+```
+
+If you want to enable key rotation for the generated KMS keys,
+you can configure it by passing `enableKeyRotation: true` when creating the pipeline.
+Note that key rotation will incur an additional cost of **$1/month**.
+
+```ts
+// Enable key rotation for the generated KMS key
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline', {
+  // ...
+  enableKeyRotation: true,
+});
+```
+
+## Stages
+
+You can provide Stages when creating the Pipeline:
+
+```ts
+// Provide a Stage when creating a pipeline
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline', {
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [
+        // see below...
+      ],
+    },
+  ],
+});
+```
+
+Or append a Stage to an existing Pipeline:
+
+```ts
+// Append a Stage to an existing Pipeline
+declare const pipeline: codepipeline.Pipeline;
+const sourceStage = pipeline.addStage({
+  stageName: 'Source',
+  actions: [ // optional property
+    // see below...
+  ],
+});
+```
+
+You can insert the new Stage at an arbitrary point in the Pipeline:
+
+```ts
+// Insert a new Stage at an arbitrary point
+declare const pipeline: codepipeline.Pipeline;
+declare const anotherStage: codepipeline.IStage;
+declare const yetAnotherStage: codepipeline.IStage;
+
+const someStage = pipeline.addStage({
+  stageName: 'SomeStage',
+  placement: {
+    // note: you can only specify one of the below properties
+    rightBefore: anotherStage,
+    justAfter: yetAnotherStage,
+  }
+});
+```
+
+You can disable transition to a Stage:
+
+```ts
+// Disable transition to a stage
+declare const pipeline: codepipeline.Pipeline;
+
+const someStage = pipeline.addStage({
+  stageName: 'SomeStage',
+  transitionToEnabled: false,
+  transitionDisabledReason: 'Manual transition only', // optional reason
+})
+```
+
+This is useful if you don't want every executions of the pipeline to flow into
+this stage automatically. The transition can then be "manually" enabled later on.
+
+## Actions
+
+Actions live in a separate package, `aws-cdk-lib/aws-codepipeline-actions`.
+
+To add an Action to a Stage, you can provide it when creating the Stage,
+in the `actions` property,
+or you can use the `IStage.addAction()` method to mutate an existing Stage:
+
+```ts
+// Use the `IStage.addAction()` method to mutate an existing Stage.
+declare const sourceStage: codepipeline.IStage;
+declare const someAction: codepipeline.Action;
+sourceStage.addAction(someAction);
+```
+
+## Custom Action Registration
+
+To make your own custom CodePipeline Action requires registering the action provider. Look to the `JenkinsProvider` in `aws-cdk-lib/aws-codepipeline-actions` for an implementation example.
+
+```ts
+// Make a custom CodePipeline Action
+new codepipeline.CustomActionRegistration(this, 'GenericGitSourceProviderResource', {
+  category: codepipeline.ActionCategory.SOURCE,
+  artifactBounds: { minInputs: 0, maxInputs: 0, minOutputs: 1, maxOutputs: 1 },
+  provider: 'GenericGitSource',
+  version: '1',
+  entityUrl: 'https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html',
+  executionUrl: 'https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html',
+  actionProperties: [
+    {
+      name: 'Branch',
+      required: true,
+      key: false,
+      secret: false,
+      queryable: false,
+      description: 'Git branch to pull',
+      type: 'String',
+    },
+    {
+      name: 'GitUrl',
+      required: true,
+      key: false,
+      secret: false,
+      queryable: false,
+      description: 'SSH git clone URL',
+      type: 'String',
+    },
+  ],
+});
+```
+
+## Cross-account CodePipelines
+
+> Cross-account Pipeline actions require that the Pipeline has *not* been
+> created with `crossAccountKeys: false`.
+
+Most pipeline Actions accept an AWS resource object to operate on. For example:
+
+* `S3DeployAction` accepts an `s3.IBucket`.
+* `CodeBuildAction` accepts a `codebuild.IProject`.
+* etc.
+
+These resources can be either newly defined (`new s3.Bucket(...)`) or imported
+(`s3.Bucket.fromBucketAttributes(...)`) and identify the resource that should
+be changed.
+
+These resources can be in different accounts than the pipeline itself. For
+example, the following action deploys to an imported S3 bucket from a
+different account:
+
+```ts
+// Deploy an imported S3 bucket from a different account
+declare const stage: codepipeline.IStage;
+declare const input: codepipeline.Artifact;
+stage.addAction(new codepipeline_actions.S3DeployAction({
+  bucket: s3.Bucket.fromBucketAttributes(this, 'Bucket', {
+    account: '123456789012',
+    // ...
+  }),
+  input: input,
+  actionName: 's3-deploy-action',
+  // ...
+}));
+```
+
+Actions that don't accept a resource object accept an explicit `account` parameter:
+
+```ts
+// Actions that don't accept a resource objet accept an explicit `account` parameter
+declare const stage: codepipeline.IStage;
+declare const templatePath: codepipeline.ArtifactPath;
+stage.addAction(new codepipeline_actions.CloudFormationCreateUpdateStackAction({
+  account: '123456789012',
+  templatePath,
+  adminPermissions: false,
+  stackName: Stack.of(this).stackName,
+  actionName: 'cloudformation-create-update',
+  // ...
+}));
+```
+
+The `Pipeline` construct automatically defines an **IAM Role** for you in the
+target account which the pipeline will assume to perform that action. This
+Role will be defined in a **support stack** named
+`<PipelineStackName>-support-<account>`, that will automatically be deployed
+before the stack containing the pipeline.
+
+If you do not want to use the generated role, you can also explicitly pass a
+`role` when creating the action. In that case, the action will operate in the
+account the role belongs to:
+
+```ts
+// Explicitly pass in a `role` when creating an action.
+declare const stage: codepipeline.IStage;
+declare const templatePath: codepipeline.ArtifactPath;
+stage.addAction(new codepipeline_actions.CloudFormationCreateUpdateStackAction({
+  templatePath,
+  adminPermissions: false,
+  stackName: Stack.of(this).stackName,
+  actionName: 'cloudformation-create-update',
+  // ...
+  role: iam.Role.fromRoleArn(this, 'ActionRole', '...'),
+}));
+```
+
+## Cross-region CodePipelines
+
+Similar to how you set up a cross-account Action, the AWS resource object you
+pass to actions can also be in different *Regions*. For example, the
+following Action deploys to an imported S3 bucket from a different Region:
+
+```ts
+// Deploy to an imported S3 bucket from a different Region.
+declare const stage: codepipeline.IStage;
+declare const input: codepipeline.Artifact;
+stage.addAction(new codepipeline_actions.S3DeployAction({
+  bucket: s3.Bucket.fromBucketAttributes(this, 'Bucket', {
+    region: 'us-west-1',
+    // ...
+  }),
+  input: input,
+  actionName: 's3-deploy-action',
+  // ...
+}));
+```
+
+Actions that don't take an AWS resource will accept an explicit `region`
+parameter:
+
+```ts
+// Actions that don't take an AWS resource will accept an explicit `region` parameter.
+declare const stage: codepipeline.IStage;
+declare const templatePath: codepipeline.ArtifactPath;
+stage.addAction(new codepipeline_actions.CloudFormationCreateUpdateStackAction({
+  templatePath,
+  adminPermissions: false,
+  stackName: Stack.of(this).stackName,
+  actionName: 'cloudformation-create-update',
+  // ...
+  region: 'us-west-1',
+}));
+```
+
+The `Pipeline` construct automatically defines a **replication bucket** for
+you in the target region, which the pipeline will replicate artifacts to and
+from. This Bucket will be defined in a **support stack** named
+`<PipelineStackName>-support-<region>`, that will automatically be deployed
+before the stack containing the pipeline.
+
+If you don't want to use these support stacks, and already have buckets in
+place to serve as replication buckets, you can supply these at Pipeline definition
+time using the `crossRegionReplicationBuckets` parameter. Example:
+
+```ts
+// Supply replication buckets for the Pipeline instead of using the generated support stack
+const pipeline = new codepipeline.Pipeline(this, 'MyFirstPipeline', {
+  // ...
+
+  crossRegionReplicationBuckets: {
+    // note that a physical name of the replication Bucket must be known at synthesis time
+    'us-west-1': s3.Bucket.fromBucketAttributes(this, 'UsWest1ReplicationBucket', {
+      bucketName: 'amzn-s3-demo-bucket',
+      // optional KMS key
+      encryptionKey: kms.Key.fromKeyArn(this, 'UsWest1ReplicationKey',
+        'arn:aws:kms:us-west-1:123456789012:key/1234-5678-9012'
+      ),
+    }),
+  },
+});
+```
+
+See [the AWS docs here](https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-cross-region.html)
+for more information on cross-region CodePipelines.
+
+### Creating an encrypted replication bucket
+
+If you're passing a replication bucket created in a different stack,
+like this:
+
+```ts
+// Passing a replication bucket created in a different stack.
+const app = new App();
+const replicationStack = new Stack(app, 'ReplicationStack', {
+  env: {
+    region: 'us-west-1',
+  },
+});
+const key = new kms.Key(replicationStack, 'ReplicationKey');
+const replicationBucket = new s3.Bucket(replicationStack, 'ReplicationBucket', {
+  // like was said above - replication buckets need a set physical name
+  bucketName: PhysicalName.GENERATE_IF_NEEDED,
+  encryptionKey: key, // does not work!
+});
+
+// later...
+new codepipeline.Pipeline(replicationStack, 'Pipeline', {
+  crossRegionReplicationBuckets: {
+    'us-west-1': replicationBucket,
+  },
+});
+```
+
+When trying to encrypt it
+(and note that if any of the cross-region actions happen to be cross-account as well,
+the bucket *has to* be encrypted - otherwise the pipeline will fail at runtime),
+you cannot use a key directly - KMS keys don't have physical names,
+and so you can't reference them across environments.
+
+In this case, you need to use an alias in place of the key when creating the bucket:
+
+```ts
+// Passing an encrypted replication bucket created in a different stack.
+const app = new App();
+const replicationStack = new Stack(app, 'ReplicationStack', {
+  env: {
+    region: 'us-west-1',
+  },
+});
+const key = new kms.Key(replicationStack, 'ReplicationKey');
+const alias = new kms.Alias(replicationStack, 'ReplicationAlias', {
+  // aliasName is required
+  aliasName: PhysicalName.GENERATE_IF_NEEDED,
+  targetKey: key,
+});
+const replicationBucket = new s3.Bucket(replicationStack, 'ReplicationBucket', {
+  bucketName: PhysicalName.GENERATE_IF_NEEDED,
+  encryptionKey: alias,
+});
+```
+
+## Variables
+
+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;
+when you want to use a variable in the configuration of a different action,
+you access the appropriate property of the interface returned from `variables`,
+which represents a single variable.
+Example:
+
+```ts fixture=action
+// MyAction is some action type that produces variables, like EcrSourceAction
+const myAction = new MyAction({
+  // ...
+  actionName: 'myAction',
+});
+new OtherAction({
+  // ...
+  config: myAction.variables.myVariable,
+  actionName: 'otherAction',
+});
+```
+
+The namespace name that will be used will be automatically generated by the pipeline construct,
+based on the stage and action name;
+you can pass a custom name when creating the action instance:
+
+```ts fixture=action
+// MyAction is some action type that produces variables, like EcrSourceAction
+const myAction = new MyAction({
+  // ...
+  variablesNamespace: 'MyNamespace',
+  actionName: 'myAction',
+});
+```
+
+There are also global variables available,
+not tied to any action;
+these are accessed through static properties of the `GlobalVariables` class:
+
+```ts fixture=action
+// OtherAction is some action type that produces variables, like EcrSourceAction
+new OtherAction({
+  // ...
+  config: codepipeline.GlobalVariables.executionId,
+  actionName: 'otherAction',
+});
+```
+
+The following is an actual code example.
+
+```ts
+declare const sourceAction: codepipeline_actions.S3SourceAction;
+declare const sourceOutput: codepipeline.Artifact;
+declare const deployBucket: s3.Bucket;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Deploy',
+      actions: [
+        new codepipeline_actions.S3DeployAction({
+          actionName: 'DeployAction',
+          // can reference the variables
+          objectKey: `${sourceAction.variables.versionId}.txt`,
+          input: sourceOutput,
+          bucket: deployBucket,
+        }),
+      ],
+    },
+  ],
+});
+```
+
+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.
+
+```ts
+declare const sourceAction: codepipeline_actions.S3SourceAction;
+declare const sourceOutput: codepipeline.Artifact;
+declare const deployBucket: s3.Bucket;
+
+// Pipeline-level variable
+const variable = new codepipeline.Variable({
+  variableName: 'bucket-var',
+  description: 'description',
+  defaultValue: 'sample',
+});
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  variables: [variable],
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Deploy',
+      actions: [
+        new codepipeline_actions.S3DeployAction({
+          actionName: 'DeployAction',
+          // can reference the variables
+          objectKey: `${variable.reference()}.txt`,
+          input: sourceOutput,
+          bucket: deployBucket,
+        }),
+      ],
+    },
+  ],
+});
+```
+
+Or append a variable to an existing pipeline:
+
+```ts
+declare const pipeline: codepipeline.Pipeline;
+
+const variable = new codepipeline.Variable({
+  variableName: 'bucket-var',
+  description: 'description',
+  defaultValue: 'sample',
+});
+pipeline.addVariable(variable);
+```
+
+## Events
+
+### Using a pipeline as an event target
+
+A pipeline can be used as a target for a CloudWatch event rule:
+
+```ts
+// A pipeline being used as a target for a CloudWatch event rule.
+import * as targets from 'aws-cdk-lib/aws-events-targets';
+import * as events from 'aws-cdk-lib/aws-events';
+
+// kick off the pipeline every day
+const rule = new events.Rule(this, 'Daily', {
+  schedule: events.Schedule.rate(Duration.days(1)),
+});
+
+declare const pipeline: codepipeline.Pipeline;
+rule.addTarget(new targets.CodePipeline(pipeline));
+```
+
+When a pipeline is used as an event target, the
+"codepipeline:StartPipelineExecution" permission is granted to the AWS
+CloudWatch Events service.
+
+### Event sources
+
+Pipelines emit CloudWatch events. To define event rules for events emitted by
+the pipeline, stages or action, use the `onXxx` methods on the respective
+construct:
+
+```ts
+// Define event rules for events emitted by the pipeline
+import * as events from 'aws-cdk-lib/aws-events';
+
+declare const myPipeline: codepipeline.Pipeline;
+declare const myStage: codepipeline.IStage;
+declare const myAction: codepipeline.Action;
+declare const target: events.IRuleTarget;
+myPipeline.onStateChange('MyPipelineStateChange', { target: target } );
+myStage.onStateChange('MyStageStateChange', target);
+myAction.onStateChange('MyActionStateChange', target);
+```
+
+## CodeStar Notifications
+
+To define CodeStar Notification rules for Pipelines, use one of the `notifyOnXxx()` methods.
+They are very similar to `onXxx()` methods for CloudWatch events:
+
+```ts
+// Define CodeStar Notification rules for Pipelines
+import * as chatbot from 'aws-cdk-lib/aws-chatbot';
+const target = new chatbot.SlackChannelConfiguration(this, 'MySlackChannel', {
+  slackChannelConfigurationName: 'YOUR_CHANNEL_NAME',
+  slackWorkspaceId: 'YOUR_SLACK_WORKSPACE_ID',
+  slackChannelId: 'YOUR_SLACK_CHANNEL_ID',
+});
+
+declare const pipeline: codepipeline.Pipeline;
+const rule = pipeline.notifyOnExecutionStateChange('NotifyOnExecutionStateChange', target);
+```
+
+## Trigger
+
+To trigger a pipeline with Git tags or branches, specify the `triggers` property.
+The triggers can only be used with pipeline type V2.
+
+### Push filter
+
+Pipelines can be started based on push events. You can specify the `pushFilter` property to
+filter the push events. The `pushFilter` can specify Git tags and branches.
+
+In the case of Git tags, your pipeline starts when a Git tag is pushed.
+You can filter with glob patterns. The `tagsExcludes` takes priority over the `tagsIncludes`.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pushFilter: [{
+        tagsExcludes: ['exclude1', 'exclude2'],
+        tagsIncludes: ['include*'],
+      }],
+    },
+  }],
+});
+```
+
+In the case of branches, your pipeline starts when a commit is pushed on the specified branches.
+You can filter with glob patterns. The `branchesExcludes` takes priority over the `branchesIncludes`.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pushFilter: [{
+        branchesExcludes: ['exclude1', 'exclude2'],
+        branchesIncludes: ['include*'],
+      }],
+    },
+  }],
+});
+```
+
+File paths can also be specified along with the branches to start the pipeline.
+You can filter with glob patterns. The `filePathsExcludes` takes priority over the `filePathsIncludes`.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pushFilter: [{
+        branchesExcludes: ['exclude1', 'exclude2'],
+        branchesIncludes: ['include1', 'include2'],
+        filePathsExcludes: ['/path/to/exclude1', '/path/to/exclude2'],
+        filePathsIncludes: ['/path/to/include1', '/path/to/include1'],
+      }],
+    },
+  }],
+});
+```
+
+### Pull request filter
+
+Pipelines can be started based on pull request events. You can specify the `pullRequestFilter` property to
+filter the pull request events. The `pullRequestFilter` can specify branches, file paths, and event types.
+
+In the case of branches, your pipeline starts when a pull request event occurs on the specified branches.
+You can filter with glob patterns. The `branchesExcludes` takes priority over the `branchesIncludes`.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pullRequestFilter: [{
+        branchesExcludes: ['exclude1', 'exclude2'],
+        branchesIncludes: ['include*'],
+      }],
+    },
+  }],
+});
+```
+
+File paths can also be specified along with the branches to start the pipeline.
+You can filter with glob patterns. The `filePathsExcludes` takes priority over the `filePathsIncludes`.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pullRequestFilter: [{
+        branchesExcludes: ['exclude1', 'exclude2'],
+        branchesIncludes: ['include1', 'include2'],
+        filePathsExcludes: ['/path/to/exclude1', '/path/to/exclude2'],
+        filePathsIncludes: ['/path/to/include1', '/path/to/include1'],
+      }],
+    },
+  }],
+});
+```
+
+To filter types of pull request events for triggers, you can specify the `events` property.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+    },
+  ],
+  triggers: [{
+    providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+    gitConfiguration: {
+      sourceAction,
+      pullRequestFilter: [{
+        branchesExcludes: ['exclude1', 'exclude2'],
+        branchesIncludes: ['include1', 'include2'],
+        events: [
+          codepipeline.GitPullRequestEvent.OPEN,
+          codepipeline.GitPullRequestEvent.CLOSED,
+        ],
+      }],
+    },
+  }],
+});
+```
+
+### Append a trigger to an existing pipeline
+
+You can append a trigger to an existing pipeline:
+
+```ts
+declare const pipeline: codepipeline.Pipeline;
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+
+pipeline.addTrigger({
+  providerType: codepipeline.ProviderType.CODE_STAR_SOURCE_CONNECTION,
+  gitConfiguration: {
+    sourceAction,
+    pushFilter: [{
+      tagsExcludes: ['exclude1', 'exclude2'],
+      tagsIncludes: ['include*'],
+    }],
+  },
+});
+```
+
+## Execution mode
+
+To control the concurrency behavior when multiple executions of a pipeline are started, you can use the `executionMode` property.
+
+The execution mode can only be used with pipeline type V2.
+
+```ts
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  executionMode: codepipeline.ExecutionMode.PARALLEL,
+});
+```
+
+## Stage Level Condition
+
+Conditions are used for specific types of expressions and each has specific options for results available as follows:
+
+  Entry - The conditions for making checks that, if met, allow entry to a stage. Rules are engaged with the following result options: Fail or Skip
+
+  On Failure - The conditions for making checks for the stage when it fails. Rules are engaged with the following result option: Rollback
+
+  On Success - The conditions for making checks for the stage when it succeeds. Rules are engaged with the following result options: Rollback or Fail
+
+Conditions are supported by a set of rules for each type of condition.
+
+For each type of condition, there are specific actions that are set up by the condition. The action is the result of the succeeded or failed condition check. For example, the condition for entry (entry condition) encounters an alarm (rule), then the check is successful and the result (action) is that the stage entry is blocked.
+
+```ts
+declare const sourceAction: codepipeline_actions.CodeStarConnectionsSourceAction;
+declare const buildAction: codepipeline_actions.CodeBuildAction;
+
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2,
+  stages: [
+    {
+      stageName: 'Source',
+      actions: [sourceAction],
+    },
+    {
+      stageName: 'Build',
+      actions: [buildAction],
+      // BeforeEntry condition - checks before entering the stage
+      beforeEntry: {
+        conditions: [{
+          rules: [ new codepipeline.Rule({
+            name: 'LambdaCheck',
+            provider: 'LambdaInvoke',
+            version: '1',
+            configuration: {
+              FunctionName: 'LambdaFunctionName',
+            },
+          })],
+          result:  codepipeline.Result.FAIL,
+        }],
+      },
+      // OnSuccess condition - checks after successful stage completion
+      onSuccess: {
+        conditions: [{
+          result: codepipeline.Result.FAIL,
+          rules: [new codepipeline.Rule({
+            name: 'CloudWatchCheck',
+            provider: 'LambdaInvoke',
+            version: '1',
+            configuration: {
+              AlarmName: 'AlarmName1',
+              WaitTime: '300', // 5 minutes
+              FunctionName: 'funcName2'
+            },
+          })],
+        }],
+      },
+      // OnFailure condition - handles stage failure
+      onFailure: {
+        conditions: [{
+          result: codepipeline.Result.ROLLBACK,
+            rules: [new codepipeline.Rule({
+            name: 'RollBackOnFailure',
+            provider: 'LambdaInvoke',
+            version: '1',
+            configuration: {
+              AlarmName: 'Alarm',
+              WaitTime: '300', // 5 minutes
+              FunctionName: 'funcName1'
+            },
+          })],
+        }],
+      },
+    },
+  ],
+
+});
+```
+
+## Use pipeline service role as default action role in pipeline
+
+You could enable this field to use pipeline service role as default action role in Codepipeline by set `usePipelineServiceRoleForActions` as true if no action role provided.
+
+## 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.
+
+When the `@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2` feature flag is set to `true` (default for new projects),
+the V2 type is selected by default if you do not specify a value for `pipelineType` property. Otherwise, the V1 type is selected.
+
+```ts
+new codepipeline.Pipeline(this, 'Pipeline', {
+  pipelineType: codepipeline.PipelineType.V2, // here
+});
+```
+
+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.

cdk/node_modules/aws-cdk-lib/aws-codepipeline/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/action.d.ts

@@ -0,0 +1,429 @@
+import type { Construct } from 'constructs';
+import type { Artifact } from './artifact';
+import type * as notifications from '../../aws-codestarnotifications';
+import * as events from '../../aws-events';
+import type * as iam from '../../aws-iam';
+import type * as s3 from '../../aws-s3';
+import type { Duration, IResource } from '../../core';
+import type { IPipelineRef } from '../../interfaces/generated/aws-codepipeline-interfaces.generated';
+export declare enum ActionCategory {
+    SOURCE = "Source",
+    BUILD = "Build",
+    TEST = "Test",
+    APPROVAL = "Approval",
+    DEPLOY = "Deploy",
+    INVOKE = "Invoke",
+    COMPUTE = "Compute"
+}
+/**
+ * Specifies the constraints on the number of input and output
+ * artifacts an action can have.
+ *
+ * The constraints for each action type are documented on the
+ * [Pipeline Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html) page.
+ */
+export interface ActionArtifactBounds {
+    readonly minInputs: number;
+    readonly maxInputs: number;
+    readonly minOutputs: number;
+    readonly maxOutputs: number;
+}
+/**
+ * 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.
+ */
+export declare class GlobalVariables {
+    /** The identifier of the current pipeline execution. */
+    static readonly executionId = "#{codepipeline.PipelineExecutionId}";
+}
+export interface ActionProperties {
+    readonly actionName: string;
+    readonly role?: iam.IRole;
+    /**
+     * The AWS region the given Action resides in.
+     * Note that a cross-region Pipeline requires replication buckets to function correctly.
+     * You can provide their names with the `PipelineProps#crossRegionReplicationBuckets` property.
+     * If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
+     * that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
+     *
+     * @default the Action resides in the same region as the Pipeline
+     */
+    readonly region?: string;
+    /**
+     * The account the Action is supposed to live in.
+     * For Actions backed by resources,
+     * this is inferred from the Stack `resource` is part of.
+     * However, some Actions, like the CloudFormation ones,
+     * are not backed by any resource, and they still might want to be cross-account.
+     * In general, a concrete Action class should specify either `resource`,
+     * or `account` - but not both.
+     */
+    readonly account?: string;
+    /**
+     * The optional resource that is backing this Action.
+     * This is used for automatically handling Actions backed by
+     * resources from a different account and/or region.
+     */
+    readonly resource?: IResource;
+    /**
+     * The category of the action.
+     * The category defines which action type the owner
+     * (the entity that performs the action) performs.
+     */
+    readonly category: ActionCategory;
+    /**
+     * The service provider that the action calls.
+     */
+    readonly provider: string;
+    readonly owner?: string;
+    readonly version?: string;
+    /**
+     * The order in which AWS CodePipeline runs this action.
+     * For more information, see the AWS CodePipeline User Guide.
+     *
+     * https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements
+     */
+    readonly runOrder?: number;
+    readonly artifactBounds: ActionArtifactBounds;
+    readonly inputs?: Artifact[];
+    readonly outputs?: Artifact[];
+    /**
+     * The name of the namespace to use for variables emitted by this action.
+     *
+     * @default - a name will be generated, based on the stage and action names
+     */
+    readonly variablesNamespace?: string;
+    /**
+     * Shell commands for the Commands action to run.
+     *
+     * @default - no commands
+     */
+    readonly commands?: string[];
+    /**
+     * The names of the variables in your environment that you want to export.
+     *
+     * @default - no output variables
+     */
+    readonly outputVariables?: string[];
+    /**
+     * A timeout duration that can be applied against the ActionType’s default timeout value
+     * specified in Quotas for AWS CodePipeline.
+     *
+     * This attribute is available only to the `ManualApprovalAction`.
+     *
+     * It is configurable up to 86400 minutes (60 days) with a minimum value of 5 minutes.
+     *
+     * @default - default timeout value defined by each ActionType
+     * @see https://docs.aws.amazon.com/codepipeline/latest/userguide/limits.html
+     */
+    readonly timeout?: Duration;
+}
+export interface ActionBindOptions {
+    readonly role: iam.IRole;
+    readonly bucket: s3.IBucket;
+}
+export interface ActionConfig {
+    readonly configuration?: any;
+}
+/**
+ * Additional options to pass to the notification rule.
+ */
+export interface PipelineNotifyOnOptions extends notifications.NotificationRuleOptions {
+    /**
+     * A list of event types associated with this notification rule for CodePipeline Pipeline.
+     * For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api
+     */
+    readonly events: PipelineNotificationEvents[];
+}
+/**
+ * A Pipeline Action.
+ * If you want to implement this interface,
+ * consider extending the `Action` class,
+ * which contains some common logic.
+ */
+export interface IAction {
+    /**
+     * The simple properties of the Action,
+     * like its Owner, name, etc.
+     * Note that this accessor will be called before the `bind` callback.
+     */
+    readonly actionProperties: ActionProperties;
+    /**
+     * 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
+     * @param options additional options the Action can use,
+     *   like the artifact Bucket of the pipeline it's being added to
+     */
+    bind(scope: Construct, stage: IStage, options: ActionBindOptions): ActionConfig;
+    /**
+     * Creates an Event that will be triggered whenever the state of this Action changes.
+     *
+     * @param name the name to use for the new Event
+     * @param target the optional target for the Event
+     * @param options additional options that can be used to customize the created Event
+     */
+    onStateChange(name: string, target?: events.IRuleTarget, options?: events.RuleProps): events.Rule;
+}
+/**
+ * The abstract view of an AWS CodePipeline as required and used by Actions.
+ * It extends `events.IRuleTarget`,
+ * so this interface can be used as a Target for CloudWatch Events.
+ */
+export interface IPipeline extends IResource, IPipelineRef, notifications.INotificationRuleSource {
+    /**
+     * The name of the Pipeline.
+     *
+     * @attribute
+     */
+    readonly pipelineName: string;
+    /**
+     * The ARN of the Pipeline.
+     *
+     * @attribute
+     */
+    readonly pipelineArn: string;
+    /**
+     * Define an event rule triggered by this CodePipeline.
+     *
+     * @param id Identifier for this event handler.
+     * @param options Additional options to pass to the event rule.
+     */
+    onEvent(id: string, options?: events.OnEventOptions): events.Rule;
+    /**
+     * Define an event rule triggered by the "CodePipeline Pipeline Execution
+     * State Change" event emitted from this pipeline.
+     *
+     * @param id Identifier for this event handler.
+     * @param options Additional options to pass to the event rule.
+     */
+    onStateChange(id: string, options?: events.OnEventOptions): events.Rule;
+    /**
+     * Defines a CodeStar notification rule triggered when the pipeline
+     * events emitted by you specified, it very similar to `onEvent` API.
+     *
+     * You can also use the methods `notifyOnExecutionStateChange`, `notifyOnAnyStageStateChange`,
+     * `notifyOnAnyActionStateChange` and `notifyOnAnyManualApprovalStateChange`
+     * to define rules for these specific event emitted.
+     *
+     * @param id The id of the CodeStar notification rule
+     * @param target The target to register for the CodeStar Notifications destination.
+     * @param options Customization options for CodeStar notification rule
+     * @returns CodeStar notification rule associated with this build project.
+     */
+    notifyOn(id: string, target: notifications.INotificationRuleTarget, options: PipelineNotifyOnOptions): notifications.INotificationRule;
+    /**
+     * Define an notification rule triggered by the set of the "Pipeline execution" events emitted from this pipeline.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     *
+     * @param id Identifier for this notification handler.
+     * @param target The target to register for the CodeStar Notifications destination.
+     * @param options Additional options to pass to the notification rule.
+     */
+    notifyOnExecutionStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    /**
+     * Define an notification rule triggered by the set of the "Stage execution" events emitted from this pipeline.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     *
+     * @param id Identifier for this notification handler.
+     * @param target The target to register for the CodeStar Notifications destination.
+     * @param options Additional options to pass to the notification rule.
+     */
+    notifyOnAnyStageStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    /**
+     * Define an notification rule triggered by the set of the "Action execution" events emitted from this pipeline.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     *
+     * @param id Identifier for this notification handler.
+     * @param target The target to register for the CodeStar Notifications destination.
+     * @param options Additional options to pass to the notification rule.
+     */
+    notifyOnAnyActionStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    /**
+     * Define an notification rule triggered by the set of the "Manual approval" events emitted from this pipeline.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     *
+     * @param id Identifier for this notification handler.
+     * @param target The target to register for the CodeStar Notifications destination.
+     * @param options Additional options to pass to the notification rule.
+     */
+    notifyOnAnyManualApprovalStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+}
+/**
+ * The abstract interface of a Pipeline Stage that is used by Actions.
+ */
+export interface IStage {
+    /**
+     * The physical, human-readable name of this Pipeline Stage.
+     */
+    readonly stageName: string;
+    readonly pipeline: IPipeline;
+    /**
+     * The actions belonging to this stage.
+     */
+    readonly actions: IAction[];
+    addAction(action: IAction): void;
+    onStateChange(name: string, target?: events.IRuleTarget, options?: events.RuleProps): events.Rule;
+}
+/**
+ * Common properties shared by all Actions.
+ */
+export interface CommonActionProps {
+    /**
+     * The physical, human-readable name of the Action.
+     * Note that Action names must be unique within a single Stage.
+     */
+    readonly actionName: string;
+    /**
+     * The runOrder property for this Action.
+     * RunOrder determines the relative order in which multiple Actions in the same Stage execute.
+     *
+     * @default 1
+     * @see https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
+     */
+    readonly runOrder?: number;
+    /**
+     * The name of the namespace to use for variables emitted by this action.
+     *
+     * @default - a name will be generated, based on the stage and action names,
+     *   if any of the action's variables were referenced - otherwise,
+     *   no namespace will be set
+     */
+    readonly variablesNamespace?: string;
+}
+/**
+ * Common properties shared by all Actions whose `ActionProperties.owner` field is 'AWS'
+ * (or unset, as 'AWS' is the default).
+ */
+export interface CommonAwsActionProps extends CommonActionProps {
+    /**
+     * The Role in which context's this Action will be executing in.
+     * The Pipeline's Role will assume this Role
+     * (the required permissions for that will be granted automatically)
+     * right before executing this Action.
+     * This Action will be passed into your `IAction.bind`
+     * method in the `ActionBindOptions.role` property.
+     *
+     * @default a new Role will be generated
+     */
+    readonly role?: iam.IRole;
+}
+/**
+ * Low-level class for generic CodePipeline Actions implementing the `IAction` interface.
+ * Contains some common logic that can be re-used by all `IAction` implementations.
+ * If you're writing your own Action class,
+ * feel free to extend this class.
+ */
+export declare abstract class Action implements IAction {
+    /**
+     * This is a renamed version of the `IAction.actionProperties` property.
+     */
+    protected abstract readonly providedActionProperties: ActionProperties;
+    private __actionProperties?;
+    private __pipeline?;
+    private __stage?;
+    private __scope?;
+    private readonly _namespaceToken;
+    private _customerProvidedNamespace?;
+    private _actualNamespace?;
+    private _variableReferenced;
+    protected constructor();
+    get actionProperties(): ActionProperties;
+    bind(scope: Construct, stage: IStage, options: ActionBindOptions): ActionConfig;
+    onStateChange(name: string, target?: events.IRuleTarget, options?: events.RuleProps): events.Rule;
+    protected variableExpression(variableName: string): string;
+    /**
+     * This is a renamed version of the `IAction.bind` method.
+     */
+    protected abstract bound(scope: Construct, stage: IStage, options: ActionBindOptions): ActionConfig;
+    private get _pipeline();
+    private get _stage();
+    /**
+     * Retrieves the Construct scope of this Action.
+     * Only available after the Action has been added to a Stage,
+     * and that Stage to a Pipeline.
+     */
+    private get _scope();
+}
+/**
+ * The list of event types for AWS Codepipeline Pipeline
+ * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+ */
+export declare enum PipelineNotificationEvents {
+    /**
+     * Trigger notification when pipeline execution failed
+     */
+    PIPELINE_EXECUTION_FAILED = "codepipeline-pipeline-pipeline-execution-failed",
+    /**
+     * Trigger notification when pipeline execution canceled
+     */
+    PIPELINE_EXECUTION_CANCELED = "codepipeline-pipeline-pipeline-execution-canceled",
+    /**
+     * Trigger notification when pipeline execution started
+     */
+    PIPELINE_EXECUTION_STARTED = "codepipeline-pipeline-pipeline-execution-started",
+    /**
+     * Trigger notification when pipeline execution resumed
+     */
+    PIPELINE_EXECUTION_RESUMED = "codepipeline-pipeline-pipeline-execution-resumed",
+    /**
+     * Trigger notification when pipeline execution succeeded
+     */
+    PIPELINE_EXECUTION_SUCCEEDED = "codepipeline-pipeline-pipeline-execution-succeeded",
+    /**
+     * Trigger notification when pipeline execution superseded
+     */
+    PIPELINE_EXECUTION_SUPERSEDED = "codepipeline-pipeline-pipeline-execution-superseded",
+    /**
+     * Trigger notification when pipeline stage execution started
+     */
+    STAGE_EXECUTION_STARTED = "codepipeline-pipeline-stage-execution-started",
+    /**
+     * Trigger notification when pipeline stage execution succeeded
+     */
+    STAGE_EXECUTION_SUCCEEDED = "codepipeline-pipeline-stage-execution-succeeded",
+    /**
+     * Trigger notification when pipeline stage execution resumed
+     */
+    STAGE_EXECUTION_RESUMED = "codepipeline-pipeline-stage-execution-resumed",
+    /**
+     * Trigger notification when pipeline stage execution canceled
+     */
+    STAGE_EXECUTION_CANCELED = "codepipeline-pipeline-stage-execution-canceled",
+    /**
+     * Trigger notification when pipeline stage execution failed
+     */
+    STAGE_EXECUTION_FAILED = "codepipeline-pipeline-stage-execution-failed",
+    /**
+     * Trigger notification when pipeline action execution succeeded
+     */
+    ACTION_EXECUTION_SUCCEEDED = "codepipeline-pipeline-action-execution-succeeded",
+    /**
+     * Trigger notification when pipeline action execution failed
+     */
+    ACTION_EXECUTION_FAILED = "codepipeline-pipeline-action-execution-failed",
+    /**
+     * Trigger notification when pipeline action execution canceled
+     */
+    ACTION_EXECUTION_CANCELED = "codepipeline-pipeline-action-execution-canceled",
+    /**
+     * Trigger notification when pipeline action execution started
+     */
+    ACTION_EXECUTION_STARTED = "codepipeline-pipeline-action-execution-started",
+    /**
+     * Trigger notification when pipeline manual approval failed
+     */
+    MANUAL_APPROVAL_FAILED = "codepipeline-pipeline-manual-approval-failed",
+    /**
+     * Trigger notification when pipeline manual approval needed
+     */
+    MANUAL_APPROVAL_NEEDED = "codepipeline-pipeline-manual-approval-needed",
+    /**
+     * Trigger notification when pipeline manual approval succeeded
+     */
+    MANUAL_APPROVAL_SUCCEEDED = "codepipeline-pipeline-manual-approval-succeeded"
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/artifact.d.ts

@@ -0,0 +1,98 @@
+import type * as s3 from '../../aws-s3';
+/**
+ * An output artifact of an action. Artifacts can be used as input by some actions.
+ */
+export declare class Artifact {
+    /**
+     * A static factory method used to create instances of the Artifact class.
+     * Mainly meant to be used from `decdk`.
+     *
+     * @param name the (required) name of the Artifact
+     * @param files file paths that you want to export as the output artifact for the action.
+     * This property can only be used in the artifact for `CommandsAction`.
+     * The length of the files array must be between 1 and 10.
+     *
+     * @jsii suppress JSII5019 For historic reasons
+     */
+    static artifact(name: string, files?: string[]): Artifact;
+    private _artifactName?;
+    private _artifactFiles?;
+    private readonly metadata;
+    /**
+     * An output artifact of an action. Artifacts can be used as input by some actions.
+     *
+     * @param artifactName the (required) name of the Artifact
+     * @param artifactFiles file paths that you want to export as the output artifact for the action.
+     * This property can only be used in the artifact for `CommandsAction`.
+     * The length of the artifactFiles array must be between 1 and 10.
+     */
+    constructor(artifactName?: string, artifactFiles?: string[]);
+    get artifactName(): string | undefined;
+    /**
+     * The file paths that you want to export as the output artifact for the action.
+     *
+     * This property can only be used in artifacts for `CommandsAction`.
+     */
+    get artifactFiles(): string[] | undefined;
+    /**
+     * Returns an ArtifactPath for a file within this artifact.
+     * CfnOutput is in the form "<artifact-name>::<file-name>"
+     * @param fileName The name of the file
+     */
+    atPath(fileName: string): ArtifactPath;
+    /**
+     * The artifact attribute for the name of the S3 bucket where the artifact is stored.
+     */
+    get bucketName(): string;
+    /**
+     * The artifact attribute for The name of the .zip file that contains the artifact that is
+     * generated by AWS CodePipeline, such as 1ABCyZZ.zip.
+     */
+    get objectKey(): string;
+    /**
+     * The artifact attribute of the Amazon Simple Storage Service (Amazon S3) URL of the artifact,
+     * such as https://s3-us-west-2.amazonaws.com/artifactstorebucket-yivczw8jma0c/test/TemplateSo/1ABCyZZ.zip.
+     */
+    get url(): string;
+    /**
+     * Returns a token for a value inside a JSON file within this artifact.
+     * @param jsonFile The JSON file name.
+     * @param keyName The hash key.
+     */
+    getParam(jsonFile: string, keyName: string): string;
+    /**
+     * Returns the location of the .zip file in S3 that this Artifact represents.
+     * Used by Lambda's `CfnParametersCode` when being deployed in a CodePipeline.
+     */
+    get s3Location(): s3.Location;
+    /**
+     * Add arbitrary extra payload to the artifact under a given key.
+     * This can be used by CodePipeline actions to communicate data between themselves.
+     * If metadata was already present under the given key,
+     * it will be overwritten with the new value.
+     */
+    setMetadata(key: string, value: any): void;
+    /**
+     * Retrieve the metadata stored in this artifact under the given key.
+     * If there is no metadata stored under the given key,
+     * null will be returned.
+     */
+    getMetadata(key: string): any;
+    toString(): string | undefined;
+    /** @internal */
+    protected _setName(name: string): void;
+}
+/**
+ * A specific file within an output artifact.
+ *
+ * The most common use case for this is specifying the template file
+ * for a CloudFormation action.
+ */
+export declare class ArtifactPath {
+    readonly artifact: Artifact;
+    readonly fileName: string;
+    /** @jsii suppress JSII5019 For historic reasons */
+    static artifactPath(artifactName: string, fileName: string): ArtifactPath;
+    constructor(artifact: Artifact, fileName: string);
+    get location(): string;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/artifact.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.ArtifactPath=exports.Artifact=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var validation=()=>{var tmp=require("./private/validation");return validation=()=>tmp,tmp},core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class Artifact{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.Artifact",version:"2.252.0"};static artifact(name,files){return new Artifact(name,files)}_artifactName;_artifactFiles;metadata={};constructor(artifactName,artifactFiles){if(validation().validateArtifactName(artifactName),artifactFiles!==void 0&&(artifactFiles.length<1||artifactFiles.length>10))throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`MustBeLengthArtifactfilesArray`,`The length of the artifactFiles array must be between 1 and 10, got: ${artifactFiles.length}`);this._artifactName=artifactName,this._artifactFiles=artifactFiles}get artifactName(){return this._artifactName}get artifactFiles(){return this._artifactFiles}atPath(fileName){return new ArtifactPath(this,fileName)}get bucketName(){return artifactAttribute(this,"BucketName")}get objectKey(){return artifactAttribute(this,"ObjectKey")}get url(){return artifactAttribute(this,"URL")}getParam(jsonFile,keyName){return artifactGetParam(this,jsonFile,keyName)}get s3Location(){return{bucketName:this.bucketName,objectKey:this.objectKey}}setMetadata(key,value){this.metadata[key]=value}getMetadata(key){return this.metadata[key]}toString(){return this.artifactName}_setName(name){if(this._artifactName)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`ArtifactAlreadyName`,`Artifact already has name '${this._artifactName}', cannot override it`);this._artifactName=name}}exports.Artifact=Artifact;class ArtifactPath{artifact;fileName;static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.ArtifactPath",version:"2.252.0"};static artifactPath(artifactName,fileName){return new ArtifactPath(Artifact.artifact(artifactName),fileName)}constructor(artifact,fileName){this.artifact=artifact,this.fileName=fileName;try{jsiiDeprecationWarnings().aws_cdk_lib_aws_codepipeline_Artifact(artifact)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,ArtifactPath),error}}get location(){return`${this.artifact.artifactName?this.artifact.artifactName:core_1().Lazy.string({produce:()=>this.artifact.artifactName})}::${this.fileName}`}}exports.ArtifactPath=ArtifactPath;function artifactAttribute(artifact,attributeName){const lazyArtifactName=core_1().Lazy.string({produce:()=>artifact.artifactName});return core_1().Token.asString({"Fn::GetArtifactAtt":[lazyArtifactName,attributeName]})}function artifactGetParam(artifact,jsonFile,keyName){const lazyArtifactName=core_1().Lazy.string({produce:()=>artifact.artifactName});return core_1().Token.asString({"Fn::GetParam":[lazyArtifactName,jsonFile,keyName]})}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/codepipeline-canned-metrics.generated.d.ts

@@ -0,0 +1,9 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class CodePipelineMetrics {
+    static failedPipelineExecutionsSum(this: void, dimensions: {}): MetricWithDims<{}>;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/codepipeline-canned-metrics.generated.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.CodePipelineMetrics=void 0;class CodePipelineMetrics{static failedPipelineExecutionsSum(dimensions){return{namespace:"AWS/CodePipeline",metricName:"FailedPipelineExecutions",dimensionsMap:dimensions,statistic:"Sum"}}}exports.CodePipelineMetrics=CodePipelineMetrics;

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/custom-action-registration.d.ts

@@ -0,0 +1,102 @@
+import { Construct } from 'constructs';
+import type { ActionCategory, ActionArtifactBounds } from './action';
+/**
+ * The creation attributes used for defining a configuration property
+ * of a custom Action.
+ */
+export interface CustomActionProperty {
+    /**
+     * The name of the property.
+     * You use this name in the `configuration` attribute when defining your custom Action class.
+     */
+    readonly name: string;
+    /**
+     * The description of the property.
+     *
+     * @default the description will be empty
+     */
+    readonly description?: string;
+    /**
+     * Whether this property is a key.
+     *
+     * @default false
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-key
+     */
+    readonly key?: boolean;
+    /**
+     * Whether this property is queryable.
+     * Note that only a single property of a custom Action can be queryable.
+     *
+     * @default false
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-queryable
+     */
+    readonly queryable?: boolean;
+    /**
+     * Whether this property is required.
+     */
+    readonly required: boolean;
+    /**
+     * Whether this property is secret,
+     * like a password, or access key.
+     *
+     * @default false
+     */
+    readonly secret?: boolean;
+    /**
+     * The type of the property,
+     * like 'String', 'Number', or 'Boolean'.
+     *
+     * @default 'String'
+     */
+    readonly type?: string;
+}
+/**
+ * Properties of registering a custom Action.
+ */
+export interface CustomActionRegistrationProps {
+    /**
+     * The category of the Action.
+     */
+    readonly category: ActionCategory;
+    /**
+     * The artifact bounds of the Action.
+     */
+    readonly artifactBounds: ActionArtifactBounds;
+    /**
+     * The provider of the Action.
+     * For example, `'MyCustomActionProvider'`
+     */
+    readonly provider: string;
+    /**
+     * The version of your Action.
+     *
+     * @default '1'
+     */
+    readonly version?: string;
+    /**
+     * The URL shown for the entire Action in the Pipeline UI.
+     * @default none
+     */
+    readonly entityUrl?: string;
+    /**
+     * The URL shown for a particular execution of an Action in the Pipeline UI.
+     * @default none
+     */
+    readonly executionUrl?: string;
+    /**
+     * The properties used for customizing the instance of your Action.
+     *
+     * @default []
+     */
+    readonly actionProperties?: CustomActionProperty[];
+}
+/**
+ * The resource representing registering a custom Action with CodePipeline.
+ * For the Action to be usable, it has to be registered for every region and every account it's used in.
+ * In addition to this class, you should most likely also provide your clients a class
+ * representing your custom Action, extending the Action class,
+ * and taking the `actionProperties` as properly typed, construction properties.
+ */
+export declare class CustomActionRegistration extends Construct {
+    constructor(scope: Construct, id: string, props: CustomActionRegistrationProps);
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/custom-action-registration.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.CustomActionRegistration=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var constructs_1=()=>{var tmp=require("constructs");return constructs_1=()=>tmp,tmp},codepipeline_generated_1=()=>{var tmp=require("./codepipeline.generated");return codepipeline_generated_1=()=>tmp,tmp};class CustomActionRegistration extends constructs_1().Construct{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.CustomActionRegistration",version:"2.252.0"};constructor(scope,id,props){super(scope,id);try{jsiiDeprecationWarnings().aws_cdk_lib_aws_codepipeline_CustomActionRegistrationProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,CustomActionRegistration),error}new(codepipeline_generated_1()).CfnCustomActionType(this,"Resource",{category:props.category,inputArtifactDetails:{minimumCount:props.artifactBounds.minInputs,maximumCount:props.artifactBounds.maxInputs},outputArtifactDetails:{minimumCount:props.artifactBounds.minOutputs,maximumCount:props.artifactBounds.maxOutputs},provider:props.provider,version:props.version||"1",settings:{entityUrlTemplate:props.entityUrl,executionUrlTemplate:props.executionUrl},configurationProperties:props.actionProperties?.map(ap=>({key:ap.key||!1,secret:ap.secret||!1,...ap}))})}}exports.CustomActionRegistration=CustomActionRegistration;

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './action';
+export * from './artifact';
+export * from './pipeline';
+export * from './trigger';
+export * from './variable';
+export * from './custom-action-registration';
+export * from './rule';
+export * from './codepipeline.generated';

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/pipeline.d.ts

@@ -0,0 +1,553 @@
+import type { Construct } from 'constructs';
+import type { IAction, IPipeline, IStage, PipelineNotifyOnOptions } from './action';
+import type { PipelineReference } from './codepipeline.generated';
+import { FullActionDescriptor } from './private/full-action-descriptor';
+import { Stage } from './private/stage';
+import type { Rule } from './rule';
+import type { TriggerProps } from './trigger';
+import { Trigger } from './trigger';
+import type { Variable } from './variable';
+import * as notifications from '../../aws-codestarnotifications';
+import * as events from '../../aws-events';
+import * as iam from '../../aws-iam';
+import * as s3 from '../../aws-s3';
+import { Resource, Stack } from '../../core';
+/**
+ * Allows you to control where to place a new Stage when it's added to the Pipeline.
+ * Note that you can provide only one of the below properties -
+ * specifying more than one will result in a validation error.
+ *
+ * @see #rightBefore
+ * @see #justAfter
+ */
+export interface StagePlacement {
+    /**
+     * Inserts the new Stage as a parent of the given Stage
+     * (changing its current parent Stage, if it had one).
+     */
+    readonly rightBefore?: IStage;
+    /**
+     * Inserts the new Stage as a child of the given Stage
+     * (changing its current child Stage, if it had one).
+     */
+    readonly justAfter?: IStage;
+}
+/**
+ * The condition for the stage.
+ *
+ * A condition is made up of the rules and the result for the condition.
+ */
+export interface Condition {
+    /**
+     * The rules that make up the condition.
+     *
+     * @default - No rules are applied
+     */
+    readonly rules?: Rule[];
+    /**
+     * The action to be done when the condition is met.
+     *
+     * @default - No result action is taken
+     */
+    readonly result?: Result;
+}
+/**
+ * The conditions for making checks for the stage.
+ */
+export interface Conditions {
+    /**
+     * The conditions that are configured as entry conditions, making check to succeed the stage, or fail the stage.
+     *
+     * @default - No conditions are configured
+     *
+     * @jsii suppress JSII5019 For historic reasons
+     */
+    readonly conditions?: Condition[];
+}
+/**
+ * The configuration that specifies the result, such as rollback, to occur upon stage failure.
+ */
+export interface FailureConditions extends Conditions {
+    /**
+     * The specified result for when the failure conditions are met, such as rolling back the stage.
+     *
+     * @default FAIL
+     */
+    readonly result?: Result;
+    /**
+     * The method that you want to configure for automatic stage retry on stage failure.
+     *
+     * @default ALL_ACTIONS
+     */
+    readonly retryMode?: RetryMode;
+}
+/**
+ * Construction properties of a Pipeline Stage.
+ */
+export interface StageProps {
+    /**
+     * The physical, human-readable name to assign to this Pipeline Stage.
+     */
+    readonly stageName: string;
+    /**
+     * The list of Actions to create this Stage with.
+     * You can always add more Actions later by calling `IStage#addAction`.
+     */
+    readonly actions?: IAction[];
+    /**
+     * Whether to enable transition to this stage.
+     *
+     * @default true
+     */
+    readonly transitionToEnabled?: boolean;
+    /**
+     * The reason for disabling transition to this stage. Only applicable
+     * if `transitionToEnabled` is set to `false`.
+     *
+     * @default 'Transition disabled'
+     */
+    readonly transitionDisabledReason?: string;
+    /**
+     * The method to use when a stage allows entry.
+     *
+     * @default - No conditions are applied before stage entry
+     */
+    readonly beforeEntry?: Conditions;
+    /**
+     * The method to use when a stage has not completed successfully.
+     *
+     * @default - No failure conditions are applied
+     */
+    readonly onFailure?: FailureConditions;
+    /**
+     * The method to use when a stage has succeeded.
+     *
+     * @default - No success conditions are applied
+     */
+    readonly onSuccess?: Conditions;
+}
+export interface StageOptions extends StageProps {
+    readonly placement?: StagePlacement;
+}
+/**
+ * The action to be done when the condition is met.
+ */
+export declare enum Result {
+    /**
+     * Rollback
+     */
+    ROLLBACK = "ROLLBACK",
+    /**
+     * Failure
+     */
+    FAIL = "FAIL",
+    /**
+     * Retry
+     */
+    RETRY = "RETRY",
+    /**
+     * Skip
+     */
+    SKIP = "SKIP"
+}
+/**
+ * The method that you want to configure for automatic stage retry on stage failure.
+ * You can specify to retry only failed action in the stage or all actions in the stage.
+ */
+export declare enum RetryMode {
+    /**
+     * Retry all actions under this stage
+     */
+    ALL_ACTIONS = "ALL_ACTIONS",
+    /**
+     * Only retry failed actions
+     */
+    FAILED_ACTIONS = "FAILED_ACTIONS"
+}
+/**
+ * Pipeline types.
+ */
+export declare enum PipelineType {
+    /**
+     * V1 type
+     */
+    V1 = "V1",
+    /**
+     * V2 type
+     */
+    V2 = "V2"
+}
+/**
+ * Execution mode.
+ */
+export declare enum ExecutionMode {
+    /**
+     * QUEUED mode.
+     *
+     * Executions are processed one by one in the order that they are queued.
+     *
+     * This requires pipeline type V2.
+     */
+    QUEUED = "QUEUED",
+    /**
+     * SUPERSEDED mode.
+     *
+     * A more recent execution can overtake an older one.
+     *
+     * This is the default.
+     */
+    SUPERSEDED = "SUPERSEDED",
+    /**
+     * PARALLEL mode.
+     *
+     * In PARALLEL mode, executions run simultaneously and independently of one
+     * another. Executions don't wait for other runs to complete before starting
+     * or finishing.
+     *
+     * This requires pipeline type V2.
+     */
+    PARALLEL = "PARALLEL"
+}
+export interface PipelineProps {
+    /**
+     * The S3 bucket used by this Pipeline to store artifacts.
+     *
+     * @default - A new S3 bucket will be created.
+     */
+    readonly artifactBucket?: s3.IBucket;
+    /**
+     * The IAM role to be assumed by this Pipeline.
+     *
+     * @default a new IAM role will be created.
+     */
+    readonly role?: iam.IRole;
+    /**
+     * Indicates whether to rerun the AWS CodePipeline pipeline after you update it.
+     *
+     * @default false
+     */
+    readonly restartExecutionOnUpdate?: boolean;
+    /**
+     * Name of the pipeline.
+     *
+     * @default - AWS CloudFormation generates an ID and uses that for the pipeline name.
+     */
+    readonly pipelineName?: string;
+    /**
+     * 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.
+     */
+    readonly crossRegionReplicationBuckets?: {
+        [region: string]: s3.IBucket;
+    };
+    /**
+     * The list of Stages, in order,
+     * to create this Pipeline with.
+     * You can always add more Stages later by calling `Pipeline#addStage`.
+     *
+     * @default - None.
+     */
+    readonly stages?: StageProps[];
+    /**
+     * Create KMS keys for cross-account deployments.
+     *
+     * This controls whether the pipeline is enabled for cross-account deployments.
+     *
+     * By default cross-account deployments are enabled, but this feature requires
+     * that KMS Customer Master Keys are created which have a cost of $1/month.
+     *
+     * If you do not need cross-account deployments, you can set this to `false` to
+     * not create those keys and save on that cost (the artifact bucket will be
+     * encrypted with an AWS-managed key). However, cross-account deployments will
+     * no longer be possible.
+     *
+     * @default false - false if the feature flag `CODEPIPELINE_CROSS_ACCOUNT_KEYS_DEFAULT_VALUE_TO_FALSE`
+     * is true, true otherwise
+     */
+    readonly crossAccountKeys?: boolean;
+    /**
+     * 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)
+     */
+    readonly enableKeyRotation?: boolean;
+    /**
+     * 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)
+     */
+    readonly reuseCrossRegionSupportStacks?: boolean;
+    /**
+     * Type of the pipeline.
+     *
+     * @default - PipelineType.V2 if the feature flag `CODEPIPELINE_DEFAULT_PIPELINE_TYPE_TO_V2`
+     * is true, PipelineType.V1 otherwise
+     *
+     * @see https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html
+     */
+    readonly pipelineType?: PipelineType;
+    /**
+     * 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
+     */
+    readonly variables?: Variable[];
+    /**
+     * 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
+     */
+    readonly triggers?: TriggerProps[];
+    /**
+     * The method that the pipeline will use to handle multiple executions.
+     *
+     * @default - ExecutionMode.SUPERSEDED
+     */
+    readonly executionMode?: ExecutionMode;
+    /**
+     * Use pipeline service role for actions if no action role configured
+     *
+     * @default - false
+     */
+    readonly usePipelineRoleForActions?: boolean;
+}
+declare abstract class PipelineBase extends Resource implements IPipeline {
+    abstract readonly pipelineName: string;
+    abstract readonly pipelineArn: string;
+    get pipelineRef(): PipelineReference;
+    /**
+     * Defines an event rule triggered by this CodePipeline.
+     *
+     * @param id Identifier for this event handler.
+     * @param options Additional options to pass to the event rule.
+     */
+    onEvent(id: string, options?: events.OnEventOptions): events.Rule;
+    /**
+     * Defines an event rule triggered by the "CodePipeline Pipeline Execution
+     * State Change" event emitted from this pipeline.
+     *
+     * @param id Identifier for this event handler.
+     * @param options Additional options to pass to the event rule.
+     */
+    onStateChange(id: string, options?: events.OnEventOptions): events.Rule;
+    bindAsNotificationRuleSource(_scope: Construct): notifications.NotificationRuleSourceConfig;
+    notifyOn(id: string, target: notifications.INotificationRuleTarget, options: PipelineNotifyOnOptions): notifications.INotificationRule;
+    notifyOnExecutionStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    notifyOnAnyStageStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    notifyOnAnyActionStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+    notifyOnAnyManualApprovalStateChange(id: string, target: notifications.INotificationRuleTarget, options?: notifications.NotificationRuleOptions): notifications.INotificationRule;
+}
+/**
+ * An AWS CodePipeline pipeline with its associated IAM role and S3 bucket.
+ *
+ * @example
+ * // create a pipeline
+ * import * as codecommit from 'aws-cdk-lib/aws-codecommit';
+ *
+ * const pipeline = new codepipeline.Pipeline(this, 'Pipeline');
+ *
+ * // add a stage
+ * const sourceStage = pipeline.addStage({ stageName: 'Source' });
+ *
+ * // add a source action to the stage
+ * declare const repo: codecommit.Repository;
+ * declare const sourceArtifact: codepipeline.Artifact;
+ * sourceStage.addAction(new codepipeline_actions.CodeCommitSourceAction({
+ *   actionName: 'Source',
+ *   output: sourceArtifact,
+ *   repository: repo,
+ * }));
+ *
+ * // ... add more stages
+ */
+export declare class Pipeline extends PipelineBase {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import a pipeline into this app.
+     *
+     * @param scope the scope into which to import this pipeline
+     * @param id the logical ID of the returned pipeline construct
+     * @param pipelineArn The ARN of the pipeline (e.g. `arn:aws:codepipeline:us-east-1:123456789012:MyDemoPipeline`)
+     */
+    static fromPipelineArn(scope: Construct, id: string, pipelineArn: string): IPipeline;
+    /**
+     * The IAM role AWS CodePipeline will use to perform actions or assume roles for actions with
+     * a more specific IAM role.
+     */
+    readonly role: iam.IRole;
+    /**
+     * Bucket used to store output artifacts
+     */
+    readonly artifactBucket: s3.IBucket;
+    private readonly _stages;
+    private readonly crossRegionBucketsPassed;
+    private readonly _crossRegionSupport;
+    private readonly _crossAccountSupport;
+    private readonly crossAccountKeys;
+    private readonly enableKeyRotation?;
+    private readonly reuseCrossRegionSupportStacks;
+    private readonly codePipeline;
+    private readonly pipelineType;
+    private readonly usePipelineRoleForActions;
+    private readonly variables;
+    private readonly triggers;
+    /**
+     * ARN of this pipeline
+     */
+    get pipelineArn(): string;
+    /**
+     * The name of the pipeline
+     */
+    get pipelineName(): string;
+    /**
+     * The version of the pipeline
+     *
+     * @attribute
+     */
+    get pipelineVersion(): string;
+    constructor(scope: Construct, id: string, props?: PipelineProps);
+    /**
+     * Creates a new Stage, and adds it to this Pipeline.
+     *
+     * @param props the creation properties of the new Stage
+     * @returns the newly created Stage
+     */
+    addStage(props: StageOptions): IStage;
+    /**
+     * Adds a statement to the pipeline role.
+     */
+    addToRolePolicy(statement: iam.PolicyStatement): void;
+    /**
+     * Adds a new Variable to this Pipeline.
+     *
+     * @param variable Variable instance to add to this Pipeline
+     * @returns the newly created variable
+     */
+    addVariable(variable: Variable): Variable;
+    /**
+     * Adds a new Trigger to this Pipeline.
+     *
+     * @param props Trigger property to add to this Pipeline
+     * @returns the newly created trigger
+     */
+    addTrigger(props: TriggerProps): Trigger;
+    /**
+     * Get the number of Stages in this Pipeline.
+     */
+    get stageCount(): number;
+    /**
+     * Returns the stages that comprise the pipeline.
+     *
+     * **Note**: the returned array is a defensive copy,
+     * so adding elements to it has no effect.
+     * Instead, use the `addStage` method if you want to add more stages
+     * to the pipeline.
+     */
+    get stages(): IStage[];
+    /**
+     * Access one of the pipeline's stages by stage name
+     */
+    stage(stageName: string): IStage;
+    /**
+     * Returns all of the `CrossRegionSupportStack`s that were generated automatically
+     * when dealing with Actions that reside in a different region than the Pipeline itself.
+     *
+     */
+    get crossRegionSupport(): {
+        [region: string]: CrossRegionSupport;
+    };
+    /** @internal */
+    _attachActionToPipeline(stage: Stage, action: IAction, actionScope: Construct): FullActionDescriptor;
+    /**
+     * Validate the pipeline structure
+     *
+     * Validation happens according to the rules documented at
+     *
+     * https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#pipeline-requirements
+     */
+    private validatePipeline;
+    private ensureReplicationResourcesExistFor;
+    /**
+     * Get or create the cross-region support construct for the given action
+     */
+    private obtainCrossRegionSupportFor;
+    private createSupportResourcesForRegion;
+    private getCrossRegionSupportSynthesizer;
+    private generateNameForDefaultBucketKeyAlias;
+    /**
+     * Gets the role used for this action,
+     * including handling the case when the action is supposed to be cross-account.
+     *
+     * @param stage the stage the action belongs to
+     * @param action the action to return/create a role for
+     * @param actionScope the scope, unique to the action, to create new resources in
+     */
+    private getRoleForAction;
+    private getRoleFromActionPropsOrGenerateIfCrossAccount;
+    /**
+     * Returns the Stack this Action belongs to if this is a cross-account Action.
+     * If this Action is not cross-account (i.e., it lives in the same account as the Pipeline),
+     * it returns undefined.
+     *
+     * @param action the Action to return the Stack for
+     */
+    private getOtherStackIfActionIsCrossAccount;
+    private isAwsOwned;
+    private getArtifactBucketFromProps;
+    private calculateInsertIndexFromPlacement;
+    private findStageIndex;
+    private validateSourceActionLocations;
+    private validateHasStages;
+    private validateStages;
+    private validateArtifacts;
+    private validateVariables;
+    private validateTriggers;
+    private renderArtifactStoresProperty;
+    private renderArtifactStoreProperty;
+    private renderPrimaryArtifactStore;
+    private renderArtifactStore;
+    private get crossRegion();
+    private renderStages;
+    private renderDisabledTransitions;
+    private renderVariables;
+    private renderTriggers;
+    private requireRegion;
+    private supportScope;
+}
+/**
+ * An interface representing resources generated in order to support
+ * the cross-region capabilities of CodePipeline.
+ * You get instances of this interface from the `Pipeline#crossRegionSupport` property.
+ *
+ */
+export interface CrossRegionSupport {
+    /**
+     * The Stack that has been created to house the replication Bucket
+     * required for this  region.
+     */
+    readonly stack: Stack;
+    /**
+     * The replication Bucket used by CodePipeline to operate in this region.
+     * Belongs to `stack`.
+     */
+    readonly replicationBucket: s3.IBucket;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/cross-region-support-stack.d.ts

@@ -0,0 +1,73 @@
+import { Construct } from 'constructs';
+import * as s3 from '../../../aws-s3';
+import * as cdk from '../../../core';
+/**
+ * Props for the support stack
+ */
+export interface CrossRegionSupportConstructProps {
+    /**
+     * Whether to create the KMS CMK
+     *
+     * (Required for cross-account deployments)
+     *
+     * @default true
+     */
+    readonly createKmsKey?: boolean;
+    /**
+     * Enables KMS key rotation for cross-account keys.
+     *
+     * @default - false (key rotation is disabled)
+     */
+    readonly enableKeyRotation?: boolean;
+}
+export declare class CrossRegionSupportConstruct extends Construct {
+    readonly replicationBucket: s3.IBucket;
+    constructor(scope: Construct, id: string, props?: CrossRegionSupportConstructProps);
+}
+/**
+ * Construction properties for `CrossRegionSupportStack`.
+ * This interface is private to the aws-codepipeline package.
+ */
+export interface CrossRegionSupportStackProps {
+    /**
+     * The name of the Stack the Pipeline itself belongs to.
+     * Used to generate a more friendly name for the support Stack.
+     */
+    readonly pipelineStackName: string;
+    /**
+     * The AWS region this Stack resides in.
+     */
+    readonly region: string;
+    /**
+     * The AWS account ID this Stack belongs to.
+     *
+     * @example '012345678901'
+     */
+    readonly account: string;
+    readonly synthesizer: cdk.IStackSynthesizer | undefined;
+    /**
+     * Whether or not to create a KMS key in the support stack
+     *
+     * (Required for cross-account deployments)
+     *
+     * @default true
+     */
+    readonly createKmsKey?: boolean;
+    /**
+     * Enables KMS key rotation for cross-account keys.
+     *
+     * @default - false (key rotation is disabled)
+     */
+    readonly enableKeyRotation?: boolean;
+}
+/**
+ * A Stack containing resources required for the cross-region CodePipeline functionality to work.
+ * This class is private to the aws-codepipeline package.
+ */
+export declare class CrossRegionSupportStack extends cdk.Stack {
+    /**
+     * The name of the S3 Bucket used for replicating the Pipeline's artifacts into the region.
+     */
+    readonly replicationBucket: s3.IBucket;
+    constructor(scope: Construct, id: string, props: CrossRegionSupportStackProps);
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/full-action-descriptor.d.ts

@@ -0,0 +1,33 @@
+import type * as iam from '../../../aws-iam';
+import type { Duration } from '../../../core';
+import type { ActionArtifactBounds, ActionCategory, ActionConfig, IAction } from '../action';
+import type { Artifact } from '../artifact';
+export interface FullActionDescriptorProps {
+    readonly action: IAction;
+    readonly actionConfig: ActionConfig;
+    readonly actionRole: iam.IRole | undefined;
+    readonly actionRegion: string | undefined;
+}
+/**
+ * This class is private to the aws-codepipeline package.
+ */
+export declare class FullActionDescriptor {
+    readonly action: IAction;
+    readonly actionName: string;
+    readonly category: ActionCategory;
+    readonly owner: string;
+    readonly provider: string;
+    readonly version: string;
+    readonly runOrder: number;
+    readonly artifactBounds: ActionArtifactBounds;
+    readonly namespace?: string;
+    readonly inputs: Artifact[];
+    readonly outputs: Artifact[];
+    readonly region?: string;
+    readonly role?: iam.IRole;
+    readonly configuration: any;
+    readonly commands?: string[];
+    readonly outputVariables?: string[];
+    readonly timeout?: Duration;
+    constructor(props: FullActionDescriptorProps);
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/full-action-descriptor.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.FullActionDescriptor=void 0;class FullActionDescriptor{action;actionName;category;owner;provider;version;runOrder;artifactBounds;namespace;inputs;outputs;region;role;configuration;commands;outputVariables;timeout;constructor(props){this.action=props.action;const actionProperties=props.action.actionProperties;this.actionName=actionProperties.actionName,this.category=actionProperties.category,this.owner=actionProperties.owner||"AWS",this.provider=actionProperties.provider,this.version=actionProperties.version||"1",this.runOrder=actionProperties.runOrder??1,this.artifactBounds=actionProperties.artifactBounds,this.namespace=actionProperties.variablesNamespace,this.inputs=deduplicateArtifacts(actionProperties.inputs),this.outputs=deduplicateArtifacts(actionProperties.outputs),this.region=props.actionRegion||actionProperties.region,this.role=actionProperties.role??props.actionRole,this.configuration=props.actionConfig.configuration,this.commands=actionProperties.commands,this.outputVariables=actionProperties.outputVariables,this.timeout=actionProperties.timeout}}exports.FullActionDescriptor=FullActionDescriptor;function deduplicateArtifacts(artifacts){const ret=new Array;for(const artifact of artifacts||[]){if(artifact.artifactName){if(ret.find(a=>a.artifactName===artifact.artifactName))continue}else if(ret.find(a=>a===artifact))continue;ret.push(artifact)}return ret}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/rich-action.d.ts

@@ -0,0 +1,46 @@
+import type { Construct } from 'constructs';
+import type * as events from '../../../aws-events';
+import { Stack } from '../../../core';
+import type { IPipelineRef } from '../../../interfaces/generated/aws-codepipeline-interfaces.generated';
+import type { ActionBindOptions, ActionConfig, ActionProperties, IAction, IStage } from '../action';
+/**
+ * Helper routines to work with Actions
+ *
+ * Can't put these on Action themselves since we only have an interface
+ * and every library would need to reimplement everything (there is no
+ * `ActionBase`).
+ *
+ * So here go the members that should have gone onto the Action class
+ * but can't.
+ *
+ * It was probably my own idea but I don't want it anymore:
+ * https://github.com/aws/aws-cdk/issues/10393
+ */
+export declare class RichAction implements IAction {
+    private readonly action;
+    private readonly pipeline;
+    readonly actionProperties: ActionProperties;
+    constructor(action: IAction, pipeline: IPipelineRef);
+    bind(scope: Construct, stage: IStage, options: ActionBindOptions): ActionConfig;
+    onStateChange(name: string, target?: events.IRuleTarget, options?: events.RuleProps): events.Rule;
+    get isCrossRegion(): boolean;
+    get isCrossAccount(): boolean;
+    /**
+     * Returns the Stack of the resource backing this action
+     * if they belong to the same environment.
+     * Returns `undefined` if either this action is not backed by a resource,
+     * or if the resource does not belong to the same env as its Stack
+     * (which can happen for imported resources).
+     */
+    get resourceStack(): Stack | undefined;
+    /**
+     * The region this action wants to execute in.
+     * `undefined` means it wants to execute in the same region as the pipeline.
+     */
+    get effectiveRegion(): string | undefined;
+    /**
+     * The account this action wants to execute in.
+     * `undefined` means it wants to execute in the same account as the pipeline.
+     */
+    get effectiveAccount(): string | undefined;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/rich-action.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.RichAction=void 0;var core_1=()=>{var tmp=require("../../../core");return core_1=()=>tmp,tmp};class RichAction{action;pipeline;actionProperties;constructor(action,pipeline){this.action=action,this.pipeline=pipeline,this.actionProperties=action.actionProperties}bind(scope,stage,options){return this.action.bind(scope,stage,options)}onStateChange(name,target,options){return this.action.onStateChange(name,target,options)}get isCrossRegion(){return!actionDimensionSameAsPipelineDimension(this.effectiveRegion,this.pipeline.env.region)}get isCrossAccount(){return!actionDimensionSameAsPipelineDimension(this.effectiveAccount,this.pipeline.env.account)}get resourceStack(){const actionResource=this.actionProperties.resource;if(!actionResource)return;const actionResourceStack=core_1().Stack.of(actionResource),actionResourceStackEnv={region:actionResourceStack.region,account:actionResourceStack.account};return sameEnv(actionResource.env,actionResourceStackEnv)?actionResourceStack:void 0}get effectiveRegion(){return this.action.actionProperties.resource?.env.region??this.action.actionProperties.region}get effectiveAccount(){return this.action.actionProperties.role?.env.account??this.action.actionProperties?.resource?.env.account??this.action.actionProperties.account}}exports.RichAction=RichAction;function actionDimensionSameAsPipelineDimension(actionDim,pipelineDim){return!actionDim||core_1().Token.isUnresolved(actionDim)?!0:core_1().Token.compareStrings(actionDim,pipelineDim)===core_1().TokenComparison.SAME}function sameEnv(env1,env2){return sameEnvDimension(env1.region,env2.region)&&sameEnvDimension(env1.account,env2.account)}function sameEnvDimension(dim1,dim2){return[core_1().TokenComparison.SAME,core_1().TokenComparison.BOTH_UNRESOLVED].includes(core_1().Token.compareStrings(dim1,dim2))}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/stage.d.ts

@@ -0,0 +1,51 @@
+import type { FullActionDescriptor } from './full-action-descriptor';
+import * as events from '../../../aws-events';
+import type { IAction, IPipeline, IStage } from '../action';
+import type { CfnPipeline } from '../codepipeline.generated';
+import type { Pipeline, StageProps } from '../pipeline';
+/**
+ * A Stage in a Pipeline.
+ *
+ * Stages are added to a Pipeline by calling `Pipeline#addStage`,
+ * which returns an instance of `codepipeline.IStage`.
+ *
+ * This class is private to the CodePipeline module.
+ */
+export declare class Stage implements IStage {
+    /**
+     * The Pipeline this Stage is a part of.
+     */
+    readonly stageName: string;
+    readonly transitionToEnabled: boolean;
+    readonly transitionDisabledReason: string;
+    private readonly beforeEntry?;
+    private readonly onSuccess?;
+    private readonly onFailure?;
+    private readonly scope;
+    private readonly _pipeline;
+    private readonly _actions;
+    /**
+     * Create a new Stage.
+     */
+    constructor(props: StageProps, pipeline: Pipeline);
+    /**
+     * Get a duplicate of this stage's list of actions.
+     */
+    get actionDescriptors(): FullActionDescriptor[];
+    get actions(): IAction[];
+    get pipeline(): IPipeline;
+    render(): CfnPipeline.StageDeclarationProperty;
+    addAction(action: IAction): void;
+    onStateChange(name: string, target?: events.IRuleTarget, options?: events.RuleProps): events.Rule;
+    validate(): string[];
+    private validateHasActions;
+    private validateActions;
+    private validateAction;
+    private attachActionToPipeline;
+    private renderAction;
+    private renderArtifacts;
+    private renderBeforeEntry;
+    private renderOnSuccess;
+    private renderOnFailure;
+    private getConditions;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/private/validation.d.ts

@@ -0,0 +1,22 @@
+import type { Construct } from 'constructs';
+import type { Artifact } from '../artifact';
+import type { GitConfiguration } from '../trigger';
+/**
+ * Validation function that checks if the number of artifacts is within the given bounds
+ */
+export declare function validateArtifactBounds(type: string, artifacts: Artifact[], min: number, max: number, category: string, provider: string): string[];
+/**
+ * Validation function that guarantees that an action is or is not a source action. This is useful because Source actions can only be
+ * in the first stage of a pipeline, and the first stage can only contain source actions.
+ */
+export declare function validateSourceAction(mustBeSource: boolean, category: string, actionName: string, stageName: string): string[];
+/**
+ * Validate the given name of a pipeline component. Pipeline component names all have the same restrictions.
+ * This can be used to validate the name of all components of a pipeline.
+ */
+export declare function validateName(scope: Construct, thing: string, name: string | undefined): void;
+export declare function validateArtifactName(artifactName: string | undefined): void;
+export declare function validateNamespaceName(scope: Construct, namespaceName: string | undefined): void;
+export declare function validatePipelineVariableName(variableName: string | undefined): void;
+export declare function validateRuleName(ruleName: string | undefined): void;
+export declare function validateTriggers(gitConfiguration: GitConfiguration): void;

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/rule.d.ts

@@ -0,0 +1,102 @@
+import type { CfnPipeline } from './codepipeline.generated';
+import type * as iam from '../../aws-iam';
+/**
+ * Properties for defining a CodePipeline Rule
+ */
+export interface RuleProps {
+    /**
+     * The shell commands to run with your commands rule in CodePipeline.
+     *
+     * All commands are supported except multi-line formats. While CodeBuild logs and permissions are used,
+     * you do not need to create any resources in CodeBuild.
+     *
+     * @remarks Using compute time for this action will incur separate charges in AWS CodeBuild.
+     * @default - No commands
+     */
+    readonly commands?: string[];
+    /**
+     * The action configuration fields for the rule.
+     * This can include custom parameters specific to the rule type.
+     *
+     * @default - No configuration
+     */
+    readonly configuration?: object;
+    /**
+     * The input artifacts fields for the rule, such as specifying an input file for the rule.
+     * Each string in the array represents an artifact name that this rule will use as input.
+     *
+     * @default - No input artifacts
+     */
+    readonly inputArtifacts?: string[];
+    /**
+     * The name of the rule that is created for the condition.
+     * Must be unique within the pipeline.
+     *
+     * @example 'VariableCheck'
+     * @default - A unique name will be generated
+     */
+    readonly name?: string;
+    /**
+     * The AWS Region for the condition associated with the rule.
+     * If not specified, uses the pipeline's region.
+     *
+     * @default - Pipeline's region
+     */
+    readonly region?: string;
+    /**
+     * The IAM role that the rule will use to execute its actions.
+     * The role must have sufficient permissions to perform the rule's tasks.
+     *
+     * @default - A new role will be created
+     */
+    readonly role?: iam.Role;
+    /**
+     * The rule provider that implements the rule's functionality.
+     *
+     * @example 'DeploymentWindow'
+     * @see AWS CodePipeline rule reference for available providers
+     * @default - No provider, must be specified if rule is used
+     */
+    readonly provider?: string;
+    /**
+     * The version of the rule to use.
+     * Different versions may have different features or behaviors.
+     *
+     * @default '1'
+     */
+    readonly version?: string;
+}
+/**
+ * Represents a rule in AWS CodePipeline that can be used to add conditions
+ * and controls to pipeline execution.
+ */
+export declare class Rule {
+    /**
+     * The name of the rule, if specified in the properties
+     */
+    readonly ruleName?: string;
+    private readonly _props;
+    /**
+     * Creates a new Rule instance.
+     * @param props - Configuration properties for the rule
+     * @throws {Error} If the rule name is invalid
+     */
+    constructor(props: RuleProps);
+    /**
+     * Validates the rule configuration
+     * @private
+     * @throws {Error} If validation fails
+     */
+    private validate;
+    /**
+     * Returns a reference to the rule that can be used in pipeline stage conditions
+     * @returns A string in the format "#{rule.ruleName}" that can be used to reference this rule
+     */
+    reference(): string;
+    /**
+     * Renders the rule configuration into a CloudFormation property
+     * @internal
+     * @returns The rule declaration property for CloudFormation
+     */
+    _render(): CfnPipeline.RuleDeclarationProperty;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/rule.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Rule=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var validation_1=()=>{var tmp=require("./private/validation");return validation_1=()=>tmp,tmp};class Rule{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.Rule",version:"2.252.0"};ruleName;_props;constructor(props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_codepipeline_RuleProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Rule),error}this.ruleName=props.name,this._props=props,this.validate()}validate(){(0,validation_1().validateRuleName)(this.ruleName)}reference(){return`#{rule.${this.ruleName}}`}_render(){return{name:this.ruleName,region:this._props.region,roleArn:this._props.role?.roleArn,configuration:this._props.configuration,inputArtifacts:this._props.inputArtifacts?.map(artifact=>({name:artifact})),commands:this._props.commands,ruleTypeId:{provider:this._props.provider,version:this._props.version,category:"Rule",owner:"AWS"}}}}exports.Rule=Rule;

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/trigger.d.ts

@@ -0,0 +1,199 @@
+import type { IAction } from './action';
+import type { CfnPipeline } from './codepipeline.generated';
+/**
+ * Git push filter for trigger.
+ */
+export interface GitPushFilter extends GitFilter {
+    /**
+     * 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.
+     */
+    readonly tagsExcludes?: string[];
+    /**
+     * 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.
+     */
+    readonly tagsIncludes?: string[];
+}
+/**
+ * Git pull request filter for trigger.
+ */
+export interface GitPullRequestFilter extends GitFilter {
+    /**
+     * The field that specifies which pull request events to filter on (opened, updated, closed)
+     * for the trigger configuration.
+     *
+     * @default - all events.
+     */
+    readonly events?: GitPullRequestEvent[];
+}
+/**
+ * Git filter of branches and files for trigger branches and files.
+ */
+interface GitFilter {
+    /**
+     * The list of patterns of Git branches that, when pull request events occurs, are
+     * to be excluded from starting the pipeline.
+     *
+     * You can filter with glob patterns. The `branchesExcludes` takes priority
+     * over the `branchesIncludes`.
+     *
+     * Maximum length of this array is 8.
+     *
+     * @default - no branches.
+     */
+    readonly branchesExcludes?: string[];
+    /**
+     * The list of patterns of Git branches that, when pull request events occurs, are
+     * to be included as criteria that starts the pipeline.
+     *
+     * You can filter with glob patterns. The `branchesExcludes` takes priority
+     * over the `branchesIncludes`.
+     *
+     * Maximum length of this array is 8.
+     *
+     * @default - no branches.
+     */
+    readonly branchesIncludes?: string[];
+    /**
+     * The list of patterns of Git repository file paths that, when pull request events occurs,
+     * are to be excluded from starting the pipeline.
+     *
+     * You can filter with glob patterns. The `filePathsExcludes` takes priority
+     * over the `filePathsIncludes`.
+     *
+     * Maximum length of this array is 8.
+     *
+     * @default - no filePaths.
+     */
+    readonly filePathsExcludes?: string[];
+    /**
+     * The list of patterns of Git repository file paths that, when pull request events occurs,
+     * are to be included as criteria that starts the pipeline.
+     *
+     * You can filter with glob patterns. The `filePathsExcludes` takes priority
+     * over the `filePathsIncludes`.
+     *
+     * Maximum length of this array is 8.
+     *
+     * @default - no filePaths.
+     */
+    readonly filePathsIncludes?: string[];
+}
+/**
+ * Event for trigger with pull request filter.
+ */
+export declare enum GitPullRequestEvent {
+    /**
+     * OPEN
+     */
+    OPEN = "OPEN",
+    /**
+     * UPDATED
+     */
+    UPDATED = "UPDATED",
+    /**
+     * CLOSED
+     */
+    CLOSED = "CLOSED"
+}
+/**
+ * Git configuration for trigger.
+ */
+export interface GitConfiguration {
+    /**
+     * 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.
+     */
+    readonly sourceAction: IAction;
+    /**
+     * The field where the repository event that will start the pipeline,
+     * such as pushing Git tags, is specified with details.
+     *
+     * Git tags, file paths and branches are supported event type.
+     *
+     * The length must be less than or equal to 3.
+     *
+     * @default - no filter.
+     */
+    readonly pushFilter?: GitPushFilter[];
+    /**
+     * The field where the repository event that will start the pipeline
+     * is specified as pull requests.
+     *
+     * The length must be less than or equal to 3.
+     *
+     * @default - no filter.
+     */
+    readonly pullRequestFilter?: GitPullRequestFilter[];
+}
+/**
+ * Provider type for trigger.
+ */
+export declare enum ProviderType {
+    /**
+     * CodeStarSourceConnection
+     */
+    CODE_STAR_SOURCE_CONNECTION = "CodeStarSourceConnection"
+}
+/**
+ * Properties of trigger.
+ */
+export interface TriggerProps {
+    /**
+     * The source provider for the event, such as connections configured
+     * for a repository with Git tags, for the specified trigger configuration.
+     */
+    readonly providerType: ProviderType;
+    /**
+     * Provides the filter criteria and the source stage for the repository
+     * event that starts the pipeline, such as Git tags.
+     *
+     * @default - no configuration.
+     */
+    readonly gitConfiguration?: GitConfiguration;
+}
+/**
+ * Trigger.
+ */
+export declare class Trigger {
+    private readonly props;
+    /**
+     * The pipeline source action where the trigger configuration.
+     */
+    readonly sourceAction: IAction | undefined;
+    constructor(props: TriggerProps);
+    private validate;
+    /**
+     * Render to CloudFormation property.
+     *
+     * @internal
+     */
+    _render(): CfnPipeline.PipelineTriggerDeclarationProperty;
+    private renderPushFilter;
+    private renderPullRequestFilter;
+    private getBranchFilterProperty;
+    private getFilePathsFilterProperty;
+    private getTagsFilterProperty;
+    private getEventsFilterProperty;
+}
+export {};

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/trigger.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Trigger=exports.ProviderType=exports.GitPullRequestEvent=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var validation_1=()=>{var tmp=require("./private/validation");return validation_1=()=>tmp,tmp},GitPullRequestEvent;(function(GitPullRequestEvent2){GitPullRequestEvent2.OPEN="OPEN",GitPullRequestEvent2.UPDATED="UPDATED",GitPullRequestEvent2.CLOSED="CLOSED"})(GitPullRequestEvent||(exports.GitPullRequestEvent=GitPullRequestEvent={}));var ProviderType;(function(ProviderType2){ProviderType2.CODE_STAR_SOURCE_CONNECTION="CodeStarSourceConnection"})(ProviderType||(exports.ProviderType=ProviderType={}));class Trigger{props;static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.Trigger",version:"2.252.0"};sourceAction;constructor(props){this.props=props;try{jsiiDeprecationWarnings().aws_cdk_lib_aws_codepipeline_TriggerProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Trigger),error}this.sourceAction=props.gitConfiguration?.sourceAction,this.validate()}validate(){this.props.gitConfiguration&&(0,validation_1().validateTriggers)(this.props.gitConfiguration)}_render(){let gitConfiguration;if(this.props.gitConfiguration){const{sourceAction,pushFilter,pullRequestFilter}=this.props.gitConfiguration,push=this.renderPushFilter(pushFilter),pullRequest=this.renderPullRequestFilter(pullRequestFilter);gitConfiguration={push:push?.length?push:void 0,pullRequest:pullRequest?.length?pullRequest:void 0,sourceActionName:sourceAction.actionProperties.actionName}}return{gitConfiguration,providerType:this.props.providerType}}renderPushFilter(pushFilter){return pushFilter?.map(filter=>{const branches=this.getBranchFilterProperty(filter),filePaths=this.getFilePathsFilterProperty(filter),tags=this.getTagsFilterProperty(filter);return{branches,filePaths,tags}})}renderPullRequestFilter(pullRequest){return pullRequest?.map(filter=>{const branches=this.getBranchFilterProperty(filter),filePaths=this.getFilePathsFilterProperty(filter),events=this.getEventsFilterProperty(filter);return{branches,filePaths,events}})}getBranchFilterProperty(filter){return filter.branchesExcludes?.length||filter.branchesIncludes?.length?{excludes:filter.branchesExcludes?.length?filter.branchesExcludes:void 0,includes:filter.branchesIncludes?.length?filter.branchesIncludes:void 0}:void 0}getFilePathsFilterProperty(filter){return filter.filePathsExcludes?.length||filter.filePathsIncludes?.length?{excludes:filter.filePathsExcludes?.length?filter.filePathsExcludes:void 0,includes:filter.filePathsIncludes?.length?filter.filePathsIncludes:void 0}:void 0}getTagsFilterProperty(filter){return filter.tagsExcludes?.length||filter.tagsIncludes?.length?{excludes:filter.tagsExcludes?.length?filter.tagsExcludes:void 0,includes:filter.tagsIncludes?.length?filter.tagsIncludes:void 0}:void 0}getEventsFilterProperty(filter){return filter.events?.length?Array.from(new Set(filter.events)):[GitPullRequestEvent.OPEN,GitPullRequestEvent.UPDATED,GitPullRequestEvent.CLOSED]}}exports.Trigger=Trigger;

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/variable.d.ts

@@ -0,0 +1,48 @@
+import type { CfnPipeline } from './codepipeline.generated';
+/**
+ * Properties of pipeline-level variable.
+ */
+export interface VariableProps {
+    /**
+     * The name of a pipeline-level variable.
+     */
+    readonly variableName: string;
+    /**
+     * 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.
+     */
+    readonly description?: string;
+    /**
+     * The default value of a pipeline-level variable.
+     *
+     * @default - No default value.
+     */
+    readonly defaultValue?: string;
+}
+/**
+ * Pipeline-Level variable.
+ */
+export declare class Variable {
+    /**
+     * The name of a pipeline-level variable.
+     */
+    readonly variableName: string;
+    private readonly description?;
+    private readonly defaultValue?;
+    constructor(props: VariableProps);
+    private validate;
+    /**
+     * Reference the variable name at Pipeline actions.
+     *
+     * @returns The variable name in a format that can be referenced at Pipeline actions
+     */
+    reference(): string;
+    /**
+     * Render to CloudFormation property.
+     *
+     * @internal
+     */
+    _render(): CfnPipeline.VariableDeclarationProperty;
+}

cdk/node_modules/aws-cdk-lib/aws-codepipeline/lib/variable.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.Variable=void 0;var jsiiDeprecationWarnings=()=>{var tmp=require("../../.warnings.jsii.js");return jsiiDeprecationWarnings=()=>tmp,tmp};const JSII_RTTI_SYMBOL_1=Symbol.for("jsii.rtti");var validation_1=()=>{var tmp=require("./private/validation");return validation_1=()=>tmp,tmp},core_1=()=>{var tmp=require("../../core");return core_1=()=>tmp,tmp},literal_string_1=()=>{var tmp=require("../../core/lib/private/literal-string");return literal_string_1=()=>tmp,tmp};class Variable{static[JSII_RTTI_SYMBOL_1]={fqn:"aws-cdk-lib.aws_codepipeline.Variable",version:"2.252.0"};variableName;description;defaultValue;constructor(props){try{jsiiDeprecationWarnings().aws_cdk_lib_aws_codepipeline_VariableProps(props)}catch(error){throw process.env.JSII_DEBUG!=="1"&&error.name==="DeprecationError"&&Error.captureStackTrace(error,Variable),error}this.variableName=props.variableName,this.description=props.description,this.defaultValue=props.defaultValue,this.validate()}validate(){if((0,validation_1().validatePipelineVariableName)(this.variableName),this.defaultValue!==void 0&&!core_1().Token.isUnresolved(this.defaultValue)&&(this.defaultValue.length<1||this.defaultValue.length>1e3))throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`MustBeDefaultValueVariable`,`Default value for variable '${this.variableName}' must be between 1 and 1000 characters long, got ${this.defaultValue.length}`);if(this.description!==void 0&&!core_1().Token.isUnresolved(this.description)&&this.description.length>200)throw new(core_1()).UnscopedValidationError((0,literal_string_1().lit)`DescriptionVariableGreaterThan`,`Description for variable '${this.variableName}' must not be greater than 200 characters long, got ${this.description.length}`)}reference(){return`#{variables.${this.variableName}}`}_render(){return{defaultValue:this.defaultValue,description:this.description,name:this.variableName}}}exports.Variable=Variable;