aws-cdk-lib 2.166.0__py3-none-any.whl → 2.167.0__py3-none-any.whl

aws_cdk/aws_cloudfront/__init__.py

@@ -1291,6 +1291,7 @@ from ..aws_iam import (
     IRole as _IRole_235f5d8e,
 )
 from ..aws_kinesis import IStream as _IStream_4e2457d2
+from ..aws_kms import IKey as _IKey_5f11635f
 from ..aws_lambda import IVersion as _IVersion_faf7234e
 from ..aws_s3 import IBucket as _IBucket_42e086fd
 from ..aws_s3_assets import AssetOptions as _AssetOptions_2aa69621
@@ -17724,6 +17725,7 @@ class ImportSource(
         *,
         deploy_time: typing.Optional[builtins.bool] = None,
         readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
+        source_kms_key: typing.Optional[_IKey_5f11635f] = None,
         asset_hash: typing.Optional[builtins.str] = None,
         asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
         bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -17736,6 +17738,7 @@ class ImportSource(
         :param path: the path to the local file.
         :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
         :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.
+        :param source_kms_key: The ARN of the KMS key used to encrypt the handler code. Default: - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.
         :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
         :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
         :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
@@ -17749,6 +17752,7 @@ class ImportSource(
         options = _AssetOptions_2aa69621(
             deploy_time=deploy_time,
             readers=readers,
+            source_kms_key=source_kms_key,
             asset_hash=asset_hash,
             asset_hash_type=asset_hash_type,
             bundling=bundling,
@@ -17813,9 +17817,11 @@ class InlineImportSource(
         import aws_cdk as cdk
         from aws_cdk import aws_cloudfront as cloudfront
         from aws_cdk import aws_iam as iam
+        from aws_cdk import aws_kms as kms
         
         # docker_image: cdk.DockerImage
         # grantable: iam.IGrantable
+        # key: kms.Key
         # local_bundling: cdk.ILocalBundling
         
         inline_import_source = cloudfront.InlineImportSource.from_asset("path",
@@ -17851,7 +17857,8 @@ class InlineImportSource(
             exclude=["exclude"],
             follow_symlinks=cdk.SymlinkFollowMode.NEVER,
             ignore_mode=cdk.IgnoreMode.GLOB,
-            readers=[grantable]
+            readers=[grantable],
+            source_kMSKey=key
         )
     '''
 
@@ -22008,9 +22015,11 @@ class S3ImportSource(
         import aws_cdk as cdk
         from aws_cdk import aws_cloudfront as cloudfront
         from aws_cdk import aws_iam as iam
+        from aws_cdk import aws_kms as kms
         
         # docker_image: cdk.DockerImage
         # grantable: iam.IGrantable
+        # key: kms.Key
         # local_bundling: cdk.ILocalBundling
         
         s3_import_source = cloudfront.S3ImportSource.from_asset("path",
@@ -22046,7 +22055,8 @@ class S3ImportSource(
             exclude=["exclude"],
             follow_symlinks=cdk.SymlinkFollowMode.NEVER,
             ignore_mode=cdk.IgnoreMode.GLOB,
-            readers=[grantable]
+            readers=[grantable],
+            source_kMSKey=key
         )
     '''
 
@@ -23090,9 +23100,11 @@ class AssetImportSource(
         import aws_cdk as cdk
         from aws_cdk import aws_cloudfront as cloudfront
         from aws_cdk import aws_iam as iam
+        from aws_cdk import aws_kms as kms
         
         # docker_image: cdk.DockerImage
         # grantable: iam.IGrantable
+        # key: kms.Key
         # local_bundling: cdk.ILocalBundling
         
         asset_import_source = cloudfront.AssetImportSource.from_asset("path",
@@ -23128,7 +23140,8 @@ class AssetImportSource(
             exclude=["exclude"],
             follow_symlinks=cdk.SymlinkFollowMode.NEVER,
             ignore_mode=cdk.IgnoreMode.GLOB,
-            readers=[grantable]
+            readers=[grantable],
+            source_kMSKey=key
         )
     '''
 
@@ -23138,6 +23151,7 @@ class AssetImportSource(
         *,
         deploy_time: typing.Optional[builtins.bool] = None,
         readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
+        source_kms_key: typing.Optional[_IKey_5f11635f] = None,
         asset_hash: typing.Optional[builtins.str] = None,
         asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
         bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -23149,6 +23163,7 @@ class AssetImportSource(
         :param path: the path to the local file.
         :param deploy_time: Whether or not the asset needs to exist beyond deployment time; i.e. are copied over to a different location and not needed afterwards. Setting this property to true has an impact on the lifecycle of the asset, because we will assume that it is safe to delete after the CloudFormation deployment succeeds. For example, Lambda Function assets are copied over to Lambda during deployment. Therefore, it is not necessary to store the asset in S3, so we consider those deployTime assets. Default: false
         :param readers: A list of principals that should be able to read this asset from S3. You can use ``asset.grantRead(principal)`` to grant read permissions later. Default: - No principals that can read file asset.
+        :param source_kms_key: The ARN of the KMS key used to encrypt the handler code. Default: - the default server-side encryption with Amazon S3 managed keys(SSE-S3) key will be used.
         :param asset_hash: Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. For consistency, this custom hash will be SHA256 hashed and encoded as hex. The resulting hash will be the asset hash. NOTE: the hash is used in order to identify a specific revision of the asset, and used for optimizing and caching deployment activities related to this asset such as packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will need to make sure it is updated every time the asset changes, or otherwise it is possible that some deployments will not be invalidated. Default: - based on ``assetHashType``
         :param asset_hash_type: Specifies the type of hash to calculate for this asset. If ``assetHash`` is configured, this option must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: - the default is ``AssetHashType.SOURCE``, but if ``assetHash`` is explicitly specified this value defaults to ``AssetHashType.CUSTOM``.
         :param bundling: Bundle the asset by executing a command in a Docker container or a custom bundling provider. The asset path will be mounted at ``/asset-input``. The Docker container is responsible for putting content at ``/asset-output``. The content at ``/asset-output`` will be zipped and used as the final asset. Default: - uploaded as-is to S3 if the asset is a regular file or a .zip file, archived into a .zip file and uploaded to S3 otherwise
@@ -23162,6 +23177,7 @@ class AssetImportSource(
         options = _AssetOptions_2aa69621(
             deploy_time=deploy_time,
             readers=readers,
+            source_kms_key=source_kms_key,
             asset_hash=asset_hash,
             asset_hash_type=asset_hash_type,
             bundling=bundling,
@@ -26238,6 +26254,7 @@ def _typecheckingstub__f5d4750ca4d7703f815ca46be8b91e46ea0b813f42846026dff63e00f
     *,
     deploy_time: typing.Optional[builtins.bool] = None,
     readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
+    source_kms_key: typing.Optional[_IKey_5f11635f] = None,
     asset_hash: typing.Optional[builtins.str] = None,
     asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
     bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -26817,6 +26834,7 @@ def _typecheckingstub__62441d3d3228ae5fb69aaca12e603944f07f9335dae80f70ce3b04e8e
     *,
     deploy_time: typing.Optional[builtins.bool] = None,
     readers: typing.Optional[typing.Sequence[_IGrantable_71c4f5de]] = None,
+    source_kms_key: typing.Optional[_IKey_5f11635f] = None,
     asset_hash: typing.Optional[builtins.str] = None,
     asset_hash_type: typing.Optional[_AssetHashType_05b67f2d] = None,
     bundling: typing.Optional[typing.Union[_BundlingOptions_588cc936, typing.Dict[builtins.str, typing.Any]]] = None,

aws_cdk/aws_cloudfront/experimental/__init__.py

@@ -247,7 +247,7 @@ class EdgeFunction(
         :param role: Lambda execution role. This is the role that will be assumed by the function upon execution. It controls the permissions that the function will have. The Role must be assumable by the 'lambda.amazonaws.com' service principal. The default Role automatically has permissions granted for Lambda execution. If you provide a Role, you must add the relevant AWS managed policies yourself. The relevant managed policies are "service-role/AWSLambdaBasicExecutionRole" and "service-role/AWSLambdaVPCAccessExecutionRole". Default: - A unique role will be generated for this lambda function. Both supplied and generated roles can always be changed by calling ``addToRolePolicy``.
         :param runtime_management_mode: Sets the runtime management configuration for a function's version. Default: Auto
         :param security_groups: The list of security groups to associate with the Lambda's network interfaces. Only used if 'vpc' is supplied. Default: - If the function is placed within a VPC and a security group is not specified, either by this or securityGroup prop, a dedicated security group will be created for this function.
-        :param snap_start: Enable SnapStart for Lambda Function. SnapStart is currently supported only for Java 11, 17 runtime Default: - No snapstart
+        :param snap_start: Enable SnapStart for Lambda Function. SnapStart is currently supported for Java 11, Java 17, Python 3.12, Python 3.13, and .NET 8 runtime Default: - No snapstart
         :param system_log_level: (deprecated) Sets the system log level for the function. Default: "INFO"
         :param system_log_level_v2: Sets the system log level for the function. Default: SystemLogLevel.INFO
         :param timeout: The function execution time (in seconds) after which Lambda terminates the function. Because the execution time affects cost, set this value based on the function's expected execution time. Default: Duration.seconds(3)
@@ -1079,7 +1079,7 @@ class EdgeFunctionProps(_FunctionProps_a308e854):
         :param role: Lambda execution role. This is the role that will be assumed by the function upon execution. It controls the permissions that the function will have. The Role must be assumable by the 'lambda.amazonaws.com' service principal. The default Role automatically has permissions granted for Lambda execution. If you provide a Role, you must add the relevant AWS managed policies yourself. The relevant managed policies are "service-role/AWSLambdaBasicExecutionRole" and "service-role/AWSLambdaVPCAccessExecutionRole". Default: - A unique role will be generated for this lambda function. Both supplied and generated roles can always be changed by calling ``addToRolePolicy``.
         :param runtime_management_mode: Sets the runtime management configuration for a function's version. Default: Auto
         :param security_groups: The list of security groups to associate with the Lambda's network interfaces. Only used if 'vpc' is supplied. Default: - If the function is placed within a VPC and a security group is not specified, either by this or securityGroup prop, a dedicated security group will be created for this function.
-        :param snap_start: Enable SnapStart for Lambda Function. SnapStart is currently supported only for Java 11, 17 runtime Default: - No snapstart
+        :param snap_start: Enable SnapStart for Lambda Function. SnapStart is currently supported for Java 11, Java 17, Python 3.12, Python 3.13, and .NET 8 runtime Default: - No snapstart
         :param system_log_level: (deprecated) Sets the system log level for the function. Default: "INFO"
         :param system_log_level_v2: Sets the system log level for the function. Default: SystemLogLevel.INFO
         :param timeout: The function execution time (in seconds) after which Lambda terminates the function. Because the execution time affects cost, set this value based on the function's expected execution time. Default: Duration.seconds(3)
@@ -1804,7 +1804,7 @@ class EdgeFunctionProps(_FunctionProps_a308e854):
     def snap_start(self) -> typing.Optional[_SnapStartConf_2ffaa769]:
         '''Enable SnapStart for Lambda Function.
 
-        SnapStart is currently supported only for Java 11, 17 runtime
+        SnapStart is currently supported for Java 11, Java 17, Python 3.12, Python 3.13, and .NET 8 runtime
 
         :default: - No snapstart
         '''

aws_cdk/aws_codebuild/__init__.py

@@ -2192,8 +2192,8 @@ class CfnFleet(
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param base_capacity: The initial number of machines allocated to the compute fleet, which defines the number of builds that can run in parallel.
-        :param compute_type: Information about the compute resources the compute fleet uses. Available values include:. - ``BUILD_GENERAL1_SMALL`` : Use up to 3 GB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 7 GB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 70 GB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 145 GB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. If you use ``BUILD_GENERAL1_SMALL`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 3 GB memory and 2 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 4 GB memory and 2 vCPUs on ARM-based processors for builds. If you use ``BUILD_GENERAL1_LARGE`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 15 GB memory and 8 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 16 GB memory and 8 vCPUs on ARM-based processors for builds. For more information, see `Build environment compute types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild User Guide.*
-        :param environment_type: The environment type of the compute fleet. - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific (Mumbai). - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), and Asia Pacific (Sydney). - The environment type ``WINDOWS_SERVER_2019_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). - The environment type ``WINDOWS_SERVER_2022_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and Asia Pacific (Mumbai). For more information, see `Build environment compute types <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild user guide* .
+        :param compute_type: Information about the compute resources the compute fleet uses. Available values include:. - ``ATTRIBUTE_BASED_COMPUTE`` : Specify the amount of vCPUs, memory, disk space, and the type of machine. .. epigraph:: If you use ``ATTRIBUTE_BASED_COMPUTE`` , you must define your attributes by using ``computeConfiguration`` . AWS CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see `Reserved capacity environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types>`_ in the *AWS CodeBuild User Guide* . - ``BUILD_GENERAL1_SMALL`` : Use up to 4 GiB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 8 GiB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. - ``BUILD_LAMBDA_1GB`` : Use up to 1 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_2GB`` : Use up to 2 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_4GB`` : Use up to 4 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_8GB`` : Use up to 8 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_10GB`` : Use up to 10 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . If you use ``BUILD_GENERAL1_SMALL`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds. If you use ``BUILD_GENERAL1_LARGE`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds. For more information, see `On-demand environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types>`_ in the *AWS CodeBuild User Guide.*
+        :param environment_type: The environment type of the compute fleet. - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific (Mumbai). - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), and Asia Pacific (Sydney). - The environment type ``MAC_ARM`` is available only in regions US East (Ohio), US East (N. Virginia), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Sydney). - The environment type ``WINDOWS_SERVER_2019_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). - The environment type ``WINDOWS_SERVER_2022_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and Asia Pacific (Mumbai). For more information, see `Build environment compute types <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild user guide* .
         :param fleet_service_role: The service role associated with the compute fleet. For more information, see `Allow a user to add a permission policy for a fleet service role <https://docs.aws.amazon.com/codebuild/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#customer-managed-policies-example-permission-policy-fleet-service-role.html>`_ in the *AWS CodeBuild User Guide* .
         :param fleet_vpc_config: Information about the VPC configuration that AWS CodeBuild accesses.
         :param image_id: The Amazon Machine Image (AMI) of the compute fleet.
@@ -2516,8 +2516,8 @@ class CfnFleetProps:
         '''Properties for defining a ``CfnFleet``.
 
         :param base_capacity: The initial number of machines allocated to the compute fleet, which defines the number of builds that can run in parallel.
-        :param compute_type: Information about the compute resources the compute fleet uses. Available values include:. - ``BUILD_GENERAL1_SMALL`` : Use up to 3 GB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 7 GB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 70 GB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 145 GB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. If you use ``BUILD_GENERAL1_SMALL`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 3 GB memory and 2 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 4 GB memory and 2 vCPUs on ARM-based processors for builds. If you use ``BUILD_GENERAL1_LARGE`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 15 GB memory and 8 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 16 GB memory and 8 vCPUs on ARM-based processors for builds. For more information, see `Build environment compute types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild User Guide.*
-        :param environment_type: The environment type of the compute fleet. - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific (Mumbai). - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), and Asia Pacific (Sydney). - The environment type ``WINDOWS_SERVER_2019_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). - The environment type ``WINDOWS_SERVER_2022_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and Asia Pacific (Mumbai). For more information, see `Build environment compute types <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild user guide* .
+        :param compute_type: Information about the compute resources the compute fleet uses. Available values include:. - ``ATTRIBUTE_BASED_COMPUTE`` : Specify the amount of vCPUs, memory, disk space, and the type of machine. .. epigraph:: If you use ``ATTRIBUTE_BASED_COMPUTE`` , you must define your attributes by using ``computeConfiguration`` . AWS CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see `Reserved capacity environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types>`_ in the *AWS CodeBuild User Guide* . - ``BUILD_GENERAL1_SMALL`` : Use up to 4 GiB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 8 GiB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. - ``BUILD_LAMBDA_1GB`` : Use up to 1 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_2GB`` : Use up to 2 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_4GB`` : Use up to 4 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_8GB`` : Use up to 8 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_10GB`` : Use up to 10 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . If you use ``BUILD_GENERAL1_SMALL`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds. If you use ``BUILD_GENERAL1_LARGE`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds. For more information, see `On-demand environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types>`_ in the *AWS CodeBuild User Guide.*
+        :param environment_type: The environment type of the compute fleet. - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo). - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific (Mumbai). - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), and Asia Pacific (Sydney). - The environment type ``MAC_ARM`` is available only in regions US East (Ohio), US East (N. Virginia), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Sydney). - The environment type ``WINDOWS_SERVER_2019_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland). - The environment type ``WINDOWS_SERVER_2022_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and Asia Pacific (Mumbai). For more information, see `Build environment compute types <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild user guide* .
         :param fleet_service_role: The service role associated with the compute fleet. For more information, see `Allow a user to add a permission policy for a fleet service role <https://docs.aws.amazon.com/codebuild/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html#customer-managed-policies-example-permission-policy-fleet-service-role.html>`_ in the *AWS CodeBuild User Guide* .
         :param fleet_vpc_config: Information about the VPC configuration that AWS CodeBuild accesses.
         :param image_id: The Amazon Machine Image (AMI) of the compute fleet.
@@ -2597,25 +2597,36 @@ class CfnFleetProps:
     def compute_type(self) -> typing.Optional[builtins.str]:
         '''Information about the compute resources the compute fleet uses. Available values include:.
 
-        - ``BUILD_GENERAL1_SMALL`` : Use up to 3 GB memory and 2 vCPUs for builds.
-        - ``BUILD_GENERAL1_MEDIUM`` : Use up to 7 GB memory and 4 vCPUs for builds.
-        - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GB memory and 8 vCPUs for builds, depending on your environment type.
-        - ``BUILD_GENERAL1_XLARGE`` : Use up to 70 GB memory and 36 vCPUs for builds, depending on your environment type.
-        - ``BUILD_GENERAL1_2XLARGE`` : Use up to 145 GB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed.
+        - ``ATTRIBUTE_BASED_COMPUTE`` : Specify the amount of vCPUs, memory, disk space, and the type of machine.
+
+        .. epigraph::
+
+           If you use ``ATTRIBUTE_BASED_COMPUTE`` , you must define your attributes by using ``computeConfiguration`` . AWS CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see `Reserved capacity environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types>`_ in the *AWS CodeBuild User Guide* .
+
+        - ``BUILD_GENERAL1_SMALL`` : Use up to 4 GiB memory and 2 vCPUs for builds.
+        - ``BUILD_GENERAL1_MEDIUM`` : Use up to 8 GiB memory and 4 vCPUs for builds.
+        - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type.
+        - ``BUILD_GENERAL1_XLARGE`` : Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type.
+        - ``BUILD_GENERAL1_2XLARGE`` : Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed.
+        - ``BUILD_LAMBDA_1GB`` : Use up to 1 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+        - ``BUILD_LAMBDA_2GB`` : Use up to 2 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+        - ``BUILD_LAMBDA_4GB`` : Use up to 4 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+        - ``BUILD_LAMBDA_8GB`` : Use up to 8 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+        - ``BUILD_LAMBDA_10GB`` : Use up to 10 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
 
         If you use ``BUILD_GENERAL1_SMALL`` :
 
-        - For environment type ``LINUX_CONTAINER`` , you can use up to 3 GB memory and 2 vCPUs for builds.
-        - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds.
-        - For environment type ``ARM_CONTAINER`` , you can use up to 4 GB memory and 2 vCPUs on ARM-based processors for builds.
+        - For environment type ``LINUX_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs for builds.
+        - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds.
+        - For environment type ``ARM_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds.
 
         If you use ``BUILD_GENERAL1_LARGE`` :
 
-        - For environment type ``LINUX_CONTAINER`` , you can use up to 15 GB memory and 8 vCPUs for builds.
-        - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds.
-        - For environment type ``ARM_CONTAINER`` , you can use up to 16 GB memory and 8 vCPUs on ARM-based processors for builds.
+        - For environment type ``LINUX_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs for builds.
+        - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds.
+        - For environment type ``ARM_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds.
 
-        For more information, see `Build environment compute types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild User Guide.*
+        For more information, see `On-demand environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types>`_ in the *AWS CodeBuild User Guide.*
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-fleet.html#cfn-codebuild-fleet-computetype
         '''
@@ -2629,6 +2640,7 @@ class CfnFleetProps:
         - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), EU (Frankfurt), and South America (São Paulo).
         - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Singapore), Asia Pacific (Sydney), South America (São Paulo), and Asia Pacific (Mumbai).
         - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Tokyo), and Asia Pacific (Sydney).
+        - The environment type ``MAC_ARM`` is available only in regions US East (Ohio), US East (N. Virginia), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Sydney).
         - The environment type ``WINDOWS_SERVER_2019_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Sydney), Asia Pacific (Tokyo), Asia Pacific (Mumbai) and EU (Ireland).
         - The environment type ``WINDOWS_SERVER_2022_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), Asia Pacific (Sydney), Asia Pacific (Singapore), Asia Pacific (Tokyo), South America (São Paulo) and Asia Pacific (Mumbai).
 
