aws-cdk 2.1005.0 → 2.1007.0

package/lib/api/cloudformation/stack-helpers.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFormationStack = void 0;
+const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const util_1 = require("../../util");
+const stack_events_1 = require("../stack-events");
+/**
+ * Represents an (existing) Stack in CloudFormation
+ *
+ * Bundle and cache some information that we need during deployment (so we don't have to make
+ * repeated calls to CloudFormation).
+ */
+class CloudFormationStack {
+    static async lookup(cfn, stackName, retrieveProcessedTemplate = false) {
+        try {
+            const response = await cfn.describeStacks({ StackName: stackName });
+            return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0], retrieveProcessedTemplate);
+        }
+        catch (e) {
+            if (e.name === 'ValidationError' && (0, util_1.formatErrorMessage)(e) === `Stack with id ${stackName} does not exist`) {
+                return new CloudFormationStack(cfn, stackName, undefined);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Return a copy of the given stack that does not exist
+     *
+     * It's a little silly that it needs arguments to do that, but there we go.
+     */
+    static doesNotExist(cfn, stackName) {
+        return new CloudFormationStack(cfn, stackName);
+    }
+    /**
+     * From static information (for testing)
+     */
+    static fromStaticInformation(cfn, stackName, stack) {
+        return new CloudFormationStack(cfn, stackName, stack);
+    }
+    constructor(cfn, stackName, stack, retrieveProcessedTemplate = false) {
+        this.cfn = cfn;
+        this.stackName = stackName;
+        this.stack = stack;
+        this.retrieveProcessedTemplate = retrieveProcessedTemplate;
+    }
+    /**
+     * Retrieve the stack's deployed template
+     *
+     * Cached, so will only be retrieved once. Will return an empty
+     * structure if the stack does not exist.
+     */
+    async template() {
+        if (!this.exists) {
+            return {};
+        }
+        if (this._template === undefined) {
+            const response = await this.cfn.getTemplate({
+                StackName: this.stackName,
+                TemplateStage: this.retrieveProcessedTemplate ? 'Processed' : 'Original',
+            });
+            this._template = (response.TemplateBody && (0, util_1.deserializeStructure)(response.TemplateBody)) || {};
+        }
+        return this._template;
+    }
+    /**
+     * Whether the stack exists
+     */
+    get exists() {
+        return this.stack !== undefined;
+    }
+    /**
+     * The stack's ID
+     *
+     * Throws if the stack doesn't exist.
+     */
+    get stackId() {
+        this.assertExists();
+        return this.stack.StackId;
+    }
+    /**
+     * The stack's current outputs
+     *
+     * Empty object if the stack doesn't exist
+     */
+    get outputs() {
+        if (!this.exists) {
+            return {};
+        }
+        const result = {};
+        (this.stack.Outputs || []).forEach((output) => {
+            result[output.OutputKey] = output.OutputValue;
+        });
+        return result;
+    }
+    /**
+     * The stack's status
+     *
+     * Special status NOT_FOUND if the stack does not exist.
+     */
+    get stackStatus() {
+        if (!this.exists) {
+            return new stack_events_1.StackStatus('NOT_FOUND', 'Stack not found during lookup');
+        }
+        return stack_events_1.StackStatus.fromStackDescription(this.stack);
+    }
+    /**
+     * The stack's current tags
+     *
+     * Empty list if the stack does not exist
+     */
+    get tags() {
+        return this.stack?.Tags || [];
+    }
+    /**
+     * SNS Topic ARNs that will receive stack events.
+     *
+     * Empty list if the stack does not exist
+     */
+    get notificationArns() {
+        return this.stack?.NotificationARNs ?? [];
+    }
+    /**
+     * Return the names of all current parameters to the stack
+     *
+     * Empty list if the stack does not exist.
+     */
+    get parameterNames() {
+        return Object.keys(this.parameters);
+    }
+    /**
+     * Return the names and values of all current parameters to the stack
+     *
+     * Empty object if the stack does not exist.
+     */
+    get parameters() {
+        if (!this.exists) {
+            return {};
+        }
+        const ret = {};
+        for (const param of this.stack.Parameters ?? []) {
+            ret[param.ParameterKey] = param.ResolvedValue ?? param.ParameterValue;
+        }
+        return ret;
+    }
+    /**
+     * Return the termination protection of the stack
+     */
+    get terminationProtection() {
+        return this.stack?.EnableTerminationProtection;
+    }
+    assertExists() {
+        if (!this.exists) {
+            throw new api_1.ToolkitError(`No stack named '${this.stackName}'`);
+        }
+    }
+}
+exports.CloudFormationStack = CloudFormationStack;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-helpers.js","sourceRoot":"","sources":["stack-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Stack, Tag } from '@aws-sdk/client-cloudformation';\nimport type { Template } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport { ToolkitError } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport { formatErrorMessage, deserializeStructure } from '../../util';\nimport type { ICloudFormationClient } from '../aws-auth';\nimport { StackStatus } from '../stack-events';\n\nexport { Template, TemplateParameter } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\n\n/**\n * Represents an (existing) Stack in CloudFormation\n *\n * Bundle and cache some information that we need during deployment (so we don't have to make\n * repeated calls to CloudFormation).\n */\nexport class CloudFormationStack {\n  public static async lookup(\n    cfn: ICloudFormationClient,\n    stackName: string,\n    retrieveProcessedTemplate: boolean = false,\n  ): Promise<CloudFormationStack> {\n    try {\n      const response = await cfn.describeStacks({ StackName: stackName });\n      return new CloudFormationStack(cfn, stackName, response.Stacks && response.Stacks[0], retrieveProcessedTemplate);\n    } catch (e: any) {\n      if (e.name === 'ValidationError' && formatErrorMessage(e) === `Stack with id ${stackName} does not exist`) {\n        return new CloudFormationStack(cfn, stackName, undefined);\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Return a copy of the given stack that does not exist\n   *\n   * It's a little silly that it needs arguments to do that, but there we go.\n   */\n  public static doesNotExist(cfn: ICloudFormationClient, stackName: string) {\n    return new CloudFormationStack(cfn, stackName);\n  }\n\n  /**\n   * From static information (for testing)\n   */\n  public static fromStaticInformation(cfn: ICloudFormationClient, stackName: string, stack: Stack) {\n    return new CloudFormationStack(cfn, stackName, stack);\n  }\n\n  private _template: any;\n\n  protected constructor(\n    private readonly cfn: ICloudFormationClient,\n    public readonly stackName: string,\n    private readonly stack?: Stack,\n    private readonly retrieveProcessedTemplate: boolean = false,\n  ) {\n  }\n\n  /**\n   * Retrieve the stack's deployed template\n   *\n   * Cached, so will only be retrieved once. Will return an empty\n   * structure if the stack does not exist.\n   */\n  public async template(): Promise<Template> {\n    if (!this.exists) {\n      return {};\n    }\n\n    if (this._template === undefined) {\n      const response = await this.cfn.getTemplate({\n        StackName: this.stackName,\n        TemplateStage: this.retrieveProcessedTemplate ? 'Processed' : 'Original',\n      });\n      this._template = (response.TemplateBody && deserializeStructure(response.TemplateBody)) || {};\n    }\n    return this._template;\n  }\n\n  /**\n   * Whether the stack exists\n   */\n  public get exists() {\n    return this.stack !== undefined;\n  }\n\n  /**\n   * The stack's ID\n   *\n   * Throws if the stack doesn't exist.\n   */\n  public get stackId() {\n    this.assertExists();\n    return this.stack!.StackId!;\n  }\n\n  /**\n   * The stack's current outputs\n   *\n   * Empty object if the stack doesn't exist\n   */\n  public get outputs(): Record<string, string> {\n    if (!this.exists) {\n      return {};\n    }\n    const result: { [name: string]: string } = {};\n    (this.stack!.Outputs || []).forEach((output) => {\n      result[output.OutputKey!] = output.OutputValue!;\n    });\n    return result;\n  }\n\n  /**\n   * The stack's status\n   *\n   * Special status NOT_FOUND if the stack does not exist.\n   */\n  public get stackStatus(): StackStatus {\n    if (!this.exists) {\n      return new StackStatus('NOT_FOUND', 'Stack not found during lookup');\n    }\n    return StackStatus.fromStackDescription(this.stack!);\n  }\n\n  /**\n   * The stack's current tags\n   *\n   * Empty list if the stack does not exist\n   */\n  public get tags(): Tag[] {\n    return this.stack?.Tags || [];\n  }\n\n  /**\n   * SNS Topic ARNs that will receive stack events.\n   *\n   * Empty list if the stack does not exist\n   */\n  public get notificationArns(): string[] {\n    return this.stack?.NotificationARNs ?? [];\n  }\n\n  /**\n   * Return the names of all current parameters to the stack\n   *\n   * Empty list if the stack does not exist.\n   */\n  public get parameterNames(): string[] {\n    return Object.keys(this.parameters);\n  }\n\n  /**\n   * Return the names and values of all current parameters to the stack\n   *\n   * Empty object if the stack does not exist.\n   */\n  public get parameters(): Record<string, string> {\n    if (!this.exists) {\n      return {};\n    }\n    const ret: Record<string, string> = {};\n    for (const param of this.stack!.Parameters ?? []) {\n      ret[param.ParameterKey!] = param.ResolvedValue ?? param.ParameterValue!;\n    }\n    return ret;\n  }\n\n  /**\n   * Return the termination protection of the stack\n   */\n  public get terminationProtection(): boolean | undefined {\n    return this.stack?.EnableTerminationProtection;\n  }\n\n  private assertExists() {\n    if (!this.exists) {\n      throw new ToolkitError(`No stack named '${this.stackName}'`);\n    }\n  }\n}\n"]}

package/lib/api/{util → cloudformation}/template-body-parameter.d.ts

@@ -1,5 +1,6 @@
 import { type CloudFormationStackArtifact, type Environment } from '@aws-cdk/cx-api';
-import { type AssetManifestBuilder } from '../deployments';
+import { type IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
+import type { AssetManifestBuilder } from '../deployments';
 import type { EnvironmentResources } from '../environment';
 export type TemplateBodyParameter = {
     TemplateBody?: string;
@@ -18,4 +19,4 @@ export type TemplateBodyParameter = {
  * @param stack     the synthesized stack that provides the CloudFormation template
  * @param toolkitInfo information about the toolkit stack
  */
-export declare function makeBodyParameter(stack: CloudFormationStackArtifact, resolvedEnvironment: Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, overrideTemplate?: any): Promise<TemplateBodyParameter>;
+export declare function makeBodyParameter(ioHelper: IoHelper, stack: CloudFormationStackArtifact, resolvedEnvironment: Environment, assetManifest: AssetManifestBuilder, resources: EnvironmentResources, overrideTemplate?: any): Promise<TemplateBodyParameter>;

package/lib/api/cloudformation/template-body-parameter.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBodyParameter = makeBodyParameter;
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const util = require("node:util");
+const cx_api_1 = require("@aws-cdk/cx-api");
+const client_s3_1 = require("@aws-sdk/client-s3");
+const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
+const chalk = require("chalk");
+const api_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api");
+const private_1 = require("../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private");
+const util_1 = require("../../util");
+const LARGE_TEMPLATE_SIZE_KB = 50;
+/**
+ * Prepares the body parameter for +CreateChangeSet+.
+ *
+ * If the template is small enough to be inlined into the API call, just return
+ * it immediately.
+ *
+ * Otherwise, add it to the asset manifest to get uploaded to the staging
+ * bucket and return its coordinates. If there is no staging bucket, an error
+ * is thrown.
+ *
+ * @param stack     the synthesized stack that provides the CloudFormation template
+ * @param toolkitInfo information about the toolkit stack
+ */
+async function makeBodyParameter(ioHelper, stack, resolvedEnvironment, assetManifest, resources, overrideTemplate) {
+    // If the template has already been uploaded to S3, just use it from there.
+    if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
+        return {
+            TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),
+        };
+    }
+    // Otherwise, pass via API call (if small) or upload here (if large)
+    const templateJson = (0, util_1.toYAML)(overrideTemplate ?? stack.template);
+    if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
+        return { TemplateBody: templateJson };
+    }
+    const toolkitInfo = await resources.lookupToolkit();
+    if (!toolkitInfo.found) {
+        await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(`The template for stack "${stack.displayName}" is ${Math.round(templateJson.length / 1024)}KiB. ` +
+            `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\n` +
+            'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\n\n', chalk.blue(`\t$ cdk bootstrap ${resolvedEnvironment.name}\n`))));
+        throw new api_1.ToolkitError('Template too large to deploy ("cdk bootstrap" is required)');
+    }
+    const templateHash = (0, util_1.contentHash)(templateJson);
+    const key = `cdk/${stack.id}/${templateHash}.yml`;
+    let templateFile = stack.templateFile;
+    if (overrideTemplate) {
+        // Add a variant of this template
+        templateFile = `${stack.templateFile}-${templateHash}.yaml`;
+        const templateFilePath = path.join(stack.assembly.directory, templateFile);
+        await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });
+    }
+    assetManifest.addFileAsset(templateHash, {
+        path: templateFile,
+    }, {
+        bucketName: toolkitInfo.bucketName,
+        objectKey: key,
+    });
+    const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
+    await ioHelper.notify(private_1.IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));
+    return { TemplateURL: templateURL };
+}
+/**
+ * Format an S3 URL in the manifest for use with CloudFormation
+ *
+ * Replaces environment placeholders (which this field may contain),
+ * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation
+ * expects)
+ */
+async function restUrlFromManifest(url, environment) {
+    const doNotUseMarker = '**DONOTUSE**';
+    const region = environment.region;
+    // This URL may contain placeholders, so still substitute those.
+    url = cx_api_1.EnvironmentPlaceholders.replace(url, {
+        accountId: environment.account,
+        region,
+        partition: doNotUseMarker,
+    });
+    // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend
+    // a lot of effort trying to thread the right value to this location.
+    if (url.indexOf(doNotUseMarker) > -1) {
+        throw new api_1.ToolkitError("Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field");
+    }
+    const s3Url = url.match(/s3:\/\/([^/]+)\/(.*)$/);
+    if (!s3Url) {
+        return url;
+    }
+    // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we
+    // got an 's3://bucket/object' URL instead. Construct the rest API URL here.
+    const bucketName = s3Url[1];
+    const objectKey = s3Url[2];
+    // SDK v3 no longer allows for getting endpoints from only region.
+    // A command and client config must now be provided.
+    const s3 = new client_s3_1.S3Client({ region });
+    const endpoint = await (0, middleware_endpoint_1.getEndpointFromInstructions)({}, client_s3_1.HeadObjectCommand, {
+        ...s3.config,
+    });
+    endpoint.url.hostname;
+    return `${endpoint.url.origin}/${bucketName}/${objectKey}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-body-parameter.js","sourceRoot":"","sources":["template-body-parameter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport * as util from 'node:util';\nimport { type CloudFormationStackArtifact, type Environment, EnvironmentPlaceholders } from '@aws-cdk/cx-api';\nimport { HeadObjectCommand, S3Client } from '@aws-sdk/client-s3';\nimport { getEndpointFromInstructions } from '@smithy/middleware-endpoint';\nimport * as chalk from 'chalk';\nimport { ToolkitError } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api';\nimport { IO, type IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';\nimport { contentHash, toYAML } from '../../util';\nimport type { AssetManifestBuilder } from '../deployments';\nimport type { EnvironmentResources } from '../environment';\n\nexport type TemplateBodyParameter = {\n  TemplateBody?: string;\n  TemplateURL?: string;\n};\n\nconst LARGE_TEMPLATE_SIZE_KB = 50;\n\n/**\n * Prepares the body parameter for +CreateChangeSet+.\n *\n * If the template is small enough to be inlined into the API call, just return\n * it immediately.\n *\n * Otherwise, add it to the asset manifest to get uploaded to the staging\n * bucket and return its coordinates. If there is no staging bucket, an error\n * is thrown.\n *\n * @param stack     the synthesized stack that provides the CloudFormation template\n * @param toolkitInfo information about the toolkit stack\n */\nexport async function makeBodyParameter(\n  ioHelper: IoHelper,\n  stack: CloudFormationStackArtifact,\n  resolvedEnvironment: Environment,\n  assetManifest: AssetManifestBuilder,\n  resources: EnvironmentResources,\n  overrideTemplate?: any,\n): Promise<TemplateBodyParameter> {\n  // If the template has already been uploaded to S3, just use it from there.\n  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {\n    return {\n      TemplateURL: await restUrlFromManifest(stack.stackTemplateAssetObjectUrl, resolvedEnvironment),\n    };\n  }\n\n  // Otherwise, pass via API call (if small) or upload here (if large)\n  const templateJson = toYAML(overrideTemplate ?? stack.template);\n\n  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {\n    return { TemplateBody: templateJson };\n  }\n\n  const toolkitInfo = await resources.lookupToolkit();\n  if (!toolkitInfo.found) {\n    await ioHelper.notify(\n      IO.DEFAULT_TOOLKIT_ERROR.msg(util.format(\n        `The template for stack \"${stack.displayName}\" is ${Math.round(templateJson.length / 1024)}KiB. ` +\n        `Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.\\n` +\n        'Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:\\n\\n',\n        chalk.blue(`\\t$ cdk bootstrap ${resolvedEnvironment.name}\\n`),\n      )),\n    );\n\n    throw new ToolkitError('Template too large to deploy (\"cdk bootstrap\" is required)');\n  }\n\n  const templateHash = contentHash(templateJson);\n  const key = `cdk/${stack.id}/${templateHash}.yml`;\n\n  let templateFile = stack.templateFile;\n  if (overrideTemplate) {\n    // Add a variant of this template\n    templateFile = `${stack.templateFile}-${templateHash}.yaml`;\n    const templateFilePath = path.join(stack.assembly.directory, templateFile);\n    await fs.writeFile(templateFilePath, templateJson, { encoding: 'utf-8' });\n  }\n\n  assetManifest.addFileAsset(\n    templateHash,\n    {\n      path: templateFile,\n    },\n    {\n      bucketName: toolkitInfo.bucketName,\n      objectKey: key,\n    },\n  );\n\n  const templateURL = `${toolkitInfo.bucketUrl}/${key}`;\n  await ioHelper.notify(IO.DEFAULT_TOOLKIT_DEBUG.msg(`Storing template in S3 at: ${templateURL}`));\n  return { TemplateURL: templateURL };\n}\n\n/**\n * Format an S3 URL in the manifest for use with CloudFormation\n *\n * Replaces environment placeholders (which this field may contain),\n * and reformats s3://.../... urls into S3 REST URLs (which CloudFormation\n * expects)\n */\nasync function restUrlFromManifest(url: string, environment: Environment): Promise<string> {\n  const doNotUseMarker = '**DONOTUSE**';\n  const region = environment.region;\n  // This URL may contain placeholders, so still substitute those.\n  url = EnvironmentPlaceholders.replace(url, {\n    accountId: environment.account,\n    region,\n    partition: doNotUseMarker,\n  });\n\n  // Yes, this is extremely crude, but we don't actually need this so I'm not inclined to spend\n  // a lot of effort trying to thread the right value to this location.\n  if (url.indexOf(doNotUseMarker) > -1) {\n    throw new ToolkitError(\"Cannot use '${AWS::Partition}' in the 'stackTemplateAssetObjectUrl' field\");\n  }\n\n  const s3Url = url.match(/s3:\\/\\/([^/]+)\\/(.*)$/);\n  if (!s3Url) {\n    return url;\n  }\n\n  // We need to pass an 'https://s3.REGION.amazonaws.com[.cn]/bucket/object' URL to CloudFormation, but we\n  // got an 's3://bucket/object' URL instead. Construct the rest API URL here.\n  const bucketName = s3Url[1];\n  const objectKey = s3Url[2];\n\n  // SDK v3 no longer allows for getting endpoints from only region.\n  // A command and client config must now be provided.\n  const s3 = new S3Client({ region });\n  const endpoint = await getEndpointFromInstructions({}, HeadObjectCommand, {\n    ...s3.config,\n  });\n  endpoint.url.hostname;\n\n  return `${endpoint.url.origin}/${bucketName}/${objectKey}`;\n}\n"]}

