aws-cdk-lib 2.186.0__py3-none-any.whl → 2.187.0__py3-none-any.whl

aws_cdk/__init__.py

@@ -1562,6 +1562,108 @@ from .cx_api import (
 )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.AddDockerImageAssetOptions",
+    jsii_struct_bases=[],
+    name_mapping={"display_name": "displayName"},
+)
+class AddDockerImageAssetOptions:
+    def __init__(self, *, display_name: typing.Optional[builtins.str] = None) -> None:
+        '''Options for the addDockerImageAsset operation.
+
+        :param display_name: A display name to associate with the asset. Default: - No display name
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk as cdk
+            
+            add_docker_image_asset_options = cdk.AddDockerImageAssetOptions(
+                display_name="displayName"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5a1ac212aad6af3e005718717aa2d00b8a797e24b74644f38d11d9f5ced18b43)
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if display_name is not None:
+            self._values["display_name"] = display_name
+
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name to associate with the asset.
+
+        :default: - No display name
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AddDockerImageAssetOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.AddFileAssetOptions",
+    jsii_struct_bases=[],
+    name_mapping={"display_name": "displayName"},
+)
+class AddFileAssetOptions:
+    def __init__(self, *, display_name: typing.Optional[builtins.str] = None) -> None:
+        '''Options for the addFileAsset operation.
+
+        :param display_name: A display name to associate with the asset. Default: - No display name
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk as cdk
+            
+            add_file_asset_options = cdk.AddFileAssetOptions(
+                display_name="displayName"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3b7bb14c4d35bab2918fcff6fafc6bf8560391fa80cf7e743756928a3ff744a2)
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if display_name is not None:
+            self._values["display_name"] = display_name
+
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name to associate with the asset.
+
+        :default: - No display name
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AddFileAssetOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class Annotations(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.Annotations"):
     '''Includes API for attaching annotations such as warning messages to constructs.
 
@@ -2562,13 +2664,9 @@ class AssetManifestBuilder(
         stack: "Stack",
         source_hash: builtins.str,
         source: typing.Union[_DockerImageSource_5db2cfa3, typing.Dict[builtins.str, typing.Any]],
+        dest: typing.Union[_DockerImageDestination_132046c7, typing.Dict[builtins.str, typing.Any]],
         *,
-        image_tag: builtins.str,
-        repository_name: builtins.str,
-        assume_role_additional_options: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-        assume_role_arn: typing.Optional[builtins.str] = None,
-        assume_role_external_id: typing.Optional[builtins.str] = None,
-        region: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
     ) -> _DockerImageDestination_132046c7:
         '''Add a docker asset source and destination to the manifest.
 
@@ -2577,28 +2675,18 @@ class AssetManifestBuilder(
         :param stack: -
         :param source_hash: -
         :param source: -
-        :param image_tag: Tag of the image to publish.
-        :param repository_name: Name of the ECR repository to publish to.
-        :param assume_role_additional_options: Additional options to pass to STS when assuming the role. - ``RoleArn`` should not be used. Use the dedicated ``assumeRoleArn`` property instead. - ``ExternalId`` should not be used. Use the dedicated ``assumeRoleExternalId`` instead. Default: - No additional options.
-        :param assume_role_arn: The role that needs to be assumed while publishing this asset. Default: - No role will be assumed
-        :param assume_role_external_id: The ExternalId that needs to be supplied while assuming this role. Default: - No ExternalId will be supplied
-        :param region: The region where this asset will need to be published. Default: - Current region
+        :param dest: -
+        :param display_name: A display name to associate with the asset. Default: - No display name
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__e4e4609083793a8b31752be2f457b6b1f1220145a70469bafc48a142860684a6)
             check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
             check_type(argname="argument source_hash", value=source_hash, expected_type=type_hints["source_hash"])
             check_type(argname="argument source", value=source, expected_type=type_hints["source"])
-        dest = _DockerImageDestination_132046c7(
-            image_tag=image_tag,
-            repository_name=repository_name,
-            assume_role_additional_options=assume_role_additional_options,
-            assume_role_arn=assume_role_arn,
-            assume_role_external_id=assume_role_external_id,
-            region=region,
-        )
+            check_type(argname="argument dest", value=dest, expected_type=type_hints["dest"])
+        options = AddDockerImageAssetOptions(display_name=display_name)
 
-        return typing.cast(_DockerImageDestination_132046c7, jsii.invoke(self, "addDockerImageAsset", [stack, source_hash, source, dest]))
+        return typing.cast(_DockerImageDestination_132046c7, jsii.invoke(self, "addDockerImageAsset", [stack, source_hash, source, dest, options]))
 
     @jsii.member(jsii_name="addFileAsset")
     def add_file_asset(
@@ -2606,13 +2694,9 @@ class AssetManifestBuilder(
         stack: "Stack",
         source_hash: builtins.str,
         source: typing.Union[_FileSource_66254048, typing.Dict[builtins.str, typing.Any]],
+        dest: typing.Union[_FileDestination_7d285b38, typing.Dict[builtins.str, typing.Any]],
         *,
-        bucket_name: builtins.str,
-        object_key: builtins.str,
-        assume_role_additional_options: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-        assume_role_arn: typing.Optional[builtins.str] = None,
-        assume_role_external_id: typing.Optional[builtins.str] = None,
-        region: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
     ) -> _FileDestination_7d285b38:
         '''Add a file asset source and destination to the manifest.
 
@@ -2621,38 +2705,27 @@ class AssetManifestBuilder(
         :param stack: -
         :param source_hash: -
         :param source: -
-        :param bucket_name: The name of the bucket.
-        :param object_key: The destination object key.
-        :param assume_role_additional_options: Additional options to pass to STS when assuming the role. - ``RoleArn`` should not be used. Use the dedicated ``assumeRoleArn`` property instead. - ``ExternalId`` should not be used. Use the dedicated ``assumeRoleExternalId`` instead. Default: - No additional options.
-        :param assume_role_arn: The role that needs to be assumed while publishing this asset. Default: - No role will be assumed
-        :param assume_role_external_id: The ExternalId that needs to be supplied while assuming this role. Default: - No ExternalId will be supplied
-        :param region: The region where this asset will need to be published. Default: - Current region
+        :param dest: -
+        :param display_name: A display name to associate with the asset. Default: - No display name
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__f12f649e9db582bca540895dead136ba4f8ce5c52abc11eb50e5224da26e06f5)
             check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
             check_type(argname="argument source_hash", value=source_hash, expected_type=type_hints["source_hash"])
             check_type(argname="argument source", value=source, expected_type=type_hints["source"])
-        dest = _FileDestination_7d285b38(
-            bucket_name=bucket_name,
-            object_key=object_key,
-            assume_role_additional_options=assume_role_additional_options,
-            assume_role_arn=assume_role_arn,
-            assume_role_external_id=assume_role_external_id,
-            region=region,
-        )
+            check_type(argname="argument dest", value=dest, expected_type=type_hints["dest"])
+        options = AddFileAssetOptions(display_name=display_name)
 
-        return typing.cast(_FileDestination_7d285b38, jsii.invoke(self, "addFileAsset", [stack, source_hash, source, dest]))
+        return typing.cast(_FileDestination_7d285b38, jsii.invoke(self, "addFileAsset", [stack, source_hash, source, dest, options]))
 
     @jsii.member(jsii_name="defaultAddDockerImageAsset")
     def default_add_docker_image_asset(
         self,
         stack: "Stack",
         asset: typing.Union["DockerImageAssetSource", typing.Dict[builtins.str, typing.Any]],
+        target: typing.Union["AssetManifestDockerImageDestination", typing.Dict[builtins.str, typing.Any]],
         *,
-        repository_name: builtins.str,
-        docker_tag_prefix: typing.Optional[builtins.str] = None,
-        role: typing.Optional[typing.Union["RoleOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        display_name: typing.Optional[builtins.str] = None,
     ) -> _DockerImageDestination_132046c7:
         '''Add a docker image asset to the manifest with default settings.
 
@@ -2660,31 +2733,26 @@ class AssetManifestBuilder(
 
         :param stack: -
         :param asset: -
-        :param repository_name: Repository name where the docker image asset should be written.
-        :param docker_tag_prefix: Prefix to add to the asset hash to make the Docker image tag. Default: ''
-        :param role: Role to use to perform the upload. Default: - No role
+        :param target: -
+        :param display_name: A display name to associate with the asset. Default: - No display name
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d8572c82a112aaa61153d2b958b8042f9e061141b483b1b0ce6429f9f7c11296)
             check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
             check_type(argname="argument asset", value=asset, expected_type=type_hints["asset"])
-        target = AssetManifestDockerImageDestination(
-            repository_name=repository_name,
-            docker_tag_prefix=docker_tag_prefix,
-            role=role,
-        )
+            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
+        options = AddDockerImageAssetOptions(display_name=display_name)
 
-        return typing.cast(_DockerImageDestination_132046c7, jsii.invoke(self, "defaultAddDockerImageAsset", [stack, asset, target]))
+        return typing.cast(_DockerImageDestination_132046c7, jsii.invoke(self, "defaultAddDockerImageAsset", [stack, asset, target, options]))
 
     @jsii.member(jsii_name="defaultAddFileAsset")
     def default_add_file_asset(
         self,
         stack: "Stack",
         asset: typing.Union["FileAssetSource", typing.Dict[builtins.str, typing.Any]],
+        target: typing.Union["AssetManifestFileDestination", typing.Dict[builtins.str, typing.Any]],
         *,
-        bucket_name: builtins.str,
-        bucket_prefix: typing.Optional[builtins.str] = None,
-        role: typing.Optional[typing.Union["RoleOptions", typing.Dict[builtins.str, typing.Any]]] = None,
+        display_name: typing.Optional[builtins.str] = None,
     ) -> _FileDestination_7d285b38:
         '''Add a file asset to the manifest with default settings.
 
@@ -2693,19 +2761,17 @@ class AssetManifestBuilder(
 
         :param stack: -
         :param asset: -
-        :param bucket_name: Bucket name where the file asset should be written.
-        :param bucket_prefix: Prefix to prepend to the asset hash. Default: ''
-        :param role: Role to use for uploading. Default: - current role
+        :param target: -
+        :param display_name: A display name to associate with the asset. Default: - No display name
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__085bf08106379af70653604775528303d429c31168f56c2439ed96f6b61197be)
             check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
             check_type(argname="argument asset", value=asset, expected_type=type_hints["asset"])
-        target = AssetManifestFileDestination(
-            bucket_name=bucket_name, bucket_prefix=bucket_prefix, role=role
-        )
+            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
+        options = AddFileAssetOptions(display_name=display_name)
 
-        return typing.cast(_FileDestination_7d285b38, jsii.invoke(self, "defaultAddFileAsset", [stack, asset, target]))
+        return typing.cast(_FileDestination_7d285b38, jsii.invoke(self, "defaultAddFileAsset", [stack, asset, target, options]))
 
     @jsii.member(jsii_name="emitManifest")
     def emit_manifest(
@@ -12375,6 +12441,7 @@ class DockerImageAssetLocation:
         "source_hash": "sourceHash",
         "asset_name": "assetName",
         "directory_name": "directoryName",
+        "display_name": "displayName",
         "docker_build_args": "dockerBuildArgs",
         "docker_build_secrets": "dockerBuildSecrets",
         "docker_build_ssh": "dockerBuildSsh",
@@ -12396,6 +12463,7 @@ class DockerImageAssetSource:
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -12413,6 +12481,7 @@ class DockerImageAssetSource:
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -12440,6 +12509,7 @@ class DockerImageAssetSource:
                 # the properties below are optional
                 asset_name="assetName",
                 directory_name="directoryName",
+                display_name="displayName",
                 docker_build_args={
                     "docker_build_args_key": "dockerBuildArgs"
                 },
@@ -12479,6 +12549,7 @@ class DockerImageAssetSource:
             check_type(argname="argument source_hash", value=source_hash, expected_type=type_hints["source_hash"])
             check_type(argname="argument asset_name", value=asset_name, expected_type=type_hints["asset_name"])
             check_type(argname="argument directory_name", value=directory_name, expected_type=type_hints["directory_name"])
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
             check_type(argname="argument docker_build_args", value=docker_build_args, expected_type=type_hints["docker_build_args"])
             check_type(argname="argument docker_build_secrets", value=docker_build_secrets, expected_type=type_hints["docker_build_secrets"])
             check_type(argname="argument docker_build_ssh", value=docker_build_ssh, expected_type=type_hints["docker_build_ssh"])
@@ -12498,6 +12569,8 @@ class DockerImageAssetSource:
             self._values["asset_name"] = asset_name
         if directory_name is not None:
             self._values["directory_name"] = directory_name
+        if display_name is not None:
+            self._values["display_name"] = display_name
         if docker_build_args is not None:
             self._values["docker_build_args"] = docker_build_args
         if docker_build_secrets is not None:
@@ -12558,6 +12631,18 @@ class DockerImageAssetSource:
         result = self._values.get("directory_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name for this asset.
+
+        If supplied, the display name will be used in locations where the asset
+        identifier is printed, like in the CLI progress information.
+
+        :default: - The asset hash is used to display the asset
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def docker_build_args(
         self,
@@ -13894,6 +13979,7 @@ class FileAssetPackaging(enum.Enum):
     name_mapping={
         "source_hash": "sourceHash",
         "deploy_time": "deployTime",
+        "display_name": "displayName",
         "executable": "executable",
         "file_name": "fileName",
         "packaging": "packaging",
@@ -13905,6 +13991,7 @@ class FileAssetSource:
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -13913,6 +14000,7 @@ class FileAssetSource:
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -13930,6 +14018,7 @@ class FileAssetSource:
             
                 # the properties below are optional
                 deploy_time=False,
+                display_name="displayName",
                 executable=["executable"],
                 file_name="fileName",
                 packaging=cdk.FileAssetPackaging.ZIP_DIRECTORY
@@ -13939,6 +14028,7 @@ class FileAssetSource:
             type_hints = typing.get_type_hints(_typecheckingstub__6a2ffcc71f7081ed98f77dcff398894a56d300191a4893d6469a2218ffed2957)
             check_type(argname="argument source_hash", value=source_hash, expected_type=type_hints["source_hash"])
             check_type(argname="argument deploy_time", value=deploy_time, expected_type=type_hints["deploy_time"])
+            check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
             check_type(argname="argument executable", value=executable, expected_type=type_hints["executable"])
             check_type(argname="argument file_name", value=file_name, expected_type=type_hints["file_name"])
             check_type(argname="argument packaging", value=packaging, expected_type=type_hints["packaging"])
@@ -13947,6 +14037,8 @@ class FileAssetSource:
         }
         if deploy_time is not None:
             self._values["deploy_time"] = deploy_time
+        if display_name is not None:
+            self._values["display_name"] = display_name
         if executable is not None:
             self._values["executable"] = executable
         if file_name is not None:
@@ -13985,6 +14077,18 @@ class FileAssetSource:
         result = self._values.get("deploy_time")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def display_name(self) -> typing.Optional[builtins.str]:
+        '''A display name for this asset.
+
+        If supplied, the display name will be used in locations where the asset
+        identifier is printed, like in the CLI progress information.
+
+        :default: - The asset hash is used to display the asset
+        '''
+        result = self._values.get("display_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def executable(self) -> typing.Optional[typing.List[builtins.str]]:
         '''An external command that will produce the packaged asset.
@@ -16699,6 +16803,7 @@ class IStackSynthesizer(typing_extensions.Protocol):
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -16719,6 +16824,7 @@ class IStackSynthesizer(typing_extensions.Protocol):
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -16740,6 +16846,7 @@ class IStackSynthesizer(typing_extensions.Protocol):
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -16750,6 +16857,7 @@ class IStackSynthesizer(typing_extensions.Protocol):
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -16805,6 +16913,7 @@ class _IStackSynthesizerProxy:
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -16825,6 +16934,7 @@ class _IStackSynthesizerProxy:
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -16842,6 +16952,7 @@ class _IStackSynthesizerProxy:
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -16864,6 +16975,7 @@ class _IStackSynthesizerProxy:
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -16874,6 +16986,7 @@ class _IStackSynthesizerProxy:
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -16881,6 +16994,7 @@ class _IStackSynthesizerProxy:
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -18405,6 +18519,24 @@ class Names(metaclass=jsii.JSIIMeta, jsii_type="aws-cdk-lib.Names"):
             check_type(argname="argument node", value=node, expected_type=type_hints["node"])
         return typing.cast(builtins.str, jsii.sinvoke(cls, "nodeUniqueId", [node]))
 
+    @jsii.member(jsii_name="stackRelativeConstructPath")
+    @builtins.classmethod
+    def stack_relative_construct_path(
+        cls,
+        construct: _constructs_77d1e7e8.IConstruct,
+    ) -> builtins.str:
+        '''Return the construct path of the given construct, starting at the nearest enclosing Stack.
+
+        Skips over Nested Stacks, in other words Nested Stacks are included in the construct
+        paths.
+
+        :param construct: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__307d610951ef0b232f9222edc6ac5421fa347060bc21fb75e850a338e9aa77c7)
+            check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
+        return typing.cast(builtins.str, jsii.sinvoke(cls, "stackRelativeConstructPath", [construct]))
+
     @jsii.member(jsii_name="uniqueId")
     @builtins.classmethod
     def unique_id(cls, construct: _constructs_77d1e7e8.IConstruct) -> builtins.str:
@@ -19428,41 +19560,20 @@ class RemovalPolicy(enum.Enum):
 
     Example::
 
-        import aws_cdk.aws_opensearchservice as opensearch
-        
-        # api: appsync.GraphqlApi
-        
-        
-        user = iam.User(self, "User")
-        domain = opensearch.Domain(self, "Domain",
-            version=opensearch.EngineVersion.OPENSEARCH_2_3,
-            removal_policy=RemovalPolicy.DESTROY,
-            fine_grained_access_control=opensearch.AdvancedSecurityOptions(master_user_arn=user.user_arn),
-            encryption_at_rest=opensearch.EncryptionAtRestOptions(enabled=True),
-            node_to_node_encryption=True,
-            enforce_https=True
-        )
-        ds = api.add_open_search_data_source("ds", domain)
+        # my_role: iam.Role
         
-        ds.create_resolver("QueryGetTestsResolver",
-            type_name="Query",
-            field_name="getTests",
-            request_mapping_template=appsync.MappingTemplate.from_string(JSON.stringify({
-                "version": "2017-02-28",
-                "operation": "GET",
-                "path": "/id/post/_search",
-                "params": {
-                    "headers": {},
-                    "query_string": {},
-                    "body": {"from": 0, "size": 50}
-                }
-            })),
-            response_mapping_template=appsync.MappingTemplate.from_string("""[
-                    #foreach($entry in $context.result.hits.hits)
-                    #if( $velocityCount > 1 ) , #end
-                    $utils.toJson($entry.get("_source"))
-                    #end
-                  ]""")
+        cr.AwsCustomResource(self, "Customized",
+            role=my_role,  # must be assumable by the `lambda.amazonaws.com` service principal
+            timeout=Duration.minutes(10),  # defaults to 2 minutes
+            memory_size=1025,  # defaults to 512 if installLatestAwsSdk is true
+            log_group=logs.LogGroup(self, "AwsCustomResourceLogs",
+                retention=logs.RetentionDays.ONE_DAY
+            ),
+            function_name="my-custom-name",  # defaults to a CloudFormation generated name
+            removal_policy=RemovalPolicy.RETAIN,  # defaults to `RemovalPolicy.DESTROY`
+            policy=cr.AwsCustomResourcePolicy.from_sdk_calls(
+                resources=cr.AwsCustomResourcePolicy.ANY_RESOURCE
+            )
         )
     '''
 
@@ -22319,6 +22430,7 @@ class StackSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -22345,6 +22457,7 @@ class StackSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -22367,6 +22480,7 @@ class StackSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -22383,6 +22497,7 @@ class StackSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -22675,6 +22790,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -22701,6 +22817,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -22718,6 +22835,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -22740,6 +22858,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -22756,6 +22875,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -22763,6 +22883,7 @@ class _StackSynthesizerProxy(StackSynthesizer):
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -35545,6 +35666,7 @@ class LegacyStackSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -35571,6 +35693,7 @@ class LegacyStackSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -35588,6 +35711,7 @@ class LegacyStackSynthesizer(
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -35610,6 +35734,7 @@ class LegacyStackSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -35626,6 +35751,7 @@ class LegacyStackSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -35633,6 +35759,7 @@ class LegacyStackSynthesizer(
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -35862,6 +35989,7 @@ class NestedStackSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -35888,6 +36016,7 @@ class NestedStackSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -35905,6 +36034,7 @@ class NestedStackSynthesizer(
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -35927,6 +36057,7 @@ class NestedStackSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -35943,6 +36074,7 @@ class NestedStackSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -35950,6 +36082,7 @@ class NestedStackSynthesizer(
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -36128,6 +36261,7 @@ class CliCredentialsStackSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -36154,6 +36288,7 @@ class CliCredentialsStackSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -36171,6 +36306,7 @@ class CliCredentialsStackSynthesizer(
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -36193,6 +36329,7 @@ class CliCredentialsStackSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -36209,6 +36346,7 @@ class CliCredentialsStackSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -36216,6 +36354,7 @@ class CliCredentialsStackSynthesizer(
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -36386,6 +36525,7 @@ class DefaultStackSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -36412,6 +36552,7 @@ class DefaultStackSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -36429,6 +36570,7 @@ class DefaultStackSynthesizer(
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -36451,6 +36593,7 @@ class DefaultStackSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -36467,6 +36610,7 @@ class DefaultStackSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -36474,6 +36618,7 @@ class DefaultStackSynthesizer(
         asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -36703,6 +36848,7 @@ class BootstraplessSynthesizer(
         source_hash: builtins.str,
         asset_name: typing.Optional[builtins.str] = None,
         directory_name: typing.Optional[builtins.str] = None,
+        display_name: typing.Optional[builtins.str] = None,
         docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -36729,6 +36875,7 @@ class BootstraplessSynthesizer(
         :param source_hash: The hash of the contents of the docker build context. This hash is used throughout the system to identify this image and avoid duplicate work in case the source did not change. NOTE: this means that if you wish to update your docker image, you must make a modification to the source (e.g. add some metadata to your Dockerfile).
         :param asset_name: Unique identifier of the docker image asset and its potential revisions. Required if using AppScopedStagingSynthesizer. Default: - no asset name
         :param directory_name: The directory where the Dockerfile is stored, must be relative to the cloud assembly root. Default: - Exactly one of ``directoryName`` and ``executable`` is required
+        :param display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param docker_build_args: Build args to pass to the ``docker build`` command. Since Docker build arguments are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build args are passed
         :param docker_build_secrets: Build secrets to pass to the ``docker build`` command. Since Docker build secrets are resolved before deployment, keys and values cannot refer to unresolved tokens (such as ``lambda.functionArn`` or ``queue.queueUrl``). Only allowed when ``directoryName`` is specified. Default: - no build secrets are passed
         :param docker_build_ssh: SSH agent socket or keys to pass to the ``docker buildx`` command. Default: - no ssh arg is passed
@@ -36746,6 +36893,7 @@ class BootstraplessSynthesizer(
             source_hash=source_hash,
             asset_name=asset_name,
             directory_name=directory_name,
+            display_name=display_name,
             docker_build_args=docker_build_args,
             docker_build_secrets=docker_build_secrets,
             docker_build_ssh=docker_build_ssh,
@@ -36768,6 +36916,7 @@ class BootstraplessSynthesizer(
         *,
         source_hash: builtins.str,
         deploy_time: typing.Optional[builtins.bool] = None,
+        display_name: typing.Optional[builtins.str] = None,
         executable: typing.Optional[typing.Sequence[builtins.str]] = None,
         file_name: typing.Optional[builtins.str] = None,
         packaging: typing.Optional[FileAssetPackaging] = None,
@@ -36784,6 +36933,7 @@ class BootstraplessSynthesizer(
 
         :param source_hash: A hash on the content source. This hash is used to uniquely identify this asset throughout the system. If this value doesn't change, the asset will not be rebuilt or republished.
         :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 display_name: A display name for this asset. If supplied, the display name will be used in locations where the asset identifier is printed, like in the CLI progress information. Default: - The asset hash is used to display the asset
         :param executable: An external command that will produce the packaged asset. The command should produce the location of a ZIP file on ``stdout``. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param file_name: The path, relative to the root of the cloud assembly, in which this asset source resides. This can be a path to a file or a directory, depending on the packaging type. Default: - Exactly one of ``fileName`` and ``executable`` is required
         :param packaging: Which type of packaging to perform. Default: - Required if ``fileName`` is specified.
@@ -36791,6 +36941,7 @@ class BootstraplessSynthesizer(
         _asset = FileAssetSource(
             source_hash=source_hash,
             deploy_time=deploy_time,
+            display_name=display_name,
             executable=executable,
             file_name=file_name,
             packaging=packaging,
@@ -36811,6 +36962,8 @@ class BootstraplessSynthesizer(
 
 
 __all__ = [
+    "AddDockerImageAssetOptions",
+    "AddFileAssetOptions",
     "Annotations",
     "App",
     "AppProps",
@@ -37648,6 +37801,20 @@ from . import pipelines
 from . import region_info
 from . import triggers
 
+def _typecheckingstub__5a1ac212aad6af3e005718717aa2d00b8a797e24b74644f38d11d9f5ced18b43(
+    *,
+    display_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3b7bb14c4d35bab2918fcff6fafc6bf8560391fa80cf7e743756928a3ff744a2(
+    *,
+    display_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__cfddeb4c359528028785fb7ca8a01e86bcda81d53c82cdaef6ad18dd0520ab91(
     scope: _constructs_77d1e7e8.IConstruct,
 ) -> None:
@@ -37781,13 +37948,9 @@ def _typecheckingstub__e4e4609083793a8b31752be2f457b6b1f1220145a70469bafc48a1428
     stack: Stack,
     source_hash: builtins.str,
     source: typing.Union[_DockerImageSource_5db2cfa3, typing.Dict[builtins.str, typing.Any]],
+    dest: typing.Union[_DockerImageDestination_132046c7, typing.Dict[builtins.str, typing.Any]],
     *,
-    image_tag: builtins.str,
-    repository_name: builtins.str,
-    assume_role_additional_options: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-    assume_role_arn: typing.Optional[builtins.str] = None,
-    assume_role_external_id: typing.Optional[builtins.str] = None,
-    region: typing.Optional[builtins.str] = None,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -37796,13 +37959,9 @@ def _typecheckingstub__f12f649e9db582bca540895dead136ba4f8ce5c52abc11eb50e5224da
     stack: Stack,
     source_hash: builtins.str,
     source: typing.Union[_FileSource_66254048, typing.Dict[builtins.str, typing.Any]],
+    dest: typing.Union[_FileDestination_7d285b38, typing.Dict[builtins.str, typing.Any]],
     *,
-    bucket_name: builtins.str,
-    object_key: builtins.str,
-    assume_role_additional_options: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
-    assume_role_arn: typing.Optional[builtins.str] = None,
-    assume_role_external_id: typing.Optional[builtins.str] = None,
-    region: typing.Optional[builtins.str] = None,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -37810,10 +37969,9 @@ def _typecheckingstub__f12f649e9db582bca540895dead136ba4f8ce5c52abc11eb50e5224da
 def _typecheckingstub__d8572c82a112aaa61153d2b958b8042f9e061141b483b1b0ce6429f9f7c11296(
     stack: Stack,
     asset: typing.Union[DockerImageAssetSource, typing.Dict[builtins.str, typing.Any]],
+    target: typing.Union[AssetManifestDockerImageDestination, typing.Dict[builtins.str, typing.Any]],
     *,
-    repository_name: builtins.str,
-    docker_tag_prefix: typing.Optional[builtins.str] = None,
-    role: typing.Optional[typing.Union[RoleOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -37821,10 +37979,9 @@ def _typecheckingstub__d8572c82a112aaa61153d2b958b8042f9e061141b483b1b0ce6429f9f
 def _typecheckingstub__085bf08106379af70653604775528303d429c31168f56c2439ed96f6b61197be(
     stack: Stack,
     asset: typing.Union[FileAssetSource, typing.Dict[builtins.str, typing.Any]],
+    target: typing.Union[AssetManifestFileDestination, typing.Dict[builtins.str, typing.Any]],
     *,
-    bucket_name: builtins.str,
-    bucket_prefix: typing.Optional[builtins.str] = None,
-    role: typing.Optional[typing.Union[RoleOptions, typing.Dict[builtins.str, typing.Any]]] = None,
+    display_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -38871,6 +39028,7 @@ def _typecheckingstub__9dc551978a96bea78751c4b4d32e87775d67d2a68f351884cf05c35d5
     source_hash: builtins.str,
     asset_name: typing.Optional[builtins.str] = None,
     directory_name: typing.Optional[builtins.str] = None,
+    display_name: typing.Optional[builtins.str] = None,
     docker_build_args: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     docker_build_secrets: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     docker_build_ssh: typing.Optional[builtins.str] = None,
@@ -39071,6 +39229,7 @@ def _typecheckingstub__6a2ffcc71f7081ed98f77dcff398894a56d300191a4893d6469a2218f
     *,
     source_hash: builtins.str,
     deploy_time: typing.Optional[builtins.bool] = None,
+    display_name: typing.Optional[builtins.str] = None,
     executable: typing.Optional[typing.Sequence[builtins.str]] = None,
     file_name: typing.Optional[builtins.str] = None,
     packaging: typing.Optional[FileAssetPackaging] = None,
@@ -39777,6 +39936,12 @@ def _typecheckingstub__569ac5c6adbac9575b4137a0343aea0625df007d849957bfacf2e65a0
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__307d610951ef0b232f9222edc6ac5421fa347060bc21fb75e850a338e9aa77c7(
+    construct: _constructs_77d1e7e8.IConstruct,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8c1ba4bae2d17f227472b42e48bc60d8c4a5dd7a3c60793d3b332fc432589917(
     construct: _constructs_77d1e7e8.IConstruct,
 ) -> None: