@aws-cdk/toolkit-lib 0.3.2 → 0.3.3

package/lib/api/refactoring/index.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceMapping = exports.ResourceLocation = exports.AmbiguityError = void 0;
+exports.resourceMovements = resourceMovements;
+exports.ambiguousMovements = ambiguousMovements;
+exports.resourceMappings = resourceMappings;
+exports.findResourceMovements = findResourceMovements;
+exports.formatTypedMappings = formatTypedMappings;
+exports.formatAmbiguousMappings = formatAmbiguousMappings;
+const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const util_1 = require("../../util");
+const plugin_1 = require("../plugin");
+const streams_1 = require("../streams");
+const digest_1 = require("./digest");
+class AmbiguityError extends Error {
+    movements;
+    constructor(movements) {
+        super('Ambiguous resource mappings');
+        this.movements = movements;
+    }
+    paths() {
+        return this.movements.map(([a, b]) => [convert(a), convert(b)]);
+        function convert(locations) {
+            return locations.map((l) => l.toPath());
+        }
+    }
+}
+exports.AmbiguityError = AmbiguityError;
+/**
+ * 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;
+function groupByKey(entries) {
+    const result = {};
+    for (const [hash, location] of entries) {
+        if (hash in result) {
+            result[hash].push(location);
+        }
+        else {
+            result[hash] = [location];
+        }
+    }
+    return result;
+}
+function resourceMovements(before, after) {
+    return Object.values(removeUnmovedResources(zip(groupByKey(before.flatMap(resourceDigests)), groupByKey(after.flatMap(resourceDigests)))));
+}
+function ambiguousMovements(movements) {
+    // A movement is considered ambiguous if these two conditions are met:
+    //  1. Both sides have at least one element (otherwise, it's just addition or deletion)
+    //  2. At least one side has more than one element
+    return movements
+        .filter(([pre, post]) => pre.length > 0 && post.length > 0)
+        .filter(([pre, post]) => pre.length > 1 || post.length > 1);
+}
+/**
+ * Converts a list of unambiguous resource movements into a list of resource mappings.
+ *
+ */
+function resourceMappings(movements, stacks) {
+    const predicate = stacks == null
+        ? () => true
+        : (m) => {
+            // Any movement that involves one of the selected stacks (either moving from or to)
+            // is considered a candidate for refactoring.
+            const stackNames = [m.source.stack.stackName, m.destination.stack.stackName];
+            return stacks.some((stack) => stackNames.includes(stack.stackName));
+        };
+    return movements
+        .filter(([pre, post]) => pre.length === 1 && post.length === 1 && !pre[0].equalTo(post[0]))
+        .map(([pre, post]) => new ResourceMapping(pre[0], post[0]))
+        .filter(predicate);
+}
+function removeUnmovedResources(m) {
+    const result = {};
+    for (const [hash, [before, after]] of Object.entries(m)) {
+        const common = before.filter((b) => after.some((a) => a.equalTo(b)));
+        result[hash] = [
+            before.filter((b) => !common.some((c) => b.equalTo(c))),
+            after.filter((a) => !common.some((c) => a.equalTo(c))),
+        ];
+    }
+    return result;
+}
+/**
+ * For each hash, identifying a single resource, zip the two lists of locations,
+ * producing a resource movement
+ */
+function zip(m1, m2) {
+    const result = {};
+    for (const [hash, locations] of Object.entries(m1)) {
+        if (hash in m2) {
+            result[hash] = [locations, m2[hash]];
+        }
+        else {
+            result[hash] = [locations, []];
+        }
+    }
+    for (const [hash, locations] of Object.entries(m2)) {
+        if (!(hash in m1)) {
+            result[hash] = [[], locations];
+        }
+    }
+    return result;
+}
+/**
+ * Computes a list of pairs [digest, location] for each resource in the stack.
+ */
+function resourceDigests(stack) {
+    const digests = (0, digest_1.computeResourceDigests)(stack.template);
+    return Object.entries(digests).map(([logicalId, digest]) => {
+        const location = new ResourceLocation(stack, logicalId);
+        return [digest, location];
+    });
+}
+/**
+ * Compares the deployed state to the cloud assembly state, and finds all resources
+ * that were moved from one location (stack + logical ID) to another. The comparison
+ * is done per environment.
+ */
+async function findResourceMovements(stacks, sdkProvider) {
+    const stackGroups = new Map();
+    // Group stacks by environment
+    for (const stack of stacks) {
+        const environment = stack.environment;
+        const key = (0, digest_1.hashObject)(environment);
+        if (stackGroups.has(key)) {
+            stackGroups.get(key)[1].push(stack);
+        }
+        else {
+            // The first time we see an environment, we need to fetch all stacks deployed to it.
+            const before = await getDeployedStacks(sdkProvider, environment);
+            stackGroups.set(key, [before, [stack]]);
+        }
+    }
+    const result = [];
+    for (const [_, [before, after]] of stackGroups) {
+        result.push(...resourceMovements(before, after));
+    }
+    return result;
+}
+async function getDeployedStacks(sdkProvider, environment) {
+    const cfn = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk.cloudFormation();
+    const summaries = await cfn.paginatedListStacks({
+        StackStatusFilter: [
+            'CREATE_COMPLETE',
+            'UPDATE_COMPLETE',
+            'UPDATE_ROLLBACK_COMPLETE',
+            'IMPORT_COMPLETE',
+            'ROLLBACK_COMPLETE',
+        ],
+    });
+    const normalize = async (summary) => {
+        const templateCommandOutput = await cfn.getTemplate({ StackName: summary.StackName });
+        const template = (0, util_1.deserializeStructure)(templateCommandOutput.TemplateBody ?? '{}');
+        return {
+            environment,
+            stackName: summary.StackName,
+            template,
+        };
+    };
+    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+    return Promise.all(summaries.map(normalize));
+}
+function formatTypedMappings(mappings) {
+    const stream = new streams_1.StringWriteStream();
+    (0, cloudformation_diff_1.formatTypedMappings)(stream, mappings);
+    return stream.toString();
+}
+function formatAmbiguousMappings(paths) {
+    const stream = new streams_1.StringWriteStream();
+    (0, cloudformation_diff_1.formatAmbiguousMappings)(stream, paths);
+    return stream.toString();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TypedMapping } from '@aws-cdk/cloudformation-diff';\nimport {\n  formatAmbiguousMappings as fmtAmbiguousMappings,\n  formatTypedMappings as fmtTypedMappings,\n} from '@aws-cdk/cloudformation-diff';\nimport type * as cxapi from '@aws-cdk/cx-api';\nimport type { StackSummary } from '@aws-sdk/client-cloudformation';\nimport { deserializeStructure } from '../../util';\nimport type { SdkProvider } from '../aws-auth/private';\nimport { Mode } from '../plugin';\nimport { StringWriteStream } from '../streams';\nimport type { CloudFormationStack } from './cloudformation';\nimport { computeResourceDigests, hashObject } from './digest';\n\n/**\n * Represents a set of possible movements of a resource from one location\n * to another. In the ideal case, there is only one source and only one\n * destination.\n */\nexport type ResourceMovement = [ResourceLocation[], ResourceLocation[]];\n\nexport class AmbiguityError extends Error {\n  constructor(public readonly movements: ResourceMovement[]) {\n    super('Ambiguous resource mappings');\n  }\n\n  public paths(): [string[], string[]][] {\n    return this.movements.map(([a, b]) => [convert(a), convert(b)]);\n\n    function convert(locations: ResourceLocation[]): string[] {\n      return locations.map((l) => l.toPath());\n    }\n  }\n}\n\n/**\n * This class mirrors the `ResourceLocation` interface from CloudFormation,\n * but is richer, since it has a reference to the stack object, rather than\n * merely the stack name.\n */\nexport class ResourceLocation {\n  constructor(public readonly stack: CloudFormationStack, public readonly logicalResourceId: string) {\n  }\n\n  public toPath(): string {\n    const stack = this.stack;\n    const resource = stack.template.Resources?.[this.logicalResourceId];\n    const result = resource?.Metadata?.['aws:cdk:path'];\n\n    if (result != null) {\n      return result;\n    }\n\n    // If the path is not available, we can use stack name and logical ID\n    return `${stack.stackName}.${this.logicalResourceId}`;\n  }\n\n  public getType(): string {\n    const resource = this.stack.template.Resources?.[this.logicalResourceId ?? ''];\n    return resource?.Type ?? 'Unknown';\n  }\n\n  public equalTo(other: ResourceLocation): boolean {\n    return this.logicalResourceId === other.logicalResourceId && this.stack.stackName === other.stack.stackName;\n  }\n}\n\n/**\n * A mapping between a source and a destination location.\n */\nexport class ResourceMapping {\n  constructor(public readonly source: ResourceLocation, public readonly destination: ResourceLocation) {\n  }\n\n  public toTypedMapping(): TypedMapping {\n    return {\n      // the type is the same in both source and destination,\n      // so we can use either one\n      type: this.source.getType(),\n      sourcePath: this.source.toPath(),\n      destinationPath: this.destination.toPath(),\n    };\n  }\n}\n\nfunction groupByKey<A>(entries: [string, A][]): Record<string, A[]> {\n  const result: Record<string, A[]> = {};\n\n  for (const [hash, location] of entries) {\n    if (hash in result) {\n      result[hash].push(location);\n    } else {\n      result[hash] = [location];\n    }\n  }\n\n  return result;\n}\n\nexport function resourceMovements(before: CloudFormationStack[], after: CloudFormationStack[]): ResourceMovement[] {\n  return Object.values(\n    removeUnmovedResources(\n      zip(groupByKey(before.flatMap(resourceDigests)), groupByKey(after.flatMap(resourceDigests))),\n    ),\n  );\n}\n\nexport function ambiguousMovements(movements: ResourceMovement[]) {\n  // A movement is considered ambiguous if these two conditions are met:\n  //  1. Both sides have at least one element (otherwise, it's just addition or deletion)\n  //  2. At least one side has more than one element\n  return movements\n    .filter(([pre, post]) => pre.length > 0 && post.length > 0)\n    .filter(([pre, post]) => pre.length > 1 || post.length > 1);\n}\n\n/**\n * Converts a list of unambiguous resource movements into a list of resource mappings.\n *\n */\nexport function resourceMappings(movements: ResourceMovement[], stacks?: CloudFormationStack[]): ResourceMapping[] {\n  const predicate = stacks == null\n    ? () => true\n    : (m: ResourceMapping) => {\n      // Any movement that involves one of the selected stacks (either moving from or to)\n      // is considered a candidate for refactoring.\n      const stackNames = [m.source.stack.stackName, m.destination.stack.stackName];\n      return stacks.some((stack) => stackNames.includes(stack.stackName));\n    };\n\n  return movements\n    .filter(([pre, post]) => pre.length === 1 && post.length === 1 && !pre[0].equalTo(post[0]))\n    .map(([pre, post]) => new ResourceMapping(pre[0], post[0]))\n    .filter(predicate);\n}\n\nfunction removeUnmovedResources(\n  m: Record<string, ResourceMovement>,\n): Record<string, ResourceMovement> {\n  const result: Record<string, ResourceMovement> = {};\n  for (const [hash, [before, after]] of Object.entries(m)) {\n    const common = before.filter((b) => after.some((a) => a.equalTo(b)));\n    result[hash] = [\n      before.filter((b) => !common.some((c) => b.equalTo(c))),\n      after.filter((a) => !common.some((c) => a.equalTo(c))),\n    ];\n  }\n\n  return result;\n}\n\n/**\n * For each hash, identifying a single resource, zip the two lists of locations,\n * producing a resource movement\n */\nfunction zip(\n  m1: Record<string, ResourceLocation[]>,\n  m2: Record<string, ResourceLocation[]>,\n): Record<string, ResourceMovement> {\n  const result: Record<string, ResourceMovement> = {};\n\n  for (const [hash, locations] of Object.entries(m1)) {\n    if (hash in m2) {\n      result[hash] = [locations, m2[hash]];\n    } else {\n      result[hash] = [locations, []];\n    }\n  }\n\n  for (const [hash, locations] of Object.entries(m2)) {\n    if (!(hash in m1)) {\n      result[hash] = [[], locations];\n    }\n  }\n\n  return result;\n}\n\n/**\n * Computes a list of pairs [digest, location] for each resource in the stack.\n */\nfunction resourceDigests(stack: CloudFormationStack): [string, ResourceLocation][] {\n  const digests = computeResourceDigests(stack.template);\n\n  return Object.entries(digests).map(([logicalId, digest]) => {\n    const location: ResourceLocation = new ResourceLocation(stack, logicalId);\n    return [digest, location];\n  });\n}\n\n/**\n * Compares the deployed state to the cloud assembly state, and finds all resources\n * that were moved from one location (stack + logical ID) to another. The comparison\n * is done per environment.\n */\nexport async function findResourceMovements(\n  stacks: CloudFormationStack[],\n  sdkProvider: SdkProvider,\n): Promise<ResourceMovement[]> {\n  const stackGroups: Map<string, [CloudFormationStack[], CloudFormationStack[]]> = new Map();\n\n  // Group stacks by environment\n  for (const stack of stacks) {\n    const environment = stack.environment;\n    const key = hashObject(environment);\n    if (stackGroups.has(key)) {\n      stackGroups.get(key)![1].push(stack);\n    } else {\n      // The first time we see an environment, we need to fetch all stacks deployed to it.\n      const before = await getDeployedStacks(sdkProvider, environment);\n      stackGroups.set(key, [before, [stack]]);\n    }\n  }\n\n  const result: ResourceMovement[] = [];\n  for (const [_, [before, after]] of stackGroups) {\n    result.push(...resourceMovements(before, after));\n  }\n  return result;\n}\n\nasync function getDeployedStacks(\n  sdkProvider: SdkProvider,\n  environment: cxapi.Environment,\n): Promise<CloudFormationStack[]> {\n  const cfn = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk.cloudFormation();\n\n  const summaries = await cfn.paginatedListStacks({\n    StackStatusFilter: [\n      'CREATE_COMPLETE',\n      'UPDATE_COMPLETE',\n      'UPDATE_ROLLBACK_COMPLETE',\n      'IMPORT_COMPLETE',\n      'ROLLBACK_COMPLETE',\n    ],\n  });\n\n  const normalize = async (summary: StackSummary) => {\n    const templateCommandOutput = await cfn.getTemplate({ StackName: summary.StackName! });\n    const template = deserializeStructure(templateCommandOutput.TemplateBody ?? '{}');\n    return {\n      environment,\n      stackName: summary.StackName!,\n      template,\n    };\n  };\n\n  // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n  return Promise.all(summaries.map(normalize));\n}\n\nexport function formatTypedMappings(mappings: TypedMapping[]): string {\n  const stream = new StringWriteStream();\n  fmtTypedMappings(stream, mappings);\n  return stream.toString();\n}\n\nexport function formatAmbiguousMappings(paths: [string[], string[]][]): string {\n  const stream = new StringWriteStream();\n  fmtAmbiguousMappings(stream, paths);\n  return stream.toString();\n}\n"]}

package/lib/api/require-approval.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @deprecated
+ */
+export declare enum RequireApproval {
+    /**
+     * Never require any security approvals
+     */
+    NEVER = "never",
+    /**
+     * Any security changes require an approval
+     */
+    ANY_CHANGE = "any-change",
+    /**
+     * Require approval only for changes that are access broadening
+     */
+    BROADENING = "broadening"
+}

package/lib/api/require-approval.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireApproval = void 0;
+/**
+ * @deprecated
+ */
+var RequireApproval;
+(function (RequireApproval) {
+    /**
+     * Never require any security approvals
+     */
+    RequireApproval["NEVER"] = "never";
+    /**
+     * Any security changes require an approval
+     */
+    RequireApproval["ANY_CHANGE"] = "any-change";
+    /**
+     * Require approval only for changes that are access broadening
+     */
+    RequireApproval["BROADENING"] = "broadening";
+})(RequireApproval || (exports.RequireApproval = RequireApproval = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZS1hcHByb3ZhbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInJlcXVpcmUtYXBwcm92YWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDSCxJQUFZLGVBYVg7QUFiRCxXQUFZLGVBQWU7SUFDekI7O09BRUc7SUFDSCxrQ0FBZSxDQUFBO0lBQ2Y7O09BRUc7SUFDSCw0Q0FBeUIsQ0FBQTtJQUN6Qjs7T0FFRztJQUNILDRDQUF5QixDQUFBO0FBQzNCLENBQUMsRUFiVyxlQUFlLCtCQUFmLGVBQWUsUUFhMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXByZWNhdGVkXG4gKi9cbmV4cG9ydCBlbnVtIFJlcXVpcmVBcHByb3ZhbCB7XG4gIC8qKlxuICAgKiBOZXZlciByZXF1aXJlIGFueSBzZWN1cml0eSBhcHByb3ZhbHNcbiAgICovXG4gIE5FVkVSID0gJ25ldmVyJyxcbiAgLyoqXG4gICAqIEFueSBzZWN1cml0eSBjaGFuZ2VzIHJlcXVpcmUgYW4gYXBwcm92YWxcbiAgICovXG4gIEFOWV9DSEFOR0UgPSAnYW55LWNoYW5nZScsXG4gIC8qKlxuICAgKiBSZXF1aXJlIGFwcHJvdmFsIG9ubHkgZm9yIGNoYW5nZXMgdGhhdCBhcmUgYWNjZXNzIGJyb2FkZW5pbmdcbiAgICovXG4gIEJST0FERU5JTkcgPSAnYnJvYWRlbmluZycsXG59XG4iXX0=

package/lib/api/resource-import/importer.d.ts

@@ -0,0 +1,216 @@
+import type { ResourceDifference } from '@aws-cdk/cloudformation-diff';
+import type * as cxapi from '@aws-cdk/cx-api';
+import type { ResourceIdentifierSummary, ResourceToImport } from '@aws-sdk/client-cloudformation';
+import type { DeploymentMethod, Deployments } from '../deployments';
+import { type IoHelper } from '../io/private';
+import type { Tag } from '../tags';
+export type ResourcesToImport = ResourceToImport[];
+export type ResourceIdentifierSummaries = ResourceIdentifierSummary[];
+export interface ResourceImporterProps {
+    deployments: Deployments;
+    ioHelper: IoHelper;
+}
+export interface ImportDeploymentOptions {
+    /**
+     * Role to pass to CloudFormation for deployment
+     *
+     * @default - Default stack role
+     */
+    readonly roleArn?: string;
+    /**
+     * Deployment method
+     *
+     * @default - Change set with default options
+     */
+    readonly deploymentMethod?: DeploymentMethod;
+    /**
+     * Stack tags (pass through to CloudFormation)
+     *
+     * @default - No tags
+     */
+    readonly tags?: Tag[];
+    /**
+     * Use previous values for unspecified parameters
+     *
+     * If not set, all parameters must be specified for every deployment.
+     *
+     * @default true
+     */
+    readonly usePreviousParameters?: boolean;
+    /**
+     * Rollback failed deployments
+     *
+     * @default true
+     */
+    readonly rollback?: boolean;
+}
+/**
+ * Set of parameters that uniquely identify a physical resource of a given type
+ * for the import operation, example:
+ *
+ * ```
+ * {
+ *   "AWS::S3::Bucket": [["BucketName"]],
+ *   "AWS::DynamoDB::GlobalTable": [["TableName"], ["TableArn"], ["TableStreamArn"]],
+ *   "AWS::Route53::KeySigningKey": [["HostedZoneId", "Name"]],
+ * }
+ * ```
+ */
+export type ResourceIdentifiers = {
+    [resourceType: string]: string[][];
+};
+type ResourceIdentifierProperties = Record<string, string>;
+/**
+ * Mapping of CDK resources (L1 constructs) to physical resources to be imported
+ * in their place, example:
+ *
+ * ```
+ * {
+ *   "MyStack/MyS3Bucket/Resource": {
+ *     "BucketName": "my-manually-created-s3-bucket"
+ *   },
+ *   "MyStack/MyVpc/Resource": {
+ *     "VpcId": "vpc-123456789"
+ *   }
+ * }
+ * ```
+ */
+type ResourceMap = {
+    [logicalResource: string]: ResourceIdentifierProperties;
+};
+/**
+ * Resource importing utility class
+ *
+ * - Determines the resources added to a template (compared to the deployed version)
+ * - Look up the identification information
+ *   - Load them from a file, or
+ *   - Ask the user, based on information supplied to us by CloudFormation's GetTemplateSummary
+ * - Translate the input to a structure expected by CloudFormation, update the template to add the
+ *   importable resources, then run an IMPORT changeset.
+ */
+export declare class ResourceImporter {
+    private _currentTemplate;
+    private readonly stack;
+    private readonly cfn;
+    private readonly ioHelper;
+    constructor(stack: cxapi.CloudFormationStackArtifact, props: ResourceImporterProps);
+    /**
+     * Ask the user for resources to import
+     */
+    askForResourceIdentifiers(available: ImportableResource[]): Promise<ImportMap>;
+    /**
+     * Load the resources to import from a file
+     */
+    loadResourceIdentifiers(available: ImportableResource[], filename: string): Promise<ImportMap>;
+    /**
+     * Based on the provided resource mapping, prepare CFN structures for import (template,
+     * ResourcesToImport structure) and perform the import operation (CloudFormation deployment)
+     *
+     * @param importMap Mapping from CDK construct tree path to physical resource import identifiers
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    importResourcesFromMap(importMap: ImportMap, options?: ImportDeploymentOptions): Promise<void>;
+    /**
+     * Based on the app and resources file generated by cdk migrate. Removes all items from the template that
+     * cannot be included in an import change-set for new stacks and performs the import operation,
+     * creating the new stack.
+     *
+     * @param resourcesToImport The mapping created by cdk migrate
+     * @param options Options to pass to CloudFormation deploy operation
+     */
+    importResourcesFromMigrate(resourcesToImport: ResourcesToImport, options?: ImportDeploymentOptions): Promise<void>;
+    private importResources;
+    /**
+     * Perform a diff between the currently running and the new template, ensure that it is valid
+     * for importing and return a list of resources that are being added in the new version
+     *
+     * @return mapping logicalResourceId -> resourceDifference
+     */
+    discoverImportableResources(allowNonAdditions?: boolean): Promise<DiscoverImportableResourcesResult>;
+    /**
+     * Resolves the environment of a stack.
+     */
+    resolveEnvironment(): Promise<cxapi.Environment>;
+    /**
+     * Get currently deployed template of the given stack (SINGLETON)
+     *
+     * @returns Currently deployed CloudFormation template
+     */
+    private currentTemplate;
+    /**
+     * Return the current template, with the given resources added to it
+     */
+    private currentTemplateWithAdditions;
+    /**
+     * Get a list of import identifiers for all resource types used in the given
+     * template that do support the import operation (SINGLETON)
+     *
+     * @returns a mapping from a resource type to a list of property names that together identify the resource for import
+     */
+    private resourceIdentifiers;
+    /**
+     * Ask for the importable identifier for the given resource
+     *
+     * There may be more than one identifier under which a resource can be imported. The `import`
+     * operation needs exactly one of them.
+     *
+     * - If we can get one from the template, we will use one.
+     * - Otherwise, we will ask the user for one of them.
+     */
+    private askForResourceIdentifier;
+    /**
+     * Convert the internal "resource mapping" structure to CloudFormation accepted "ResourcesToImport" structure
+     */
+    private makeResourcesToImport;
+    /**
+     * Convert CloudFormation logical resource ID to CDK construct tree path
+     *
+     * @param logicalId CloudFormation logical ID of the resource (the key in the template's Resources section)
+     * @returns Forward-slash separated path of the resource in CDK construct tree, e.g. MyStack/MyBucket/Resource
+     */
+    private describeResource;
+    /**
+     * Removes CDKMetadata and Outputs in the template so that only resources for importing are left.
+     * @returns template with import resources only
+     */
+    private removeNonImportResources;
+}
+/**
+ * Information about a resource in the template that is importable
+ */
+export interface ImportableResource {
+    /**
+     * The logical ID of the resource
+     */
+    readonly logicalId: string;
+    /**
+     * The resource definition in the new template
+     */
+    readonly resourceDefinition: any;
+    /**
+     * The diff as reported by `cloudformation-diff`.
+     */
+    readonly resourceDiff: ResourceDifference;
+}
+/**
+ * The information necessary to execute an import operation
+ */
+export interface ImportMap {
+    /**
+     * Mapping logical IDs to physical names
+     */
+    readonly resourceMap: ResourceMap;
+    /**
+     * The selection of resources we are actually importing
+     *
+     * For each of the resources in this list, there is a corresponding entry in
+     * the `resourceMap` map.
+     */
+    readonly importResources: ImportableResource[];
+}
+export interface DiscoverImportableResourcesResult {
+    readonly additions: ImportableResource[];
+    readonly hasNonAdditions: boolean;
+}
+export declare function removeNonImportResources(stack: cxapi.CloudFormationStackArtifact): any;
+export {};