"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FromScan = exports.CfnTemplateGeneratorProvider = exports.FilterType = exports.ScanStatus = exports.TemplateSourceOptions = void 0;
exports.generateCdkApp = generateCdkApp;
exports.generateStack = generateStack;
exports.readFromPath = readFromPath;
exports.readFromStack = readFromStack;
exports.generateTemplate = generateTemplate;
exports.chunks = chunks;
exports.setEnvironment = setEnvironment;
exports.parseSourceOptions = parseSourceOptions;
exports.printBar = printBar;
exports.printDots = printDots;
exports.rewriteLine = rewriteLine;
exports.writeMigrateJsonFile = writeMigrateJsonFile;
exports.getMigrateScanType = getMigrateScanType;
exports.isThereAWarning = isThereAWarning;
exports.buildGeneratedTemplateOutput = buildGeneratedTemplateOutput;
exports.buildCfnClient = buildCfnClient;
exports.appendWarningsToReadme = appendWarningsToReadme;
/* eslint-disable @typescript-eslint/no-require-imports */
/* eslint-disable @typescript-eslint/no-var-requires */
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const cloud_assembly_api_1 = require("@aws-cdk/cloud-assembly-api");
const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
const cdk_from_cfn = __importStar(require("cdk-from-cfn"));
const chalk_1 = __importDefault(require("chalk"));
const init_1 = require("./init");
const cloudformation_1 = require("../api/cloudformation");
const plugin_1 = require("../api/plugin");
const tools_1 = require("../private/tools");
const camelCase = require('camelcase');
const decamelize = require('decamelize');
/** The list of languages supported by the built-in noctilucent binary. */
const MIGRATE_SUPPORTED_LANGUAGES = cdk_from_cfn.supported_languages();
/**
 * Generates a CDK app from a yaml or json template.
 *
 * @param stackName - The name to assign to the stack in the generated app
 * @param stack - The yaml or json template for the stack
 * @param language - The language to generate the CDK app in
 * @param outputPath - The path at which to generate the CDK app
 */
async function generateCdkApp(ioHelper, stackName, stack, language, outputPath, compress) {
    const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);
    const formattedStackName = decamelize(stackName);
    try {
        fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
        fs.mkdirSync(resolvedOutputPath, { recursive: true });
        const generateOnly = compress;
        await (0, init_1.cliInit)({
            ioHelper,
            type: 'app',
            language,
            canUseNetwork: true,
            generateOnly,
            workDir: resolvedOutputPath,
            stackName,
            migrate: true,
        });
        let stackFileName;
        switch (language) {
            case 'typescript':
                stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;
                break;
            case 'java':
                stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;
                break;
            case 'python':
                stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;
                break;
            case 'csharp':
                stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;
                break;
            case 'go':
                stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;
                break;
            default:
                throw new toolkit_lib_1.ToolkitError('UnsupportedMigrateLanguage', `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`);
        }
        fs.writeFileSync(stackFileName, stack);
        if (compress) {
            await (0, tools_1.zipDirectory)(resolvedOutputPath, `${resolvedOutputPath}.zip`);
            fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
        }
    }
    catch (error) {
        fs.rmSync(resolvedOutputPath, { recursive: true, force: true });
        throw error;
    }
}
/**
 * Generates a CDK stack file.
 * @param template - The template to translate into a CDK stack
 * @param stackName - The name to assign to the stack
 * @param language - The language to generate the stack in
 * @returns A string representation of a CDK stack file
 */
function generateStack(template, stackName, language) {
    const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;
    try {
        return cdk_from_cfn.transmute(template, language, formattedStackName);
    }
    catch (e) {
        throw new toolkit_lib_1.ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${e.message}`);
    }
}
/**
 * Reads and returns a stack template from a local path.
 *
 * @param inputPath - The location of the template
 * @returns A string representation of the template if present, otherwise undefined
 */
function readFromPath(inputPath) {
    let readFile;
    try {
        readFile = fs.readFileSync(inputPath, 'utf8');
    }
    catch (e) {
        throw new toolkit_lib_1.ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);
    }
    if (readFile == '') {
        throw new toolkit_lib_1.ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);
    }
    return readFile;
}
/**
 * Reads and returns a stack template from a deployed CloudFormation stack.
 *
 * @param stackName - The name of the stack
 * @param sdkProvider - The sdk provider for making CloudFormation calls
 * @param environment - The account and region where the stack is deployed
 * @returns A string representation of the template if present, otherwise undefined
 */
async function readFromStack(stackName, sdkProvider, environment) {
    const cloudFormation = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk.cloudFormation();
    const stack = await cloudformation_1.CloudFormationStack.lookup(cloudFormation, stackName, true);
    if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {
        return JSON.stringify(await stack.template());
    }
    else {
        throw new toolkit_lib_1.ToolkitError('UnhealthyStackStatus', `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`);
    }
}
/**
 * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation
 * template generator.
 *
 * @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag
 * @returns a generated cloudformation template
 */
async function generateTemplate(options) {
    const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);
    const ioHelper = options.ioHelper;
    const scanId = await findLastSuccessfulScan(cfn, options);
    // if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off
    const curScan = await cfn.describeResourceScan(scanId);
    if (curScan.Status == ScanStatus.IN_PROGRESS) {
        await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');
        await scanProgressBar(ioHelper, scanId, cfn);
    }
    await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime));
    let resources = await cfn.listResourceScanResources(scanId, options.filters);
    await ioHelper.defaults.info('finding related resources.');
    let relatedResources = await cfn.getResourceScanRelatedResources(scanId, resources);
    await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);
    await ioHelper.defaults.info('Generating CFN template from scanned resources.');
    const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId;
    let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
    await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');
    while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {
        await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);
        generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);
    }
    await ioHelper.defaults.info('\nTemplate successfully generated!');
    return buildGeneratedTemplateOutput(generatedTemplate, (await cfn.getGeneratedTemplate(templateArn)).TemplateBody, templateArn);
}
async function findLastSuccessfulScan(cfn, options) {
    const ioHelper = options.ioHelper;
    let resourceScanSummaries = [];
    const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;
    if (options.fromScan === FromScan.NEW) {
        await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);
        try {
            await cfn.startResourceScan(clientRequestToken);
            resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
        }
        catch (e) {
            // continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress
            // or the customer hit a rate limit. In either case we want to continue with the most recent scan.
            // If this happens to fail for a credential error then that will be caught immediately after anyway.
            await ioHelper.defaults.info(`Scan failed to start due to error '${e.message}', defaulting to latest scan.`);
        }
    }
    else {
        resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
        await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);
    }
    // get the latest scan, which we know will exist
    resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;
    let scanId = resourceScanSummaries[0].ResourceScanId;
    // find the most recent scan that isn't in a failed state in case we didn't start a new one
    for (const summary of resourceScanSummaries) {
        if (summary.Status !== ScanStatus.FAILED) {
            scanId = summary.ResourceScanId;
            break;
        }
    }
    return scanId;
}
/**
 * Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.
 *
 * @param filters - a string of filters in the format of key1=value1,key2=value2
 * @returns a map of the filters
 */
function parseFilters(filters) {
    if (!filters) {
        return {
            'resource-identifier': undefined,
            'resource-type-prefix': undefined,
            'tag-key': undefined,
            'tag-value': undefined,
        };
    }
    const filterShorthands = {
        'identifier': FilterType.RESOURCE_IDENTIFIER,
        'id': FilterType.RESOURCE_IDENTIFIER,
        'type': FilterType.RESOURCE_TYPE_PREFIX,
        'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,
    };
    const filterList = filters.split(',');
    let filterMap = {
        [FilterType.RESOURCE_IDENTIFIER]: undefined,
        [FilterType.RESOURCE_TYPE_PREFIX]: undefined,
        [FilterType.TAG_KEY]: undefined,
        [FilterType.TAG_VALUE]: undefined,
    };
    for (const fil of filterList) {
        const filter = fil.split('=');
        let filterKey = filter[0];
        const filterValue = filter[1];
        // if the key is a shorthand, replace it with the full name
        if (filterKey in filterShorthands) {
            filterKey = filterShorthands[filterKey];
        }
        if (Object.values(FilterType).includes(filterKey)) {
            filterMap[filterKey] = filterValue;
        }
        else {
            throw new toolkit_lib_1.ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);
        }
    }
    return filterMap;
}
/**
 * Takes a list of any type and breaks it up into chunks of a specified size.
 *
 * @param list - The list to break up
 * @param chunkSize - The size of each chunk
 * @returns A list of lists of the specified size
 */
function chunks(list, chunkSize) {
    const chunkedList = [];
    for (let i = 0; i < list.length; i += chunkSize) {
        chunkedList.push(list.slice(i, i + chunkSize));
    }
    return chunkedList;
}
/**
 * Sets the account and region for making CloudFormation calls.
 * @param account - The account to use
 * @param region - The region to use
 * @returns The environment object
 */
function setEnvironment(account, region) {
    return {
        account: account ?? cloud_assembly_api_1.UNKNOWN_ACCOUNT,
        region: region ?? cloud_assembly_api_1.UNKNOWN_REGION,
        name: 'cdk-migrate-env',
    };
}
/**
 * Enum for the source options for the template
 */
var TemplateSourceOptions;
(function (TemplateSourceOptions) {
    TemplateSourceOptions["PATH"] = "path";
    TemplateSourceOptions["STACK"] = "stack";
    TemplateSourceOptions["SCAN"] = "scan";
})(TemplateSourceOptions || (exports.TemplateSourceOptions = TemplateSourceOptions = {}));
/**
 * Enum for the status of a resource scan
 */
var ScanStatus;
(function (ScanStatus) {
    ScanStatus["IN_PROGRESS"] = "IN_PROGRESS";
    ScanStatus["COMPLETE"] = "COMPLETE";
    ScanStatus["FAILED"] = "FAILED";
})(ScanStatus || (exports.ScanStatus = ScanStatus = {}));
var FilterType;
(function (FilterType) {
    FilterType["RESOURCE_IDENTIFIER"] = "resource-identifier";
    FilterType["RESOURCE_TYPE_PREFIX"] = "resource-type-prefix";
    FilterType["TAG_KEY"] = "tag-key";
    FilterType["TAG_VALUE"] = "tag-value";
})(FilterType || (exports.FilterType = FilterType = {}));
/**
 * Validates that exactly one source option has been provided.
 * @param fromPath - The content of the flag `--from-path`
 * @param fromStack - the content of the flag `--from-stack`
 */
function parseSourceOptions(fromPath, fromStack, stackName) {
    if (fromPath && fromStack) {
        throw new toolkit_lib_1.ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');
    }
    if (!stackName) {
        throw new toolkit_lib_1.ToolkitError('MissingStackName', '`--stack-name` is a required field.');
    }
    if (!fromPath && !fromStack) {
        return { source: TemplateSourceOptions.SCAN };
    }
    if (fromPath) {
        return { source: TemplateSourceOptions.PATH, templatePath: fromPath };
    }
    return { source: TemplateSourceOptions.STACK, stackName: stackName };
}
/**
 * Takes a set of resources and removes any with the managedbystack flag set to true.
 *
 * @param resourceList - the list of resources provided by the list scanned resources calls
 * @returns a list of resources not managed by cfn stacks
 */
function excludeManaged(resourceList) {
    return resourceList
        .filter((r) => !r.ManagedByStack)
        .map((r) => ({
        ResourceType: r.ResourceType,
        ResourceIdentifier: r.ResourceIdentifier,
    }));
}
/**
 * Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.
 * Setting the value of the field to undefined effectively removes it from the object.
 *
 * @param resourceList - the list of resources provided by the list scanned resources calls
 * @returns a list of ScannedResourceIdentifier[]
 */
function resourceIdentifiers(resourceList) {
    const identifiers = [];
    resourceList.forEach((r) => {
        const identifier = {
            ResourceType: r.ResourceType,
            ResourceIdentifier: r.ResourceIdentifier,
        };
        identifiers.push(identifier);
    });
    return identifiers;
}
/**
 * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.
 *
 * @param scanId - A string representing the scan id
 * @param cloudFormation - The CloudFormation sdk client to use
 */
async function scanProgressBar(ioHelper, scanId, cfn) {
    let curProgress = 0.5;
    // we know it's in progress initially since we wouldn't have gotten here if it wasn't
    let curScan = {
        Status: ScanStatus.IN_PROGRESS,
        $metadata: {},
    };
    while (curScan.Status == ScanStatus.IN_PROGRESS) {
        curScan = await cfn.describeResourceScan(scanId);
        curProgress = curScan.PercentageCompleted ?? curProgress;
        printBar(30, curProgress);
        await new Promise((resolve) => setTimeout(resolve, 2000));
    }
    await ioHelper.defaults.info('\n✅ Scan Complete!');
}
/**
 * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.
 * The progress bar deletes the current line on the console and rewrites it with the progress amount.
 *
 * @param width - The width of the progress bar
 * @param progress - The current progress to display as a percentage of 100
 */
function printBar(width, progress) {
    if (!process.env.MIGRATE_INTEG_TEST) {
        const FULL_BLOCK = '█';
        const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
        const fraction = Math.min(progress / 100, 1);
        const innerWidth = Math.max(1, width - 2);
        const chars = innerWidth * fraction;
        const remainder = chars - Math.floor(chars);
        const fullChars = FULL_BLOCK.repeat(Math.floor(chars));
        const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];
        const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));
        const color = chalk_1.default.green;
        rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);
    }
}
/**
 * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.
 * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.
 *
 * @param message - The message to display
 * @param timeoutx4 - The amount of time to wait before printing the next period
 */
async function printDots(message, timeoutx4) {
    if (!process.env.MIGRATE_INTEG_TEST) {
        rewriteLine(message + ' .');
        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
        rewriteLine(message + ' ..');
        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
        rewriteLine(message + ' ...');
        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
        rewriteLine(message);
        await new Promise((resolve) => setTimeout(resolve, timeoutx4));
    }
}
/**
 * Rewrites the current line on the console and writes a new message to it.
 * This is a helper funciton for printDots and printBar.
 *
 * @param message - The message to display
 */
function rewriteLine(message) {
    process.stdout.clearLine(0);
    process.stdout.cursorTo(0);
    process.stdout.write(message);
}
/**
 * Prints the time difference between two dates in days, hours, and minutes.
 *
 * @param time1 - The first date to compare
 * @param time2 - The second date to compare
 */
async function displayTimeDiff(ioHelper, time1, time2) {
    const diff = Math.abs(time1.getTime() - time2.getTime());
    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
    const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
    await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);
}
/**
 * Writes a migrate.json file to the output directory.
 *
 * @param outputPath - The path to write the migrate.json file to
 * @param stackName - The name of the stack
 * @param generatedOutput - The output of the template generator
 */
function writeMigrateJsonFile(outputPath, stackName, migrateJson) {
    const outputToJson = {
        '//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',
        'Source': migrateJson.source,
        'Resources': migrateJson.resources,
    };
    fs.writeFileSync(`${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`, JSON.stringify(outputToJson, null, 2));
}
/**
 * Takes a string representing the from-scan flag and returns a FromScan enum value.
 *
 * @param scanType - A string representing the from-scan flag
 * @returns A FromScan enum value
 */
function getMigrateScanType(scanType) {
    switch (scanType) {
        case 'new':
            return FromScan.NEW;
        case 'most-recent':
            return FromScan.MOST_RECENT;
        case '':
            return FromScan.DEFAULT;
        case undefined:
            return FromScan.DEFAULT;
        default:
            throw new toolkit_lib_1.ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);
    }
}
/**
 * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.
 *
 * @param generatedTemplateOutput - A GenerateTemplateOutput object
 * @returns A boolean representing whether there are any warnings on any rescources
 */
function isThereAWarning(generatedTemplateOutput) {
    if (generatedTemplateOutput.resources) {
        for (const resource of generatedTemplateOutput.resources) {
            if (resource.Warnings && resource.Warnings.length > 0) {
                return true;
            }
        }
    }
    return false;
}
/**
 * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.
 *
 * @param generatedTemplateSummary - The output of the describe generated template call
 * @param templateBody - The body of the generated template
 * @returns A GenerateTemplateOutput object
 */
function buildGeneratedTemplateOutput(generatedTemplateSummary, templateBody, source) {
    const resources = generatedTemplateSummary.Resources;
    const migrateJson = {
        templateBody: templateBody,
        source: source,
        resources: generatedTemplateSummary.Resources.map((r) => ({
            ResourceType: r.ResourceType,
            LogicalResourceId: r.LogicalResourceId,
            ResourceIdentifier: r.ResourceIdentifier,
        })),
    };
    const templateId = generatedTemplateSummary.GeneratedTemplateId;
    return {
        migrateJson: migrateJson,
        resources: resources,
        templateId: templateId,
    };
}
/**
 * Builds a CloudFormation sdk client for making requests with the CFN template generator.
 *
 * @param sdkProvider - The sdk provider for making CloudFormation calls
 * @param environment - The account and region where the stack is deployed
 * @returns A CloudFormation sdk client
 */
async function buildCfnClient(sdkProvider, environment) {
    const sdk = (await sdkProvider.forEnvironment(environment, plugin_1.Mode.ForReading)).sdk;
    sdk.appendCustomUserAgent('cdk-migrate');
    return sdk.cloudFormation();
}
/**
 * Appends a list of warnings to a readme file.
 *
 * @param filepath - The path to the readme file
 * @param resources - A list of resources to append warnings for
 */
function appendWarningsToReadme(filepath, resources) {
    const readme = fs.readFileSync(filepath, 'utf8');
    const lines = readme.split('\n');
    const index = lines.findIndex((line) => line.trim() === 'Enjoy!');
    let linesToAdd = ['\n## Warnings'];
    linesToAdd.push('### Write-only properties');
    linesToAdd.push("Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).");
    linesToAdd.push('\n');
    linesToAdd.push('Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).');
    for (const resource of resources) {
        if (resource.Warnings && resource.Warnings.length > 0) {
            linesToAdd.push(`### ${resource.LogicalResourceId}`);
            for (const warning of resource.Warnings) {
                linesToAdd.push(`- **${warning.Type}**: `);
                for (const property of warning.Properties) {
                    linesToAdd.push(`  - ${property.PropertyPath}: ${property.Description}`);
                }
            }
        }
    }
    lines.splice(index, 0, ...linesToAdd);
    fs.writeFileSync(filepath, lines.join('\n'));
}
/**
 * takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.
 *
 * @param resources - A list of resources to deduplicate
 * @returns A list of unique resources
 */
function deduplicateResources(resources) {
    let uniqueResources = {};
    for (const resource of resources) {
        // Creating our unique identifier using the resource type and the full resource identifier.
        // The resource identifier can be made up of more than one key/value pair (e.g. a resource
        // like AWS::Route53::KeySigningKey is identified by the pair HostedZoneId + Name), so every
        // key must be included -- using only the first key would incorrectly collapse distinct
        // resources that merely share the value of their first identifier component.
        const sortedIdentifierEntries = Object.entries(resource.ResourceIdentifier).sort(([a], [b]) => a.localeCompare(b));
        const uniqueIdentifer = `${resource.ResourceType}:${sortedIdentifierEntries.map(([k, v]) => `${k}=${v}`).join(',')}`;
        uniqueResources[uniqueIdentifer] = resource;
    }
    return Object.values(uniqueResources);
}
/**
 * Class for making CloudFormation template generator calls
 */
class CfnTemplateGeneratorProvider {
    cfn;
    ioHelper;
    constructor(cfn, ioHelper) {
        this.cfn = cfn;
        this.ioHelper = ioHelper;
    }
    async checkForResourceScan(resourceScanSummaries, options, clientRequestToken) {
        if (!resourceScanSummaries || resourceScanSummaries.length === 0) {
            if (options.fromScan === FromScan.MOST_RECENT) {
                throw new toolkit_lib_1.ToolkitError('NoScansFound', 'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.');
            }
            else {
                await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');
                await this.startResourceScan(clientRequestToken);
            }
        }
    }
    /**
     * Retrieves a tokenized list of resources and their associated scan. If a token is present the function
     * will loop through all pages and combine them into a single list of ScannedRelatedResources
     *
     * @param scanId - scan id for the to list resources for
     * @param resources - A list of resources to find related resources for
     */
    async getResourceScanRelatedResources(scanId, resources) {
        let relatedResourceList = resources;
        // break the list of resources into chunks of 100 to avoid hitting the 100 resource limit
        for (const chunk of chunks(resources, 100)) {
            // get the first page of related resources
            const res = await this.cfn.listResourceScanRelatedResources({
                ResourceScanId: scanId,
                Resources: chunk,
            });
            // add the first page to the list
            relatedResourceList.push(...(res.RelatedResources ?? []));
            let nextToken = res.NextToken;
            // if there are more pages, cycle through them and add them to the list before moving on to the next chunk
            while (nextToken) {
                const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({
                    ResourceScanId: scanId,
                    Resources: resourceIdentifiers(resources),
                    NextToken: nextToken,
                });
                nextToken = nextRelatedResources.NextToken;
                relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));
            }
        }
        relatedResourceList = deduplicateResources(relatedResourceList);
        // prune the managedbystack flag off of them again.
        return process.env.MIGRATE_INTEG_TEST
            ? resourceIdentifiers(relatedResourceList)
            : resourceIdentifiers(excludeManaged(relatedResourceList));
    }
    /**
     * Kicks off a scan of a customers account, returning the scan id. A scan can take
     * 10 minutes or longer to complete. However this will return a scan id as soon as
     * the scan has begun.
     *
     * @returns A string representing the scan id
     */
    async startResourceScan(requestToken) {
        return (await this.cfn.startResourceScan({
            ClientRequestToken: requestToken,
        })).ResourceScanId;
    }
    /**
     * Gets the most recent scans a customer has completed
     *
     * @returns a list of resource scan summaries
     */
    async listResourceScans() {
        return this.cfn.listResourceScans();
    }
    /**
     * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function
     * will loop through all pages and combine them into a single list of ScannedResource[].
     * Additionally will apply any filters provided by the customer.
     *
     * @param scanId - scan id for the to list resources for
     * @param filters - a string of filters in the format of key1=value1,key2=value2
     * @returns a combined list of all resources from the scan
     */
    async listResourceScanResources(scanId, filters = []) {
        let resourceList = [];
        let resourceScanInputs;
        if (filters.length > 0) {
            await this.ioHelper.defaults.info('Applying filters to resource scan.');
            for (const filter of filters) {
                const filterList = parseFilters(filter);
                resourceScanInputs = {
                    ResourceScanId: scanId,
                    ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],
                    ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],
                    TagKey: filterList[FilterType.TAG_KEY],
                    TagValue: filterList[FilterType.TAG_VALUE],
                };
                const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
                resourceList = resourceList.concat(resources.Resources ?? []);
                let nextToken = resources.NextToken;
                // cycle through the pages adding all resources to the list until we run out of pages
                while (nextToken) {
                    resourceScanInputs.NextToken = nextToken;
                    const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
                    nextToken = nextResources.NextToken;
                    resourceList = resourceList.concat(nextResources.Resources ?? []);
                }
            }
        }
        else {
            await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');
            resourceScanInputs = {
                ResourceScanId: scanId,
            };
            const resources = await this.cfn.listResourceScanResources(resourceScanInputs);
            resourceList = resourceList.concat(resources.Resources ?? []);
            let nextToken = resources.NextToken;
            // cycle through the pages adding all resources to the list until we run out of pages
            while (nextToken) {
                resourceScanInputs.NextToken = nextToken;
                const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);
                nextToken = nextResources.NextToken;
                resourceList = resourceList.concat(nextResources.Resources ?? []);
            }
        }
        if (resourceList.length === 0) {
            throw new toolkit_lib_1.ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);
        }
        resourceList = deduplicateResources(resourceList);
        return process.env.MIGRATE_INTEG_TEST
            ? resourceIdentifiers(resourceList)
            : resourceIdentifiers(excludeManaged(resourceList));
    }
    /**
     * Retrieves information about a resource scan.
     *
     * @param scanId - scan id for the to list resources for
     * @returns information about the scan
     */
    async describeResourceScan(scanId) {
        return this.cfn.describeResourceScan({
            ResourceScanId: scanId,
        });
    }
    /**
     * Describes the current status of the template being generated.
     *
     * @param templateId - A string representing the template id
     * @returns DescribeGeneratedTemplateOutput an object containing the template status and results
     */
    async describeGeneratedTemplate(templateId) {
        const generatedTemplate = await this.cfn.describeGeneratedTemplate({
            GeneratedTemplateName: templateId,
        });
        if (generatedTemplate.Status == ScanStatus.FAILED) {
            throw new toolkit_lib_1.ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason);
        }
        return generatedTemplate;
    }
    /**
     * Retrieves a completed generated cloudformation template from the template generator.
     *
     * @param templateId - A string representing the template id
     * @param cloudFormation - The CloudFormation sdk client to use
     * @returns DescribeGeneratedTemplateOutput an object containing the template status and body
     */
    async getGeneratedTemplate(templateId) {
        return this.cfn.getGeneratedTemplate({
            GeneratedTemplateName: templateId,
        });
    }
    /**
     * Kicks off a template generation for a set of resources.
     *
     * @param stackName - The name of the stack
     * @param resources - A list of resources to generate the template from
     * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later
     */
    async createGeneratedTemplate(stackName, resources) {
        const createTemplateOutput = await this.cfn.createGeneratedTemplate({
            Resources: resources,
            GeneratedTemplateName: stackName,
        });
        if (createTemplateOutput.GeneratedTemplateId === undefined) {
            throw new toolkit_lib_1.ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');
        }
        return createTemplateOutput;
    }
    /**
     * Deletes a generated template from the template generator.
     *
     * @param templateArn - The arn of the template to delete
     * @returns A promise that resolves when the template has been deleted
     */
    async deleteGeneratedTemplate(templateArn) {
        await this.cfn.deleteGeneratedTemplate({
            GeneratedTemplateName: templateArn,
        });
    }
}
exports.CfnTemplateGeneratorProvider = CfnTemplateGeneratorProvider;
/**
 * The possible ways to choose a scan to generate a CDK application from
 */
