cdktn 0.25.0.dev26__tar.gz → 0.25.0.dev28__tar.gz

{cdktn-0.25.0.dev26/src/cdktn.egg-info → cdktn-0.25.0.dev28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdktn
-Version: 0.25.0.dev26
+Version: 0.25.0.dev28
 Summary: Cloud Development Kit for Terraform
 Home-page: https://github.com/open-constructs/cdk-terrain
 Author: OpenConstructs

{cdktn-0.25.0.dev26 → cdktn-0.25.0.dev28}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "cdktn",
-    "version": "0.25.0.dev26",
+    "version": "0.25.0.dev28",
     "description": "Cloud Development Kit for Terraform",
     "license": "MPL-2.0",
     "url": "https://github.com/open-constructs/cdk-terrain",
@@ -27,7 +27,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "cdktn._jsii": [
-            "cdktn@0.25.0-pre.26.jsii.tgz"
+            "cdktn@0.25.0-pre.28.jsii.tgz"
         ],
         "cdktn": [
             "py.typed"

{cdktn-0.25.0.dev26 → cdktn-0.25.0.dev28}/src/cdktn/__init__.py

@@ -782,6 +782,182 @@ class AssetPackaging(metaclass=jsii.JSIIMeta, jsii_type="cdktn.AssetPackaging"):
         return typing.cast("IAssetPackaging", jsii.sget(cls, "ZIP"))
 
 
+@jsii.data_type(
+    jsii_type="cdktn.AssetStagingOptions",
+    jsii_struct_bases=[AssetOptions],
+    name_mapping={
+        "asset_hash": "assetHash",
+        "asset_hash_type": "assetHashType",
+        "packaging": "packaging",
+        "source_path": "sourcePath",
+        "exclude": "exclude",
+        "extra_hash": "extraHash",
+        "ignore_strategy": "ignoreStrategy",
+    },
+)
+class AssetStagingOptions(AssetOptions):
+    def __init__(
+        self,
+        *,
+        asset_hash: typing.Optional[builtins.str] = None,
+        asset_hash_type: typing.Optional["AssetHashType"] = None,
+        packaging: "IAssetPackaging",
+        source_path: builtins.str,
+        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+        extra_hash: typing.Optional[builtins.str] = None,
+        ignore_strategy: typing.Optional["IIgnoreStrategy"] = None,
+    ) -> None:
+        '''(experimental) Options for {@link AssetStaging}.
+
+        :param asset_hash: (experimental) Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. The value is used verbatim as the asset hash, and because it names the staged asset file it may only contain letters, digits, ``_``, ``.`` and ``-``. 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 cloud storage, 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: (experimental) 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 packaging: (experimental) How the staged result is produced and shaped. The caller decides this (e.g. from its own ``AssetType``) — ``AssetStaging`` never infers or changes it based on ``exclude``/``extraHash``.
+        :param source_path: (experimental) Absolute path to the source file or directory. Resolving a relative path against ``cdktf.json`` is the caller's responsibility.
+        :param exclude: (experimental) Paths to exclude, relative to ``sourcePath``. Cannot be combined with ``ignoreStrategy``, which replaces this matcher rather than layering on top of it. Default: - nothing is excluded
+        :param extra_hash: (experimental) Extra information to fold into the hash (e.g. build instructions and other inputs). Default: - no extra hash
+        :param ignore_strategy: (experimental) Exclusion matching, for callers that need ``.gitignore`` / ``.dockerignore`` parity rather than the built-in exact-path / suffix / directory matcher. Default: - ``exclude`` is used with the built-in matcher
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = cached_type_hints(_typecheckingstub__5026244ff290924dad88f65421d8025b8bcb105d693dec43cd93a0c7d8d0e7ba)
+            check_type(argname="argument asset_hash", value=asset_hash, expected_type=type_hints["asset_hash"])
+            check_type(argname="argument asset_hash_type", value=asset_hash_type, expected_type=type_hints["asset_hash_type"])
+            check_type(argname="argument packaging", value=packaging, expected_type=type_hints["packaging"])
+            check_type(argname="argument source_path", value=source_path, expected_type=type_hints["source_path"])
+            check_type(argname="argument exclude", value=exclude, expected_type=type_hints["exclude"])
+            check_type(argname="argument extra_hash", value=extra_hash, expected_type=type_hints["extra_hash"])
+            check_type(argname="argument ignore_strategy", value=ignore_strategy, expected_type=type_hints["ignore_strategy"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "packaging": packaging,
+            "source_path": source_path,
+        }
+        if asset_hash is not None:
+            self._values["asset_hash"] = asset_hash
+        if asset_hash_type is not None:
+            self._values["asset_hash_type"] = asset_hash_type
+        if exclude is not None:
+            self._values["exclude"] = exclude
+        if extra_hash is not None:
+            self._values["extra_hash"] = extra_hash
+        if ignore_strategy is not None:
+            self._values["ignore_strategy"] = ignore_strategy
+
+    @builtins.property
+    def asset_hash(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Specify a custom hash for this asset.
+
+        If ``assetHashType`` is set it must
+        be set to ``AssetHashType.CUSTOM``. The value is used verbatim as the asset
+        hash, and because it names the staged asset file it may only contain
+        letters, digits, ``_``, ``.`` and ``-``.
+
+        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 cloud storage, 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``
+
+        :stability: experimental
+        '''
+        result = self._values.get("asset_hash")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def asset_hash_type(self) -> typing.Optional["AssetHashType"]:
+        '''(experimental) 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``.
+
+        :stability: experimental
+        '''
+        result = self._values.get("asset_hash_type")
+        return typing.cast(typing.Optional["AssetHashType"], result)
+
+    @builtins.property
+    def packaging(self) -> "IAssetPackaging":
+        '''(experimental) How the staged result is produced and shaped.
+
+        The caller decides this
+        (e.g. from its own ``AssetType``) — ``AssetStaging`` never infers or changes
+        it based on ``exclude``/``extraHash``.
+
+        :stability: experimental
+        '''
+        result = self._values.get("packaging")
+        assert result is not None, "Required property 'packaging' is missing"
+        return typing.cast("IAssetPackaging", result)
+
+    @builtins.property
+    def source_path(self) -> builtins.str:
+        '''(experimental) Absolute path to the source file or directory.
+
+        Resolving a relative path
+        against ``cdktf.json`` is the caller's responsibility.
+
+        :stability: experimental
+        '''
+        result = self._values.get("source_path")
+        assert result is not None, "Required property 'source_path' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def exclude(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Paths to exclude, relative to ``sourcePath``.
+
+        Cannot be combined with
+        ``ignoreStrategy``, which replaces this matcher rather than layering on
+        top of it.
+
+        :default: - nothing is excluded
+
+        :stability: experimental
+        '''
+        result = self._values.get("exclude")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def extra_hash(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Extra information to fold into the hash (e.g. build instructions and other inputs).
+
+        :default: - no extra hash
+
+        :stability: experimental
+        '''
+        result = self._values.get("extra_hash")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def ignore_strategy(self) -> typing.Optional["IIgnoreStrategy"]:
+        '''(experimental) Exclusion matching, for callers that need ``.gitignore`` / ``.dockerignore`` parity rather than the built-in exact-path / suffix / directory matcher.
+
+        :default: - ``exclude`` is used with the built-in matcher
+
+        :stability: experimental
+        '''
+        result = self._values.get("ignore_strategy")
+        return typing.cast(typing.Optional["IIgnoreStrategy"], 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 "AssetStagingOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="cdktn.AssetType")
 class AssetType(enum.Enum):
     '''
@@ -5217,6 +5393,24 @@ class IAssetPackaging(typing_extensions.Protocol):
         '''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="omitsDirectoryEntries")
+    def omits_directory_entries(self) -> builtins.bool:
+        '''(experimental) Whether ``pack`` emits an artifact with no directory entries of its own — only the ignore-strategy-aware source walk.
+
+        ``hashPath``'s ``archive`` frame
+        must agree with this or the hash and the artifact describe different
+        file sets.
+
+        ``ZipPackaging`` sets this because ``archiveSync`` never emits ZIP directory
+        entries. A directory-producing packaging that mirrors the source tree
+        (e.g. ``DirectoryPackaging``) leaves this false, since its directories are
+        real entries on disk.
+
+        :stability: experimental
+        '''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="producesDirectory")
     def produces_directory(self) -> builtins.bool:
@@ -5271,6 +5465,24 @@ class _IAssetPackagingProxy:
         '''
         return typing.cast(builtins.str, jsii.get(self, "extension"))
 
+    @builtins.property
+    @jsii.member(jsii_name="omitsDirectoryEntries")
+    def omits_directory_entries(self) -> builtins.bool:
+        '''(experimental) Whether ``pack`` emits an artifact with no directory entries of its own — only the ignore-strategy-aware source walk.
+
+        ``hashPath``'s ``archive`` frame
+        must agree with this or the hash and the artifact describe different
+        file sets.
+
+        ``ZipPackaging`` sets this because ``archiveSync`` never emits ZIP directory
+        entries. A directory-producing packaging that mirrors the source tree
+        (e.g. ``DirectoryPackaging``) leaves this false, since its directories are
+        real entries on disk.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.bool, jsii.get(self, "omitsDirectoryEntries"))
+
     @builtins.property
     @jsii.member(jsii_name="producesDirectory")
     def produces_directory(self) -> builtins.bool:
