@depup/aws-cdk 2.1117.0-depup.0

package/lib/commands/context.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextHandler = contextHandler;
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const chalk = require("chalk");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const picomatch = require("picomatch");
+const display_version_1 = require("../cli/display-version");
+const tables_1 = require("../cli/tables");
+const user_configuration_1 = require("../cli/user-configuration");
+async function contextHandler(options) {
+    const ioHelper = options.ioHelper;
+    if (options.clear) {
+        options.context.clear();
+        await options.context.save(user_configuration_1.PROJECT_CONTEXT);
+        await ioHelper.defaults.info('All context values cleared.');
+    }
+    else if (options.reset) {
+        await invalidateContext(ioHelper, options.context, options.reset, options.force ?? false);
+        await options.context.save(user_configuration_1.PROJECT_CONTEXT);
+    }
+    else {
+        // List -- support '--json' flag
+        if (options.json) {
+            /* c8 ignore start */
+            const contextValues = options.context.all;
+            await ioHelper.defaults.result(JSON.stringify(contextValues, undefined, 2));
+            /* c8 ignore stop */
+        }
+        else {
+            await listContext(ioHelper, options.context);
+        }
+    }
+    await (0, display_version_1.displayVersionMessage)(ioHelper);
+    return 0;
+}
+async function listContext(ioHelper, context) {
+    const keys = contextKeys(context);
+    if (keys.length === 0) {
+        await ioHelper.defaults.info('This CDK application does not have any saved context values yet.');
+        await ioHelper.defaults.info('');
+        await ioHelper.defaults.info('Context will automatically be saved when you synthesize CDK apps');
+        await ioHelper.defaults.info('that use environment context information like AZ information, VPCs,');
+        await ioHelper.defaults.info('SSM parameters, and so on.');
+        return;
+    }
+    // Print config by default
+    const data_out = [[chalk.green('#'), chalk.green('Key'), chalk.green('Value')]];
+    for (const [i, key] of keys) {
+        const jsonWithoutNewlines = JSON.stringify(context.all[key], undefined, 2).replace(/\s+/g, ' ');
+        data_out.push([i, key, jsonWithoutNewlines]);
+    }
+    await ioHelper.defaults.info('Context found in %s:', chalk.blue(user_configuration_1.PROJECT_CONFIG));
+    await ioHelper.defaults.info('');
+    await ioHelper.defaults.info((0, tables_1.renderTable)(data_out, process.stdout.columns));
+    // eslint-disable-next-line @stylistic/max-len
+    await ioHelper.defaults.info(`Run ${chalk.blue('cdk context --reset KEY_OR_NUMBER')} to remove a context key. It will be refreshed on the next CDK synthesis run.`);
+}
+async function invalidateContext(ioHelper, context, key, force) {
+    const i = parseInt(key, 10);
+    if (`${i}` === key) {
+        // was a number and we fully parsed it.
+        key = keyByNumber(context, i);
+    }
+    // Unset!
+    if (context.has(key)) {
+        context.unset(key);
+        // check if the value was actually unset.
+        if (!context.has(key)) {
+            await ioHelper.defaults.info('Context value %s reset. It will be refreshed on next synthesis', chalk.blue(key));
+            return;
+        }
+        // Value must be in readonly bag
+        await ioHelper.defaults.error('Only context values specified in %s can be reset through the CLI', chalk.blue(user_configuration_1.PROJECT_CONTEXT));
+        if (!force) {
+            throw new toolkit_lib_1.ToolkitError('ReadonlyContextKey', `Cannot reset readonly context value with key: ${key}`);
+        }
+    }
+    // check if value is expression matching keys
+    const matches = keysByExpression(context, key);
+    if (matches.length > 0) {
+        matches.forEach((match) => {
+            context.unset(match);
+        });
+        const { unset, readonly } = getUnsetAndReadonly(context, matches);
+        // output the reset values
+        await printUnset(ioHelper, unset);
+        // warn about values not reset
+        await printReadonly(ioHelper, readonly);
+        // throw when none of the matches were reset
+        if (!force && unset.length === 0) {
+            throw new toolkit_lib_1.ToolkitError('NoResettableContextValues', 'None of the matched context values could be reset');
+        }
+        return;
+    }
+    if (!force) {
+        throw new toolkit_lib_1.ToolkitError('ContextKeyNotFound', `No context value matching key: ${key}`);
+    }
+}
+async function printUnset(ioHelper, unset) {
+    if (unset.length === 0)
+        return;
+    await ioHelper.defaults.info('The following matched context values reset. They will be refreshed on next synthesis');
+    for (const match of unset) {
+        await ioHelper.defaults.info('  %s', match);
+    }
+}
+async function printReadonly(ioHelper, readonly) {
+    if (readonly.length === 0)
+        return;
+    await ioHelper.defaults.warn('The following matched context values could not be reset through the CLI');
+    for (const match of readonly) {
+        await ioHelper.defaults.info('  %s', match);
+    }
+    await ioHelper.defaults.info('');
+    await ioHelper.defaults.info('This usually means they are configured in %s or %s', chalk.blue(user_configuration_1.PROJECT_CONFIG), chalk.blue(user_configuration_1.USER_DEFAULTS));
+}
+function keysByExpression(context, expression) {
+    const matchesExpression = picomatch(expression);
+    return context.keys.filter(key => matchesExpression(key));
+}
+function getUnsetAndReadonly(context, matches) {
+    return matches.reduce((acc, match) => {
+        if (context.has(match)) {
+            acc.readonly.push(match);
+        }
+        else {
+            acc.unset.push(match);
+        }
+        return acc;
+    }, { unset: [], readonly: [] });
+}
+function keyByNumber(context, n) {
+    for (const [i, key] of contextKeys(context)) {
+        if (n === i) {
+            return key;
+        }
+    }
+    throw new toolkit_lib_1.ToolkitError('ContextKeyNumberNotFound', `No context key with number: ${n}`);
+}
+/**
+ * Return enumerated keys in a definitive order
+ */
+function contextKeys(context) {
+    const keys = context.keys;
+    keys.sort();
+    return enumerate1(keys);
+}
+function enumerate1(xs) {
+    const ret = new Array();
+    let i = 1;
+    for (const x of xs) {
+        ret.push([i, x]);
+        i += 1;
+    }
+    return ret;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context.js","sourceRoot":"","sources":["context.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport * as chalk from 'chalk';\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nimport picomatch = require('picomatch');\nimport type { Context } from '../api/context';\nimport type { IoHelper } from '../api-private';\nimport { displayVersionMessage } from '../cli/display-version';\nimport { renderTable } from '../cli/tables';\nimport { PROJECT_CONFIG, PROJECT_CONTEXT, USER_DEFAULTS } from '../cli/user-configuration';\n\n/**\n * Options for the context command\n */\nexport interface ContextOptions {\n  /**\n   * The context object sourced from all context locations\n   */\n  readonly context: Context;\n\n  /**\n   * The context key (or its index) to reset\n   *\n   * @default undefined\n   */\n  readonly reset?: string;\n\n  /**\n   * Ignore missing key error\n   *\n   * @default false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Clear all context\n   *\n   * @default false\n   */\n  readonly clear?: boolean;\n\n  /**\n   * Use JSON output instead of YAML when templates are printed to STDOUT\n   *\n   * @default false\n   */\n  readonly json?: boolean;\n\n  /**\n   * IoHelper for messaging.\n   */\n  readonly ioHelper: IoHelper;\n}\n\nexport async function contextHandler(options: ContextOptions): Promise<number> {\n  const ioHelper = options.ioHelper;\n\n  if (options.clear) {\n    options.context.clear();\n    await options.context.save(PROJECT_CONTEXT);\n    await ioHelper.defaults.info('All context values cleared.');\n  } else if (options.reset) {\n    await invalidateContext(ioHelper, options.context, options.reset, options.force ?? false);\n    await options.context.save(PROJECT_CONTEXT);\n  } else {\n    // List -- support '--json' flag\n    if (options.json) {\n      /* c8 ignore start */\n      const contextValues = options.context.all;\n      await ioHelper.defaults.result(JSON.stringify(contextValues, undefined, 2));\n      /* c8 ignore stop */\n    } else {\n      await listContext(ioHelper, options.context);\n    }\n  }\n  await displayVersionMessage(ioHelper);\n\n  return 0;\n}\n\nasync function listContext(ioHelper: IoHelper, context: Context) {\n  const keys = contextKeys(context);\n\n  if (keys.length === 0) {\n    await ioHelper.defaults.info('This CDK application does not have any saved context values yet.');\n    await ioHelper.defaults.info('');\n    await ioHelper.defaults.info('Context will automatically be saved when you synthesize CDK apps');\n    await ioHelper.defaults.info('that use environment context information like AZ information, VPCs,');\n    await ioHelper.defaults.info('SSM parameters, and so on.');\n\n    return;\n  }\n\n  // Print config by default\n  const data_out: any[] = [[chalk.green('#'), chalk.green('Key'), chalk.green('Value')]];\n  for (const [i, key] of keys) {\n    const jsonWithoutNewlines = JSON.stringify(context.all[key], undefined, 2).replace(/\\s+/g, ' ');\n    data_out.push([i, key, jsonWithoutNewlines]);\n  }\n  await ioHelper.defaults.info('Context found in %s:', chalk.blue(PROJECT_CONFIG));\n  await ioHelper.defaults.info('');\n  await ioHelper.defaults.info(renderTable(data_out, process.stdout.columns));\n\n  // eslint-disable-next-line @stylistic/max-len\n  await ioHelper.defaults.info(`Run ${chalk.blue('cdk context --reset KEY_OR_NUMBER')} to remove a context key. It will be refreshed on the next CDK synthesis run.`);\n}\n\nasync function invalidateContext(ioHelper: IoHelper, context: Context, key: string, force: boolean) {\n  const i = parseInt(key, 10);\n  if (`${i}` === key) {\n    // was a number and we fully parsed it.\n    key = keyByNumber(context, i);\n  }\n  // Unset!\n  if (context.has(key)) {\n    context.unset(key);\n    // check if the value was actually unset.\n    if (!context.has(key)) {\n      await ioHelper.defaults.info('Context value %s reset. It will be refreshed on next synthesis', chalk.blue(key));\n      return;\n    }\n\n    // Value must be in readonly bag\n    await ioHelper.defaults.error('Only context values specified in %s can be reset through the CLI', chalk.blue(PROJECT_CONTEXT));\n    if (!force) {\n      throw new ToolkitError('ReadonlyContextKey', `Cannot reset readonly context value with key: ${key}`);\n    }\n  }\n\n  // check if value is expression matching keys\n  const matches = keysByExpression(context, key);\n\n  if (matches.length > 0) {\n    matches.forEach((match) => {\n      context.unset(match);\n    });\n\n    const { unset, readonly } = getUnsetAndReadonly(context, matches);\n\n    // output the reset values\n    await printUnset(ioHelper, unset);\n\n    // warn about values not reset\n    await printReadonly(ioHelper, readonly);\n\n    // throw when none of the matches were reset\n    if (!force && unset.length === 0) {\n      throw new ToolkitError('NoResettableContextValues', 'None of the matched context values could be reset');\n    }\n    return;\n  }\n  if (!force) {\n    throw new ToolkitError('ContextKeyNotFound', `No context value matching key: ${key}`);\n  }\n}\n\nasync function printUnset(ioHelper: IoHelper, unset: string[]) {\n  if (unset.length === 0) return;\n  await ioHelper.defaults.info('The following matched context values reset. They will be refreshed on next synthesis');\n  for (const match of unset) {\n    await ioHelper.defaults.info('  %s', match);\n  }\n}\n\nasync function printReadonly(ioHelper: IoHelper, readonly: string[]) {\n  if (readonly.length === 0) return;\n  await ioHelper.defaults.warn('The following matched context values could not be reset through the CLI');\n  for (const match of readonly) {\n    await ioHelper.defaults.info('  %s', match);\n  }\n  await ioHelper.defaults.info('');\n  await ioHelper.defaults.info('This usually means they are configured in %s or %s', chalk.blue(PROJECT_CONFIG), chalk.blue(USER_DEFAULTS));\n}\n\nfunction keysByExpression(context: Context, expression: string) {\n  const matchesExpression = picomatch(expression);\n  return context.keys.filter(key => matchesExpression(key));\n}\n\nfunction getUnsetAndReadonly(context: Context, matches: string[]) {\n  return matches.reduce<{ unset: string[]; readonly: string[] }>((acc, match) => {\n    if (context.has(match)) {\n      acc.readonly.push(match);\n    } else {\n      acc.unset.push(match);\n    }\n    return acc;\n  }, { unset: [], readonly: [] });\n}\n\nfunction keyByNumber(context: Context, n: number) {\n  for (const [i, key] of contextKeys(context)) {\n    if (n === i) {\n      return key;\n    }\n  }\n  throw new ToolkitError('ContextKeyNumberNotFound', `No context key with number: ${n}`);\n}\n\n/**\n * Return enumerated keys in a definitive order\n */\nfunction contextKeys(context: Context): [number, string][] {\n  const keys = context.keys;\n  keys.sort();\n  return enumerate1(keys);\n}\n\nfunction enumerate1<T>(xs: T[]): Array<[number, T]> {\n  const ret = new Array<[number, T]>();\n  let i = 1;\n  for (const x of xs) {\n    ret.push([i, x]);\n    i += 1;\n  }\n  return ret;\n}\n"]}

package/lib/commands/deploy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Supported display modes for stack deployment activity
+ */
+export declare enum StackActivityProgress {
+    /**
+     * Displays a progress bar with only the events for the resource currently being deployed
+     */
+    BAR = "bar",
+    /**
+     * Displays complete history with all CloudFormation stack events
+     */
+    EVENTS = "events"
+}

package/lib/commands/deploy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StackActivityProgress = void 0;
+/**
+ * Supported display modes for stack deployment activity
+ */
+var StackActivityProgress;
+(function (StackActivityProgress) {
+    /**
+     * Displays a progress bar with only the events for the resource currently being deployed
+     */
+    StackActivityProgress["BAR"] = "bar";
+    /**
+     * Displays complete history with all CloudFormation stack events
+     */
+    StackActivityProgress["EVENTS"] = "events";
+})(StackActivityProgress || (exports.StackActivityProgress = StackActivityProgress = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZGVwbG95LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOztHQUVHO0FBQ0gsSUFBWSxxQkFVWDtBQVZELFdBQVkscUJBQXFCO0lBQy9COztPQUVHO0lBQ0gsb0NBQVcsQ0FBQTtJQUVYOztPQUVHO0lBQ0gsMENBQWlCLENBQUE7QUFDbkIsQ0FBQyxFQVZXLHFCQUFxQixxQ0FBckIscUJBQXFCLFFBVWhDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTdXBwb3J0ZWQgZGlzcGxheSBtb2RlcyBmb3Igc3RhY2sgZGVwbG95bWVudCBhY3Rpdml0eVxuICovXG5leHBvcnQgZW51bSBTdGFja0FjdGl2aXR5UHJvZ3Jlc3Mge1xuICAvKipcbiAgICogRGlzcGxheXMgYSBwcm9ncmVzcyBiYXIgd2l0aCBvbmx5IHRoZSBldmVudHMgZm9yIHRoZSByZXNvdXJjZSBjdXJyZW50bHkgYmVpbmcgZGVwbG95ZWRcbiAgICovXG4gIEJBUiA9ICdiYXInLFxuXG4gIC8qKlxuICAgKiBEaXNwbGF5cyBjb21wbGV0ZSBoaXN0b3J5IHdpdGggYWxsIENsb3VkRm9ybWF0aW9uIHN0YWNrIGV2ZW50c1xuICAgKi9cbiAgRVZFTlRTID0gJ2V2ZW50cycsXG59XG4iXX0=

package/lib/commands/docs.d.ts

@@ -0,0 +1,18 @@
+import type { IoHelper } from '../api-private';
+export declare const command = "docs";
+export declare const describe = "Opens the reference documentation in a browser";
+export declare const aliases: string[];
+/**
+ * Options for the docs command
+ */
+export interface DocsOptions {
+    /**
+     * The command to use to open the browser
+     */
+    readonly browser: string;
+    /**
+     * IoHelper for messaging
+     */
+    readonly ioHelper: IoHelper;
+}
+export declare function docs(options: DocsOptions): Promise<number>;

package/lib/commands/docs.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliases = exports.describe = exports.command = void 0;
+exports.docs = docs;
+const childProcess = require("child_process");
+const node_util_1 = require("node:util");
+const chalk = require("chalk");
+exports.command = 'docs';
+exports.describe = 'Opens the reference documentation in a browser';
+exports.aliases = ['doc'];
+async function docs(options) {
+    const ioHelper = options.ioHelper;
+    const url = 'https://docs.aws.amazon.com/cdk/api/v2/';
+    await ioHelper.defaults.info(chalk.green(url));
+    const browserCommand = (options.browser).replace(/%u/g, url);
+    await ioHelper.defaults.debug(`Opening documentation ${chalk.green(browserCommand)}`);
+    const exec = (0, node_util_1.promisify)(childProcess.exec);
+    try {
+        const { stdout, stderr } = await exec(browserCommand);
+        if (stdout) {
+            await ioHelper.defaults.debug(stdout);
+        }
+        if (stderr) {
+            await ioHelper.defaults.warn(stderr);
+        }
+    }
+    catch (err) {
+        const e = err;
+        await ioHelper.defaults.debug(`An error occurred when trying to open a browser: ${e.stack || e.message}`);
+    }
+    return 0;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { IoHelper } from '../api-private';
+export declare function doctor({ ioHelper }: {
+    ioHelper: IoHelper;
+}): Promise<number>;

package/lib/commands/doctor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+const process = require("process");
+const cxapi = require("@aws-cdk/cx-api");
+const chalk = require("chalk");
+const display_version_1 = require("../cli/display-version");
+const version_1 = require("../cli/version");
+async function doctor({ ioHelper }) {
+    let exitStatus = 0;
+    for (const verification of verifications) {
+        if (!await verification(ioHelper)) {
+            exitStatus = -1;
+        }
+    }
+    await (0, display_version_1.displayVersionMessage)(ioHelper);
+    return exitStatus;
+}
+const verifications = [
+    displayVersionInformation,
+    displayAwsEnvironmentVariables,
+    displayCdkEnvironmentVariables,
+];
+// ### Verifications ###
+async function displayVersionInformation(ioHelper) {
+    await ioHelper.defaults.info(`ℹ️ CDK Version: ${chalk.green((0, version_1.versionWithBuild)())}`);
+    return true;
+}
+async function displayAwsEnvironmentVariables(ioHelper) {
+    const keys = Object.keys(process.env).filter(s => s.startsWith('AWS_'));
+    if (keys.length === 0) {
+        await ioHelper.defaults.info('ℹ️ No AWS environment variables');
+        return true;
+    }
+    await ioHelper.defaults.info('ℹ️ AWS environment variables:');
+    for (const key of keys) {
+        await ioHelper.defaults.info(`  - ${chalk.blue(key)} = ${chalk.green(anonymizeAwsVariable(key, process.env[key]))}`);
+    }
+    return true;
+}
+async function displayCdkEnvironmentVariables(ioHelper) {
+    const keys = Object.keys(process.env).filter(s => s.startsWith('CDK_'));
+    if (keys.length === 0) {
+        await ioHelper.defaults.info('ℹ️ No CDK environment variables');
+        return true;
+    }
+    await ioHelper.defaults.info('ℹ️ CDK environment variables:');
+    let healthy = true;
+    for (const key of keys.sort()) {
+        if (key === cxapi.CONTEXT_ENV || key === cxapi.CONTEXT_OVERFLOW_LOCATION_ENV || key === cxapi.OUTDIR_ENV) {
+            await ioHelper.defaults.info(`  - ${chalk.red(key)} = ${chalk.green(process.env[key])} (⚠️ reserved for use by the CDK toolkit)`);
+            healthy = false;
+        }
+        else {
+            await ioHelper.defaults.info(`  - ${chalk.blue(key)} = ${chalk.green(process.env[key])}`);
+        }
+    }
+    return healthy;
+}
+function anonymizeAwsVariable(name, value) {
+    if (name === 'AWS_ACCESS_KEY_ID') {
+        return value.slice(0, 4) + '<redacted>';
+    } // Show ASIA/AKIA key type, but hide identifier
+    if (name === 'AWS_SECRET_ACCESS_KEY' || name === 'AWS_SESSION_TOKEN' || name === 'AWS_SECURITY_TOKEN') {
+        return '<redacted>';
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZG9jdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBT0Esd0JBU0M7QUFoQkQsbUNBQW1DO0FBQ25DLHlDQUF5QztBQUN6QywrQkFBK0I7QUFFL0IsNERBQStEO0FBQy9ELDRDQUFrRDtBQUUzQyxLQUFLLFVBQVUsTUFBTSxDQUFDLEVBQUUsUUFBUSxFQUEwQjtJQUMvRCxJQUFJLFVBQVUsR0FBVyxDQUFDLENBQUM7SUFDM0IsS0FBSyxNQUFNLFlBQVksSUFBSSxhQUFhLEVBQUUsQ0FBQztRQUN6QyxJQUFJLENBQUMsTUFBTSxZQUFZLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQztZQUNsQyxVQUFVLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDbEIsQ0FBQztJQUNILENBQUM7SUFDRCxNQUFNLElBQUEsdUNBQXFCLEVBQUMsUUFBUSxDQUFDLENBQUM7SUFDdEMsT0FBTyxVQUFVLENBQUM7QUFDcEIsQ0FBQztBQUVELE1BQU0sYUFBYSxHQUE4RDtJQUMvRSx5QkFBeUI7SUFDekIsOEJBQThCO0lBQzlCLDhCQUE4QjtDQUMvQixDQUFDO0FBRUYsd0JBQXdCO0FBRXhCLEtBQUssVUFBVSx5QkFBeUIsQ0FBQyxRQUFrQjtJQUN6RCxNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLG1CQUFtQixLQUFLLENBQUMsS0FBSyxDQUFDLElBQUEsMEJBQWdCLEdBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNuRixPQUFPLElBQUksQ0FBQztBQUNkLENBQUM7QUFFRCxLQUFLLFVBQVUsOEJBQThCLENBQUMsUUFBa0I7SUFDOUQsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0lBQ3hFLElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUN0QixNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7UUFDaEUsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBQ0QsTUFBTSxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO0lBQzlELEtBQUssTUFBTSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDdkIsTUFBTSxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sS0FBSyxDQUFDLEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3hILENBQUM7SUFDRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUM7QUFFRCxLQUFLLFVBQVUsOEJBQThCLENBQUMsUUFBa0I7SUFDOUQsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0lBQ3hFLElBQUksSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUN0QixNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7UUFDaEUsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBQ0QsTUFBTSxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO0lBQzlELElBQUksT0FBTyxHQUFHLElBQUksQ0FBQztJQUNuQixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDO1FBQzlCLElBQUksR0FBRyxLQUFLLEtBQUssQ0FBQyxXQUFXLElBQUksR0FBRyxLQUFLLEtBQUssQ0FBQyw2QkFBNkIsSUFBSSxHQUFHLEtBQUssS0FBSyxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ3pHLE1BQU0sUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxNQUFNLEtBQUssQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUUsQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO1lBQ25JLE9BQU8sR0FBRyxLQUFLLENBQUM7UUFDbEIsQ0FBQzthQUFNLENBQUM7WUFDTixNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxLQUFLLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDN0YsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDO0FBRUQsU0FBUyxvQkFBb0IsQ0FBQyxJQUFZLEVBQUUsS0FBYTtJQUN2RCxJQUFJLElBQUksS0FBSyxtQkFBbUIsRUFBRSxDQUFDO1FBQ2pDLE9BQU8sS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsWUFBWSxDQUFDO0lBQzFDLENBQUMsQ0FBQywrQ0FBK0M7SUFDakQsSUFBSSxJQUFJLEtBQUssdUJBQXVCLElBQUksSUFBSSxLQUFLLG1CQUFtQixJQUFJLElBQUksS0FBSyxvQkFBb0IsRUFBRSxDQUFDO1FBQ3RHLE9BQU8sWUFBWSxDQUFDO0lBQ3RCLENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwcm9jZXNzIGZyb20gJ3Byb2Nlc3MnO1xuaW1wb3J0ICogYXMgY3hhcGkgZnJvbSAnQGF3cy1jZGsvY3gtYXBpJztcbmltcG9ydCAqIGFzIGNoYWxrIGZyb20gJ2NoYWxrJztcbmltcG9ydCB0eXBlIHsgSW9IZWxwZXIgfSBmcm9tICcuLi9hcGktcHJpdmF0ZSc7XG5pbXBvcnQgeyBkaXNwbGF5VmVyc2lvbk1lc3NhZ2UgfSBmcm9tICcuLi9jbGkvZGlzcGxheS12ZXJzaW9uJztcbmltcG9ydCB7IHZlcnNpb25XaXRoQnVpbGQgfSBmcm9tICcuLi9jbGkvdmVyc2lvbic7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBkb2N0b3IoeyBpb0hlbHBlciB9OiB7IGlvSGVscGVyOiBJb0hlbHBlciB9KTogUHJvbWlzZTxudW1iZXI+IHtcbiAgbGV0IGV4aXRTdGF0dXM6IG51bWJlciA9IDA7XG4gIGZvciAoY29uc3QgdmVyaWZpY2F0aW9uIG9mIHZlcmlmaWNhdGlvbnMpIHtcbiAgICBpZiAoIWF3YWl0IHZlcmlmaWNhdGlvbihpb0hlbHBlcikpIHtcbiAgICAgIGV4aXRTdGF0dXMgPSAtMTtcbiAgICB9XG4gIH1cbiAgYXdhaXQgZGlzcGxheVZlcnNpb25NZXNzYWdlKGlvSGVscGVyKTtcbiAgcmV0dXJuIGV4aXRTdGF0dXM7XG59XG5cbmNvbnN0IHZlcmlmaWNhdGlvbnM6IEFycmF5PChpb0hlbHBlcjogSW9IZWxwZXIpID0+IGJvb2xlYW4gfCBQcm9taXNlPGJvb2xlYW4+PiA9IFtcbiAgZGlzcGxheVZlcnNpb25JbmZvcm1hdGlvbixcbiAgZGlzcGxheUF3c0Vudmlyb25tZW50VmFyaWFibGVzLFxuICBkaXNwbGF5Q2RrRW52aXJvbm1lbnRWYXJpYWJsZXMsXG5dO1xuXG4vLyAjIyMgVmVyaWZpY2F0aW9ucyAjIyNcblxuYXN5bmMgZnVuY3Rpb24gZGlzcGxheVZlcnNpb25JbmZvcm1hdGlvbihpb0hlbHBlcjogSW9IZWxwZXIpIHtcbiAgYXdhaXQgaW9IZWxwZXIuZGVmYXVsdHMuaW5mbyhg4oS577iPIENESyBWZXJzaW9uOiAke2NoYWxrLmdyZWVuKHZlcnNpb25XaXRoQnVpbGQoKSl9YCk7XG4gIHJldHVybiB0cnVlO1xufVxuXG5hc3luYyBmdW5jdGlvbiBkaXNwbGF5QXdzRW52aXJvbm1lbnRWYXJpYWJsZXMoaW9IZWxwZXI6IElvSGVscGVyKSB7XG4gIGNvbnN0IGtleXMgPSBPYmplY3Qua2V5cyhwcm9jZXNzLmVudikuZmlsdGVyKHMgPT4gcy5zdGFydHNXaXRoKCdBV1NfJykpO1xuICBpZiAoa2V5cy5sZW5ndGggPT09IDApIHtcbiAgICBhd2FpdCBpb0hlbHBlci5kZWZhdWx0cy5pbmZvKCfihLnvuI8gTm8gQVdTIGVudmlyb25tZW50IHZhcmlhYmxlcycpO1xuICAgIHJldHVybiB0cnVlO1xuICB9XG4gIGF3YWl0IGlvSGVscGVyLmRlZmF1bHRzLmluZm8oJ+KEue+4jyBBV1MgZW52aXJvbm1lbnQgdmFyaWFibGVzOicpO1xuICBmb3IgKGNvbnN0IGtleSBvZiBrZXlzKSB7XG4gICAgYXdhaXQgaW9IZWxwZXIuZGVmYXVsdHMuaW5mbyhgICAtICR7Y2hhbGsuYmx1ZShrZXkpfSA9ICR7Y2hhbGsuZ3JlZW4oYW5vbnltaXplQXdzVmFyaWFibGUoa2V5LCBwcm9jZXNzLmVudltrZXldISkpfWApO1xuICB9XG4gIHJldHVybiB0cnVlO1xufVxuXG5hc3luYyBmdW5jdGlvbiBkaXNwbGF5Q2RrRW52aXJvbm1lbnRWYXJpYWJsZXMoaW9IZWxwZXI6IElvSGVscGVyKSB7XG4gIGNvbnN0IGtleXMgPSBPYmplY3Qua2V5cyhwcm9jZXNzLmVudikuZmlsdGVyKHMgPT4gcy5zdGFydHNXaXRoKCdDREtfJykpO1xuICBpZiAoa2V5cy5sZW5ndGggPT09IDApIHtcbiAgICBhd2FpdCBpb0hlbHBlci5kZWZhdWx0cy5pbmZvKCfihLnvuI8gTm8gQ0RLIGVudmlyb25tZW50IHZhcmlhYmxlcycpO1xuICAgIHJldHVybiB0cnVlO1xuICB9XG4gIGF3YWl0IGlvSGVscGVyLmRlZmF1bHRzLmluZm8oJ+KEue+4jyBDREsgZW52aXJvbm1lbnQgdmFyaWFibGVzOicpO1xuICBsZXQgaGVhbHRoeSA9IHRydWU7XG4gIGZvciAoY29uc3Qga2V5IG9mIGtleXMuc29ydCgpKSB7XG4gICAgaWYgKGtleSA9PT0gY3hhcGkuQ09OVEVYVF9FTlYgfHwga2V5ID09PSBjeGFwaS5DT05URVhUX09WRVJGTE9XX0xPQ0FUSU9OX0VOViB8fCBrZXkgPT09IGN4YXBpLk9VVERJUl9FTlYpIHtcbiAgICAgIGF3YWl0IGlvSGVscGVyLmRlZmF1bHRzLmluZm8oYCAgLSAke2NoYWxrLnJlZChrZXkpfSA9ICR7Y2hhbGsuZ3JlZW4ocHJvY2Vzcy5lbnZba2V5XSEpfSAo4pqg77iPIHJlc2VydmVkIGZvciB1c2UgYnkgdGhlIENESyB0b29sa2l0KWApO1xuICAgICAgaGVhbHRoeSA9IGZhbHNlO1xuICAgIH0gZWxzZSB7XG4gICAgICBhd2FpdCBpb0hlbHBlci5kZWZhdWx0cy5pbmZvKGAgIC0gJHtjaGFsay5ibHVlKGtleSl9ID0gJHtjaGFsay5ncmVlbihwcm9jZXNzLmVudltrZXldISl9YCk7XG4gICAgfVxuICB9XG4gIHJldHVybiBoZWFsdGh5O1xufVxuXG5mdW5jdGlvbiBhbm9ueW1pemVBd3NWYXJpYWJsZShuYW1lOiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcpIHtcbiAgaWYgKG5hbWUgPT09ICdBV1NfQUNDRVNTX0tFWV9JRCcpIHtcbiAgICByZXR1cm4gdmFsdWUuc2xpY2UoMCwgNCkgKyAnPHJlZGFjdGVkPic7XG4gIH0gLy8gU2hvdyBBU0lBL0FLSUEga2V5IHR5cGUsIGJ1dCBoaWRlIGlkZW50aWZpZXJcbiAgaWYgKG5hbWUgPT09ICdBV1NfU0VDUkVUX0FDQ0VTU19LRVknIHx8IG5hbWUgPT09ICdBV1NfU0VTU0lPTl9UT0tFTicgfHwgbmFtZSA9PT0gJ0FXU19TRUNVUklUWV9UT0tFTicpIHtcbiAgICByZXR1cm4gJzxyZWRhY3RlZD4nO1xuICB9XG4gIHJldHVybiB2YWx1ZTtcbn1cbiJdfQ==

package/lib/commands/flags/flags.d.ts

@@ -0,0 +1,13 @@
+import type { FeatureFlag, Toolkit } from '@aws-cdk/toolkit-lib';
+import type { FlagOperationsParams } from './types';
+import type { IoHelper } from '../../api-private';
+export declare class FlagCommandHandler {
+    private readonly flags;
+    private readonly router;
+    private readonly options;
+    private readonly ioHelper;
+    /** Main component that sets up all flag operation components */
+    constructor(flagData: FeatureFlag[], ioHelper: IoHelper, options: FlagOperationsParams, toolkit: Toolkit, cliContextValues?: Record<string, any>);
+    /** Main entry point that processes the flags command */
+    processFlagsCommand(): Promise<void>;
+}

package/lib/commands/flags/flags.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagCommandHandler = void 0;
+const interactive_handler_1 = require("./interactive-handler");
+const obsolete_flags_1 = require("./obsolete-flags");
+const operations_1 = require("./operations");
+const router_1 = require("./router");
+const validator_1 = require("./validator");
+class FlagCommandHandler {
+    /** Main component that sets up all flag operation components */
+    constructor(flagData, ioHelper, options, toolkit, cliContextValues = {}) {
+        this.flags = flagData.filter(flag => !obsolete_flags_1.OBSOLETE_FLAGS.includes(flag.name));
+        this.options = { ...options, concurrency: options.concurrency ?? 4 };
+        this.ioHelper = ioHelper;
+        const validator = new validator_1.FlagValidator(ioHelper);
+        const flagOperations = new operations_1.FlagOperations(this.flags, toolkit, ioHelper, cliContextValues);
+        const interactiveHandler = new interactive_handler_1.InteractiveHandler(this.flags, flagOperations);
+        this.router = new router_1.FlagOperationRouter(validator, interactiveHandler, flagOperations);
+    }
+    /** Main entry point that processes the flags command */
+    async processFlagsCommand() {
+        if (this.flags.length === 0) {
+            await this.ioHelper.defaults.error('The \'cdk flags\' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');
+            return;
+        }
+        await this.router.route(this.options);
+    }
+}
+exports.FlagCommandHandler = FlagCommandHandler;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/flags/interactive-handler.d.ts

@@ -0,0 +1,16 @@
+import type { FeatureFlag } from '@aws-cdk/toolkit-lib';
+import type { FlagOperations } from './operations';
+import { type FlagOperationsParams } from './types';
+export declare class InteractiveHandler {
+    private readonly flags;
+    private readonly flagOperations;
+    constructor(flags: FeatureFlag[], flagOperations: FlagOperations);
+    /** Displays flags that have differences between user and recommended values */
+    private displayFlagsWithDifferences;
+    /** Checks if user value matches recommended value */
+    private isUserValueEqualToRecommended;
+    /** Main interactive mode handler that shows menu and processes user selection */
+    handleInteractiveMode(): Promise<FlagOperationsParams | null>;
+    /** Handles the specific flag selection flow with flag and value prompts */
+    private handleSpecificFlagSelection;
+}

package/lib/commands/flags/interactive-handler.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveHandler = void 0;
+// @ts-ignore
+const enquirer_1 = require("enquirer");
+const types_1 = require("./types");
+class InteractiveHandler {
+    constructor(flags, flagOperations) {
+        this.flags = flags;
+        this.flagOperations = flagOperations;
+    }
+    /** Displays flags that have differences between user and recommended values */
+    async displayFlagsWithDifferences() {
+        const flagsWithDifferences = this.flags.filter(flag => flag.userValue === undefined || !this.isUserValueEqualToRecommended(flag));
+        if (flagsWithDifferences.length > 0) {
+            await this.flagOperations.displayFlagTable(flagsWithDifferences);
+        }
+    }
+    /** Checks if user value matches recommended value */
+    isUserValueEqualToRecommended(flag) {
+        return String(flag.userValue) === String(flag.recommendedValue);
+    }
+    /** Main interactive mode handler that shows menu and processes user selection */
+    async handleInteractiveMode() {
+        await this.displayFlagsWithDifferences();
+        const prompt = new enquirer_1.Select({
+            name: 'option',
+            message: 'Menu',
+            choices: Object.values(types_1.FlagsMenuOptions),
+        });
+        const answer = await prompt.run();
+        switch (answer) {
+            case types_1.FlagsMenuOptions.ALL_TO_RECOMMENDED:
+                return { recommended: true, all: true, set: true };
+            case types_1.FlagsMenuOptions.UNCONFIGURED_TO_RECOMMENDED:
+                return { recommended: true, unconfigured: true, set: true };
+            case types_1.FlagsMenuOptions.UNCONFIGURED_TO_DEFAULT:
+                return { default: true, unconfigured: true, set: true };
+            case types_1.FlagsMenuOptions.MODIFY_SPECIFIC_FLAG:
+                return this.handleSpecificFlagSelection();
+            case types_1.FlagsMenuOptions.EXIT:
+                return null;
+            default:
+                return null;
+        }
+    }
+    /** Handles the specific flag selection flow with flag and value prompts */
+    async handleSpecificFlagSelection() {
+        const booleanFlags = this.flags.filter(flag => this.flagOperations.isBooleanFlag(flag));
+        const flagPrompt = new enquirer_1.Select({
+            name: 'flag',
+            message: 'Select which flag you would like to modify:',
+            limit: 100,
+            choices: booleanFlags.map(flag => flag.name),
+        });
+        const selectedFlagName = await flagPrompt.run();
+        const valuePrompt = new enquirer_1.Select({
+            name: 'value',
+            message: 'Select a value:',
+            choices: ['true', 'false'],
+        });
+        const value = await valuePrompt.run();
+        return {
+            FLAGNAME: [selectedFlagName],
+            value,
+            set: true,
+        };
+    }
+}
+exports.InteractiveHandler = InteractiveHandler;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/commands/flags/obsolete-flags.d.ts

@@ -0,0 +1 @@
+export declare const OBSOLETE_FLAGS: string[];

package/lib/commands/flags/obsolete-flags.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBSOLETE_FLAGS = void 0;
+exports.OBSOLETE_FLAGS = [
+    '@aws-cdk/core:enableStackNameDuplicates',
+    '@aws-cdk/aws-s3:grantWriteWithoutAcl',
+    '@aws-cdk/aws-kms:defaultKeyPolicies',
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2Jzb2xldGUtZmxhZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJvYnNvbGV0ZS1mbGFncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLGNBQWMsR0FBRztJQUM1Qix5Q0FBeUM7SUFDekMsc0NBQXNDO0lBQ3RDLHFDQUFxQztDQUN0QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE9CU09MRVRFX0ZMQUdTID0gW1xuICAnQGF3cy1jZGsvY29yZTplbmFibGVTdGFja05hbWVEdXBsaWNhdGVzJyxcbiAgJ0Bhd3MtY2RrL2F3cy1zMzpncmFudFdyaXRlV2l0aG91dEFjbCcsXG4gICdAYXdzLWNkay9hd3Mta21zOmRlZmF1bHRLZXlQb2xpY2llcycsXG5dO1xuIl19

package/lib/commands/flags/operations.d.ts

@@ -0,0 +1,80 @@
+import type { FeatureFlag, Toolkit } from '@aws-cdk/toolkit-lib';
+import type { FlagOperationsParams } from './types';
+import type { IoHelper } from '../../api-private';
+export declare class FlagOperations {
+    private readonly flags;
+    private readonly toolkit;
+    private readonly ioHelper;
+    private readonly cliContextValues;
+    /**
+     * Returns only those feature flags that need configuration
+     *
+     * That is those flags:
+     * - That are unconfigured
+     * - That are not obsolete
+     * - Whose default value is different from the recommended value
+     *
+     * The default value being equal to the recommended value sounds odd, but
+     * crops up in a number of situtations:
+     *
+     * - Security-related fixes that we want to force on people, but want to
+     *   give them a flag to back out of the changes if they really need to.
+     * - Flags that changed their default value in the most recent major
+     *   version.
+     * - Flags that we've introduced at some point in the past, but have gone
+     *   back on.
+     */
+    static filterNeedsAttention(flags: FeatureFlag[]): FeatureFlag[];
+    private app;
+    private baseContextValues;
+    private allStacks;
+    private queue;
+    private baselineTempDir?;
+    constructor(flags: FeatureFlag[], toolkit: Toolkit, ioHelper: IoHelper, cliContextValues?: Record<string, any>);
+    /** Main entry point that routes to either flag setting or display operations */
+    execute(params: FlagOperationsParams): Promise<void>;
+    /** Sets a single specific flag with validation and user confirmation */
+    setFlag(params: FlagOperationsParams): Promise<void>;
+    /** Sets multiple flags (all or unconfigured) with validation and user confirmation */
+    setMultipleFlags(params: FlagOperationsParams): Promise<void>;
+    /** Determines which flags should be set based on the provided parameters */
+    private getFlagsToSet;
+    /** Sets flags that don't cause template changes */
+    setSafeFlags(params: FlagOperationsParams): Promise<void>;
+    /** Initializes the safety check by reading context and synthesizing baseline templates */
+    private initializeSafetyCheck;
+    /** Cleans up temporary directories created during safety checks */
+    private cleanupSafetyCheck;
+    /** Tests multiple flags together and isolates unsafe ones using binary search */
+    private batchTestFlags;
+    /** Tests if a set of context values causes template changes by synthesizing and diffing */
+    private testBatch;
+    /** Uses binary search to isolate which flags are safe to set without template changes */
+    private isolateUnsafeFlags;
+    /** Prototypes flag changes by synthesizing templates and showing diffs to the user */
+    private prototypeChanges;
+    /** Displays a summary of flag changes showing old and new values */
+    private displayFlagChanges;
+    /** Builds the update object with new flag values based on parameters and current context */
+    private buildUpdateObject;
+    /** Prompts user for confirmation and applies changes if accepted */
+    private handleUserResponse;
+    /** Removes temporary directories created during flag operations */
+    private cleanupTempDirectories;
+    /** Actually modifies the cdk.json file with the new flag values */
+    private modifyValues;
+    /** Displays flags in a table format, either specific flags or filtered by criteria */
+    displayFlags(params: FlagOperationsParams): Promise<void>;
+    /** Displays detailed information for specific flags matching the given names */
+    private displaySpecificFlags;
+    /** Returns sort order for flags */
+    private getFlagSortOrder;
+    /** Displays flags in a formatted table grouped by module and sorted */
+    displayFlagTable(flags: FeatureFlag[]): Promise<void>;
+    /** Checks if a flag has a boolean recommended value */
+    isBooleanFlag(flag: FeatureFlag): boolean;
+    /** Shows helpful usage examples and available command options */
+    displayHelpMessage(): Promise<void>;
+}
+/** Checks if the flags current effective value matches the recommended value */
+export declare function isEffectiveValueEqualToRecommended(flag: FeatureFlag): boolean;