@aws-cdk/toolkit-lib 0.3.3 → 0.3.5

package/lib/api/plugin/context-provider-plugin.js

@@ -4,4 +4,4 @@ exports.isContextProviderPlugin = isContextProviderPlugin;
 function isContextProviderPlugin(x) {
     return typeof x === 'object' && !!x && !!x.getValue;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1wcm92aWRlci1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb250ZXh0LXByb3ZpZGVyLXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDBEQUVDO0FBRkQsU0FBZ0IsdUJBQXVCLENBQUMsQ0FBVTtJQUNoRCxPQUFPLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBRSxDQUFTLENBQUMsUUFBUSxDQUFDO0FBQy9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvbnRleHRQcm92aWRlclBsdWdpbiB7XG4gIGdldFZhbHVlKGFyZ3M6IHtba2V5OiBzdHJpbmddOiBhbnl9KTogUHJvbWlzZTxhbnk+O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNDb250ZXh0UHJvdmlkZXJQbHVnaW4oeDogdW5rbm93bik6IHggaXMgQ29udGV4dFByb3ZpZGVyUGx1Z2luIHtcbiAgcmV0dXJuIHR5cGVvZiB4ID09PSAnb2JqZWN0JyAmJiAhIXggJiYgISEoeCBhcyBhbnkpLmdldFZhbHVlO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC1wcm92aWRlci1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb250ZXh0LXByb3ZpZGVyLXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLDBEQUVDO0FBRkQsU0FBZ0IsdUJBQXVCLENBQUMsQ0FBVTtJQUNoRCxPQUFPLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBRSxDQUFTLENBQUMsUUFBUSxDQUFDO0FBQy9ELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIENvbnRleHRQcm92aWRlclBsdWdpbiB7XG4gIGdldFZhbHVlKGFyZ3M6IHsgW2tleTogc3RyaW5nXTogYW55IH0pOiBQcm9taXNlPGFueT47XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0NvbnRleHRQcm92aWRlclBsdWdpbih4OiB1bmtub3duKTogeCBpcyBDb250ZXh0UHJvdmlkZXJQbHVnaW4ge1xuICByZXR1cm4gdHlwZW9mIHggPT09ICdvYmplY3QnICYmICEheCAmJiAhISh4IGFzIGFueSkuZ2V0VmFsdWU7XG59XG4iXX0=

package/lib/api/plugin/plugin.d.ts

@@ -1,8 +1,6 @@
 import type { CredentialProviderSource, IPluginHost } from '@aws-cdk/cli-plugin-contract';
 import { type ContextProviderPlugin } from './context-provider-plugin';
 import type { IIoHost } from '../io';
-export declare let TESTING: boolean;
-export declare function markTesting(): void;
 /**
  * Class to manage a plugin collection
  *
@@ -24,16 +22,16 @@ export declare class PluginHost implements IPluginHost {
      *
      * Will use `require.resolve()` to get the most accurate representation of what
      * code will get loaded in error messages. As such, it will not work in
-     * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.
+     * unit tests with Jest virtual modules becauase of \<https://github.com/jestjs/jest/issues/9543\>.
      *
-     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
-     * @param ioHost the I/O host to use for printing progress information
+     * @param moduleSpec - the specification (path or name) of the plug-in module to be loaded.
+     * @param ioHost - the I/O host to use for printing progress information
      */
     load(moduleSpec: string, ioHost?: IIoHost): void;
     /**
      * Allows plug-ins to register new CredentialProviderSources.
      *
-     * @param source a new CredentialProviderSource to register.
+     * @param source - a new CredentialProviderSource to register.
      */
     registerCredentialProviderSource(source: CredentialProviderSource): void;
     /**

package/lib/api/plugin/plugin.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginHost = exports.TESTING = void 0;
-exports.markTesting = markTesting;
+exports.PluginHost = void 0;
 const util_1 = require("util");
 const context_provider_plugin_1 = require("./context-provider-plugin");
-const private_1 = require("../private");
-const toolkit_error_1 = require("../toolkit-error");
-exports.TESTING = false;
-function markTesting() {
-    exports.TESTING = true;
-}
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+const private_1 = require("../io/private");
 /**
  * Class to manage a plugin collection
  *
@@ -31,10 +26,10 @@ class PluginHost {
      *
      * Will use `require.resolve()` to get the most accurate representation of what
      * code will get loaded in error messages. As such, it will not work in
-     * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.
+     * unit tests with Jest virtual modules becauase of \<https://github.com/jestjs/jest/issues/9543\>.
      *
-     * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
-     * @param ioHost the I/O host to use for printing progress information
+     * @param moduleSpec - the specification (path or name) of the plug-in module to be loaded.
+     * @param ioHost - the I/O host to use for printing progress information
      */
     load(moduleSpec, ioHost) {
         try {
@@ -83,7 +78,7 @@ class PluginHost {
     /**
      * Allows plug-ins to register new CredentialProviderSources.
      *
-     * @param source a new CredentialProviderSource to register.
+     * @param source - a new CredentialProviderSource to register.
      */
     registerCredentialProviderSource(source) {
         // Forward to the right credentials-related plugin host
@@ -129,4 +124,4 @@ class PluginHost {
     }
 }
 exports.PluginHost = PluginHost;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["plugin.ts"],"names":[],"mappings":";;;AASA,kCAEC;AAXD,+BAA+B;AAE/B,uEAAgG;AAEhG,wCAAyD;AACzD,oDAAgD;AAErC,QAAA,OAAO,GAAG,KAAK,CAAC;AAE3B,SAAgB,WAAW;IACzB,eAAO,GAAG,IAAI,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAa,UAAU;IACrB;;;OAGG;IACa,yBAAyB,GAAG,IAAI,KAAK,EAA4B,CAAC;IAElE,sBAAsB,GAA0C,EAAE,CAAC;IAE5E,MAAM,CAAW;IAEP,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnD;;;;;;;;;OASG;IACI,IAAI,CAAC,UAAkB,EAAE,MAAgB;QAC9C,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,2BAAiB,CAAC,kBAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,QAAQ,SAAS,UAAU,EAAE,CAAC,CAAC;YACtH,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,+EAA+E;YAC/E,yEAAyE;YACzE,gFAAgF;YAChF,wEAAwE;YACxE,MAAM,IAAI,4BAAY,CAAC,kDAAkD,UAAU,MAAM,CAAC,EAAE,CAAC,CAAC;QAChG,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,OAAO,CAAC,QAAgB;QAC7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrC,OAAO;YACT,CAAC;YAED,0DAA0D;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACjC,mBAAmB;YACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,4BAAY,CAAC,UAAU,QAAQ,yDAAyD,CAAC,CAAC;YACtG,CAAC;YACD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAED,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,4BAAY,CAAC,SAAS,CAAC,2BAA2B,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC;QAC1E,CAAC;QAED,SAAS,QAAQ,CAAC,CAAM;YACtB,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,gCAAgC,CAAC,MAAgC;QACtE,uDAAuD;QACvD,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACI,4BAA4B,CAAC,kBAA0B,EAAE,QAA+B;QAC7F,IAAI,CAAC,IAAA,iDAAuB,EAAC,QAAQ,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,4BAAY,CAAC,kEAAkE,IAAA,cAAO,EAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChH,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,kBAAkB,CAAC,GAAG,QAAQ,CAAC;IAC7D,CAAC;CACF;AAtHD,gCAsHC","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, IPluginHost, Plugin } from '@aws-cdk/cli-plugin-contract';\nimport { type ContextProviderPlugin, isContextProviderPlugin } from './context-provider-plugin';\nimport type { IIoHost } from '../io';\nimport { IoDefaultMessages, IoHelper } from '../private';\nimport { ToolkitError } from '../toolkit-error';\n\nexport let TESTING = false;\n\nexport function markTesting() {\n  TESTING = true;\n}\n\n/**\n * Class to manage a plugin collection\n *\n * It provides a `load()` function that loads a JavaScript\n * module from disk, and gives it access to the `IPluginHost` interface\n * to register itself.\n */\nexport class PluginHost implements IPluginHost {\n  /**\n   * Access the currently registered CredentialProviderSources. New sources can\n   * be registered using the +registerCredentialProviderSource+ method.\n   */\n  public readonly credentialProviderSources = new Array<CredentialProviderSource>();\n\n  public readonly contextProviderPlugins: Record<string, ContextProviderPlugin> = {};\n\n  public ioHost?: IIoHost;\n\n  private readonly alreadyLoaded = new Set<string>();\n\n  /**\n   * Loads a plug-in into this PluginHost.\n   *\n   * Will use `require.resolve()` to get the most accurate representation of what\n   * code will get loaded in error messages. As such, it will not work in\n   * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.\n   *\n   * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.\n   * @param ioHost the I/O host to use for printing progress information\n   */\n  public load(moduleSpec: string, ioHost?: IIoHost) {\n    try {\n      const resolved = require.resolve(moduleSpec);\n      if (ioHost) {\n        new IoDefaultMessages(IoHelper.fromIoHost(ioHost, 'init')).debug(`Loading plug-in: ${resolved} from ${moduleSpec}`);\n      }\n      return this._doLoad(resolved);\n    } catch (e: any) {\n      // according to Node.js docs `MODULE_NOT_FOUND` is the only possible error here\n      // @see https://nodejs.org/api/modules.html#requireresolverequest-options\n      // Not using `withCause()` here, since the node error contains a \"Require Stack\"\n      // as part of the error message that is inherently useless to our users.\n      throw new ToolkitError(`Unable to resolve plug-in: Cannot find module '${moduleSpec}': ${e}`);\n    }\n  }\n\n  /**\n   * Do the loading given an already-resolved module name\n   *\n   * @internal\n   */\n  public _doLoad(resolved: string) {\n    try {\n      if (this.alreadyLoaded.has(resolved)) {\n        return;\n      }\n\n      /* eslint-disable @typescript-eslint/no-require-imports */\n      const plugin = require(resolved);\n      /* eslint-enable */\n      if (!isPlugin(plugin)) {\n        throw new ToolkitError(`Module ${resolved} is not a valid plug-in, or has an unsupported version.`);\n      }\n      if (plugin.init) {\n        plugin.init(this);\n      }\n\n      this.alreadyLoaded.add(resolved);\n    } catch (e: any) {\n      throw ToolkitError.withCause(`Unable to load plug-in '${resolved}'`, e);\n    }\n\n    function isPlugin(x: any): x is Plugin {\n      return x != null && x.version === '1';\n    }\n  }\n\n  /**\n   * Allows plug-ins to register new CredentialProviderSources.\n   *\n   * @param source a new CredentialProviderSource to register.\n   */\n  public registerCredentialProviderSource(source: CredentialProviderSource) {\n    // Forward to the right credentials-related plugin host\n    this.credentialProviderSources.push(source);\n  }\n\n  /**\n   * (EXPERIMENTAL) Allow plugins to register context providers\n   *\n   * Context providers are objects with the following method:\n   *\n   * ```ts\n   *   getValue(args: {[key: string]: any}): Promise<any>;\n   * ```\n   *\n   * Currently, they cannot reuse the CDK's authentication mechanisms, so they\n   * must be prepared to either not make AWS calls or use their own source of\n   * AWS credentials.\n   *\n   * This feature is experimental, and only intended to be used internally at Amazon\n   * as a trial.\n   *\n   * After registering with 'my-plugin-name', the provider must be addressed as follows:\n   *\n   * ```ts\n   * const value = ContextProvider.getValue(this, {\n   *   providerName: 'plugin',\n   *   props: {\n   *     pluginName: 'my-plugin-name',\n   *     myParameter1: 'xyz',\n   *   },\n   *   includeEnvironment: true | false,\n   *   dummyValue: 'what-to-return-on-the-first-pass',\n   * })\n   * ```\n   *\n   * @experimental\n   */\n  public registerContextProviderAlpha(pluginProviderName: string, provider: ContextProviderPlugin) {\n    if (!isContextProviderPlugin(provider)) {\n      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${inspect(provider)}`);\n    }\n    this.contextProviderPlugins[pluginProviderName] = provider;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["plugin.ts"],"names":[],"mappings":";;;AAAA,+BAA+B;AAE/B,uEAAgG;AAChG,+DAA2D;AAE3D,2CAA4D;AAE5D;;;;;;GAMG;AACH,MAAa,UAAU;IACrB;;;OAGG;IACa,yBAAyB,GAAG,IAAI,KAAK,EAA4B,CAAC;IAElE,sBAAsB,GAA0C,EAAE,CAAC;IAE5E,MAAM,CAAW;IAEP,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnD;;;;;;;;;OASG;IACI,IAAI,CAAC,UAAkB,EAAE,MAAgB;QAC9C,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC7C,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,2BAAiB,CAAC,kBAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,oBAAoB,QAAQ,SAAS,UAAU,EAAE,CAAC,CAAC;YACtH,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,+EAA+E;YAC/E,yEAAyE;YACzE,gFAAgF;YAChF,wEAAwE;YACxE,MAAM,IAAI,4BAAY,CAAC,kDAAkD,UAAU,MAAM,CAAC,EAAE,CAAC,CAAC;QAChG,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,OAAO,CAAC,QAAgB;QAC7B,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrC,OAAO;YACT,CAAC;YAED,0DAA0D;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACjC,mBAAmB;YACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,4BAAY,CAAC,UAAU,QAAQ,yDAAyD,CAAC,CAAC;YACtG,CAAC;YACD,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;YAED,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,4BAAY,CAAC,SAAS,CAAC,2BAA2B,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC;QAC1E,CAAC;QAED,SAAS,QAAQ,CAAC,CAAM;YACtB,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC;QACxC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,gCAAgC,CAAC,MAAgC;QACtE,uDAAuD;QACvD,IAAI,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACI,4BAA4B,CAAC,kBAA0B,EAAE,QAA+B;QAC7F,IAAI,CAAC,IAAA,iDAAuB,EAAC,QAAQ,CAAC,EAAE,CAAC;YACvC,MAAM,IAAI,4BAAY,CAAC,kEAAkE,IAAA,cAAO,EAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChH,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,kBAAkB,CAAC,GAAG,QAAQ,CAAC;IAC7D,CAAC;CACF;AAtHD,gCAsHC","sourcesContent":["import { inspect } from 'util';\nimport type { CredentialProviderSource, IPluginHost, Plugin } from '@aws-cdk/cli-plugin-contract';\nimport { type ContextProviderPlugin, isContextProviderPlugin } from './context-provider-plugin';\nimport { ToolkitError } from '../../toolkit/toolkit-error';\nimport type { IIoHost } from '../io';\nimport { IoDefaultMessages, IoHelper } from '../io/private';\n\n/**\n * Class to manage a plugin collection\n *\n * It provides a `load()` function that loads a JavaScript\n * module from disk, and gives it access to the `IPluginHost` interface\n * to register itself.\n */\nexport class PluginHost implements IPluginHost {\n  /**\n   * Access the currently registered CredentialProviderSources. New sources can\n   * be registered using the +registerCredentialProviderSource+ method.\n   */\n  public readonly credentialProviderSources = new Array<CredentialProviderSource>();\n\n  public readonly contextProviderPlugins: Record<string, ContextProviderPlugin> = {};\n\n  public ioHost?: IIoHost;\n\n  private readonly alreadyLoaded = new Set<string>();\n\n  /**\n   * Loads a plug-in into this PluginHost.\n   *\n   * Will use `require.resolve()` to get the most accurate representation of what\n   * code will get loaded in error messages. As such, it will not work in\n   * unit tests with Jest virtual modules becauase of \\<https://github.com/jestjs/jest/issues/9543\\>.\n   *\n   * @param moduleSpec - the specification (path or name) of the plug-in module to be loaded.\n   * @param ioHost - the I/O host to use for printing progress information\n   */\n  public load(moduleSpec: string, ioHost?: IIoHost) {\n    try {\n      const resolved = require.resolve(moduleSpec);\n      if (ioHost) {\n        new IoDefaultMessages(IoHelper.fromIoHost(ioHost, 'init')).debug(`Loading plug-in: ${resolved} from ${moduleSpec}`);\n      }\n      return this._doLoad(resolved);\n    } catch (e: any) {\n      // according to Node.js docs `MODULE_NOT_FOUND` is the only possible error here\n      // @see https://nodejs.org/api/modules.html#requireresolverequest-options\n      // Not using `withCause()` here, since the node error contains a \"Require Stack\"\n      // as part of the error message that is inherently useless to our users.\n      throw new ToolkitError(`Unable to resolve plug-in: Cannot find module '${moduleSpec}': ${e}`);\n    }\n  }\n\n  /**\n   * Do the loading given an already-resolved module name\n   *\n   * @internal\n   */\n  public _doLoad(resolved: string) {\n    try {\n      if (this.alreadyLoaded.has(resolved)) {\n        return;\n      }\n\n      /* eslint-disable @typescript-eslint/no-require-imports */\n      const plugin = require(resolved);\n      /* eslint-enable */\n      if (!isPlugin(plugin)) {\n        throw new ToolkitError(`Module ${resolved} is not a valid plug-in, or has an unsupported version.`);\n      }\n      if (plugin.init) {\n        plugin.init(this);\n      }\n\n      this.alreadyLoaded.add(resolved);\n    } catch (e: any) {\n      throw ToolkitError.withCause(`Unable to load plug-in '${resolved}'`, e);\n    }\n\n    function isPlugin(x: any): x is Plugin {\n      return x != null && x.version === '1';\n    }\n  }\n\n  /**\n   * Allows plug-ins to register new CredentialProviderSources.\n   *\n   * @param source - a new CredentialProviderSource to register.\n   */\n  public registerCredentialProviderSource(source: CredentialProviderSource) {\n    // Forward to the right credentials-related plugin host\n    this.credentialProviderSources.push(source);\n  }\n\n  /**\n   * (EXPERIMENTAL) Allow plugins to register context providers\n   *\n   * Context providers are objects with the following method:\n   *\n   * ```ts\n   *   getValue(args: {[key: string]: any}): Promise<any>;\n   * ```\n   *\n   * Currently, they cannot reuse the CDK's authentication mechanisms, so they\n   * must be prepared to either not make AWS calls or use their own source of\n   * AWS credentials.\n   *\n   * This feature is experimental, and only intended to be used internally at Amazon\n   * as a trial.\n   *\n   * After registering with 'my-plugin-name', the provider must be addressed as follows:\n   *\n   * ```ts\n   * const value = ContextProvider.getValue(this, {\n   *   providerName: 'plugin',\n   *   props: {\n   *     pluginName: 'my-plugin-name',\n   *     myParameter1: 'xyz',\n   *   },\n   *   includeEnvironment: true | false,\n   *   dummyValue: 'what-to-return-on-the-first-pass',\n   * })\n   * ```\n   *\n   * @experimental\n   */\n  public registerContextProviderAlpha(pluginProviderName: string, provider: ContextProviderPlugin) {\n    if (!isContextProviderPlugin(provider)) {\n      throw new ToolkitError(`Object you gave me does not look like a ContextProviderPlugin: ${inspect(provider)}`);\n    }\n    this.contextProviderPlugins[pluginProviderName] = provider;\n  }\n}\n"]}

package/lib/api/refactoring/cloudformation.d.ts

@@ -1,3 +1,4 @@
+import type { TypedMapping } from '@aws-cdk/cloudformation-diff';
 import type * as cxapi from '@aws-cdk/cx-api';
 export interface CloudFormationTemplate {
     Resources?: {
@@ -13,3 +14,25 @@ export interface CloudFormationStack {
     readonly stackName: string;
     readonly template: CloudFormationTemplate;
 }
+/**
+ * This class mirrors the `ResourceLocation` interface from CloudFormation,
+ * but is richer, since it has a reference to the stack object, rather than
+ * merely the stack name.
+ */
+export declare class ResourceLocation {
+    readonly stack: CloudFormationStack;
+    readonly logicalResourceId: string;
+    constructor(stack: CloudFormationStack, logicalResourceId: string);
+    toPath(): string;
+    getType(): string;
+    equalTo(other: ResourceLocation): boolean;
+}
+/**
+ * A mapping between a source and a destination location.
+ */
+export declare class ResourceMapping {
+    readonly source: ResourceLocation;
+    readonly destination: ResourceLocation;
+    constructor(source: ResourceLocation, destination: ResourceLocation);
+    toTypedMapping(): TypedMapping;
+}

package/lib/api/refactoring/cloudformation.js

@@ -1,3 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvdWRmb3JtYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbG91ZGZvcm1hdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgKiBhcyBjeGFwaSBmcm9tICdAYXdzLWNkay9jeC1hcGknO1xuXG5leHBvcnQgaW50ZXJmYWNlIENsb3VkRm9ybWF0aW9uVGVtcGxhdGUge1xuICBSZXNvdXJjZXM/OiB7XG4gICAgW2xvZ2ljYWxJZDogc3RyaW5nXToge1xuICAgICAgVHlwZTogc3RyaW5nO1xuICAgICAgUHJvcGVydGllcz86IGFueTtcbiAgICAgIE1ldGFkYXRhPzogUmVjb3JkPHN0cmluZywgYW55PjtcbiAgICB9O1xuICB9O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENsb3VkRm9ybWF0aW9uU3RhY2sge1xuICByZWFkb25seSBlbnZpcm9ubWVudDogY3hhcGkuRW52aXJvbm1lbnQ7XG4gIHJlYWRvbmx5IHN0YWNrTmFtZTogc3RyaW5nO1xuICByZWFkb25seSB0ZW1wbGF0ZTogQ2xvdWRGb3JtYXRpb25UZW1wbGF0ZTtcbn1cbiJdfQ==
+exports.ResourceMapping = exports.ResourceLocation = void 0;
+/**
+ * This class mirrors the `ResourceLocation` interface from CloudFormation,
+ * but is richer, since it has a reference to the stack object, rather than
+ * merely the stack name.
+ */
+class ResourceLocation {
+    stack;
+    logicalResourceId;
+    constructor(stack, logicalResourceId) {
+        this.stack = stack;
+        this.logicalResourceId = logicalResourceId;
+    }
+    toPath() {
+        const stack = this.stack;
+        const resource = stack.template.Resources?.[this.logicalResourceId];
+        const result = resource?.Metadata?.['aws:cdk:path'];
+        if (result != null) {
+            return result;
+        }
+        // If the path is not available, we can use stack name and logical ID
+        return `${stack.stackName}.${this.logicalResourceId}`;
+    }
+    getType() {
+        const resource = this.stack.template.Resources?.[this.logicalResourceId ?? ''];
+        return resource?.Type ?? 'Unknown';
+    }
+    equalTo(other) {
+        return this.logicalResourceId === other.logicalResourceId && this.stack.stackName === other.stack.stackName;
+    }
+}
+exports.ResourceLocation = ResourceLocation;
+/**
+ * A mapping between a source and a destination location.
+ */
+class ResourceMapping {
+    source;
+    destination;
+    constructor(source, destination) {
+        this.source = source;
+        this.destination = destination;
+    }
+    toTypedMapping() {
+        return {
+            // the type is the same in both source and destination,
+            // so we can use either one
+            type: this.source.getType(),
+            sourcePath: this.source.toPath(),
+            destinationPath: this.destination.toPath(),
+        };
+    }
+}
+exports.ResourceMapping = ResourceMapping;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/refactoring/exclude.d.ts

@@ -0,0 +1,29 @@
+import type { AssemblyManifest } from '@aws-cdk/cloud-assembly-schema';
+import type { ResourceLocation } from './cloudformation';
+export interface ExcludeList {
+    isExcluded(location: ResourceLocation): boolean;
+}
+export declare class ManifestExcludeList implements ExcludeList {
+    private readonly excludedLocations;
+    constructor(manifest: AssemblyManifest);
+    private getExcludedLocations;
+    isExcluded(location: ResourceLocation): boolean;
+}
+export declare class InMemoryExcludeList implements ExcludeList {
+    private readonly excludedLocations;
+    private readonly excludedPaths;
+    constructor(items: string[]);
+    isExcluded(location: ResourceLocation): boolean;
+}
+export declare class UnionExcludeList implements ExcludeList {
+    private readonly excludeLists;
+    constructor(excludeLists: ExcludeList[]);
+    isExcluded(location: ResourceLocation): boolean;
+}
+export declare class NeverExclude implements ExcludeList {
+    isExcluded(_location: ResourceLocation): boolean;
+}
+export declare class AlwaysExclude implements ExcludeList {
+    isExcluded(_location: ResourceLocation): boolean;
+}
+export declare function fromManifestAndExclusionList(manifest: AssemblyManifest, exclude?: string[]): ExcludeList;

package/lib/api/refactoring/exclude.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlwaysExclude = exports.NeverExclude = exports.UnionExcludeList = exports.InMemoryExcludeList = exports.ManifestExcludeList = void 0;
+exports.fromManifestAndExclusionList = fromManifestAndExclusionList;
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+class ManifestExcludeList {
+    excludedLocations;
+    constructor(manifest) {
+        this.excludedLocations = this.getExcludedLocations(manifest);
+    }
+    getExcludedLocations(asmManifest) {
+        // First, we need to filter the artifacts to only include CloudFormation stacks
+        const stackManifests = Object.entries(asmManifest.artifacts ?? {}).filter(([_, manifest]) => manifest.type === cloud_assembly_schema_1.ArtifactType.AWS_CLOUDFORMATION_STACK);
+        const result = [];
+        for (let [stackName, manifest] of stackManifests) {
+            const locations = Object.values(manifest.metadata ?? {})
+                // Then pick only the resources in each stack marked with DO_NOT_REFACTOR
+                .filter((entries) => entries.some((entry) => entry.type === cloud_assembly_schema_1.ArtifactMetadataEntryType.DO_NOT_REFACTOR && entry.data === true))
+                // Finally, get the logical ID of each resource
+                .map((entries) => {
+                const logicalIdEntry = entries.find((entry) => entry.type === cloud_assembly_schema_1.ArtifactMetadataEntryType.LOGICAL_ID);
+                const location = {
+                    StackName: stackName,
+                    LogicalResourceId: logicalIdEntry.data,
+                };
+                return location;
+            });
+            result.push(...locations);
+        }
+        return result;
+    }
+    isExcluded(location) {
+        return this.excludedLocations.some((loc) => loc.StackName === location.stack.stackName && loc.LogicalResourceId === location.logicalResourceId);
+    }
+}
+exports.ManifestExcludeList = ManifestExcludeList;
+class InMemoryExcludeList {
+    excludedLocations;
+    excludedPaths;
+    constructor(items) {
+        this.excludedLocations = [];
+        this.excludedPaths = [];
+        if (items.length === 0) {
+            return;
+        }
+        const locationRegex = /^[A-Za-z0-9]+\.[A-Za-z0-9]+$/;
+        items.forEach((item) => {
+            if (locationRegex.test(item)) {
+                const [stackName, logicalId] = item.split('.');
+                this.excludedLocations.push({
+                    StackName: stackName,
+                    LogicalResourceId: logicalId,
+                });
+            }
+            else {
+                this.excludedPaths.push(item);
+            }
+        });
+    }
+    isExcluded(location) {
+        const containsLocation = this.excludedLocations.some((loc) => {
+            return loc.StackName === location.stack.stackName && loc.LogicalResourceId === location.logicalResourceId;
+        });
+        const containsPath = this.excludedPaths.some((path) => location.toPath() === path);
+        return containsLocation || containsPath;
+    }
+}
+exports.InMemoryExcludeList = InMemoryExcludeList;
+class UnionExcludeList {
+    excludeLists;
+    constructor(excludeLists) {
+        this.excludeLists = excludeLists;
+    }
+    isExcluded(location) {
+        return this.excludeLists.some((excludeList) => excludeList.isExcluded(location));
+    }
+}
+exports.UnionExcludeList = UnionExcludeList;
+class NeverExclude {
+    isExcluded(_location) {
+        return false;
+    }
+}
+exports.NeverExclude = NeverExclude;
+class AlwaysExclude {
+    isExcluded(_location) {
+        return true;
+    }
+}
+exports.AlwaysExclude = AlwaysExclude;
+function fromManifestAndExclusionList(manifest, exclude) {
+    return new UnionExcludeList([new ManifestExcludeList(manifest), new InMemoryExcludeList(exclude ?? [])]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exclude.js","sourceRoot":"","sources":["exclude.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AssemblyManifest } from '@aws-cdk/cloud-assembly-schema';\nimport { ArtifactMetadataEntryType, ArtifactType } from '@aws-cdk/cloud-assembly-schema';\nimport type { ResourceLocation as CfnResourceLocation } from '@aws-sdk/client-cloudformation';\nimport type { ResourceLocation } from './cloudformation';\n\nexport interface ExcludeList {\n  isExcluded(location: ResourceLocation): boolean;\n}\n\nexport class ManifestExcludeList implements ExcludeList {\n  private readonly excludedLocations: CfnResourceLocation[];\n\n  constructor(manifest: AssemblyManifest) {\n    this.excludedLocations = this.getExcludedLocations(manifest);\n  }\n\n  private getExcludedLocations(asmManifest: AssemblyManifest): CfnResourceLocation[] {\n    // First, we need to filter the artifacts to only include CloudFormation stacks\n    const stackManifests = Object.entries(asmManifest.artifacts ?? {}).filter(\n      ([_, manifest]) => manifest.type === ArtifactType.AWS_CLOUDFORMATION_STACK,\n    );\n\n    const result: CfnResourceLocation[] = [];\n    for (let [stackName, manifest] of stackManifests) {\n      const locations = Object.values(manifest.metadata ?? {})\n        // Then pick only the resources in each stack marked with DO_NOT_REFACTOR\n        .filter((entries) =>\n          entries.some((entry) => entry.type === ArtifactMetadataEntryType.DO_NOT_REFACTOR && entry.data === true),\n        )\n        // Finally, get the logical ID of each resource\n        .map((entries) => {\n          const logicalIdEntry = entries.find((entry) => entry.type === ArtifactMetadataEntryType.LOGICAL_ID);\n          const location: CfnResourceLocation = {\n            StackName: stackName,\n            LogicalResourceId: logicalIdEntry!.data! as string,\n          };\n          return location;\n        });\n      result.push(...locations);\n    }\n    return result;\n  }\n\n  isExcluded(location: ResourceLocation): boolean {\n    return this.excludedLocations.some(\n      (loc) => loc.StackName === location.stack.stackName && loc.LogicalResourceId === location.logicalResourceId,\n    );\n  }\n}\n\nexport class InMemoryExcludeList implements ExcludeList {\n  private readonly excludedLocations: CfnResourceLocation[];\n  private readonly excludedPaths: string[];\n\n  constructor(items: string[]) {\n    this.excludedLocations = [];\n    this.excludedPaths = [];\n\n    if (items.length === 0) {\n      return;\n    }\n\n    const locationRegex = /^[A-Za-z0-9]+\\.[A-Za-z0-9]+$/;\n\n    items.forEach((item: string) => {\n      if (locationRegex.test(item)) {\n        const [stackName, logicalId] = item.split('.');\n        this.excludedLocations.push({\n          StackName: stackName,\n          LogicalResourceId: logicalId,\n        });\n      } else {\n        this.excludedPaths.push(item);\n      }\n    });\n  }\n\n  isExcluded(location: ResourceLocation): boolean {\n    const containsLocation = this.excludedLocations.some((loc) => {\n      return loc.StackName === location.stack.stackName && loc.LogicalResourceId === location.logicalResourceId;\n    });\n\n    const containsPath = this.excludedPaths.some((path) => location.toPath() === path);\n    return containsLocation || containsPath;\n  }\n}\n\nexport class UnionExcludeList implements ExcludeList {\n  constructor(private readonly excludeLists: ExcludeList[]) {\n  }\n\n  isExcluded(location: ResourceLocation): boolean {\n    return this.excludeLists.some((excludeList) => excludeList.isExcluded(location));\n  }\n}\n\nexport class NeverExclude implements ExcludeList {\n  isExcluded(_location: ResourceLocation): boolean {\n    return false;\n  }\n}\n\nexport class AlwaysExclude implements ExcludeList {\n  isExcluded(_location: ResourceLocation): boolean {\n    return true;\n  }\n}\n\nexport function fromManifestAndExclusionList(manifest: AssemblyManifest, exclude?: string[]): ExcludeList {\n  return new UnionExcludeList([new ManifestExcludeList(manifest), new InMemoryExcludeList(exclude ?? [])]);\n}\n\n"]}

package/lib/api/refactoring/execution.d.ts

@@ -0,0 +1,7 @@
+import type { StackDefinition } from '@aws-sdk/client-cloudformation';
+import type { CloudFormationStack, ResourceMapping } from './cloudformation';
+/**
+ * Generates a list of stack definitions to be sent to the CloudFormation API
+ * by applying each mapping to the corresponding stack template(s).
+ */
+export declare function generateStackDefinitions(mappings: ResourceMapping[], deployedStacks: CloudFormationStack[]): StackDefinition[];

package/lib/api/refactoring/execution.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStackDefinitions = generateStackDefinitions;
+const toolkit_error_1 = require("../../toolkit/toolkit-error");
+/**
+ * Generates a list of stack definitions to be sent to the CloudFormation API
+ * by applying each mapping to the corresponding stack template(s).
+ */
+function generateStackDefinitions(mappings, deployedStacks) {
+    const templates = Object.fromEntries(deployedStacks
+        .filter((s) => mappings.some((m) => 
+    // We only care about stacks that are part of the mappings
+    m.source.stack.stackName === s.stackName || m.destination.stack.stackName === s.stackName))
+        .map((s) => [s.stackName, JSON.parse(JSON.stringify(s.template))]));
+    mappings.forEach((mapping) => {
+        const sourceStackName = mapping.source.stack.stackName;
+        const sourceLogicalId = mapping.source.logicalResourceId;
+        const sourceTemplate = templates[sourceStackName];
+        const destinationStackName = mapping.destination.stack.stackName;
+        const destinationLogicalId = mapping.destination.logicalResourceId;
+        if (templates[destinationStackName] == null) {
+            // The API doesn't allow anything in the template other than the resources
+            // that are part of the mappings. So we need to create an empty template
+            // to start adding resources to.
+            templates[destinationStackName] = { Resources: {} };
+        }
+        const destinationTemplate = templates[destinationStackName];
+        // Do the move
+        destinationTemplate.Resources[destinationLogicalId] = sourceTemplate.Resources[sourceLogicalId];
+        delete sourceTemplate.Resources[sourceLogicalId];
+    });
+    // CloudFormation doesn't allow empty stacks
+    for (const [stackName, template] of Object.entries(templates)) {
+        if (Object.keys(template.Resources ?? {}).length === 0) {
+            throw new toolkit_error_1.ToolkitError(`Stack ${stackName} has no resources after refactor. You must add a resource to this stack. This resource can be a simple one, like a waitCondition resource type.`);
+        }
+    }
+    return Object.entries(templates).map(([stackName, template]) => ({
+        StackName: stackName,
+        TemplateBody: JSON.stringify(template),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlY3V0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZXhlY3V0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBUUEsNERBNENDO0FBbERELCtEQUEyRDtBQUUzRDs7O0dBR0c7QUFDSCxTQUFnQix3QkFBd0IsQ0FBQyxRQUEyQixFQUFFLGNBQXFDO0lBQ3pHLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxXQUFXLENBQ2xDLGNBQWM7U0FDWCxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUNaLFFBQVEsQ0FBQyxJQUFJLENBQ1gsQ0FBQyxDQUFDLEVBQUUsRUFBRTtJQUNKLDBEQUEwRDtJQUMxRCxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLEtBQUssQ0FBQyxDQUFDLFNBQVMsSUFBSSxDQUFDLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxTQUFTLEtBQUssQ0FBQyxDQUFDLFNBQVMsQ0FDNUYsQ0FDRjtTQUNBLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQ3JFLENBQUM7SUFFRixRQUFRLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7UUFDM0IsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDO1FBQ3ZELE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsaUJBQWlCLENBQUM7UUFDekQsTUFBTSxjQUFjLEdBQUcsU0FBUyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBRWxELE1BQU0sb0JBQW9CLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDO1FBQ2pFLE1BQU0sb0JBQW9CLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQztRQUNuRSxJQUFJLFNBQVMsQ0FBQyxvQkFBb0IsQ0FBQyxJQUFJLElBQUksRUFBRSxDQUFDO1lBQzVDLDBFQUEwRTtZQUMxRSx3RUFBd0U7WUFDeEUsZ0NBQWdDO1lBQ2hDLFNBQVMsQ0FBQyxvQkFBb0IsQ0FBQyxHQUFHLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQ3RELENBQUM7UUFDRCxNQUFNLG1CQUFtQixHQUFHLFNBQVMsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBRTVELGNBQWM7UUFDZCxtQkFBbUIsQ0FBQyxTQUFTLENBQUMsb0JBQW9CLENBQUMsR0FBRyxjQUFjLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ2hHLE9BQU8sY0FBYyxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUMsQ0FBQztJQUNuRCxDQUFDLENBQUMsQ0FBQztJQUVILDRDQUE0QztJQUM1QyxLQUFLLE1BQU0sQ0FBQyxTQUFTLEVBQUUsUUFBUSxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDO1FBQzlELElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN2RCxNQUFNLElBQUksNEJBQVksQ0FBQyxTQUFTLFNBQVMsaUpBQWlKLENBQUMsQ0FBQztRQUM5TCxDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLFNBQVMsRUFBRSxRQUFRLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUMvRCxTQUFTLEVBQUUsU0FBUztRQUNwQixZQUFZLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUM7S0FDdkMsQ0FBQyxDQUFDLENBQUM7QUFDTixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTdGFja0RlZmluaXRpb24gfSBmcm9tICdAYXdzLXNkay9jbGllbnQtY2xvdWRmb3JtYXRpb24nO1xuaW1wb3J0IHR5cGUgeyBDbG91ZEZvcm1hdGlvblN0YWNrLCBSZXNvdXJjZU1hcHBpbmcgfSBmcm9tICcuL2Nsb3VkZm9ybWF0aW9uJztcbmltcG9ydCB7IFRvb2xraXRFcnJvciB9IGZyb20gJy4uLy4uL3Rvb2xraXQvdG9vbGtpdC1lcnJvcic7XG5cbi8qKlxuICogR2VuZXJhdGVzIGEgbGlzdCBvZiBzdGFjayBkZWZpbml0aW9ucyB0byBiZSBzZW50IHRvIHRoZSBDbG91ZEZvcm1hdGlvbiBBUElcbiAqIGJ5IGFwcGx5aW5nIGVhY2ggbWFwcGluZyB0byB0aGUgY29ycmVzcG9uZGluZyBzdGFjayB0ZW1wbGF0ZShzKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdlbmVyYXRlU3RhY2tEZWZpbml0aW9ucyhtYXBwaW5nczogUmVzb3VyY2VNYXBwaW5nW10sIGRlcGxveWVkU3RhY2tzOiBDbG91ZEZvcm1hdGlvblN0YWNrW10pOiBTdGFja0RlZmluaXRpb25bXSB7XG4gIGNvbnN0IHRlbXBsYXRlcyA9IE9iamVjdC5mcm9tRW50cmllcyhcbiAgICBkZXBsb3llZFN0YWNrc1xuICAgICAgLmZpbHRlcigocykgPT5cbiAgICAgICAgbWFwcGluZ3Muc29tZShcbiAgICAgICAgICAobSkgPT5cbiAgICAgICAgICAgIC8vIFdlIG9ubHkgY2FyZSBhYm91dCBzdGFja3MgdGhhdCBhcmUgcGFydCBvZiB0aGUgbWFwcGluZ3NcbiAgICAgICAgICAgIG0uc291cmNlLnN0YWNrLnN0YWNrTmFtZSA9PT0gcy5zdGFja05hbWUgfHwgbS5kZXN0aW5hdGlvbi5zdGFjay5zdGFja05hbWUgPT09IHMuc3RhY2tOYW1lLFxuICAgICAgICApLFxuICAgICAgKVxuICAgICAgLm1hcCgocykgPT4gW3Muc3RhY2tOYW1lLCBKU09OLnBhcnNlKEpTT04uc3RyaW5naWZ5KHMudGVtcGxhdGUpKV0pLFxuICApO1xuXG4gIG1hcHBpbmdzLmZvckVhY2goKG1hcHBpbmcpID0+IHtcbiAgICBjb25zdCBzb3VyY2VTdGFja05hbWUgPSBtYXBwaW5nLnNvdXJjZS5zdGFjay5zdGFja05hbWU7XG4gICAgY29uc3Qgc291cmNlTG9naWNhbElkID0gbWFwcGluZy5zb3VyY2UubG9naWNhbFJlc291cmNlSWQ7XG4gICAgY29uc3Qgc291cmNlVGVtcGxhdGUgPSB0ZW1wbGF0ZXNbc291cmNlU3RhY2tOYW1lXTtcblxuICAgIGNvbnN0IGRlc3RpbmF0aW9uU3RhY2tOYW1lID0gbWFwcGluZy5kZXN0aW5hdGlvbi5zdGFjay5zdGFja05hbWU7XG4gICAgY29uc3QgZGVzdGluYXRpb25Mb2dpY2FsSWQgPSBtYXBwaW5nLmRlc3RpbmF0aW9uLmxvZ2ljYWxSZXNvdXJjZUlkO1xuICAgIGlmICh0ZW1wbGF0ZXNbZGVzdGluYXRpb25TdGFja05hbWVdID09IG51bGwpIHtcbiAgICAgIC8vIFRoZSBBUEkgZG9lc24ndCBhbGxvdyBhbnl0aGluZyBpbiB0aGUgdGVtcGxhdGUgb3RoZXIgdGhhbiB0aGUgcmVzb3VyY2VzXG4gICAgICAvLyB0aGF0IGFyZSBwYXJ0IG9mIHRoZSBtYXBwaW5ncy4gU28gd2UgbmVlZCB0byBjcmVhdGUgYW4gZW1wdHkgdGVtcGxhdGVcbiAgICAgIC8vIHRvIHN0YXJ0IGFkZGluZyByZXNvdXJjZXMgdG8uXG4gICAgICB0ZW1wbGF0ZXNbZGVzdGluYXRpb25TdGFja05hbWVdID0geyBSZXNvdXJjZXM6IHt9IH07XG4gICAgfVxuICAgIGNvbnN0IGRlc3RpbmF0aW9uVGVtcGxhdGUgPSB0ZW1wbGF0ZXNbZGVzdGluYXRpb25TdGFja05hbWVdO1xuXG4gICAgLy8gRG8gdGhlIG1vdmVcbiAgICBkZXN0aW5hdGlvblRlbXBsYXRlLlJlc291cmNlc1tkZXN0aW5hdGlvbkxvZ2ljYWxJZF0gPSBzb3VyY2VUZW1wbGF0ZS5SZXNvdXJjZXNbc291cmNlTG9naWNhbElkXTtcbiAgICBkZWxldGUgc291cmNlVGVtcGxhdGUuUmVzb3VyY2VzW3NvdXJjZUxvZ2ljYWxJZF07XG4gIH0pO1xuXG4gIC8vIENsb3VkRm9ybWF0aW9uIGRvZXNuJ3QgYWxsb3cgZW1wdHkgc3RhY2tzXG4gIGZvciAoY29uc3QgW3N0YWNrTmFtZSwgdGVtcGxhdGVdIG9mIE9iamVjdC5lbnRyaWVzKHRlbXBsYXRlcykpIHtcbiAgICBpZiAoT2JqZWN0LmtleXModGVtcGxhdGUuUmVzb3VyY2VzID8/IHt9KS5sZW5ndGggPT09IDApIHtcbiAgICAgIHRocm93IG5ldyBUb29sa2l0RXJyb3IoYFN0YWNrICR7c3RhY2tOYW1lfSBoYXMgbm8gcmVzb3VyY2VzIGFmdGVyIHJlZmFjdG9yLiBZb3UgbXVzdCBhZGQgYSByZXNvdXJjZSB0byB0aGlzIHN0YWNrLiBUaGlzIHJlc291cmNlIGNhbiBiZSBhIHNpbXBsZSBvbmUsIGxpa2UgYSB3YWl0Q29uZGl0aW9uIHJlc291cmNlIHR5cGUuYCk7XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIE9iamVjdC5lbnRyaWVzKHRlbXBsYXRlcykubWFwKChbc3RhY2tOYW1lLCB0ZW1wbGF0ZV0pID0+ICh7XG4gICAgU3RhY2tOYW1lOiBzdGFja05hbWUsXG4gICAgVGVtcGxhdGVCb2R5OiBKU09OLnN0cmluZ2lmeSh0ZW1wbGF0ZSksXG4gIH0pKTtcbn1cbiJdfQ==

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

@@ -1,6 +1,10 @@
 import type { TypedMapping } from '@aws-cdk/cloudformation-diff';
 import type { SdkProvider } from '../aws-auth/private';
 import type { CloudFormationStack } from './cloudformation';
+import { ResourceLocation, ResourceMapping } from './cloudformation';
+import { type ExcludeList } from './exclude';
+import type { MappingGroup } from '../../actions';
+export * from './exclude';
 /**
  * Represents a set of possible movements of a resource from one location
  * to another. In the ideal case, there is only one source and only one
@@ -12,28 +16,7 @@ export declare class AmbiguityError extends Error {
     constructor(movements: ResourceMovement[]);
     paths(): [string[], string[]][];
 }
-/**
- * This class mirrors the `ResourceLocation` interface from CloudFormation,
- * but is richer, since it has a reference to the stack object, rather than
- * merely the stack name.
- */
-export declare class ResourceLocation {
-    readonly stack: CloudFormationStack;
-    readonly logicalResourceId: string;
-    constructor(stack: CloudFormationStack, logicalResourceId: string);
-    toPath(): string;
-    getType(): string;
-    equalTo(other: ResourceLocation): boolean;
-}
-/**
- * A mapping between a source and a destination location.
- */
-export declare class ResourceMapping {
-    readonly source: ResourceLocation;
-    readonly destination: ResourceLocation;
-    constructor(source: ResourceLocation, destination: ResourceLocation);
-    toTypedMapping(): TypedMapping;
-}
+export declare function usePrescribedMappings(mappingGroups: MappingGroup[], sdkProvider: SdkProvider): Promise<ResourceMapping[]>;
 export declare function resourceMovements(before: CloudFormationStack[], after: CloudFormationStack[]): ResourceMovement[];
 export declare function ambiguousMovements(movements: ResourceMovement[]): ResourceMovement[];
 /**
@@ -46,6 +29,6 @@ export declare function resourceMappings(movements: ResourceMovement[], stacks?:
  * that were moved from one location (stack + logical ID) to another. The comparison
  * is done per environment.
  */
-export declare function findResourceMovements(stacks: CloudFormationStack[], sdkProvider: SdkProvider): Promise<ResourceMovement[]>;
+export declare function findResourceMovements(stacks: CloudFormationStack[], sdkProvider: SdkProvider, exclude?: ExcludeList): Promise<ResourceMovement[]>;
 export declare function formatTypedMappings(mappings: TypedMapping[]): string;
 export declare function formatAmbiguousMappings(paths: [string[], string[]][]): string;