agent-claw: automated task changes

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;