var FromScan;
(function (FromScan) {
    /**
     * Initiate a new resource scan to build the CDK application from.
     */
    FromScan[FromScan["NEW"] = 0] = "NEW";
    /**
     * Use the last successful scan to build the CDK application from. Will fail if no scan is found.
     */
    FromScan[FromScan["MOST_RECENT"] = 1] = "MOST_RECENT";
    /**
     * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.
     */
    FromScan[FromScan["DEFAULT"] = 2] = "DEFAULT";
})(FromScan || (exports.FromScan = FromScan = {}));
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrate.js","sourceRoot":"","sources":["migrate.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\n/* eslint-disable @typescript-eslint/no-var-requires */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport type { Environment } from '@aws-cdk/cloud-assembly-api';\nimport { UNKNOWN_ACCOUNT, UNKNOWN_REGION } from '@aws-cdk/cloud-assembly-api';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport type {\n  DescribeGeneratedTemplateCommandOutput,\n  DescribeResourceScanCommandOutput,\n  GetGeneratedTemplateCommandOutput,\n  ListResourceScanResourcesCommandInput,\n  ResourceDefinition,\n  ResourceDetail,\n  ResourceIdentifierSummary,\n  ResourceScanSummary,\n  ScannedResource,\n  ScannedResourceIdentifier,\n} from '@aws-sdk/client-cloudformation';\nimport * as cdk_from_cfn from 'cdk-from-cfn';\nimport chalk from 'chalk';\nimport { cliInit } from './init';\nimport type { ICloudFormationClient, SdkProvider } from '../api/aws-auth';\nimport { CloudFormationStack } from '../api/cloudformation';\nimport { Mode } from '../api/plugin';\nimport type { IoHelper } from '../api-private';\nimport { zipDirectory } from '../private/tools';\nconst camelCase = require('camelcase');\nconst decamelize = require('decamelize');\n/** The list of languages supported by the built-in noctilucent binary. */\nconst MIGRATE_SUPPORTED_LANGUAGES: readonly string[] = cdk_from_cfn.supported_languages();\n\n/**\n * Generates a CDK app from a yaml or json template.\n *\n * @param stackName - The name to assign to the stack in the generated app\n * @param stack - The yaml or json template for the stack\n * @param language - The language to generate the CDK app in\n * @param outputPath - The path at which to generate the CDK app\n */\nexport async function generateCdkApp(\n  ioHelper: IoHelper,\n  stackName: string,\n  stack: string,\n  language: string,\n  outputPath?: string,\n  compress?: boolean,\n): Promise<void> {\n  const resolvedOutputPath = path.join(outputPath ?? process.cwd(), stackName);\n  const formattedStackName = decamelize(stackName);\n\n  try {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    fs.mkdirSync(resolvedOutputPath, { recursive: true });\n    const generateOnly = compress;\n    await cliInit({\n      ioHelper,\n      type: 'app',\n      language,\n      canUseNetwork: true,\n      generateOnly,\n      workDir: resolvedOutputPath,\n      stackName,\n      migrate: true,\n    });\n\n    let stackFileName: string;\n    switch (language) {\n      case 'typescript':\n        stackFileName = `${resolvedOutputPath}/lib/${formattedStackName}-stack.ts`;\n        break;\n      case 'java':\n        stackFileName = `${resolvedOutputPath}/src/main/java/com/myorg/${camelCase(formattedStackName, { pascalCase: true })}Stack.java`;\n        break;\n      case 'python':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName.replace(/-/g, '_')}/${formattedStackName.replace(/-/g, '_')}_stack.py`;\n        break;\n      case 'csharp':\n        stackFileName = `${resolvedOutputPath}/src/${camelCase(formattedStackName, { pascalCase: true })}/${camelCase(formattedStackName, { pascalCase: true })}Stack.cs`;\n        break;\n      case 'go':\n        stackFileName = `${resolvedOutputPath}/${formattedStackName}.go`;\n        break;\n      default:\n        throw new ToolkitError(\n          'UnsupportedMigrateLanguage',\n          `${language} is not supported by CDK Migrate. Please choose from: ${MIGRATE_SUPPORTED_LANGUAGES.join(', ')}`,\n        );\n    }\n    fs.writeFileSync(stackFileName, stack);\n    if (compress) {\n      await zipDirectory(resolvedOutputPath, `${resolvedOutputPath}.zip`);\n      fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    }\n  } catch (error) {\n    fs.rmSync(resolvedOutputPath, { recursive: true, force: true });\n    throw error;\n  }\n}\n\n/**\n * Generates a CDK stack file.\n * @param template - The template to translate into a CDK stack\n * @param stackName - The name to assign to the stack\n * @param language - The language to generate the stack in\n * @returns A string representation of a CDK stack file\n */\nexport function generateStack(template: string, stackName: string, language: string) {\n  const formattedStackName = `${camelCase(decamelize(stackName), { pascalCase: true })}Stack`;\n  try {\n    return cdk_from_cfn.transmute(template, language, formattedStackName);\n  } catch (e) {\n    throw new ToolkitError('StackGenerationFailed', `${formattedStackName} could not be generated because ${(e as Error).message}`);\n  }\n}\n\n/**\n * Reads and returns a stack template from a local path.\n *\n * @param inputPath - The location of the template\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport function readFromPath(inputPath: string): string {\n  let readFile: string;\n  try {\n    readFile = fs.readFileSync(inputPath, 'utf8');\n  } catch (e) {\n    throw new ToolkitError('InvalidPath', `'${inputPath}' is not a valid path.`);\n  }\n  if (readFile == '') {\n    throw new ToolkitError('EmptyTemplateFile', `Cloudformation template filepath: '${inputPath}' is an empty file.`);\n  }\n  return readFile;\n}\n\n/**\n * Reads and returns a stack template from a deployed CloudFormation stack.\n *\n * @param stackName - The name of the stack\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A string representation of the template if present, otherwise undefined\n */\nexport async function readFromStack(\n  stackName: string,\n  sdkProvider: SdkProvider,\n  environment: Environment,\n): Promise<string | undefined> {\n  const cloudFormation = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk.cloudFormation();\n\n  const stack = await CloudFormationStack.lookup(cloudFormation, stackName, true);\n  if (stack.stackStatus.isDeploySuccess || stack.stackStatus.isRollbackSuccess) {\n    return JSON.stringify(await stack.template());\n  } else {\n    throw new ToolkitError(\n      'UnhealthyStackStatus',\n      `Stack '${stackName}' in account ${environment.account} and region ${environment.region} has a status of '${stack.stackStatus.name}' due to '${stack.stackStatus.reason}'. The stack cannot be migrated until it is in a healthy state.`,\n    );\n  }\n}\n\n/**\n * Takes in a stack name and account and region and returns a generated cloudformation template using the cloudformation\n * template generator.\n *\n * @param GenerateTemplateOptions - An object containing the stack name, filters, sdkProvider, environment, and newScan flag\n * @returns a generated cloudformation template\n */\nexport async function generateTemplate(options: GenerateTemplateOptions): Promise<GenerateTemplateOutput> {\n  const cfn = new CfnTemplateGeneratorProvider(await buildCfnClient(options.sdkProvider, options.environment), options.ioHelper);\n  const ioHelper = options.ioHelper;\n\n  const scanId = await findLastSuccessfulScan(cfn, options);\n\n  // if a customer accidentally ctrl-c's out of the command and runs it again, this will continue the progress bar where it left off\n  const curScan = await cfn.describeResourceScan(scanId);\n  if (curScan.Status == ScanStatus.IN_PROGRESS) {\n    await ioHelper.defaults.info('Resource scan in progress. Please wait, this can take 10 minutes or longer.');\n    await scanProgressBar(ioHelper, scanId, cfn);\n  }\n\n  await displayTimeDiff(ioHelper, new Date(), new Date(curScan.StartTime!));\n\n  let resources: ScannedResource[] = await cfn.listResourceScanResources(scanId!, options.filters);\n\n  await ioHelper.defaults.info('finding related resources.');\n  let relatedResources = await cfn.getResourceScanRelatedResources(scanId!, resources);\n\n  await ioHelper.defaults.info(`Found ${relatedResources.length} resources.`);\n\n  await ioHelper.defaults.info('Generating CFN template from scanned resources.');\n  const templateArn = (await cfn.createGeneratedTemplate(options.stackName, relatedResources)).GeneratedTemplateId!;\n\n  let generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n\n  await ioHelper.defaults.info('Please wait, template creation in progress. This may take a couple minutes.');\n  while (generatedTemplate.Status !== ScanStatus.COMPLETE && generatedTemplate.Status !== ScanStatus.FAILED) {\n    await printDots(`[${generatedTemplate.Status}] Template Creation in Progress`, 400);\n    generatedTemplate = await cfn.describeGeneratedTemplate(templateArn);\n  }\n  await ioHelper.defaults.info('\\nTemplate successfully generated!');\n  return buildGeneratedTemplateOutput(\n    generatedTemplate,\n    (await cfn.getGeneratedTemplate(templateArn)).TemplateBody!,\n    templateArn,\n  );\n}\n\nasync function findLastSuccessfulScan(\n  cfn: CfnTemplateGeneratorProvider,\n  options: GenerateTemplateOptions,\n): Promise<string> {\n  const ioHelper = options.ioHelper;\n  let resourceScanSummaries: ResourceScanSummary[] | undefined = [];\n  const clientRequestToken = `cdk-migrate-${options.environment.account}-${options.environment.region}`;\n  if (options.fromScan === FromScan.NEW) {\n    await ioHelper.defaults.info(`Starting new scan for account ${options.environment.account} in region ${options.environment.region}`);\n    try {\n      await cfn.startResourceScan(clientRequestToken);\n      resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    } catch (e) {\n      // continuing here because if the scan fails on a new-scan it is very likely because there is either already a scan in progress\n      // or the customer hit a rate limit. In either case we want to continue with the most recent scan.\n      // If this happens to fail for a credential error then that will be caught immediately after anyway.\n      await ioHelper.defaults.info(`Scan failed to start due to error '${(e as Error).message}', defaulting to latest scan.`);\n    }\n  } else {\n    resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n    await cfn.checkForResourceScan(resourceScanSummaries, options, clientRequestToken);\n  }\n  // get the latest scan, which we know will exist\n  resourceScanSummaries = (await cfn.listResourceScans()).ResourceScanSummaries;\n  let scanId: string | undefined = resourceScanSummaries![0].ResourceScanId;\n\n  // find the most recent scan that isn't in a failed state in case we didn't start a new one\n  for (const summary of resourceScanSummaries!) {\n    if (summary.Status !== ScanStatus.FAILED) {\n      scanId = summary.ResourceScanId!;\n      break;\n    }\n  }\n\n  return scanId!;\n}\n\n/**\n * Takes a string of filters in the format of key1=value1,key2=value2 and returns a map of the filters.\n *\n * @param filters - a string of filters in the format of key1=value1,key2=value2\n * @returns a map of the filters\n */\nfunction parseFilters(filters: string): {\n  [key in FilterType]: string | undefined;\n} {\n  if (!filters) {\n    return {\n      'resource-identifier': undefined,\n      'resource-type-prefix': undefined,\n      'tag-key': undefined,\n      'tag-value': undefined,\n    };\n  }\n\n  const filterShorthands: { [key: string]: FilterType } = {\n    'identifier': FilterType.RESOURCE_IDENTIFIER,\n    'id': FilterType.RESOURCE_IDENTIFIER,\n    'type': FilterType.RESOURCE_TYPE_PREFIX,\n    'type-prefix': FilterType.RESOURCE_TYPE_PREFIX,\n  };\n\n  const filterList = filters.split(',');\n\n  let filterMap: { [key in FilterType]: string | undefined } = {\n    [FilterType.RESOURCE_IDENTIFIER]: undefined,\n    [FilterType.RESOURCE_TYPE_PREFIX]: undefined,\n    [FilterType.TAG_KEY]: undefined,\n    [FilterType.TAG_VALUE]: undefined,\n  };\n\n  for (const fil of filterList) {\n    const filter = fil.split('=');\n    let filterKey = filter[0];\n    const filterValue = filter[1];\n    // if the key is a shorthand, replace it with the full name\n    if (filterKey in filterShorthands) {\n      filterKey = filterShorthands[filterKey];\n    }\n    if (Object.values(FilterType).includes(filterKey as any)) {\n      filterMap[filterKey as keyof typeof filterMap] = filterValue;\n    } else {\n      throw new ToolkitError('InvalidFilter', `Invalid filter: ${filterKey}`);\n    }\n  }\n  return filterMap;\n}\n\n/**\n * Takes a list of any type and breaks it up into chunks of a specified size.\n *\n * @param list - The list to break up\n * @param chunkSize - The size of each chunk\n * @returns A list of lists of the specified size\n */\nexport function chunks(list: any[], chunkSize: number): any[][] {\n  const chunkedList: any[][] = [];\n  for (let i = 0; i < list.length; i += chunkSize) {\n    chunkedList.push(list.slice(i, i + chunkSize));\n  }\n  return chunkedList;\n}\n\n/**\n * Sets the account and region for making CloudFormation calls.\n * @param account - The account to use\n * @param region - The region to use\n * @returns The environment object\n */\nexport function setEnvironment(account?: string, region?: string): Environment {\n  return {\n    account: account ?? UNKNOWN_ACCOUNT,\n    region: region ?? UNKNOWN_REGION,\n    name: 'cdk-migrate-env',\n  };\n}\n\n/**\n * Enum for the source options for the template\n */\nexport enum TemplateSourceOptions {\n  PATH = 'path',\n  STACK = 'stack',\n  SCAN = 'scan',\n}\n\n/**\n * An object representing the source of a template.\n */\ntype TemplateSource =\n  | { source: TemplateSourceOptions.SCAN }\n  | { source: TemplateSourceOptions.PATH; templatePath: string }\n  | { source: TemplateSourceOptions.STACK; stackName: string };\n\n/**\n * Enum for the status of a resource scan\n */\nexport enum ScanStatus {\n  IN_PROGRESS = 'IN_PROGRESS',\n  COMPLETE = 'COMPLETE',\n  FAILED = 'FAILED',\n}\n\nexport enum FilterType {\n  RESOURCE_IDENTIFIER = 'resource-identifier',\n  RESOURCE_TYPE_PREFIX = 'resource-type-prefix',\n  TAG_KEY = 'tag-key',\n  TAG_VALUE = 'tag-value',\n}\n\n/**\n * Validates that exactly one source option has been provided.\n * @param fromPath - The content of the flag `--from-path`\n * @param fromStack - the content of the flag `--from-stack`\n */\nexport function parseSourceOptions(fromPath?: string, fromStack?: boolean, stackName?: string): TemplateSource {\n  if (fromPath && fromStack) {\n    throw new ToolkitError('ConflictingSourceOptions', 'Only one of `--from-path` or `--from-stack` may be provided.');\n  }\n  if (!stackName) {\n    throw new ToolkitError('MissingStackName', '`--stack-name` is a required field.');\n  }\n  if (!fromPath && !fromStack) {\n    return { source: TemplateSourceOptions.SCAN };\n  }\n  if (fromPath) {\n    return { source: TemplateSourceOptions.PATH, templatePath: fromPath };\n  }\n  return { source: TemplateSourceOptions.STACK, stackName: stackName! };\n}\n\n/**\n * Takes a set of resources and removes any with the managedbystack flag set to true.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of resources not managed by cfn stacks\n */\nfunction excludeManaged(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  return resourceList\n    .filter((r) => !r.ManagedByStack)\n    .map((r) => ({\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    }));\n}\n\n/**\n * Transforms a list of resources into a list of resource identifiers by removing the ManagedByStack flag.\n * Setting the value of the field to undefined effectively removes it from the object.\n *\n * @param resourceList - the list of resources provided by the list scanned resources calls\n * @returns a list of ScannedResourceIdentifier[]\n */\nfunction resourceIdentifiers(resourceList: ScannedResource[]): ScannedResourceIdentifier[] {\n  const identifiers: ScannedResourceIdentifier[] = [];\n  resourceList.forEach((r) => {\n    const identifier: ScannedResourceIdentifier = {\n      ResourceType: r.ResourceType!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    };\n    identifiers.push(identifier);\n  });\n  return identifiers;\n}\n\n/**\n * Takes a scan id and maintains a progress bar to display the progress of a scan to the user.\n *\n * @param scanId - A string representing the scan id\n * @param cloudFormation - The CloudFormation sdk client to use\n */\nasync function scanProgressBar(ioHelper: IoHelper, scanId: string, cfn: CfnTemplateGeneratorProvider) {\n  let curProgress = 0.5;\n  // we know it's in progress initially since we wouldn't have gotten here if it wasn't\n  let curScan: DescribeResourceScanCommandOutput = {\n    Status: ScanStatus.IN_PROGRESS,\n    $metadata: {},\n  };\n  while (curScan.Status == ScanStatus.IN_PROGRESS) {\n    curScan = await cfn.describeResourceScan(scanId);\n    curProgress = curScan.PercentageCompleted ?? curProgress;\n    printBar(30, curProgress);\n    await new Promise((resolve) => setTimeout(resolve, 2000));\n  }\n  await ioHelper.defaults.info('\\n✅ Scan Complete!');\n}\n\n/**\n * Prints a progress bar to the console. To be used in a while loop to show progress of a long running task.\n * The progress bar deletes the current line on the console and rewrites it with the progress amount.\n *\n * @param width - The width of the progress bar\n * @param progress - The current progress to display as a percentage of 100\n */\nexport function printBar(width: number, progress: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    const FULL_BLOCK = '█';\n    const PARTIAL_BLOCK = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];\n    const fraction = Math.min(progress / 100, 1);\n    const innerWidth = Math.max(1, width - 2);\n    const chars = innerWidth * fraction;\n    const remainder = chars - Math.floor(chars);\n\n    const fullChars = FULL_BLOCK.repeat(Math.floor(chars));\n    const partialChar = PARTIAL_BLOCK[Math.floor(remainder * PARTIAL_BLOCK.length)];\n    const filler = '·'.repeat(innerWidth - Math.floor(chars) - (partialChar ? 1 : 0));\n\n    const color = chalk.green;\n\n    rewriteLine('[' + color(fullChars + partialChar) + filler + `] (${progress}%)`);\n  }\n}\n\n/**\n * Prints a message to the console with a series periods appended to it. To be used in a while loop to show progress of a long running task.\n * The message deletes the current line and rewrites it several times to display 1-3 periods to show the user that the task is still running.\n *\n * @param message - The message to display\n * @param timeoutx4 - The amount of time to wait before printing the next period\n */\nexport async function printDots(message: string, timeoutx4: number) {\n  if (!process.env.MIGRATE_INTEG_TEST) {\n    rewriteLine(message + ' .');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ..');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message + ' ...');\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n\n    rewriteLine(message);\n    await new Promise((resolve) => setTimeout(resolve, timeoutx4));\n  }\n}\n\n/**\n * Rewrites the current line on the console and writes a new message to it.\n * This is a helper funciton for printDots and printBar.\n *\n * @param message - The message to display\n */\nexport function rewriteLine(message: string) {\n  process.stdout.clearLine(0);\n  process.stdout.cursorTo(0);\n  process.stdout.write(message);\n}\n\n/**\n * Prints the time difference between two dates in days, hours, and minutes.\n *\n * @param time1 - The first date to compare\n * @param time2 - The second date to compare\n */\nasync function displayTimeDiff(ioHelper: IoHelper, time1: Date, time2: Date): Promise<void> {\n  const diff = Math.abs(time1.getTime() - time2.getTime());\n\n  const days = Math.floor(diff / (1000 * 60 * 60 * 24));\n  const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));\n  const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));\n\n  await ioHelper.defaults.info(`Using the latest successful scan which is ${days} days, ${hours} hours, and ${minutes} minutes old.`);\n}\n\n/**\n * Writes a migrate.json file to the output directory.\n *\n * @param outputPath - The path to write the migrate.json file to\n * @param stackName - The name of the stack\n * @param generatedOutput - The output of the template generator\n */\nexport function writeMigrateJsonFile(\n  outputPath: string | undefined,\n  stackName: string,\n  migrateJson: MigrateJsonFormat,\n) {\n  const outputToJson = {\n    '//': 'This file is generated by cdk migrate. It will be automatically deleted after the first successful deployment of this app to the environment of the original resources.',\n    'Source': migrateJson.source,\n    'Resources': migrateJson.resources,\n  };\n  fs.writeFileSync(\n    `${path.join(outputPath ?? process.cwd(), stackName)}/migrate.json`,\n    JSON.stringify(outputToJson, null, 2),\n  );\n}\n\n/**\n * Takes a string representing the from-scan flag and returns a FromScan enum value.\n *\n * @param scanType - A string representing the from-scan flag\n * @returns A FromScan enum value\n */\nexport function getMigrateScanType(scanType: string) {\n  switch (scanType) {\n    case 'new':\n      return FromScan.NEW;\n    case 'most-recent':\n      return FromScan.MOST_RECENT;\n    case '':\n      return FromScan.DEFAULT;\n    case undefined:\n      return FromScan.DEFAULT;\n    default:\n      throw new ToolkitError('UnknownScanType', `Unknown scan type: ${scanType}`);\n  }\n}\n\n/**\n * Takes a generatedTemplateOutput objct and returns a boolean representing whether there are any warnings on any rescources.\n *\n * @param generatedTemplateOutput - A GenerateTemplateOutput object\n * @returns A boolean representing whether there are any warnings on any rescources\n */\nexport function isThereAWarning(generatedTemplateOutput: GenerateTemplateOutput) {\n  if (generatedTemplateOutput.resources) {\n    for (const resource of generatedTemplateOutput.resources) {\n      if (resource.Warnings && resource.Warnings.length > 0) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\n/**\n * Builds the GenerateTemplateOutput object from the DescribeGeneratedTemplateOutput and the template body.\n *\n * @param generatedTemplateSummary - The output of the describe generated template call\n * @param templateBody - The body of the generated template\n * @returns A GenerateTemplateOutput object\n */\nexport function buildGeneratedTemplateOutput(\n  generatedTemplateSummary: DescribeGeneratedTemplateCommandOutput,\n  templateBody: string,\n  source: string,\n): GenerateTemplateOutput {\n  const resources: ResourceDetail[] | undefined = generatedTemplateSummary.Resources;\n  const migrateJson: MigrateJsonFormat = {\n    templateBody: templateBody,\n    source: source,\n    resources: generatedTemplateSummary.Resources!.map((r) => ({\n      ResourceType: r.ResourceType!,\n      LogicalResourceId: r.LogicalResourceId!,\n      ResourceIdentifier: r.ResourceIdentifier!,\n    })),\n  };\n  const templateId = generatedTemplateSummary.GeneratedTemplateId!;\n  return {\n    migrateJson: migrateJson,\n    resources: resources,\n    templateId: templateId,\n  };\n}\n\n/**\n * Builds a CloudFormation sdk client for making requests with the CFN template generator.\n *\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n * @returns A CloudFormation sdk client\n */\nexport async function buildCfnClient(sdkProvider: SdkProvider, environment: Environment) {\n  const sdk = (await sdkProvider.forEnvironment(environment, Mode.ForReading)).sdk;\n  sdk.appendCustomUserAgent('cdk-migrate');\n  return sdk.cloudFormation();\n}\n\n/**\n * Appends a list of warnings to a readme file.\n *\n * @param filepath - The path to the readme file\n * @param resources - A list of resources to append warnings for\n */\nexport function appendWarningsToReadme(filepath: string, resources: ResourceDetail[]) {\n  const readme = fs.readFileSync(filepath, 'utf8');\n  const lines = readme.split('\\n');\n  const index = lines.findIndex((line) => line.trim() === 'Enjoy!');\n  let linesToAdd = ['\\n## Warnings'];\n  linesToAdd.push('### Write-only properties');\n  linesToAdd.push(\n    \"Write-only properties are resource property values that can be written to but can't be read by AWS CloudFormation or CDK Migrate. For more information, see [IaC generator and write-only properties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/generate-IaC-write-only-properties.html).\",\n  );\n  linesToAdd.push('\\n');\n  linesToAdd.push(\n    'Write-only properties discovered during migration are organized here by resource ID and categorized by write-only property type. Resolve write-only properties by providing property values in your CDK app. For guidance, see [Resolve write-only properties](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html#migrate-resources-writeonly).',\n  );\n  for (const resource of resources) {\n    if (resource.Warnings && resource.Warnings.length > 0) {\n      linesToAdd.push(`### ${resource.LogicalResourceId}`);\n      for (const warning of resource.Warnings) {\n        linesToAdd.push(`- **${warning.Type}**: `);\n        for (const property of warning.Properties!) {\n          linesToAdd.push(`  - ${property.PropertyPath}: ${property.Description}`);\n        }\n      }\n    }\n  }\n  lines.splice(index, 0, ...linesToAdd);\n  fs.writeFileSync(filepath, lines.join('\\n'));\n}\n\n/**\n * takes a list of resources and returns a list of unique resources based on the resource type and logical resource id.\n *\n * @param resources - A list of resources to deduplicate\n * @returns A list of unique resources\n */\nfunction deduplicateResources(resources: ResourceDetail[]) {\n  let uniqueResources: { [key: string]: ResourceDetail } = {};\n\n  for (const resource of resources) {\n    // Creating our unique identifier using the resource type and the full resource identifier.\n    // The resource identifier can be made up of more than one key/value pair (e.g. a resource\n    // like AWS::Route53::KeySigningKey is identified by the pair HostedZoneId + Name), so every\n    // key must be included -- using only the first key would incorrectly collapse distinct\n    // resources that merely share the value of their first identifier component.\n    const sortedIdentifierEntries = Object.entries(resource.ResourceIdentifier!).sort(([a], [b]) => a.localeCompare(b));\n    const uniqueIdentifer = `${resource.ResourceType}:${sortedIdentifierEntries.map(([k, v]) => `${k}=${v}`).join(',')}`;\n    uniqueResources[uniqueIdentifer] = resource;\n  }\n\n  return Object.values(uniqueResources);\n}\n\n/**\n * Class for making CloudFormation template generator calls\n */\nexport class CfnTemplateGeneratorProvider {\n  private cfn: ICloudFormationClient;\n  private ioHelper: IoHelper;\n  constructor(cfn: ICloudFormationClient, ioHelper: IoHelper) {\n    this.cfn = cfn;\n    this.ioHelper = ioHelper;\n  }\n\n  async checkForResourceScan(\n    resourceScanSummaries: ResourceScanSummary[] | undefined,\n    options: GenerateTemplateOptions,\n    clientRequestToken: string,\n  ) {\n    if (!resourceScanSummaries || resourceScanSummaries.length === 0) {\n      if (options.fromScan === FromScan.MOST_RECENT) {\n        throw new ToolkitError(\n          'NoScansFound',\n          'No scans found. Please either start a new scan with the `--from-scan` new or do not specify a `--from-scan` option.',\n        );\n      } else {\n        await this.ioHelper.defaults.info('No scans found. Initiating a new resource scan.');\n        await this.startResourceScan(clientRequestToken);\n      }\n    }\n  }\n\n  /**\n   * Retrieves a tokenized list of resources and their associated scan. If a token is present the function\n   * will loop through all pages and combine them into a single list of ScannedRelatedResources\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param resources - A list of resources to find related resources for\n   */\n  async getResourceScanRelatedResources(\n    scanId: string,\n    resources: ScannedResource[],\n  ): Promise<ScannedResourceIdentifier[]> {\n    let relatedResourceList = resources;\n\n    // break the list of resources into chunks of 100 to avoid hitting the 100 resource limit\n    for (const chunk of chunks(resources, 100)) {\n      // get the first page of related resources\n      const res = await this.cfn.listResourceScanRelatedResources({\n        ResourceScanId: scanId,\n        Resources: chunk,\n      });\n\n      // add the first page to the list\n      relatedResourceList.push(...(res.RelatedResources ?? []));\n      let nextToken = res.NextToken;\n\n      // if there are more pages, cycle through them and add them to the list before moving on to the next chunk\n      while (nextToken) {\n        const nextRelatedResources = await this.cfn.listResourceScanRelatedResources({\n          ResourceScanId: scanId,\n          Resources: resourceIdentifiers(resources),\n          NextToken: nextToken,\n        });\n        nextToken = nextRelatedResources.NextToken;\n        relatedResourceList.push(...(nextRelatedResources.RelatedResources ?? []));\n      }\n    }\n\n    relatedResourceList = deduplicateResources(relatedResourceList);\n\n    // prune the managedbystack flag off of them again.\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(relatedResourceList)\n      : resourceIdentifiers(excludeManaged(relatedResourceList));\n  }\n\n  /**\n   * Kicks off a scan of a customers account, returning the scan id. A scan can take\n   * 10 minutes or longer to complete. However this will return a scan id as soon as\n   * the scan has begun.\n   *\n   * @returns A string representing the scan id\n   */\n  async startResourceScan(requestToken: string) {\n    return (\n      await this.cfn.startResourceScan({\n        ClientRequestToken: requestToken,\n      })\n    ).ResourceScanId;\n  }\n\n  /**\n   * Gets the most recent scans a customer has completed\n   *\n   * @returns a list of resource scan summaries\n   */\n  async listResourceScans() {\n    return this.cfn.listResourceScans();\n  }\n\n  /**\n   * Retrieves a tokenized list of resources from a resource scan. If a token is present, this function\n   * will loop through all pages and combine them into a single list of ScannedResource[].\n   * Additionally will apply any filters provided by the customer.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @param filters - a string of filters in the format of key1=value1,key2=value2\n   * @returns a combined list of all resources from the scan\n   */\n  async listResourceScanResources(scanId: string, filters: string[] = []): Promise<ScannedResourceIdentifier[]> {\n    let resourceList: ScannedResource[] = [];\n    let resourceScanInputs: ListResourceScanResourcesCommandInput;\n\n    if (filters.length > 0) {\n      await this.ioHelper.defaults.info('Applying filters to resource scan.');\n      for (const filter of filters) {\n        const filterList = parseFilters(filter);\n        resourceScanInputs = {\n          ResourceScanId: scanId,\n          ResourceIdentifier: filterList[FilterType.RESOURCE_IDENTIFIER],\n          ResourceTypePrefix: filterList[FilterType.RESOURCE_TYPE_PREFIX],\n          TagKey: filterList[FilterType.TAG_KEY],\n          TagValue: filterList[FilterType.TAG_VALUE],\n        };\n        const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        resourceList = resourceList.concat(resources.Resources ?? []);\n        let nextToken = resources.NextToken;\n\n        // cycle through the pages adding all resources to the list until we run out of pages\n        while (nextToken) {\n          resourceScanInputs.NextToken = nextToken;\n          const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n          nextToken = nextResources.NextToken;\n          resourceList = resourceList!.concat(nextResources.Resources ?? []);\n        }\n      }\n    } else {\n      await this.ioHelper.defaults.info('No filters provided. Retrieving all resources from scan.');\n      resourceScanInputs = {\n        ResourceScanId: scanId,\n      };\n      const resources = await this.cfn.listResourceScanResources(resourceScanInputs);\n      resourceList = resourceList!.concat(resources.Resources ?? []);\n      let nextToken = resources.NextToken;\n\n      // cycle through the pages adding all resources to the list until we run out of pages\n      while (nextToken) {\n        resourceScanInputs.NextToken = nextToken;\n        const nextResources = await this.cfn.listResourceScanResources(resourceScanInputs);\n        nextToken = nextResources.NextToken;\n        resourceList = resourceList!.concat(nextResources.Resources ?? []);\n      }\n    }\n    if (resourceList.length === 0) {\n      throw new ToolkitError('NoResourcesFound', `No resources found with filters ${filters.join(' ')}. Please try again with different filters.`);\n    }\n    resourceList = deduplicateResources(resourceList);\n\n    return process.env.MIGRATE_INTEG_TEST\n      ? resourceIdentifiers(resourceList)\n      : resourceIdentifiers(excludeManaged(resourceList));\n  }\n\n  /**\n   * Retrieves information about a resource scan.\n   *\n   * @param scanId - scan id for the to list resources for\n   * @returns information about the scan\n   */\n  async describeResourceScan(scanId: string): Promise<DescribeResourceScanCommandOutput> {\n    return this.cfn.describeResourceScan({\n      ResourceScanId: scanId,\n    });\n  }\n\n  /**\n   * Describes the current status of the template being generated.\n   *\n   * @param templateId - A string representing the template id\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and results\n   */\n  async describeGeneratedTemplate(templateId: string): Promise<DescribeGeneratedTemplateCommandOutput> {\n    const generatedTemplate = await this.cfn.describeGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n\n    if (generatedTemplate.Status == ScanStatus.FAILED) {\n      throw new ToolkitError('TemplateGenerationFailed', generatedTemplate.StatusReason!);\n    }\n\n    return generatedTemplate;\n  }\n\n  /**\n   * Retrieves a completed generated cloudformation template from the template generator.\n   *\n   * @param templateId - A string representing the template id\n   * @param cloudFormation - The CloudFormation sdk client to use\n   * @returns DescribeGeneratedTemplateOutput an object containing the template status and body\n   */\n  async getGeneratedTemplate(templateId: string): Promise<GetGeneratedTemplateCommandOutput> {\n    return this.cfn.getGeneratedTemplate({\n      GeneratedTemplateName: templateId,\n    });\n  }\n\n  /**\n   * Kicks off a template generation for a set of resources.\n   *\n   * @param stackName - The name of the stack\n   * @param resources - A list of resources to generate the template from\n   * @returns CreateGeneratedTemplateOutput an object containing the template arn to query on later\n   */\n  async createGeneratedTemplate(stackName: string, resources: ResourceDefinition[]) {\n    const createTemplateOutput = await this.cfn.createGeneratedTemplate({\n      Resources: resources,\n      GeneratedTemplateName: stackName,\n    });\n\n    if (createTemplateOutput.GeneratedTemplateId === undefined) {\n      throw new ToolkitError('MissingTemplateArn', 'CreateGeneratedTemplate failed to return an Arn.');\n    }\n    return createTemplateOutput;\n  }\n\n  /**\n   * Deletes a generated template from the template generator.\n   *\n   * @param templateArn - The arn of the template to delete\n   * @returns A promise that resolves when the template has been deleted\n   */\n  async deleteGeneratedTemplate(templateArn: string): Promise<void> {\n    await this.cfn.deleteGeneratedTemplate({\n      GeneratedTemplateName: templateArn,\n    });\n  }\n}\n\n/**\n * The possible ways to choose a scan to generate a CDK application from\n */\nexport enum FromScan {\n  /**\n   * Initiate a new resource scan to build the CDK application from.\n   */\n  NEW,\n\n  /**\n   * Use the last successful scan to build the CDK application from. Will fail if no scan is found.\n   */\n  MOST_RECENT,\n\n  /**\n   * Starts a scan if none exists, otherwise uses the most recent successful scan to build the CDK application from.\n   */\n  DEFAULT,\n}\n\n/**\n * Interface for the options object passed to the generateTemplate function\n *\n * @param stackName - The name of the stack\n * @param filters - A list of filters to apply to the scan\n * @param fromScan - An enum value specifying whether a new scan should be started or the most recent successful scan should be used\n * @param sdkProvider - The sdk provider for making CloudFormation calls\n * @param environment - The account and region where the stack is deployed\n */\nexport interface GenerateTemplateOptions {\n  stackName: string;\n  filters?: string[];\n  fromScan?: FromScan;\n  sdkProvider: SdkProvider;\n  environment: Environment;\n  ioHelper: IoHelper;\n}\n\n/**\n * Interface for the output of the generateTemplate function\n *\n * @param migrateJson - The generated Migrate.json file\n * @param resources - The generated template\n */\nexport interface GenerateTemplateOutput {\n  migrateJson: MigrateJsonFormat;\n  resources?: ResourceDetail[];\n  templateId?: string;\n}\n\n/**\n * Interface defining the format of the generated Migrate.json file\n *\n * @param TemplateBody - The generated template\n * @param Source - The source of the template\n * @param Resources - A list of resources that were used to generate the template\n */\nexport interface MigrateJsonFormat {\n  templateBody: string;\n  source: string;\n  resources?: GeneratedResourceImportIdentifier[];\n}\n\n/**\n * Interface representing the format of a resource identifier required for resource import\n *\n * @param ResourceType - The type of resource\n * @param LogicalResourceId - The logical id of the resource\n * @param ResourceIdentifier - The resource identifier of the resource\n */\nexport interface GeneratedResourceImportIdentifier {\n  // cdk deploy expects the migrate.json resource identifiers to be PascalCase, not camelCase.\n  ResourceType: string;\n  LogicalResourceId: string;\n  ResourceIdentifier: ResourceIdentifierSummary;\n}\n"]}