aws-cdk-lib 2.178.1__py3-none-any.whl → 2.179.0__py3-none-any.whl

aws_cdk/aws_codebuild/__init__.py

@@ -497,6 +497,29 @@ codebuild.Project(self, "Project",
 )
 ```
 
+### Attribute-based compute
+
+You can use [attribute-based compute](https://docs.aws.amazon.com/codebuild/latest/userguide/fleets.html#fleets.attribute-compute) for your fleet by setting the `computeType` to `ATTRIBUTE_BASED`.
+This allows you to specify the attributes in `computeConfiguration` such as vCPUs, memory, disk space, and the machineType.
+After specifying some or all of the available attributes, CodeBuild will select the cheapest compute type from available instance types as that at least matches all given criteria.
+
+```python
+from aws_cdk import Size
+
+
+fleet = codebuild.Fleet(self, "MyFleet",
+    base_capacity=1,
+    compute_type=codebuild.FleetComputeType.ATTRIBUTE_BASED,
+    environment_type=codebuild.EnvironmentType.LINUX_CONTAINER,
+    compute_configuration=codebuild.ComputeConfiguration(
+        v_cpu=2,
+        memory=Size.gibibytes(4),
+        disk=Size.gibibytes(10),
+        machine_type=codebuild.MachineType.GENERAL
+    )
+)
+```
+
 ## Logs
 
 CodeBuild lets you specify an S3 Bucket, CloudWatch Log Group or both to receive logs from your projects.
@@ -1049,6 +1072,7 @@ from .. import (
     RemovalPolicy as _RemovalPolicy_9f93c814,
     Resource as _Resource_45bc6135,
     SecretValue as _SecretValue_3dd0ddae,
+    Size as _Size_7b441c34,
     SymlinkFollowMode as _SymlinkFollowMode_047ec1f6,
     TagManager as _TagManager_0a598cb3,
     TreeInspector as _TreeInspector_488e0dd5,
@@ -8799,6 +8823,122 @@ class CommonProjectProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codebuild.ComputeConfiguration",
+    jsii_struct_bases=[],
+    name_mapping={
+        "disk": "disk",
+        "machine_type": "machineType",
+        "memory": "memory",
+        "v_cpu": "vCpu",
+    },
+)
+class ComputeConfiguration:
+    def __init__(
+        self,
+        *,
+        disk: typing.Optional[_Size_7b441c34] = None,
+        machine_type: typing.Optional["MachineType"] = None,
+        memory: typing.Optional[_Size_7b441c34] = None,
+        v_cpu: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''The compute configuration for the fleet.
+
+        Despite what the CloudFormation schema says, the numeric properties (disk, memory, vCpu) are not optional.
+        An ``undefined`` value will cause the CloudFormation deployment to fail, e.g.
+        .. epigraph::
+
+           Cannot invoke "java.lang.Integer.intValue()" because the return value of "software.amazon.codebuild.fleet.ComputeConfiguration.getMemory()" is null
+           Therefore, these properties default value is set to 0.
+
+        :param disk: The amount of disk space of the instance type included in your fleet. Default: - No requirement, the actual value will be based on the other selected configuration properties
+        :param machine_type: The machine type of the instance type included in your fleet. Default: - No requirement, the actual value will be based on the other selected configuration properties
+        :param memory: The amount of memory of the instance type included in your fleet. Default: - No requirement, the actual value will be based on the other selected configuration properties
+        :param v_cpu: The number of vCPUs of the instance type included in your fleet. Default: - No requirement, the actual value will be based on the other selected configuration properties
+
+        :exampleMetadata: infused
+
+        Example::
+
+            from aws_cdk import Size
+            
+            
+            fleet = codebuild.Fleet(self, "MyFleet",
+                base_capacity=1,
+                compute_type=codebuild.FleetComputeType.ATTRIBUTE_BASED,
+                environment_type=codebuild.EnvironmentType.LINUX_CONTAINER,
+                compute_configuration=codebuild.ComputeConfiguration(
+                    v_cpu=2,
+                    memory=Size.gibibytes(4),
+                    disk=Size.gibibytes(10),
+                    machine_type=codebuild.MachineType.GENERAL
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__b104977b55c72c0577553444ac08838cdefde5acef91d6c00ad996d1c464b61b)
+            check_type(argname="argument disk", value=disk, expected_type=type_hints["disk"])
+            check_type(argname="argument machine_type", value=machine_type, expected_type=type_hints["machine_type"])
+            check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
+            check_type(argname="argument v_cpu", value=v_cpu, expected_type=type_hints["v_cpu"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if disk is not None:
+            self._values["disk"] = disk
+        if machine_type is not None:
+            self._values["machine_type"] = machine_type
+        if memory is not None:
+            self._values["memory"] = memory
+        if v_cpu is not None:
+            self._values["v_cpu"] = v_cpu
+
+    @builtins.property
+    def disk(self) -> typing.Optional[_Size_7b441c34]:
+        '''The amount of disk space of the instance type included in your fleet.
+
+        :default: - No requirement, the actual value will be based on the other selected configuration properties
+        '''
+        result = self._values.get("disk")
+        return typing.cast(typing.Optional[_Size_7b441c34], result)
+
+    @builtins.property
+    def machine_type(self) -> typing.Optional["MachineType"]:
+        '''The machine type of the instance type included in your fleet.
+
+        :default: - No requirement, the actual value will be based on the other selected configuration properties
+        '''
+        result = self._values.get("machine_type")
+        return typing.cast(typing.Optional["MachineType"], result)
+
+    @builtins.property
+    def memory(self) -> typing.Optional[_Size_7b441c34]:
+        '''The amount of memory of the instance type included in your fleet.
+
+        :default: - No requirement, the actual value will be based on the other selected configuration properties
+        '''
+        result = self._values.get("memory")
+        return typing.cast(typing.Optional[_Size_7b441c34], result)
+
+    @builtins.property
+    def v_cpu(self) -> typing.Optional[jsii.Number]:
+        '''The number of vCPUs of the instance type included in your fleet.
+
+        :default: - No requirement, the actual value will be based on the other selected configuration properties
+        '''
+        result = self._values.get("v_cpu")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ComputeConfiguration(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_codebuild.ComputeType")
 class ComputeType(enum.Enum):
     '''Build machine compute type.
@@ -8868,6 +9008,7 @@ class ComputeType(enum.Enum):
     LAMBDA_4GB = "LAMBDA_4GB"
     LAMBDA_8GB = "LAMBDA_8GB"
     LAMBDA_10GB = "LAMBDA_10GB"
+    ATTRIBUTE_BASED = "ATTRIBUTE_BASED"
 
 
 @jsii.data_type(
@@ -9559,6 +9700,13 @@ class FleetComputeType(enum.Enum):
     {@link https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types docs}
     for more information.
     '''
+    ATTRIBUTE_BASED = "ATTRIBUTE_BASED"
+    '''Specify the amount of vCPUs, memory, disk space, and the type of machine.
+
+    AWS CodeBuild will select the cheapest instance that satisfies your specified attributes from ``computeConfiguration``.
+
+    :see: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types
+    '''
 
 
 @jsii.data_type(
@@ -9568,6 +9716,7 @@ class FleetComputeType(enum.Enum):
         "base_capacity": "baseCapacity",
         "compute_type": "computeType",
         "environment_type": "environmentType",
+        "compute_configuration": "computeConfiguration",
         "fleet_name": "fleetName",
     },
 )
@@ -9578,6 +9727,7 @@ class FleetProps:
         base_capacity: jsii.Number,
         compute_type: FleetComputeType,
         environment_type: EnvironmentType,
+        compute_configuration: typing.Optional[typing.Union[ComputeConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
         fleet_name: typing.Optional[builtins.str] = None,
     ) -> None:
         '''Construction properties of a CodeBuild {@link Fleet}.
@@ -9585,6 +9735,7 @@ class FleetProps:
         :param base_capacity: The number of machines allocated to the compute fleet. Defines the number of builds that can run in parallel. Minimum value of 1.
         :param compute_type: The instance type of the compute fleet.
         :param environment_type: The build environment (operating system/architecture/accelerator) type made available to projects using this fleet.
+        :param compute_configuration: The compute configuration of the compute fleet. This is only required if ``computeType`` is set to ATTRIBUTE_BASED. Default: - do not specify compute configuration
         :param fleet_name: The name of the Fleet. Default: - CloudFormation generated name
 
         :exampleMetadata: infused
@@ -9604,17 +9755,22 @@ class FleetProps:
                 )
             )
         '''
+        if isinstance(compute_configuration, dict):
+            compute_configuration = ComputeConfiguration(**compute_configuration)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__e7911aefc20674030e6eb6a13611d08046f9412fc45f97ff43a4ecf7591a2d5d)
             check_type(argname="argument base_capacity", value=base_capacity, expected_type=type_hints["base_capacity"])
             check_type(argname="argument compute_type", value=compute_type, expected_type=type_hints["compute_type"])
             check_type(argname="argument environment_type", value=environment_type, expected_type=type_hints["environment_type"])
+            check_type(argname="argument compute_configuration", value=compute_configuration, expected_type=type_hints["compute_configuration"])
             check_type(argname="argument fleet_name", value=fleet_name, expected_type=type_hints["fleet_name"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "base_capacity": base_capacity,
             "compute_type": compute_type,
             "environment_type": environment_type,
         }
+        if compute_configuration is not None:
+            self._values["compute_configuration"] = compute_configuration
         if fleet_name is not None:
             self._values["fleet_name"] = fleet_name
 
@@ -9645,6 +9801,19 @@ class FleetProps:
         assert result is not None, "Required property 'environment_type' is missing"
         return typing.cast(EnvironmentType, result)
 
+    @builtins.property
+    def compute_configuration(self) -> typing.Optional[ComputeConfiguration]:
+        '''The compute configuration of the compute fleet.
+
+        This is only required if ``computeType`` is set to ATTRIBUTE_BASED.
+
+        :default: - do not specify compute configuration
+
+        :see: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types
+        '''
+        result = self._values.get("compute_configuration")
+        return typing.cast(typing.Optional[ComputeConfiguration], result)
+
     @builtins.property
     def fleet_name(self) -> typing.Optional[builtins.str]:
         '''The name of the Fleet.
@@ -12862,6 +13031,36 @@ class MacBuildImage(
         return typing.cast(typing.Optional[_ISecret_6e020e6a], jsii.get(self, "secretsManagerCredentials"))
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_codebuild.MachineType")
+class MachineType(enum.Enum):
+    '''The compute type of the fleet.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        from aws_cdk import Size
+        
+        
+        fleet = codebuild.Fleet(self, "MyFleet",
+            base_capacity=1,
+            compute_type=codebuild.FleetComputeType.ATTRIBUTE_BASED,
+            environment_type=codebuild.EnvironmentType.LINUX_CONTAINER,
+            compute_configuration=codebuild.ComputeConfiguration(
+                v_cpu=2,
+                memory=Size.gibibytes(4),
+                disk=Size.gibibytes(10),
+                machine_type=codebuild.MachineType.GENERAL
+            )
+        )
+    '''
+
+    GENERAL = "GENERAL"
+    '''General purpose compute type.'''
+    NVME = "NVME"
+    '''Non-Volatile Memory Express (NVMe) storage optimized compute type.'''
+
+
 class PhaseChangeEvent(
     metaclass=jsii.JSIIMeta,
     jsii_type="aws-cdk-lib.aws_codebuild.PhaseChangeEvent",
@@ -17049,6 +17248,7 @@ class Fleet(
         base_capacity: jsii.Number,
         compute_type: FleetComputeType,
         environment_type: EnvironmentType,
+        compute_configuration: typing.Optional[typing.Union[ComputeConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
         fleet_name: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
@@ -17057,6 +17257,7 @@ class Fleet(
         :param base_capacity: The number of machines allocated to the compute fleet. Defines the number of builds that can run in parallel. Minimum value of 1.
         :param compute_type: The instance type of the compute fleet.
         :param environment_type: The build environment (operating system/architecture/accelerator) type made available to projects using this fleet.
+        :param compute_configuration: The compute configuration of the compute fleet. This is only required if ``computeType`` is set to ATTRIBUTE_BASED. Default: - do not specify compute configuration
         :param fleet_name: The name of the Fleet. Default: - CloudFormation generated name
         '''
         if __debug__:
@@ -17067,6 +17268,7 @@ class Fleet(
             base_capacity=base_capacity,
             compute_type=compute_type,
             environment_type=environment_type,
+            compute_configuration=compute_configuration,
             fleet_name=fleet_name,
         )
 
@@ -18222,6 +18424,7 @@ __all__ = [
     "CloudWatchLoggingOptions",
     "CodeCommitSourceProps",
     "CommonProjectProps",
+    "ComputeConfiguration",
     "ComputeType",
     "DockerImageOptions",
     "EfsFileSystemLocationProps",
@@ -18256,6 +18459,7 @@ __all__ = [
     "LocalCacheMode",
     "LoggingOptions",
     "MacBuildImage",
+    "MachineType",
     "PhaseChangeEvent",
     "PipelineProject",
     "PipelineProjectProps",
@@ -19191,6 +19395,16 @@ def _typecheckingstub__45bdedf6c9b38dcb0797768fa0fdec382e282ebd8679405f7dd9df6cb
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__b104977b55c72c0577553444ac08838cdefde5acef91d6c00ad996d1c464b61b(
+    *,
+    disk: typing.Optional[_Size_7b441c34] = None,
+    machine_type: typing.Optional[MachineType] = None,
+    memory: typing.Optional[_Size_7b441c34] = None,
+    v_cpu: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a9bdff78eb0c7b03d745a4a031a5cd7fe7b54a46e7733dc247bae3735e3c5300(
     *,
     secrets_manager_credentials: typing.Optional[_ISecret_6e020e6a] = None,
@@ -19334,6 +19548,7 @@ def _typecheckingstub__e7911aefc20674030e6eb6a13611d08046f9412fc45f97ff43a4ecf75
     base_capacity: jsii.Number,
     compute_type: FleetComputeType,
     environment_type: EnvironmentType,
+    compute_configuration: typing.Optional[typing.Union[ComputeConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
     fleet_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -20157,6 +20372,7 @@ def _typecheckingstub__68e9f035c12fa2c35bc62bc8d306e3651814bea9f53875aeea43b85f6
     base_capacity: jsii.Number,
     compute_type: FleetComputeType,
     environment_type: EnvironmentType,
+    compute_configuration: typing.Optional[typing.Union[ComputeConfiguration, typing.Dict[builtins.str, typing.Any]]] = None,
     fleet_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""

aws_cdk/aws_codepipeline/__init__.py

@@ -1015,6 +1015,7 @@ class ActionCategory(enum.Enum):
     APPROVAL = "APPROVAL"
     DEPLOY = "DEPLOY"
     INVOKE = "INVOKE"
+    COMPUTE = "COMPUTE"
 
 
 @jsii.data_type(
@@ -1074,8 +1075,10 @@ class ActionConfig:
         "category": "category",
         "provider": "provider",
         "account": "account",
+        "commands": "commands",
         "inputs": "inputs",
         "outputs": "outputs",
+        "output_variables": "outputVariables",
         "owner": "owner",
         "region": "region",
         "resource": "resource",
@@ -1094,8 +1097,10 @@ class ActionProperties:
         category: ActionCategory,
         provider: builtins.str,
         account: typing.Optional[builtins.str] = None,
+        commands: typing.Optional[typing.Sequence[builtins.str]] = None,
         inputs: typing.Optional[typing.Sequence["Artifact"]] = None,
         outputs: typing.Optional[typing.Sequence["Artifact"]] = None,
+        output_variables: typing.Optional[typing.Sequence[builtins.str]] = None,
         owner: typing.Optional[builtins.str] = None,
         region: typing.Optional[builtins.str] = None,
         resource: typing.Optional[_IResource_c80c4260] = None,
@@ -1110,8 +1115,10 @@ class ActionProperties:
         :param category: The category of the action. The category defines which action type the owner (the entity that performs the action) performs.
         :param provider: The service provider that the action calls.
         :param account: 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.
+        :param commands: Shell commands for the Commands action to run. Default: - no commands
         :param inputs: 
         :param outputs: 
+        :param output_variables: The names of the variables in your environment that you want to export. Default: - no output variables
         :param owner: 
         :param region: 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
         :param resource: 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.
@@ -1147,8 +1154,10 @@ class ActionProperties:
             
                 # the properties below are optional
                 account="account",
+                commands=["commands"],
                 inputs=[artifact],
                 outputs=[artifact],
+                output_variables=["outputVariables"],
                 owner="owner",
                 region="region",
                 resource=resource,
@@ -1167,8 +1176,10 @@ class ActionProperties:
             check_type(argname="argument category", value=category, expected_type=type_hints["category"])
             check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
             check_type(argname="argument account", value=account, expected_type=type_hints["account"])
+            check_type(argname="argument commands", value=commands, expected_type=type_hints["commands"])
             check_type(argname="argument inputs", value=inputs, expected_type=type_hints["inputs"])
             check_type(argname="argument outputs", value=outputs, expected_type=type_hints["outputs"])
+            check_type(argname="argument output_variables", value=output_variables, expected_type=type_hints["output_variables"])
             check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
             check_type(argname="argument region", value=region, expected_type=type_hints["region"])
             check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
@@ -1184,10 +1195,14 @@ class ActionProperties:
         }
         if account is not None:
             self._values["account"] = account
+        if commands is not None:
+            self._values["commands"] = commands
         if inputs is not None:
             self._values["inputs"] = inputs
         if outputs is not None:
             self._values["outputs"] = outputs
+        if output_variables is not None:
+            self._values["output_variables"] = output_variables
         if owner is not None:
             self._values["owner"] = owner
         if region is not None:
@@ -1247,6 +1262,15 @@ class ActionProperties:
         result = self._values.get("account")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def commands(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''Shell commands for the Commands action to run.
+
+        :default: - no commands
+        '''
+        result = self._values.get("commands")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     @builtins.property
     def inputs(self) -> typing.Optional[typing.List["Artifact"]]:
         result = self._values.get("inputs")
@@ -1257,6 +1281,15 @@ class ActionProperties:
         result = self._values.get("outputs")
         return typing.cast(typing.Optional[typing.List["Artifact"]], result)
 
+    @builtins.property
+    def output_variables(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''The names of the variables in your environment that you want to export.
+
+        :default: - no output variables
+        '''
+        result = self._values.get("output_variables")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
     @builtins.property
     def owner(self) -> typing.Optional[builtins.str]:
         result = self._values.get("owner")
@@ -1374,28 +1407,43 @@ class Artifact(
         )
     '''
 
-    def __init__(self, artifact_name: typing.Optional[builtins.str] = None) -> None:
-        '''
-        :param artifact_name: -
+    def __init__(
+        self,
+        artifact_name: typing.Optional[builtins.str] = None,
+        artifact_files: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> None:
+        '''An output artifact of an action.
+
+        Artifacts can be used as input by some actions.
+
+        :param artifact_name: the (required) name of the Artifact.
+        :param artifact_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 artifactFiles array must be between 1 and 10.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f54b8d044be8c6120e635522855c750b47ac8841ab3f60bdbffb0d5bc115acd6)
             check_type(argname="argument artifact_name", value=artifact_name, expected_type=type_hints["artifact_name"])
-        jsii.create(self.__class__, self, [artifact_name])
+            check_type(argname="argument artifact_files", value=artifact_files, expected_type=type_hints["artifact_files"])
+        jsii.create(self.__class__, self, [artifact_name, artifact_files])
 
     @jsii.member(jsii_name="artifact")
     @builtins.classmethod
-    def artifact(cls, name: builtins.str) -> "Artifact":
+    def artifact(
+        cls,
+        name: builtins.str,
+        files: typing.Optional[typing.Sequence[builtins.str]] = None,
+    ) -> "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.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__162b74657e69163ea68e052eb239ee6234ff6e7032951e1dfa2a29c0547c72f2)
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
-        return typing.cast("Artifact", jsii.sinvoke(cls, "artifact", [name]))
+            check_type(argname="argument files", value=files, expected_type=type_hints["files"])
+        return typing.cast("Artifact", jsii.sinvoke(cls, "artifact", [name, files]))
 
     @jsii.member(jsii_name="atPath")
     def at_path(self, file_name: builtins.str) -> "ArtifactPath":
@@ -1486,6 +1534,15 @@ class Artifact(
         '''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.'''
         return typing.cast(builtins.str, jsii.get(self, "url"))
 
+    @builtins.property
+    @jsii.member(jsii_name="artifactFiles")
+    def artifact_files(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''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``.
+        '''
+        return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "artifactFiles"))
+
     @builtins.property
     @jsii.member(jsii_name="artifactName")
     def artifact_name(self) -> typing.Optional[builtins.str]:
@@ -9364,35 +9421,35 @@ class PipelineProps:
 
         Example::
 
-            # source_action: codepipeline_actions.S3SourceAction
-            # source_output: codepipeline.Artifact
-            # deploy_bucket: s3.Bucket
-            
+            # Source action
+            bucket = s3.Bucket(self, "SourceBucket",
+                versioned=True
+            )
+            source_artifact = codepipeline.Artifact("SourceArtifact")
+            source_action = codepipeline_actions.S3SourceAction(
+                action_name="Source",
+                output=source_artifact,
+                bucket=bucket,
+                bucket_key="my.zip"
+            )
             
-            # Pipeline-level variable
-            variable = codepipeline.Variable(
-                variable_name="bucket-var",
-                description="description",
-                default_value="sample"
+            # Commands action
+            output_artifact = codepipeline.Artifact("OutputArtifact")
+            commands_action = codepipeline_actions.CommandsAction(
+                action_name="Commands",
+                commands=["echo \"some commands\""
+                ],
+                input=source_artifact,
+                output=output_artifact
             )
             
-            codepipeline.Pipeline(self, "Pipeline",
-                pipeline_type=codepipeline.PipelineType.V2,
-                variables=[variable],
+            pipeline = codepipeline.Pipeline(self, "Pipeline",
                 stages=[codepipeline.StageProps(
                     stage_name="Source",
                     actions=[source_action]
                 ), codepipeline.StageProps(
-                    stage_name="Deploy",
-                    actions=[
-                        codepipeline_actions.S3DeployAction(
-                            action_name="DeployAction",
-                            # can reference the variables
-                            object_key=f"{variable.reference()}.txt",
-                            input=source_output,
-                            bucket=deploy_bucket
-                        )
-                    ]
+                    stage_name="Commands",
+                    actions=[commands_action]
                 )
                 ]
             )
@@ -10572,8 +10629,10 @@ def _typecheckingstub__9d5af996beb5106d261c46a26d8be39e2a16f31935368b97303970d10
     category: ActionCategory,
     provider: builtins.str,
     account: typing.Optional[builtins.str] = None,
+    commands: typing.Optional[typing.Sequence[builtins.str]] = None,
     inputs: typing.Optional[typing.Sequence[Artifact]] = None,
     outputs: typing.Optional[typing.Sequence[Artifact]] = None,
+    output_variables: typing.Optional[typing.Sequence[builtins.str]] = None,
     owner: typing.Optional[builtins.str] = None,
     region: typing.Optional[builtins.str] = None,
     resource: typing.Optional[_IResource_c80c4260] = None,
@@ -10587,12 +10646,14 @@ def _typecheckingstub__9d5af996beb5106d261c46a26d8be39e2a16f31935368b97303970d10
 
 def _typecheckingstub__f54b8d044be8c6120e635522855c750b47ac8841ab3f60bdbffb0d5bc115acd6(
     artifact_name: typing.Optional[builtins.str] = None,
+    artifact_files: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
 
 def _typecheckingstub__162b74657e69163ea68e052eb239ee6234ff6e7032951e1dfa2a29c0547c72f2(
     name: builtins.str,
+    files: typing.Optional[typing.Sequence[builtins.str]] = None,
 ) -> None:
     """Type checking stubs"""
     pass