package/lib/api/context.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.PROJECT_CONTEXT = exports.TRANSIENT_CONTEXT_KEY = void 0;
 const settings_1 = require("./settings");
-const error_1 = require("../toolkit/error");
+const api_1 = require("../../../@aws-cdk/tmp-toolkit-helpers/src/api");
 var settings_2 = require("./settings");
 Object.defineProperty(exports, "TRANSIENT_CONTEXT_KEY", { enumerable: true, get: function () { return settings_2.TRANSIENT_CONTEXT_KEY; } });
 exports.PROJECT_CONTEXT = 'cdk.context.json';
@@ -72,11 +72,11 @@ class Context {
         }
         const bag = this.bags[index];
         if (bag.readOnly) {
-            throw new error_1.ToolkitError(`Context file ${fileName} is read only!`);
+            throw new api_1.ToolkitError(`Context file ${fileName} is read only!`);
         }
         await bag.save(fileName);
         return this;
     }
 }
 exports.Context = Context;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/cxapp/cloud-assembly.d.ts

@@ -1,5 +1,6 @@
 import type * as cxapi from '@aws-cdk/cx-api';
-import { type StackDetails } from '@aws-cdk/tmp-toolkit-helpers';
+import { type StackDetails } from '../../../../@aws-cdk/tmp-toolkit-helpers';
+import { type IoHelper } from '../../../../@aws-cdk/tmp-toolkit-helpers/src/api/io/private';
 export declare enum DefaultSelection {
     /**
      * Returns an empty selection in case there are no selectors.
@@ -77,12 +78,13 @@ export declare class CloudAssembly {
      * The directory this CloudAssembly was read from
      */
     readonly directory: string;
-    constructor(assembly: cxapi.CloudAssembly);
+    private readonly ioHelper;
+    constructor(assembly: cxapi.CloudAssembly, ioHelper: IoHelper);
     selectStacks(selector: StackSelector, options: SelectStacksOptions): Promise<StackCollection>;
     private selectTopLevelStacks;
-    protected selectMatchingStacks(stacks: cxapi.CloudFormationStackArtifact[], patterns: string[], extend?: ExtendedStackSelection): StackCollection;
+    protected selectMatchingStacks(stacks: cxapi.CloudFormationStackArtifact[], patterns: string[], extend?: ExtendedStackSelection): Promise<StackCollection>;
     private selectDefaultStacks;
-    protected extendStacks(matched: cxapi.CloudFormationStackArtifact[], all: cxapi.CloudFormationStackArtifact[], extend?: ExtendedStackSelection): StackCollection;
+    protected extendStacks(matched: cxapi.CloudFormationStackArtifact[], all: cxapi.CloudFormationStackArtifact[], extend?: ExtendedStackSelection): Promise<StackCollection>;
     /**
      * Select a single stack by its ID
      */