@@ -3985,7 +3997,7 @@ class CfnProject(
         ) -> None:
             '''``Environment`` is a property of the `AWS::CodeBuild::Project <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html>`_ resource that specifies the environment for an AWS CodeBuild project.
 
-            :param compute_type: The type of compute environment. This determines the number of CPU cores and memory the build environment uses. Available values include: - ``BUILD_GENERAL1_SMALL`` : Use up to 3 GB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 7 GB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 70 GB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 145 GB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. - ``BUILD_LAMBDA_1GB`` : Use up to 1 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_2GB`` : Use up to 2 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_4GB`` : Use up to 4 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_8GB`` : Use up to 8 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_10GB`` : Use up to 10 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . For more information, see `Build Environment Compute Types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild User Guide.*
+            :param compute_type: The type of compute environment. This determines the number of CPU cores and memory the build environment uses. Available values include: - ``ATTRIBUTE_BASED_COMPUTE`` : Specify the amount of vCPUs, memory, disk space, and the type of machine. .. epigraph:: If you use ``ATTRIBUTE_BASED_COMPUTE`` , you must define your attributes by using ``computeConfiguration`` . AWS CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see `Reserved capacity environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types>`_ in the *AWS CodeBuild User Guide* . - ``BUILD_GENERAL1_SMALL`` : Use up to 4 GiB memory and 2 vCPUs for builds. - ``BUILD_GENERAL1_MEDIUM`` : Use up to 8 GiB memory and 4 vCPUs for builds. - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_XLARGE`` : Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type. - ``BUILD_GENERAL1_2XLARGE`` : Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed. - ``BUILD_LAMBDA_1GB`` : Use up to 1 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_2GB`` : Use up to 2 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_4GB`` : Use up to 4 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_8GB`` : Use up to 8 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . - ``BUILD_LAMBDA_10GB`` : Use up to 10 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` . If you use ``BUILD_GENERAL1_SMALL`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds. If you use ``BUILD_GENERAL1_LARGE`` : - For environment type ``LINUX_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs for builds. - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds. - For environment type ``ARM_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds. For more information, see `On-demand environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types>`_ in the *AWS CodeBuild User Guide.*
             :param image: The image tag or image digest that identifies the Docker image to use for this build project. Use the following formats: - For an image tag: ``<registry>/<repository>:<tag>`` . For example, in the Docker repository that CodeBuild uses to manage its Docker images, this would be ``aws/codebuild/standard:4.0`` . - For an image digest: ``<registry>/<repository>@<digest>`` . For example, to specify an image with the digest "sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf," use ``<registry>/<repository>@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf`` . For more information, see `Docker images provided by CodeBuild <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-available.html>`_ in the *AWS CodeBuild user guide* .
             :param type: The type of build environment to use for related builds. - The environment type ``ARM_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Sydney), and EU (Frankfurt). - The environment type ``LINUX_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Canada (Central), EU (Ireland), EU (London), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Seoul), Asia Pacific (Singapore), Asia Pacific (Sydney), China (Beijing), and China (Ningxia). - The environment type ``LINUX_GPU_CONTAINER`` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Canada (Central), EU (Ireland), EU (London), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Seoul), Asia Pacific (Singapore), Asia Pacific (Sydney) , China (Beijing), and China (Ningxia). - The environment types ``ARM_LAMBDA_CONTAINER`` and ``LINUX_LAMBDA_CONTAINER`` are available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Mumbai), Asia Pacific (Singapore), Asia Pacific (Sydney), Asia Pacific (Tokyo), EU (Frankfurt), EU (Ireland), and South America (São Paulo). - The environment types ``WINDOWS_CONTAINER`` and ``WINDOWS_SERVER_2019_CONTAINER`` are available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), and EU (Ireland). .. epigraph:: If you're using compute fleets during project creation, ``type`` will be ignored. For more information, see `Build environment compute types <https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild user guide* .
             :param certificate: The ARN of the Amazon S3 bucket, path prefix, and object key that contains the PEM-encoded certificate for the build project. For more information, see `certificate <https://docs.aws.amazon.com/codebuild/latest/userguide/create-project-cli.html#cli.environment.certificate>`_ in the *AWS CodeBuild User Guide* .
@@ -4064,18 +4076,36 @@ class CfnProject(
 
             This determines the number of CPU cores and memory the build environment uses. Available values include:
 
-            - ``BUILD_GENERAL1_SMALL`` : Use up to 3 GB memory and 2 vCPUs for builds.
-            - ``BUILD_GENERAL1_MEDIUM`` : Use up to 7 GB memory and 4 vCPUs for builds.
-            - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GB memory and 8 vCPUs for builds, depending on your environment type.
-            - ``BUILD_GENERAL1_XLARGE`` : Use up to 70 GB memory and 36 vCPUs for builds, depending on your environment type.
-            - ``BUILD_GENERAL1_2XLARGE`` : Use up to 145 GB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed.
-            - ``BUILD_LAMBDA_1GB`` : Use up to 1 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
-            - ``BUILD_LAMBDA_2GB`` : Use up to 2 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
-            - ``BUILD_LAMBDA_4GB`` : Use up to 4 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
-            - ``BUILD_LAMBDA_8GB`` : Use up to 8 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
-            - ``BUILD_LAMBDA_10GB`` : Use up to 10 GB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
-
-            For more information, see `Build Environment Compute Types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html>`_ in the *AWS CodeBuild User Guide.*
+            - ``ATTRIBUTE_BASED_COMPUTE`` : Specify the amount of vCPUs, memory, disk space, and the type of machine.
+
+            .. epigraph::
+
+               If you use ``ATTRIBUTE_BASED_COMPUTE`` , you must define your attributes by using ``computeConfiguration`` . AWS CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see `Reserved capacity environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types>`_ in the *AWS CodeBuild User Guide* .
+
+            - ``BUILD_GENERAL1_SMALL`` : Use up to 4 GiB memory and 2 vCPUs for builds.
+            - ``BUILD_GENERAL1_MEDIUM`` : Use up to 8 GiB memory and 4 vCPUs for builds.
+            - ``BUILD_GENERAL1_LARGE`` : Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type.
+            - ``BUILD_GENERAL1_XLARGE`` : Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type.
+            - ``BUILD_GENERAL1_2XLARGE`` : Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed.
+            - ``BUILD_LAMBDA_1GB`` : Use up to 1 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+            - ``BUILD_LAMBDA_2GB`` : Use up to 2 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+            - ``BUILD_LAMBDA_4GB`` : Use up to 4 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+            - ``BUILD_LAMBDA_8GB`` : Use up to 8 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+            - ``BUILD_LAMBDA_10GB`` : Use up to 10 GiB memory for builds. Only available for environment type ``LINUX_LAMBDA_CONTAINER`` and ``ARM_LAMBDA_CONTAINER`` .
+
+            If you use ``BUILD_GENERAL1_SMALL`` :
+
+            - For environment type ``LINUX_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs for builds.
+            - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds.
+            - For environment type ``ARM_CONTAINER`` , you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds.
+
+            If you use ``BUILD_GENERAL1_LARGE`` :
+
+            - For environment type ``LINUX_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs for builds.
+            - For environment type ``LINUX_GPU_CONTAINER`` , you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds.
+            - For environment type ``ARM_CONTAINER`` , you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds.
+
+            For more information, see `On-demand environment types <https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types>`_ in the *AWS CodeBuild User Guide.*
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-environment.html#cfn-codebuild-project-environment-computetype
             '''

