terraconstructs 0.0.25 → 0.1.0

package/lib/assets.d.ts

@@ -0,0 +1,359 @@
+import { BundlingOptions } from "./bundling";
+/**
+ * Common interface for all assets.
+ */
+export interface IAsset {
+    /**
+     * 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.
+     */
+    readonly assetHash: string;
+}
+/**
+ * Asset hash options
+ */
+export interface AssetOptions {
+    /**
+     * Specify a custom hash for this asset. If `assetHashType` is set it must
+     * be set to `AssetHashType.CUSTOM`. For consistency, this custom hash will
+     * be SHA256 hashed and encoded as hex. The resulting hash will be the asset
+     * hash.
+     *
+     * NOTE: the hash is used in order to identify a specific revision of the asset, and
+     * used for optimizing and caching deployment activities related to this asset such as
+     * packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will
+     * need to make sure it is updated every time the asset changes, or otherwise it is
+     * possible that some deployments will not be invalidated.
+     *
+     * @default - based on `assetHashType`
+     */
+    readonly assetHash?: string;
+    /**
+     * 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`.
+     */
+    readonly assetHashType?: AssetHashType;
+    /**
+     * Bundle the asset by executing a command in a Docker container or a custom bundling provider.
+     *
+     * The asset path will be mounted at `/asset-input`. The Docker
+     * container is responsible for putting content at `/asset-output`.
+     * The content at `/asset-output` will be zipped and used as the
+     * final asset.
+     *
+     * @default - uploaded as-is to S3 if the asset is a regular file or a .zip file,
+     * archived into a .zip file and uploaded to S3 otherwise
+     */
+    readonly bundling?: BundlingOptions;
+}
+/**
+ * The type of asset hash
+ *
+ * NOTE: the hash is used in order to identify a specific revision of the asset, and
+ * used for optimizing and caching deployment activities related to this asset such as
+ * packaging, uploading to Amazon S3, etc.
+ */
+export declare enum AssetHashType {
+    /**
+     * Based on the content of the source path
+     *
+     * When bundling, use `SOURCE` when the content of the bundling output is not
+     * stable across repeated bundling operations.
+     */
+    SOURCE = "source",
+    /**
+     * Based on the content of the bundled path
+     *
+     * @deprecated use `OUTPUT` instead
+     */
+    BUNDLE = "bundle",
+    /**
+     * Based on the content of the bundling output
+     *
+     * Use `OUTPUT` when the source of the asset is a top level folder containing
+     * code and/or dependencies that are not directly linked to the asset.
+     */
+    OUTPUT = "output",
+    /**
+     * Use a custom hash
+     */
+    CUSTOM = "custom"
+}
+/**
+ * Represents the source for a file asset.
+ */
+export interface FileAssetSource {
+    /**
+     * 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.
+     */
+    readonly sourceHash: string;
+    /**
+     * 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.
+     *
+     */
+    readonly fileName: string;
+    /**
+     * Which type of packaging to perform.
+     *
+     * @default - Required if `fileName` is specified.
+     */
+    readonly packaging?: FileAssetPackaging;
+    /**
+     * 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 Terraform
+     * 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
+     */
+    readonly deployTime?: boolean;
+}
+export interface DockerImageAssetSource {
+    /**
+     * 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).
+     */
+    readonly sourceHash: string;
+    /**
+     * The directory where the Dockerfile is stored, must be relative
+     * to the cloud assembly root.
+     */
+    readonly directoryName: string;
+    /**
+     * 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
+     */
+    readonly dockerBuildArgs?: {
+        [key: string]: string;
+    };
+    /**
+     * 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
+     */
+    readonly dockerBuildSecrets?: {
+        [key: string]: string;
+    };
+    /**
+     * SSH agent socket or keys to pass to the `docker buildx` command.
+     *
+     *
+     * @default - no ssh arg is passed
+     */
+    readonly dockerBuildSsh?: string;
+    /**
+     * Docker target to build to
+     *
+     * Only allowed when `directoryName` is specified.
+     *
+     * @default - no target
+     */
+    readonly dockerBuildTarget?: string;
+    /**
+     * Path to the Dockerfile (relative to the directory).
+     *
+     * Only allowed when `directoryName` is specified.
+     *
+     * @default - no file
+     */
+    readonly dockerFile?: string;
+    /**
+     * Networking mode for the RUN commands during build. _Requires Docker Engine API v1.25+_.
+     *
+     * Specify this property to build images on a specific networking mode.
+     *
+     * @default - no networking mode specified
+     */
+    readonly networkMode?: string;
+    /**
+     * Platform to build for. _Requires Docker Buildx_.
+     *
+     * Specify this property to build images on a specific platform.
+     *
+     * @default - no platform specified (the current machine architecture will be used)
+     */
+    readonly platform?: string;
+    /**
+     * Outputs to pass to the `docker build` command.
+     *
+     * @default - no build args are passed
+     */
+    readonly dockerOutputs?: string[];
+    /**
+     * Unique identifier of the docker image asset and its potential revisions.
+     *
+     * @default - no asset name
+     */
+    readonly assetName?: string;
+    /**
+     * Cache from options to pass to the `docker build` command.
+     *
+     * @default - no cache from args are passed
+     */
+    readonly dockerCacheFrom?: DockerCacheOption[];
+    /**
+     * Cache to options to pass to the `docker build` command.
+     *
+     * @default - no cache to args are passed
+     */
+    readonly dockerCacheTo?: DockerCacheOption;
+    /**
+     * Disable the cache and pass `--no-cache` to the `docker build` command.
+     *
+     * @default - cache is used
+     */
+    readonly dockerCacheDisabled?: boolean;
+}
+/**
+ * Packaging modes for file assets.
+ */
+export declare enum FileAssetPackaging {
+    /**
+     * The asset source path points to a directory, which should be archived using
+     * zip and and then uploaded to cloud provider object storage (e.g. Amazon S3).
+     */
+    ZIP_DIRECTORY = "zip",
+    /**
+     * The asset source path points to a single file, which should be uploaded
+     * to cloud provider object storage (e.g. Amazon S3).
+     */
+    FILE = "file"
+}
+/**
+ * The location of the published file asset. This is where the asset
+ * can be consumed at runtime.
+ */
+export interface FileAssetLocation {
+    /**
+     * The name of the Amazon S3 bucket.
+     */
+    readonly bucketName: string;
+    /**
+     * The Amazon S3 object key.
+     */
+    readonly objectKey: string;
+    /**
+     * The HTTP URL of this asset on Amazon S3.
+     * @default - value specified in `httpUrl` is used.
+     * @deprecated use `httpUrl`
+     */
+    readonly s3Url?: string;
+    /**
+     * The HTTP URL of this asset on Amazon S3.
+     *
+     * This value suitable for inclusion in a CloudFormation template, and
+     * may be an encoded token.
+     *
+     * Example value: `https://s3-us-east-1.amazonaws.com/mybucket/myobject`
+     */
+    readonly httpUrl: string;
+    /**
+     * The S3 URL of this asset on Amazon S3.
+     *
+     * This value suitable for inclusion in a CloudFormation template, and
+     * may be an encoded token.
+     *
+     * Example value: `s3://mybucket/myobject`
+     */
+    readonly s3ObjectUrl: string;
+    /**
+     * The ARN of the KMS key used to encrypt the file asset bucket, if any.
+     *
+     * The CDK bootstrap stack comes with a key policy that does not require
+     * setting this property, so you only need to set this property if you
+     * have customized the bootstrap stack to require it.
+     *
+     * @default - Asset bucket is not encrypted, or decryption permissions are
+     * defined by a Key Policy.
+     */
+    readonly kmsKeyArn?: string;
+    /**
+     * Like `s3ObjectUrl`, but not suitable for CloudFormation consumption
+     *
+     * If there are placeholders in the S3 URL, they will be returned un-replaced
+     * and un-evaluated.
+     *
+     * @default - This feature cannot be used
+     */
+    readonly s3ObjectUrlWithPlaceholders?: string;
+}
+/**
+ * The location of the published docker image. This is where the image can be
+ * consumed at runtime.
+ */
+export interface DockerImageAssetLocation {
+    /**
+     * The URI of the image in Amazon ECR (including a tag).
+     */
+    readonly imageUri: string;
+    /**
+     * The name of the ECR repository.
+     */
+    readonly repositoryName: string;
+    /**
+     * The tag of the image in Amazon ECR.
+     * @default - the hash of the asset, or the `dockerTagPrefix` concatenated with the asset hash if a `dockerTagPrefix` is specified in the stack synthesizer
+     */
+    readonly imageTag?: string;
+}
+/**
+ * Options for configuring the Docker cache backend
+ */
+export interface DockerCacheOption {
+    /**
+     * The type of cache to use.
+     * Refer to https://docs.docker.com/build/cache/backends/ for full list of backends.
+     * @default - unspecified
+     *
+     * @example 'registry'
+     */
+    readonly type: string;
+    /**
+     * Any parameters to pass into the docker cache backend configuration.
+     * Refer to https://docs.docker.com/build/cache/backends/ for cache backend configuration.
+     * @default {} No options provided
+     *
+     * @example
+     * declare const branch: string;
+     *
+     * const params = {
+     *   ref: `12345678.dkr.ecr.us-west-2.amazonaws.com/cache:${branch}`,
+     *   mode: "max",
+     * };
+     */
+    readonly params?: {
+        [key: string]: string;
+    };
+}

