@aws-cdk/toolkit-lib 0.3.1 → 0.3.3

package/lib/api/diff/diff-formatter.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffFormatter = void 0;
+const node_util_1 = require("node:util");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const payloads_1 = require("../../payloads");
+const private_1 = require("../io/private");
+const streams_1 = require("../streams");
+/**
+ * Class for formatting the diff output
+ */
+class DiffFormatter {
+    ioHelper;
+    oldTemplate;
+    newTemplate;
+    stackName;
+    changeSet;
+    nestedStacks;
+    isImport;
+    /**
+     * Stores the TemplateDiffs that get calculated in this DiffFormatter,
+     * indexed by the stack name.
+     */
+    _diffs = {};
+    constructor(props) {
+        this.ioHelper = props.ioHelper;
+        this.oldTemplate = props.templateInfo.oldTemplate;
+        this.newTemplate = props.templateInfo.newTemplate;
+        this.stackName = props.templateInfo.newTemplate.stackName;
+        this.changeSet = props.templateInfo.changeSet;
+        this.nestedStacks = props.templateInfo.nestedStacks;
+        this.isImport = props.templateInfo.isImport ?? false;
+    }
+    get diffs() {
+        return this._diffs;
+    }
+    /**
+     * Get or creates the diff of a stack.
+     * If it creates the diff, it stores the result in a map for
+     * easier retreval later.
+     */
+    diff(stackName, oldTemplate) {
+        const realStackName = stackName ?? this.stackName;
+        if (!this._diffs[realStackName]) {
+            this._diffs[realStackName] = (0, cloudformation_diff_1.fullDiff)(oldTemplate ?? this.oldTemplate, this.newTemplate.template, this.changeSet, this.isImport);
+        }
+        return this._diffs[realStackName];
+    }
+    /**
+     * Return whether the diff has security-impacting changes that need confirmation.
+     *
+     * If no stackName is given, then the root stack name is used.
+     */
+    permissionType(stackName) {
+        const diff = this.diff(stackName);
+        if (diff.permissionsBroadened) {
+            return payloads_1.PermissionChangeType.BROADENING;
+        }
+        else if (diff.permissionsAnyChanges) {
+            return payloads_1.PermissionChangeType.NON_BROADENING;
+        }
+        else {
+            return payloads_1.PermissionChangeType.NONE;
+        }
+    }
+    /**
+     * Format the stack diff
+     */
+    formatStackDiff(options = {}) {
+        const ioDefaultHelper = new private_1.IoDefaultMessages(this.ioHelper);
+        return this.formatStackDiffHelper(this.oldTemplate, this.stackName, this.nestedStacks, {
+            ...options,
+            ioDefaultHelper,
+        });
+    }
+    formatStackDiffHelper(oldTemplate, stackName, nestedStackTemplates, options) {
+        let diff = this.diff(stackName, oldTemplate);
+        // The stack diff is formatted via `Formatter`, which takes in a stream
+        // and sends its output directly to that stream. To faciliate use of the
+        // global CliIoHost, we create our own stream to capture the output of
+        // `Formatter` and return the output as a string for the consumer of
+        // `formatStackDiff` to decide what to do with it.
+        const stream = new streams_1.StringWriteStream();
+        let numStacksWithChanges = 0;
+        let formattedDiff = '';
+        let filteredChangesCount = 0;
+        try {
+            // must output the stack name if there are differences, even if quiet
+            if (stackName && (!options.quiet || !diff.isEmpty)) {
+                stream.write((0, node_util_1.format)(`Stack ${chalk.bold(stackName)}\n`));
+            }
+            if (!options.quiet && this.isImport) {
+                stream.write('Parameters and rules created during migration do not affect resource configuration.\n');
+            }
+            // detect and filter out mangled characters from the diff
+            if (diff.differenceCount && !options.strict) {
+                const mangledNewTemplate = JSON.parse((0, cloudformation_diff_1.mangleLikeCloudFormation)(JSON.stringify(this.newTemplate.template)));
+                const mangledDiff = (0, cloudformation_diff_1.fullDiff)(this.oldTemplate, mangledNewTemplate, this.changeSet);
+                filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);
+                if (filteredChangesCount > 0) {
+                    diff = mangledDiff;
+                }
+            }
+            // filter out 'AWS::CDK::Metadata' resources from the template
+            // filter out 'CheckBootstrapVersion' rules from the template
+            if (!options.strict) {
+                obscureDiff(diff);
+            }
+            if (!diff.isEmpty) {
+                numStacksWithChanges++;
+                // formatDifferences updates the stream with the formatted stack diff
+                (0, cloudformation_diff_1.formatDifferences)(stream, diff, {
+                    ...logicalIdMapFromTemplate(this.oldTemplate),
+                    ...buildLogicalToPathMap(this.newTemplate),
+                }, options.context);
+            }
+            else if (!options.quiet) {
+                stream.write(chalk.green('There were no differences\n'));
+            }
+            if (filteredChangesCount > 0) {
+                stream.write(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.\n`));
+            }
+        }
+        finally {
+            // store the stream containing a formatted stack diff
+            formattedDiff = stream.toString();
+            stream.end();
+        }
+        for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {
+            if (!nestedStackTemplates) {
+                break;
+            }
+            const nestedStack = nestedStackTemplates[nestedStackLogicalId];
+            this.newTemplate._template = nestedStack.generatedTemplate;
+            const nextDiff = this.formatStackDiffHelper(nestedStack.deployedTemplate, nestedStack.physicalName ?? nestedStackLogicalId, nestedStack.nestedStackTemplates, options);
+            numStacksWithChanges += nextDiff.numStacksWithChanges;
+            formattedDiff += nextDiff.formattedDiff;
+        }
+        return {
+            numStacksWithChanges,
+            formattedDiff,
+        };
+    }
+    /**
+     * Format the security diff
+     */
+    formatSecurityDiff() {
+        const diff = this.diff();
+        // The security diff is formatted via `Formatter`, which takes in a stream
+        // and sends its output directly to that stream. To faciliate use of the
+        // global CliIoHost, we create our own stream to capture the output of
+        // `Formatter` and return the output as a string for the consumer of
+        // `formatSecurityDiff` to decide what to do with it.
+        const stream = new streams_1.StringWriteStream();
+        stream.write((0, node_util_1.format)(`Stack ${chalk.bold(this.stackName)}\n`));
+        try {
+            // formatSecurityChanges updates the stream with the formatted security diff
+            (0, cloudformation_diff_1.formatSecurityChanges)(stream, diff, buildLogicalToPathMap(this.newTemplate));
+        }
+        finally {
+            stream.end();
+        }
+        // store the stream containing a formatted stack diff
+        const formattedDiff = stream.toString();
+        return { formattedDiff, permissionChangeType: this.permissionType() };
+    }
+}
+exports.DiffFormatter = DiffFormatter;
+function buildLogicalToPathMap(stack) {
+    const map = {};
+    for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {
+        map[md.data] = md.path;
+    }
+    return map;
+}
+function logicalIdMapFromTemplate(template) {
+    const ret = {};
+    for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {
+        const path = resource?.Metadata?.['aws:cdk:path'];
+        if (path) {
+            ret[logicalId] = path;
+        }
+    }
+    return ret;
+}
+/**
+ * Remove any template elements that we don't want to show users.
+ * This is currently:
+ * - AWS::CDK::Metadata resource
+ * - CheckBootstrapVersion Rule
+ */
+function obscureDiff(diff) {
+    if (diff.unknown) {
+        // see https://github.com/aws/aws-cdk/issues/17942
+        diff.unknown = diff.unknown.filter(change => {
+            if (!change) {
+                return true;
+            }
+            if (change.newValue?.CheckBootstrapVersion) {
+                return false;
+            }
+            if (change.oldValue?.CheckBootstrapVersion) {
+                return false;
+            }
+            return true;
+        });
+    }
+    if (diff.resources) {
+        diff.resources = diff.resources.filter(change => {
+            if (!change) {
+                return true;
+            }
+            if (change.newResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            if (change.oldResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff-formatter.js","sourceRoot":"","sources":["diff-formatter.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'node:util';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport {\n  formatDifferences,\n  formatSecurityChanges,\n  fullDiff,\n  mangleLikeCloudFormation,\n  type TemplateDiff,\n} from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { PermissionChangeType } from '../../payloads';\nimport type { NestedStackTemplates } from '../cloudformation';\nimport type { IoHelper } from '../io/private';\nimport { IoDefaultMessages } from '../io/private';\nimport { StringWriteStream } from '../streams';\n\n/**\n * Output of formatSecurityDiff\n */\ninterface FormatSecurityDiffOutput {\n  /**\n   * Complete formatted security diff\n   */\n  readonly formattedDiff: string;\n\n  /**\n   * The type of permission changes in the security diff.\n   * The IoHost will use this to decide whether or not to print.\n   */\n  readonly permissionChangeType: PermissionChangeType;\n}\n\n/**\n * Output of formatStackDiff\n */\ninterface FormatStackDiffOutput {\n  /**\n   * Number of stacks with diff changes\n   */\n  readonly numStacksWithChanges: number;\n\n  /**\n   * Complete formatted diff\n   */\n  readonly formattedDiff: string;\n}\n\n/**\n * Props for the Diff Formatter\n */\ninterface DiffFormatterProps {\n  /**\n   * Helper for the IoHost class\n   */\n  readonly ioHelper: IoHelper;\n\n  /**\n   * The relevant information for the Template that is being diffed.\n   * Includes the old/current state of the stack as well as the new state.\n   */\n  readonly templateInfo: TemplateInfo;\n}\n\n/**\n * PRoperties specific to formatting the stack diff\n */\ninterface FormatStackDiffOptions {\n  /**\n   * do not filter out AWS::CDK::Metadata or Rules\n   *\n   * @default false\n   */\n  readonly strict?: boolean;\n\n  /**\n   * lines of context to use in arbitrary JSON diff\n   *\n   * @default 3\n   */\n  readonly context?: number;\n\n  /**\n   * silences \\'There were no differences\\' messages\n   *\n   * @default false\n   */\n  readonly quiet?: boolean;\n}\n\ninterface ReusableStackDiffOptions extends FormatStackDiffOptions {\n  readonly ioDefaultHelper: IoDefaultMessages;\n}\n\n/**\n * Information on a template's old/new state\n * that is used for diff.\n */\nexport interface TemplateInfo {\n  /**\n   * The old/existing template\n   */\n  readonly oldTemplate: any;\n\n  /**\n   * The new template\n   */\n  readonly newTemplate: cxapi.CloudFormationStackArtifact;\n\n  /**\n   * A CloudFormation ChangeSet to help the diff operation.\n   * Probably created via `createDiffChangeSet`.\n   *\n   * @default undefined\n   */\n  readonly changeSet?: any;\n\n  /**\n   * Whether or not there are any imported resources\n   *\n   * @default false\n   */\n  readonly isImport?: boolean;\n\n  /**\n   * Any nested stacks included in the template\n   *\n   * @default {}\n   */\n  readonly nestedStacks?: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\n/**\n * Class for formatting the diff output\n */\nexport class DiffFormatter {\n  private readonly ioHelper: IoHelper;\n  private readonly oldTemplate: any;\n  private readonly newTemplate: cxapi.CloudFormationStackArtifact;\n  private readonly stackName: string;\n  private readonly changeSet?: any;\n  private readonly nestedStacks: { [nestedStackLogicalId: string]: NestedStackTemplates } | undefined;\n  private readonly isImport: boolean;\n\n  /**\n   * Stores the TemplateDiffs that get calculated in this DiffFormatter,\n   * indexed by the stack name.\n   */\n  private _diffs: { [name: string]: TemplateDiff } = {};\n\n  constructor(props: DiffFormatterProps) {\n    this.ioHelper = props.ioHelper;\n    this.oldTemplate = props.templateInfo.oldTemplate;\n    this.newTemplate = props.templateInfo.newTemplate;\n    this.stackName = props.templateInfo.newTemplate.stackName;\n    this.changeSet = props.templateInfo.changeSet;\n    this.nestedStacks = props.templateInfo.nestedStacks;\n    this.isImport = props.templateInfo.isImport ?? false;\n  }\n\n  public get diffs() {\n    return this._diffs;\n  }\n\n  /**\n   * Get or creates the diff of a stack.\n   * If it creates the diff, it stores the result in a map for\n   * easier retreval later.\n   */\n  private diff(stackName?: string, oldTemplate?: any) {\n    const realStackName = stackName ?? this.stackName;\n\n    if (!this._diffs[realStackName]) {\n      this._diffs[realStackName] = fullDiff(\n        oldTemplate ?? this.oldTemplate,\n        this.newTemplate.template,\n        this.changeSet,\n        this.isImport,\n      );\n    }\n    return this._diffs[realStackName];\n  }\n\n  /**\n   * Return whether the diff has security-impacting changes that need confirmation.\n   *\n   * If no stackName is given, then the root stack name is used.\n   */\n  private permissionType(stackName?: string): PermissionChangeType {\n    const diff = this.diff(stackName);\n\n    if (diff.permissionsBroadened) {\n      return PermissionChangeType.BROADENING;\n    } else if (diff.permissionsAnyChanges) {\n      return PermissionChangeType.NON_BROADENING;\n    } else {\n      return PermissionChangeType.NONE;\n    }\n  }\n\n  /**\n   * Format the stack diff\n   */\n  public formatStackDiff(options: FormatStackDiffOptions = {}): FormatStackDiffOutput {\n    const ioDefaultHelper = new IoDefaultMessages(this.ioHelper);\n    return this.formatStackDiffHelper(\n      this.oldTemplate,\n      this.stackName,\n      this.nestedStacks,\n      {\n        ...options,\n        ioDefaultHelper,\n      },\n    );\n  }\n\n  private formatStackDiffHelper(\n    oldTemplate: any,\n    stackName: string,\n    nestedStackTemplates: { [nestedStackLogicalId: string]: NestedStackTemplates } | undefined,\n    options: ReusableStackDiffOptions,\n  ) {\n    let diff = this.diff(stackName, oldTemplate);\n\n    // The stack diff is formatted via `Formatter`, which takes in a stream\n    // and sends its output directly to that stream. To faciliate use of the\n    // global CliIoHost, we create our own stream to capture the output of\n    // `Formatter` and return the output as a string for the consumer of\n    // `formatStackDiff` to decide what to do with it.\n    const stream = new StringWriteStream();\n\n    let numStacksWithChanges = 0;\n    let formattedDiff = '';\n    let filteredChangesCount = 0;\n    try {\n      // must output the stack name if there are differences, even if quiet\n      if (stackName && (!options.quiet || !diff.isEmpty)) {\n        stream.write(format(`Stack ${chalk.bold(stackName)}\\n`));\n      }\n\n      if (!options.quiet && this.isImport) {\n        stream.write('Parameters and rules created during migration do not affect resource configuration.\\n');\n      }\n\n      // detect and filter out mangled characters from the diff\n      if (diff.differenceCount && !options.strict) {\n        const mangledNewTemplate = JSON.parse(mangleLikeCloudFormation(JSON.stringify(this.newTemplate.template)));\n        const mangledDiff = fullDiff(this.oldTemplate, mangledNewTemplate, this.changeSet);\n        filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);\n        if (filteredChangesCount > 0) {\n          diff = mangledDiff;\n        }\n      }\n\n      // filter out 'AWS::CDK::Metadata' resources from the template\n      // filter out 'CheckBootstrapVersion' rules from the template\n      if (!options.strict) {\n        obscureDiff(diff);\n      }\n\n      if (!diff.isEmpty) {\n        numStacksWithChanges++;\n\n        // formatDifferences updates the stream with the formatted stack diff\n        formatDifferences(stream, diff, {\n          ...logicalIdMapFromTemplate(this.oldTemplate),\n          ...buildLogicalToPathMap(this.newTemplate),\n        }, options.context);\n      } else if (!options.quiet) {\n        stream.write(chalk.green('There were no differences\\n'));\n      }\n\n      if (filteredChangesCount > 0) {\n        stream.write(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.\\n`));\n      }\n    } finally {\n      // store the stream containing a formatted stack diff\n      formattedDiff = stream.toString();\n      stream.end();\n    }\n\n    for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {\n      if (!nestedStackTemplates) {\n        break;\n      }\n      const nestedStack = nestedStackTemplates[nestedStackLogicalId];\n\n      (this.newTemplate as any)._template = nestedStack.generatedTemplate;\n      const nextDiff = this.formatStackDiffHelper(\n        nestedStack.deployedTemplate,\n        nestedStack.physicalName ?? nestedStackLogicalId,\n        nestedStack.nestedStackTemplates,\n        options,\n      );\n      numStacksWithChanges += nextDiff.numStacksWithChanges;\n      formattedDiff += nextDiff.formattedDiff;\n    }\n\n    return {\n      numStacksWithChanges,\n      formattedDiff,\n    };\n  }\n\n  /**\n   * Format the security diff\n   */\n  public formatSecurityDiff(): FormatSecurityDiffOutput {\n    const diff = this.diff();\n\n    // The security diff is formatted via `Formatter`, which takes in a stream\n    // and sends its output directly to that stream. To faciliate use of the\n    // global CliIoHost, we create our own stream to capture the output of\n    // `Formatter` and return the output as a string for the consumer of\n    // `formatSecurityDiff` to decide what to do with it.\n    const stream = new StringWriteStream();\n\n    stream.write(format(`Stack ${chalk.bold(this.stackName)}\\n`));\n\n    try {\n      // formatSecurityChanges updates the stream with the formatted security diff\n      formatSecurityChanges(stream, diff, buildLogicalToPathMap(this.newTemplate));\n    } finally {\n      stream.end();\n    }\n    // store the stream containing a formatted stack diff\n    const formattedDiff = stream.toString();\n    return { formattedDiff, permissionChangeType: this.permissionType() };\n  }\n}\n\nfunction buildLogicalToPathMap(stack: cxapi.CloudFormationStackArtifact) {\n  const map: { [id: string]: string } = {};\n  for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {\n    map[md.data as string] = md.path;\n  }\n  return map;\n}\n\nfunction logicalIdMapFromTemplate(template: any) {\n  const ret: Record<string, string> = {};\n\n  for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {\n    const path = (resource as any)?.Metadata?.['aws:cdk:path'];\n    if (path) {\n      ret[logicalId] = path;\n    }\n  }\n  return ret;\n}\n\n/**\n * Remove any template elements that we don't want to show users.\n * This is currently:\n * - AWS::CDK::Metadata resource\n * - CheckBootstrapVersion Rule\n */\nfunction obscureDiff(diff: TemplateDiff) {\n  if (diff.unknown) {\n    // see https://github.com/aws/aws-cdk/issues/17942\n    diff.unknown = diff.unknown.filter(change => {\n      if (!change) {\n        return true;\n      }\n      if (change.newValue?.CheckBootstrapVersion) {\n        return false;\n      }\n      if (change.oldValue?.CheckBootstrapVersion) {\n        return false;\n      }\n      return true;\n    });\n  }\n\n  if (diff.resources) {\n    diff.resources = diff.resources.filter(change => {\n      if (!change) {\n        return true;\n      }\n      if (change.newResourceType === 'AWS::CDK::Metadata') {\n        return false;\n      }\n      if (change.oldResourceType === 'AWS::CDK::Metadata') {\n        return false;\n      }\n      return true;\n    });\n  }\n}\n"]}

package/lib/api/diff/index.d.ts

@@ -0,0 +1 @@
+export * from './diff-formatter';

package/lib/api/diff/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./diff-formatter"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kaWZmLWZvcm1hdHRlcic7XG4iXX0=

package/lib/api/environment/environment-access.d.ts

@@ -0,0 +1,139 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { EnvironmentResources } from './environment-resources';
+import type { StringWithoutPlaceholders } from './placeholders';
+import type { SDK, SdkProvider } from '../aws-auth/private';
+import { type IoHelper } from '../io/private';
+/**
+ * Access particular AWS resources, based on information from the CX manifest
+ *
+ * It is not possible to grab direct access to AWS credentials; 9 times out of 10
+ * we have to allow for role assumption, and role assumption can only work if
+ * there is a CX Manifest that contains a role ARN.
+ *
+ * This class exists so new code isn't tempted to go and get SDK credentials directly.
+ */
+export declare class EnvironmentAccess {
+    private readonly sdkProvider;
+    private readonly sdkCache;
+    private readonly environmentResources;
+    private readonly ioHelper;
+    constructor(sdkProvider: SdkProvider, toolkitStackName: string, ioHelper: IoHelper);
+    /**
+     * Resolves the environment for a stack.
+     */
+    resolveStackEnvironment(stack: cxapi.CloudFormationStackArtifact): Promise<cxapi.Environment>;
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will ask plugins for readonly credentials if available, use the default
+     * AWS credentials if not.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    accessStackForReadOnlyStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment>;
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will ask plugins for mutating credentials if available, use the default AWS
+     * credentials if not.  The `mode` parameter is only used for querying
+     * plugins.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    accessStackForMutableStackOperations(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment>;
+    /**
+     * Get an SDK to access the given stack's environment for environmental lookups
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will assume the lookup role if configured on the stack. Check the default `lookup-role`
+     * policies to see what you can do with this role. It can generally read everything
+     * in the account that does not require KMS access.
+     *
+     * ---
+     *
+     * For backwards compatibility reasons, there are some scenarios that are handled here:
+     *
+     *  1. The lookup role may not exist (it was added in bootstrap stack version 7). If so:
+     *     a. Return the default credentials if the default credentials are for the stack account
+     *        (you will notice this as `isFallbackCredentials=true`).
+     *     b. Throw an error if the default credentials are not for the stack account.
+     *
+     *  2. The lookup role may not have the correct permissions (for example, ReadOnlyAccess was added in
+     *     bootstrap stack version 8); the stack will have a minimum version number on it.
+     *     a. If it does not we throw an error which should be handled in the calling
+     *        function (and fallback to use a different role, etc)
+     *
+     * Upon success, caller will have an SDK for the right account, which may or may not have
+     * the right permissions.
+     */
+    accessStackForLookup(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment>;
+    /**
+     * Get an SDK to access the given stack's environment for reading stack attributes
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will try to assume the lookup role if given, will use the regular stack operations
+     * access (deploy-role) otherwise. When calling this, you should assume that you will get
+     * the least privileged role, so don't try to use it for anything the `deploy-role`
+     * wouldn't be able to do. Also you cannot rely on being able to read encrypted anything.
+     */
+    accessStackForLookupBestEffort(stack: cxapi.CloudFormationStackArtifact): Promise<TargetEnvironment>;
+    /**
+     * Get an SDK to access the given stack's environment for stack operations
+     *
+     * Will use a plugin if available, use the default AWS credentials if not.
+     * The `mode` parameter is only used for querying plugins.
+     *
+     * Will assume the deploy role if configured on the stack. Check the default `deploy-role`
+     * policies to see what you can do with this role.
+     */
+    private accessStackForStackOperations;
+    /**
+     * Prepare an SDK for use in the given environment and optionally with a role assumed.
+     */
+    private prepareSdk;
+    private cachedSdkForEnvironment;
+}
+/**
+ * SDK obtained by assuming the deploy role
+ * for a given environment
+ */
+export interface TargetEnvironment {
+    /**
+     * The SDK for the given environment
+     */
+    readonly sdk: SDK;
+    /**
+     * The resolved environment for the stack
+     * (no more 'unknown-account/unknown-region')
+     */
+    readonly resolvedEnvironment: cxapi.Environment;
+    /**
+     * Access class for environmental resources to help the deployment
+     */
+    readonly resources: EnvironmentResources;
+    /**
+     * Whether or not we assumed a role in the process of getting these credentials
+     */
+    readonly didAssumeRole: boolean;
+    /**
+     * Whether or not these are fallback credentials
+     *
+     * Fallback credentials means that assuming the intended role failed, but the
+     * base credentials happen to be for the right account so we just picked those
+     * and hope the future SDK calls succeed.
+     *
+     * This is a backwards compatibility mechanism from around the time we introduced
+     * deployment roles.
+     */
+    readonly isFallbackCredentials: boolean;
+    /**
+     * Replace environment placeholders according to the current environment
+     */
+    replacePlaceholders(x: string | undefined): Promise<StringWithoutPlaceholders | undefined>;
+}