aws_cdk/aws_datasync/__init__.py

@@ -6787,6 +6787,7 @@ class CfnTask(
                 key="key",
                 value="value"
             )],
+            task_mode="taskMode",
             task_report_config=datasync.CfnTask.TaskReportConfigProperty(
                 destination=datasync.CfnTask.DestinationProperty(
                     s3=datasync.CfnTask.S3Property(
@@ -6833,6 +6834,7 @@ class CfnTask(
         options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTask.OptionsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         schedule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTask.TaskScheduleProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+        task_mode: typing.Optional[builtins.str] = None,
         task_report_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTask.TaskReportConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''
@@ -6848,6 +6850,7 @@ class CfnTask(
         :param options: Specifies your task's settings, such as preserving file metadata, verifying data integrity, among other options.
         :param schedule: Specifies a schedule for when you want your task to run. For more information, see `Scheduling your task <https://docs.aws.amazon.com/datasync/latest/userguide/task-scheduling.html>`_ .
         :param tags: Specifies the tags that you want to apply to your task. *Tags* are key-value pairs that help you manage, filter, and search for your DataSync resources.
+        :param task_mode: Specifies one of the following task modes for your data transfer:. - ``ENHANCED`` - Transfer virtually unlimited numbers of objects with higher performance than Basic mode. Enhanced mode tasks optimize the data transfer process by listing, preparing, transferring, and verifying data in parallel. Enhanced mode is currently available for transfers between Amazon S3 locations. .. epigraph:: To create an Enhanced mode task, the IAM role that you use to call the ``CreateTask`` operation must have the ``iam:CreateServiceLinkedRole`` permission. - ``BASIC`` (default) - Transfer files or objects between AWS storage and all other supported DataSync locations. Basic mode tasks are subject to `quotas <https://docs.aws.amazon.com/datasync/latest/userguide/datasync-limits.html>`_ on the number of files, objects, and directories in a dataset. Basic mode sequentially prepares, transfers, and verifies data, making it slower than Enhanced mode for most workloads. For more information, see `Understanding task mode differences <https://docs.aws.amazon.com/datasync/latest/userguide/choosing-task-mode.html#task-mode-differences>`_ .
         :param task_report_config: Specifies how you want to configure a task report, which provides detailed information about your DataSync transfer. For more information, see `Monitoring your DataSync transfers with task reports <https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html>`_ . When using this parameter, your caller identity (the role that you're using DataSync with) must have the ``iam:PassRole`` permission. The `AWSDataSyncFullAccess <https://docs.aws.amazon.com/datasync/latest/userguide/security-iam-awsmanpol.html#security-iam-awsmanpol-awsdatasyncfullaccess>`_ policy includes this permission.
         '''
         if __debug__:
@@ -6865,6 +6868,7 @@ class CfnTask(
             options=options,
             schedule=schedule,
             tags=tags,
+            task_mode=task_mode,
             task_report_config=task_report_config,
         )
 
@@ -7102,6 +7106,19 @@ class CfnTask(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tagsRaw", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="taskMode")
+    def task_mode(self) -> typing.Optional[builtins.str]:
+        '''Specifies one of the following task modes for your data transfer:.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "taskMode"))
+
+    @task_mode.setter
+    def task_mode(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__6e99e4be24e51c3d44b26f48102cf77d9140bcbda1c9d60362e39294acbc3244)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "taskMode", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="taskReportConfig")
     def task_report_config(
@@ -8647,6 +8664,7 @@ class CfnTask(
         "options": "options",
         "schedule": "schedule",
         "tags": "tags",
+        "task_mode": "taskMode",
         "task_report_config": "taskReportConfig",
     },
 )
@@ -8664,6 +8682,7 @@ class CfnTaskProps:
         options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.OptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         schedule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskScheduleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+        task_mode: typing.Optional[builtins.str] = None,
         task_report_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskReportConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnTask``.
@@ -8678,6 +8697,7 @@ class CfnTaskProps:
         :param options: Specifies your task's settings, such as preserving file metadata, verifying data integrity, among other options.
         :param schedule: Specifies a schedule for when you want your task to run. For more information, see `Scheduling your task <https://docs.aws.amazon.com/datasync/latest/userguide/task-scheduling.html>`_ .
         :param tags: Specifies the tags that you want to apply to your task. *Tags* are key-value pairs that help you manage, filter, and search for your DataSync resources.
+        :param task_mode: Specifies one of the following task modes for your data transfer:. - ``ENHANCED`` - Transfer virtually unlimited numbers of objects with higher performance than Basic mode. Enhanced mode tasks optimize the data transfer process by listing, preparing, transferring, and verifying data in parallel. Enhanced mode is currently available for transfers between Amazon S3 locations. .. epigraph:: To create an Enhanced mode task, the IAM role that you use to call the ``CreateTask`` operation must have the ``iam:CreateServiceLinkedRole`` permission. - ``BASIC`` (default) - Transfer files or objects between AWS storage and all other supported DataSync locations. Basic mode tasks are subject to `quotas <https://docs.aws.amazon.com/datasync/latest/userguide/datasync-limits.html>`_ on the number of files, objects, and directories in a dataset. Basic mode sequentially prepares, transfers, and verifies data, making it slower than Enhanced mode for most workloads. For more information, see `Understanding task mode differences <https://docs.aws.amazon.com/datasync/latest/userguide/choosing-task-mode.html#task-mode-differences>`_ .
         :param task_report_config: Specifies how you want to configure a task report, which provides detailed information about your DataSync transfer. For more information, see `Monitoring your DataSync transfers with task reports <https://docs.aws.amazon.com/datasync/latest/userguide/task-reports.html>`_ . When using this parameter, your caller identity (the role that you're using DataSync with) must have the ``iam:PassRole`` permission. The `AWSDataSyncFullAccess <https://docs.aws.amazon.com/datasync/latest/userguide/security-iam-awsmanpol.html#security-iam-awsmanpol-awsdatasyncfullaccess>`_ policy includes this permission.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-datasync-task.html
@@ -8743,6 +8763,7 @@ class CfnTaskProps:
                     key="key",
                     value="value"
                 )],
+                task_mode="taskMode",
                 task_report_config=datasync.CfnTask.TaskReportConfigProperty(
                     destination=datasync.CfnTask.DestinationProperty(
                         s3=datasync.CfnTask.S3Property(
@@ -8785,6 +8806,7 @@ class CfnTaskProps:
             check_type(argname="argument options", value=options, expected_type=type_hints["options"])
             check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+            check_type(argname="argument task_mode", value=task_mode, expected_type=type_hints["task_mode"])
             check_type(argname="argument task_report_config", value=task_report_config, expected_type=type_hints["task_report_config"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "destination_location_arn": destination_location_arn,
@@ -8806,6 +8828,8 @@ class CfnTaskProps:
             self._values["schedule"] = schedule
         if tags is not None:
             self._values["tags"] = tags
+        if task_mode is not None:
+            self._values["task_mode"] = task_mode
         if task_report_config is not None:
             self._values["task_report_config"] = task_report_config
 
@@ -8925,6 +8949,25 @@ class CfnTaskProps:
         result = self._values.get("tags")
         return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)
 
+    @builtins.property
+    def task_mode(self) -> typing.Optional[builtins.str]:
+        '''Specifies one of the following task modes for your data transfer:.
+
+        - ``ENHANCED`` - Transfer virtually unlimited numbers of objects with higher performance than Basic mode. Enhanced mode tasks optimize the data transfer process by listing, preparing, transferring, and verifying data in parallel. Enhanced mode is currently available for transfers between Amazon S3 locations.
+
+        .. epigraph::
+
+           To create an Enhanced mode task, the IAM role that you use to call the ``CreateTask`` operation must have the ``iam:CreateServiceLinkedRole`` permission.
+
+        - ``BASIC`` (default) - Transfer files or objects between AWS storage and all other supported DataSync locations. Basic mode tasks are subject to `quotas <https://docs.aws.amazon.com/datasync/latest/userguide/datasync-limits.html>`_ on the number of files, objects, and directories in a dataset. Basic mode sequentially prepares, transfers, and verifies data, making it slower than Enhanced mode for most workloads.
+
+        For more information, see `Understanding task mode differences <https://docs.aws.amazon.com/datasync/latest/userguide/choosing-task-mode.html#task-mode-differences>`_ .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-datasync-task.html#cfn-datasync-task-taskmode
+        '''
+        result = self._values.get("task_mode")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def task_report_config(
         self,
@@ -10192,6 +10235,7 @@ def _typecheckingstub__9add9673a1f0ceb078949e967bce91066ff7e0441dae95d55c11c4a50
     options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.OptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     schedule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskScheduleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+    task_mode: typing.Optional[builtins.str] = None,
     task_report_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskReportConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -10269,6 +10313,12 @@ def _typecheckingstub__b6a7067dff337df84908e53f4652767faada60769f6c9d1eed4c84d05
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__6e99e4be24e51c3d44b26f48102cf77d9140bcbda1c9d60362e39294acbc3244(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__06ecaf368f7ae42942552393e7a68a01ddc8712caa5620400a489d0b07baae6e(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTask.TaskReportConfigProperty]],
 ) -> None:
@@ -10415,6 +10465,7 @@ def _typecheckingstub__5632ab868186e470f4d8f0c14e3f12b71107be017f54f3194a076b9da
     options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.OptionsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     schedule: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskScheduleProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+    task_mode: typing.Optional[builtins.str] = None,
     task_report_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTask.TaskReportConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""