@@ -12933,6 +13145,8 @@ class TerraformAsset(
         path: builtins.str,
         asset_hash: typing.Optional[builtins.str] = None,
         asset_hash_type: typing.Optional["AssetHashType"] = None,
+        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+        extra_hash: typing.Optional[builtins.str] = None,
         type: typing.Optional["AssetType"] = None,
     ) -> None:
         '''(experimental) A Terraform Asset takes a file or directory outside of the CDK Terrain context and moves it into it.
@@ -12943,7 +13157,9 @@ class TerraformAsset(
         :param id: -
         :param path: 
         :param asset_hash: 
-        :param asset_hash_type: (experimental) How the ``assetHash`` is derived. ``SOURCE`` (the default) hashes the source path. ``CUSTOM`` uses the ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` is not supported yet — there is no bundling step to produce an output to hash — and throws if requested. If ``assetHash`` is set, this must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: AssetHashType.SOURCE
+        :param asset_hash_type: (experimental) How the ``assetHash`` is derived. ``SOURCE`` (the default) hashes the source path. ``CUSTOM`` uses the ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` also hashes the source path today — there is no bundling step yet, so the "output" of an asset is its source verbatim — but will hash the bundler's output once bundling is introduced. If ``assetHash`` is set, this must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: AssetHashType.SOURCE
+        :param exclude: (experimental) Paths to exclude from the asset, relative to ``path``. See ``AssetStagingOptions.exclude`` for the accepted forms. Both the computed hash and the staged/packed content honor the exclusion. Default: - nothing is excluded
+        :param extra_hash: (experimental) Extra information to fold into the hash (e.g. build instructions and other inputs). Default: - no extra hash
         :param type: 
 
         :stability: experimental
@@ -12956,6 +13172,8 @@ class TerraformAsset(
             path=path,
             asset_hash=asset_hash,
             asset_hash_type=asset_hash_type,
+            exclude=exclude,
+            extra_hash=extra_hash,
             type=type,
         )
 
@@ -13015,6 +13233,8 @@ class TerraformAsset(
         "path": "path",
         "asset_hash": "assetHash",
         "asset_hash_type": "assetHashType",
+        "exclude": "exclude",
+        "extra_hash": "extraHash",
         "type": "type",
     },
 )
@@ -13025,12 +13245,16 @@ class TerraformAssetConfig:
         path: builtins.str,
         asset_hash: typing.Optional[builtins.str] = None,
         asset_hash_type: typing.Optional["AssetHashType"] = None,
+        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+        extra_hash: typing.Optional[builtins.str] = None,
         type: typing.Optional["AssetType"] = None,
     ) -> None:
         '''
         :param path: 
         :param asset_hash: 