package/lib/assets.js

@@ -0,0 +1,55 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/assets.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAssetPackaging = exports.AssetHashType = void 0;
+/**
+ * The type of asset hash
+ *
+ * NOTE: the hash is used in order to identify a specific revision of the asset, and
+ * used for optimizing and caching deployment activities related to this asset such as
+ * packaging, uploading to Amazon S3, etc.
+ */
+var AssetHashType;
+(function (AssetHashType) {
+    /**
+     * Based on the content of the source path
+     *
+     * When bundling, use `SOURCE` when the content of the bundling output is not
+     * stable across repeated bundling operations.
+     */
+    AssetHashType["SOURCE"] = "source";
+    /**
+     * Based on the content of the bundled path
+     *
+     * @deprecated use `OUTPUT` instead
+     */
+    AssetHashType["BUNDLE"] = "bundle";
+    /**
+     * Based on the content of the bundling output
+     *
+     * Use `OUTPUT` when the source of the asset is a top level folder containing
+     * code and/or dependencies that are not directly linked to the asset.
+     */
+    AssetHashType["OUTPUT"] = "output";
+    /**
+     * Use a custom hash
+     */
+    AssetHashType["CUSTOM"] = "custom";
+})(AssetHashType || (exports.AssetHashType = AssetHashType = {}));
+/**
+ * Packaging modes for file assets.
+ */
+var FileAssetPackaging;
+(function (FileAssetPackaging) {
+    /**
+     * The asset source path points to a directory, which should be archived using
+     * zip and and then uploaded to cloud provider object storage (e.g. Amazon S3).
+     */
+    FileAssetPackaging["ZIP_DIRECTORY"] = "zip";
+    /**
+     * The asset source path points to a single file, which should be uploaded
+     * to cloud provider object storage (e.g. Amazon S3).
+     */
+    FileAssetPackaging["FILE"] = "file";
+})(FileAssetPackaging || (exports.FileAssetPackaging = FileAssetPackaging = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assets.js","sourceRoot":"","sources":["../src/assets.ts"],"names":[],"mappings":";AAAA,uFAAuF;;;AA6DvF;;;;;;GAMG;AACH,IAAY,aA4BX;AA5BD,WAAY,aAAa;IACvB;;;;;OAKG;IACH,kCAAiB,CAAA;IAEjB;;;;OAIG;IACH,kCAAiB,CAAA;IAEjB;;;;;OAKG;IACH,kCAAiB,CAAA;IAEjB;;OAEG;IACH,kCAAiB,CAAA;AACnB,CAAC,EA5BW,aAAa,6BAAb,aAAa,QA4BxB;AAyMD;;GAEG;AACH,IAAY,kBAYX;AAZD,WAAY,kBAAkB;IAC5B;;;OAGG;IACH,2CAAqB,CAAA;IAErB;;;OAGG;IACH,mCAAa,CAAA;AACf,CAAC,EAZW,kBAAkB,kCAAlB,kBAAkB,QAY7B","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/core/lib/assets.ts\n\nimport { BundlingOptions } from \"./bundling\";\n\n/**\n * Common interface for all assets.\n */\nexport interface IAsset {\n  /**\n   * A hash of this asset, which is available at construction time. As this is a plain string, it\n   * can be used in construct IDs in order to enforce creation of a new resource when the content\n   * hash has changed.\n   */\n  readonly assetHash: string;\n}\n\n/**\n * Asset hash options\n */\nexport interface AssetOptions {\n  /**\n   * Specify a custom hash for this asset. If `assetHashType` is set it must\n   * be set to `AssetHashType.CUSTOM`. For consistency, this custom hash will\n   * be SHA256 hashed and encoded as hex. The resulting hash will be the asset\n   * hash.\n   *\n   * NOTE: the hash is used in order to identify a specific revision of the asset, and\n   * used for optimizing and caching deployment activities related to this asset such as\n   * packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will\n   * need to make sure it is updated every time the asset changes, or otherwise it is\n   * possible that some deployments will not be invalidated.\n   *\n   * @default - based on `assetHashType`\n   */\n  readonly assetHash?: string;\n\n  /**\n   * Specifies the type of hash to calculate for this asset.\n   *\n   * If `assetHash` is configured, this option must be `undefined` or\n   * `AssetHashType.CUSTOM`.\n   *\n   * @default - the default is `AssetHashType.SOURCE`, but if `assetHash` is\n   * explicitly specified this value defaults to `AssetHashType.CUSTOM`.\n   */\n  readonly assetHashType?: AssetHashType;\n\n  /**\n   * Bundle the asset by executing a command in a Docker container or a custom bundling provider.\n   *\n   * The asset path will be mounted at `/asset-input`. The Docker\n   * container is responsible for putting content at `/asset-output`.\n   * The content at `/asset-output` will be zipped and used as the\n   * final asset.\n   *\n   * @default - uploaded as-is to S3 if the asset is a regular file or a .zip file,\n   * archived into a .zip file and uploaded to S3 otherwise\n   */\n  readonly bundling?: BundlingOptions;\n}\n\n/**\n * The type of asset hash\n *\n * NOTE: the hash is used in order to identify a specific revision of the asset, and\n * used for optimizing and caching deployment activities related to this asset such as\n * packaging, uploading to Amazon S3, etc.\n */\nexport enum AssetHashType {\n  /**\n   * Based on the content of the source path\n   *\n   * When bundling, use `SOURCE` when the content of the bundling output is not\n   * stable across repeated bundling operations.\n   */\n  SOURCE = \"source\",\n\n  /**\n   * Based on the content of the bundled path\n   *\n   * @deprecated use `OUTPUT` instead\n   */\n  BUNDLE = \"bundle\",\n\n  /**\n   * Based on the content of the bundling output\n   *\n   * Use `OUTPUT` when the source of the asset is a top level folder containing\n   * code and/or dependencies that are not directly linked to the asset.\n   */\n  OUTPUT = \"output\",\n\n  /**\n   * Use a custom hash\n   */\n  CUSTOM = \"custom\",\n}\n\n/**\n * Represents the source for a file asset.\n */\nexport interface FileAssetSource {\n  /**\n   * A hash on the content source. This hash is used to uniquely identify this\n   * asset throughout the system. If this value doesn't change, the asset will\n   * not be rebuilt or republished.\n   */\n  readonly sourceHash: string;\n\n  // TODO: Support executable feature\n  // /**\n  //  * An external command that will produce the packaged asset.\n  //  *\n  //  * The command should produce the location of a ZIP file on `stdout`.\n  //  *\n  //  * @default - Exactly one of `fileName` and `executable` is required\n  //  */\n  // readonly executable?: string[];\n  // * @default - Exactly one of `fileName` and `executable` is required\n\n  /**\n   * The path, relative to the root of the cloud assembly, in which this asset\n   * source resides. This can be a path to a file or a directory, depending on the\n   * packaging type.\n   *\n   */\n  readonly fileName: string;\n\n  /**\n   * Which type of packaging to perform.\n   *\n   * @default - Required if `fileName` is specified.\n   */\n  readonly packaging?: FileAssetPackaging;\n\n  /**\n   * Whether or not the asset needs to exist beyond deployment time; i.e.\n   * are copied over to a different location and not needed afterwards.\n   * Setting this property to true has an impact on the lifecycle of the asset,\n   * because we will assume that it is safe to delete after the Terraform\n   * deployment succeeds.\n   *\n   * For example, Lambda Function assets are copied over to Lambda during\n   * deployment. Therefore, it is not necessary to store the asset in S3, so\n   * we consider those deployTime assets.\n   *\n   * @default false\n   */\n  readonly deployTime?: boolean;\n}\n\nexport interface DockerImageAssetSource {\n  /**\n   * The hash of the contents of the docker build context. This hash is used\n   * throughout the system to identify this image and avoid duplicate work\n   * in case the source did not change.\n   *\n   * NOTE: this means that if you wish to update your docker image, you\n   * must make a modification to the source (e.g. add some metadata to your Dockerfile).\n   */\n  readonly sourceHash: string;\n\n  // TODO: Support executable feature\n  // /**\n  //  * An external command that will produce the packaged asset.\n  //  *\n  //  * The command should produce the name of a local Docker image on `stdout`.\n  //  *\n  //  * @default - Exactly one of `directoryName` and `executable` is required\n  //  */\n  // readonly executable?: string[];\n  // * @default - Exactly one of `directoryName` and `executable` is required\n\n  /**\n   * The directory where the Dockerfile is stored, must be relative\n   * to the cloud assembly root.\n   */\n  readonly directoryName: string;\n\n  /**\n   * Build args to pass to the `docker build` command.\n   *\n   * Since Docker build arguments are resolved before deployment, keys and\n   * values cannot refer to unresolved tokens (such as `lambda.functionArn` or\n   * `queue.queueUrl`).\n   *\n   * Only allowed when `directoryName` is specified.\n   *\n   * @default - no build args are passed\n   */\n  readonly dockerBuildArgs?: { [key: string]: string };\n\n  /**\n   * Build secrets to pass to the `docker build` command.\n   *\n   * Since Docker build secrets are resolved before deployment, keys and\n   * values cannot refer to unresolved tokens (such as `lambda.functionArn` or\n   * `queue.queueUrl`).\n   *\n   * Only allowed when `directoryName` is specified.\n   *\n   * @default - no build secrets are passed\n   */\n  readonly dockerBuildSecrets?: { [key: string]: string };\n\n  /**\n   * SSH agent socket or keys to pass to the `docker buildx` command.\n   *\n   *\n   * @default - no ssh arg is passed\n   */\n  readonly dockerBuildSsh?: string;\n\n  /**\n   * Docker target to build to\n   *\n   * Only allowed when `directoryName` is specified.\n   *\n   * @default - no target\n   */\n  readonly dockerBuildTarget?: string;\n\n  /**\n   * Path to the Dockerfile (relative to the directory).\n   *\n   * Only allowed when `directoryName` is specified.\n   *\n   * @default - no file\n   */\n  readonly dockerFile?: string;\n\n  // /**\n  //  * ECR repository name\n  //  *\n  //  * Specify this property if you need to statically address the image, e.g.\n  //  * from a Kubernetes Pod. Note, this is only the repository name, without the\n  //  * registry and the tag parts.\n  //  *\n  //  * @default - automatically derived from the asset's ID.\n  //  * @deprecated repository name should be specified at the environment-level and not at the image level\n  //  */\n  // readonly repositoryName?: string;\n\n  /**\n   * Networking mode for the RUN commands during build. _Requires Docker Engine API v1.25+_.\n   *\n   * Specify this property to build images on a specific networking mode.\n   *\n   * @default - no networking mode specified\n   */\n  readonly networkMode?: string;\n\n  /**\n   * Platform to build for. _Requires Docker Buildx_.\n   *\n   * Specify this property to build images on a specific platform.\n   *\n   * @default - no platform specified (the current machine architecture will be used)\n   */\n  readonly platform?: string;\n\n  /**\n   * Outputs to pass to the `docker build` command.\n   *\n   * @default - no build args are passed\n   */\n  readonly dockerOutputs?: string[];\n\n  /**\n   * Unique identifier of the docker image asset and its potential revisions.\n   *\n   * @default - no asset name\n   */\n  readonly assetName?: string;\n\n  /**\n   * Cache from options to pass to the `docker build` command.\n   *\n   * @default - no cache from args are passed\n   */\n  readonly dockerCacheFrom?: DockerCacheOption[];\n\n  /**\n   * Cache to options to pass to the `docker build` command.\n   *\n   * @default - no cache to args are passed\n   */\n  readonly dockerCacheTo?: DockerCacheOption;\n\n  /**\n   * Disable the cache and pass `--no-cache` to the `docker build` command.\n   *\n   * @default - cache is used\n   */\n  readonly dockerCacheDisabled?: boolean;\n}\n\n/**\n * Packaging modes for file assets.\n */\nexport enum FileAssetPackaging {\n  /**\n   * The asset source path points to a directory, which should be archived using\n   * zip and and then uploaded to cloud provider object storage (e.g. Amazon S3).\n   */\n  ZIP_DIRECTORY = \"zip\",\n\n  /**\n   * The asset source path points to a single file, which should be uploaded\n   * to cloud provider object storage (e.g. Amazon S3).\n   */\n  FILE = \"file\",\n}\n\n/**\n * The location of the published file asset. This is where the asset\n * can be consumed at runtime.\n */\nexport interface FileAssetLocation {\n  /**\n   * The name of the Amazon S3 bucket.\n   */\n  readonly bucketName: string;\n\n  /**\n   * The Amazon S3 object key.\n   */\n  readonly objectKey: string;\n\n  /**\n   * The HTTP URL of this asset on Amazon S3.\n   * @default - value specified in `httpUrl` is used.\n   * @deprecated use `httpUrl`\n   */\n  readonly s3Url?: string;\n\n  /**\n   * The HTTP URL of this asset on Amazon S3.\n   *\n   * This value suitable for inclusion in a CloudFormation template, and\n   * may be an encoded token.\n   *\n   * Example value: `https://s3-us-east-1.amazonaws.com/mybucket/myobject`\n   */\n  readonly httpUrl: string;\n\n  /**\n   * The S3 URL of this asset on Amazon S3.\n   *\n   * This value suitable for inclusion in a CloudFormation template, and\n   * may be an encoded token.\n   *\n   * Example value: `s3://mybucket/myobject`\n   */\n  readonly s3ObjectUrl: string;\n\n  /**\n   * The ARN of the KMS key used to encrypt the file asset bucket, if any.\n   *\n   * The CDK bootstrap stack comes with a key policy that does not require\n   * setting this property, so you only need to set this property if you\n   * have customized the bootstrap stack to require it.\n   *\n   * @default - Asset bucket is not encrypted, or decryption permissions are\n   * defined by a Key Policy.\n   */\n  readonly kmsKeyArn?: string;\n\n  /**\n   * Like `s3ObjectUrl`, but not suitable for CloudFormation consumption\n   *\n   * If there are placeholders in the S3 URL, they will be returned un-replaced\n   * and un-evaluated.\n   *\n   * @default - This feature cannot be used\n   */\n  readonly s3ObjectUrlWithPlaceholders?: string;\n}\n\n/**\n * The location of the published docker image. This is where the image can be\n * consumed at runtime.\n */\nexport interface DockerImageAssetLocation {\n  /**\n   * The URI of the image in Amazon ECR (including a tag).\n   */\n  readonly imageUri: string;\n\n  /**\n   * The name of the ECR repository.\n   */\n  readonly repositoryName: string;\n\n  /**\n   * The tag of the image in Amazon ECR.\n   * @default - the hash of the asset, or the `dockerTagPrefix` concatenated with the asset hash if a `dockerTagPrefix` is specified in the stack synthesizer\n   */\n  readonly imageTag?: string;\n}\n\n/**\n * Options for configuring the Docker cache backend\n */\nexport interface DockerCacheOption {\n  /**\n   * The type of cache to use.\n   * Refer to https://docs.docker.com/build/cache/backends/ for full list of backends.\n   * @default - unspecified\n   *\n   * @example 'registry'\n   */\n  readonly type: string;\n  /**\n   * Any parameters to pass into the docker cache backend configuration.\n   * Refer to https://docs.docker.com/build/cache/backends/ for cache backend configuration.\n   * @default {} No options provided\n   *\n   * @example\n   * declare const branch: string;\n   *\n   * const params = {\n   *   ref: `12345678.dkr.ecr.us-west-2.amazonaws.com/cache:${branch}`,\n   *   mode: \"max\",\n   * };\n   */\n  readonly params?: { [key: string]: string };\n}\n"]}