-        :param asset_hash_type: (experimental) How the ``assetHash`` is derived. ``SOURCE`` (the default) hashes the source path. ``CUSTOM`` uses the ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` is not supported yet — there is no bundling step to produce an output to hash — and throws if requested. If ``assetHash`` is set, this must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: AssetHashType.SOURCE
+        :param asset_hash_type: (experimental) How the ``assetHash`` is derived. ``SOURCE`` (the default) hashes the source path. ``CUSTOM`` uses the ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` also hashes the source path today — there is no bundling step yet, so the "output" of an asset is its source verbatim — but will hash the bundler's output once bundling is introduced. If ``assetHash`` is set, this must be ``undefined`` or ``AssetHashType.CUSTOM``. Default: AssetHashType.SOURCE
+        :param exclude: (experimental) Paths to exclude from the asset, relative to ``path``. See ``AssetStagingOptions.exclude`` for the accepted forms. Both the computed hash and the staged/packed content honor the exclusion. Default: - nothing is excluded
+        :param extra_hash: (experimental) Extra information to fold into the hash (e.g. build instructions and other inputs). Default: - no extra hash
         :param type: 
 
         :stability: experimental
@@ -13040,6 +13264,8 @@ class TerraformAssetConfig:
             check_type(argname="argument path", value=path, expected_type=type_hints["path"])
             check_type(argname="argument asset_hash", value=asset_hash, expected_type=type_hints["asset_hash"])
             check_type(argname="argument asset_hash_type", value=asset_hash_type, expected_type=type_hints["asset_hash_type"])
+            check_type(argname="argument exclude", value=exclude, expected_type=type_hints["exclude"])
+            check_type(argname="argument extra_hash", value=extra_hash, expected_type=type_hints["extra_hash"])
             check_type(argname="argument type", value=type, expected_type=type_hints["type"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "path": path,
@@ -13048,6 +13274,10 @@ class TerraformAssetConfig:
             self._values["asset_hash"] = asset_hash
         if asset_hash_type is not None:
             self._values["asset_hash_type"] = asset_hash_type
+        if exclude is not None:
+            self._values["exclude"] = exclude
+        if extra_hash is not None:
+            self._values["extra_hash"] = extra_hash
         if type is not None:
             self._values["type"] = type
 
@@ -13073,9 +13303,10 @@ class TerraformAssetConfig:
         '''(experimental) How the ``assetHash`` is derived.
 
         ``SOURCE`` (the default) hashes the source path. ``CUSTOM`` uses the
-        ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` is not
-        supported yet — there is no bundling step to produce an output to hash —
-        and throws if requested.
+        ``assetHash`` value verbatim and requires it to be set. ``OUTPUT`` also
+        hashes the source path today — there is no bundling step yet, so the
+        "output" of an asset is its source verbatim — but will hash the
+        bundler's output once bundling is introduced.
 
         If ``assetHash`` is set, this must be ``undefined`` or ``AssetHashType.CUSTOM``.
 
@@ -13086,6 +13317,32 @@ class TerraformAssetConfig:
         result = self._values.get("asset_hash_type")
         return typing.cast(typing.Optional["AssetHashType"], result)
 
+    @builtins.property
+    def exclude(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Paths to exclude from the asset, relative to ``path``.
+
+        See
+        ``AssetStagingOptions.exclude`` for the accepted forms. Both the computed
+        hash and the staged/packed content honor the exclusion.
+
+        :default: - nothing is excluded
+
+        :stability: experimental
+        '''
+        result = self._values.get("exclude")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def extra_hash(self) -> typing.Optional[builtins.str]:
+        '''(experimental) Extra information to fold into the hash (e.g. build instructions and other inputs).
+
+        :default: - no extra hash
+
+        :stability: experimental
+        '''
+        result = self._values.get("extra_hash")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def type(self) -> typing.Optional["AssetType"]:
         '''
@@ -19568,6 +19825,121 @@ class AnyMapMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.AnyMapMap"):
         jsii.set(self, "terraformResource", value) # pyright: ignore[reportArgumentType]
 
 
+@jsii.implements(IAsset)
+class AssetStaging(
+    _constructs_77d1e7e8.Construct,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="cdktn.AssetStaging",
+):
+    '''(experimental) Resolves an asset's identity (``SOURCE``/``OUTPUT``/``CUSTOM`` hashing, with ``exclude``/``extraHash``) and stages it to disk.
+
+    Hashing happens eagerly in the constructor; staging the content to
+    ``targetPath`` only happens when ``stage()`` is called, which callers do from
+    their own ``onSynthesize`` hook. This keeps the filesystem side effect in the
+    one window where it is safe to run, and keeps this class skippable once a
+    bundler is introduced.
+
+    ``SOURCE`` and ``OUTPUT`` compute identically here: without a bundler, the
+    "output" of an asset is its source verbatim. A future bundler changes what
+    ``OUTPUT`` hashes, not this class.
+
+    The source-tree walk behind ``SOURCE``/``OUTPUT`` is cached per synth (see
+    {@link hashCachesByRoot}), so referencing the same asset from more than one
+    resource or stack hashes it once. ``ASSET_HASH_SALT_CONTEXT_KEY`` folds an
+    app-wide value into every computed hash, for bulk cache-busting across an
+    entire tree rather than one asset's ``extraHash``.
+
+    :stability: experimental
+    '''
+
+    def __init__(
+        self,
+        scope: "_constructs_77d1e7e8.Construct",
+        id: builtins.str,
+        *,
+        packaging: "IAssetPackaging",
+        source_path: builtins.str,
+        exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+        extra_hash: typing.Optional[builtins.str] = None,
+        ignore_strategy: typing.Optional["IIgnoreStrategy"] = None,
+        asset_hash: typing.Optional[builtins.str] = None,
+        asset_hash_type: typing.Optional["AssetHashType"] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param packaging: (experimental) How the staged result is produced and shaped. The caller decides this (e.g. from its own ``AssetType``) — ``AssetStaging`` never infers or changes it based on ``exclude``/``extraHash``.
+        :param source_path: (experimental) Absolute path to the source file or directory. Resolving a relative path against ``cdktf.json`` is the caller's responsibility.
+        :param exclude: (experimental) Paths to exclude, relative to ``sourcePath``. Cannot be combined with ``ignoreStrategy``, which replaces this matcher rather than layering on top of it. Default: - nothing is excluded
+        :param extra_hash: (experimental) Extra information to fold into the hash (e.g. build instructions and other inputs). Default: - no extra hash
+        :param ignore_strategy: (experimental) Exclusion matching, for callers that need ``.gitignore`` / ``.dockerignore`` parity rather than the built-in exact-path / suffix / directory matcher. Default: - ``exclude`` is used with the built-in matcher
+        :param asset_hash: (experimental) Specify a custom hash for this asset. If ``assetHashType`` is set it must be set to ``AssetHashType.CUSTOM``. The value is used verbatim as the asset hash, and because it names the staged asset file it may only contain letters, digits, ``_``, ``.`` and ``-``. 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 cloud storage, 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: (experimental) 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``.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = cached_type_hints(_typecheckingstub__a694062800c2f527dfda0d5a21ceaa0607085c2bef7277ea0a32170587d80fac)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = AssetStagingOptions(
+            packaging=packaging,
+            source_path=source_path,
+            exclude=exclude,
+            extra_hash=extra_hash,
+            ignore_strategy=ignore_strategy,
+            asset_hash=asset_hash,
+            asset_hash_type=asset_hash_type,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="stage")
+    def stage(self, target_path: builtins.str) -> None:
+        '''(experimental) Write the staged content to ``targetPath``.
+
+        Called from the owning
+        construct's ``onSynthesize`` hook, once the target path is known.
+
+        :param target_path: - path the packaged result should be written to.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = cached_type_hints(_typecheckingstub__6e5f7b43a804b26df0e67b9684d7b357c04b21cffadbaed5c7f0681097e7a8b0)
+            check_type(argname="argument target_path", value=target_path, expected_type=type_hints["target_path"])
+        return typing.cast(None, jsii.invoke(self, "stage", [target_path]))
+
+    @builtins.property
+    @jsii.member(jsii_name="assetHash")
+    def asset_hash(self) -> builtins.str:
+        '''(experimental) A hash of this asset, which is available at construction time.
+
+        As this is a plain string, it
+        can be used in construct IDs in order to enforce creation of a new resource when the content
+        hash has changed.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "assetHash"))
+
+    @builtins.property
+    @jsii.member(jsii_name="isDirectory")
+    def is_directory(self) -> builtins.bool:
+        '''
+        :stability: experimental
+        '''
+        return typing.cast(builtins.bool, jsii.get(self, "isDirectory"))
+
+    @builtins.property
+    @jsii.member(jsii_name="packaging")
+    def packaging(self) -> "IAssetPackaging":
+        '''
+        :stability: experimental
+        '''
+        return typing.cast("IAssetPackaging", jsii.get(self, "packaging"))
+
+
 @jsii.implements(ITerraformAddressable, IResolvable)
 class BooleanMap(metaclass=jsii.JSIIMeta, jsii_type="cdktn.BooleanMap"):
     '''
@@ -28861,6 +29233,8 @@ __all__ = [
     "AssetHashType",
     "AssetOptions",
     "AssetPackaging",
+    "AssetStaging",
+    "AssetStagingOptions",
     "AssetType",
     "AzurermBackend",
     "AzurermBackendConfig",
@@ -29175,6 +29549,19 @@ def _typecheckingstub__b971ff06f951bbd97e185f053a7332b738b2ccfe46cb213fb9ce66163
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5026244ff290924dad88f65421d8025b8bcb105d693dec43cd93a0c7d8d0e7ba(
+    *,
+    asset_hash: typing.Optional[builtins.str] = None,
+    asset_hash_type: typing.Optional[AssetHashType] = None,
+    packaging: IAssetPackaging,
+    source_path: builtins.str,
+    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+    extra_hash: typing.Optional[builtins.str] = None,
+    ignore_strategy: typing.Optional[IIgnoreStrategy] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__912173407c419eae209032e0ac104680f082bb5aad4825d0e858e8efc0f9fa76(
     *,
     container_name: builtins.str,
@@ -31143,6 +31530,8 @@ def _typecheckingstub__6f29998a5dacee0da3977e8d51379662670eb6942990ac7e6e052ab5e
     path: builtins.str,
     asset_hash: typing.Optional[builtins.str] = None,
     asset_hash_type: typing.Optional[AssetHashType] = None,
+    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+    extra_hash: typing.Optional[builtins.str] = None,
     type: typing.Optional[AssetType] = None,
 ) -> None:
     """Type checking stubs"""
@@ -31159,6 +31548,8 @@ def _typecheckingstub__e7a613b39a707470fb3fa76a5d5d750aa8285bec8b92786190d69d5b7
     path: builtins.str,
     asset_hash: typing.Optional[builtins.str] = None,
     asset_hash_type: typing.Optional[AssetHashType] = None,
+    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+    extra_hash: typing.Optional[builtins.str] = None,
     type: typing.Optional[AssetType] = None,
 ) -> None:
     """Type checking stubs"""
@@ -32543,6 +32934,27 @@ def _typecheckingstub__e05f43129af3028ae44938231937cc6abd778cc24ebddc1d1db7a1806
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a694062800c2f527dfda0d5a21ceaa0607085c2bef7277ea0a32170587d80fac(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    packaging: IAssetPackaging,
+    source_path: builtins.str,
+    exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
+    extra_hash: typing.Optional[builtins.str] = None,
+    ignore_strategy: typing.Optional[IIgnoreStrategy] = None,
+    asset_hash: typing.Optional[builtins.str] = None,
+    asset_hash_type: typing.Optional[AssetHashType] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__6e5f7b43a804b26df0e67b9684d7b357c04b21cffadbaed5c7f0681097e7a8b0(
+    target_path: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b4cbbedf36a8746a1d5c9c145d7b08835c4ba037baf7c170a739d514ac054c5d(
     terraform_resource: IInterpolatingParent,
     terraform_attribute: builtins.str,

{cdktn-0.25.0.dev26 → cdktn-0.25.0.dev28}/src/cdktn/_jsii/__init__.py

@@ -21,7 +21,7 @@ _SUBMODULE_FQN_MAP = {
 }
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "cdktn", "0.25.0-pre.26", __name__[0:-6], "cdktn@0.25.0-pre.26.jsii.tgz"
+    "cdktn", "0.25.0-pre.28", __name__[0:-6], "cdktn@0.25.0-pre.28.jsii.tgz"
 )
 
 __all__ = [

{cdktn-0.25.0.dev26 → cdktn-0.25.0.dev28/src/cdktn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cdktn
-Version: 0.25.0.dev26
+Version: 0.25.0.dev28
 Summary: Cloud Development Kit for Terraform
 Home-page: https://github.com/open-constructs/cdk-terrain
 Author: OpenConstructs

{cdktn-0.25.0.dev26 → cdktn-0.25.0.dev28}/src/cdktn.egg-info/SOURCES.txt

@@ -11,5 +11,5 @@ src/cdktn.egg-info/dependency_links.txt
 src/cdktn.egg-info/requires.txt
 src/cdktn.egg-info/top_level.txt
 src/cdktn/_jsii/__init__.py
-src/cdktn/_jsii/cdktn@0.25.0-pre.26.jsii.tgz
+src/cdktn/_jsii/cdktn@0.25.0-pre.28.jsii.tgz
 src/cdktn/testing_matchers/__init__.py