aws-cdk 2.1021.0 → 2.1022.0

package/lib/cli/telemetry/schema.d.ts

@@ -1,26 +1,37 @@
-interface Identifiers {
+interface SessionIdentifiers {
     readonly cdkCliVersion: string;
     readonly cdkLibraryVersion?: string;
     readonly telemetryVersion: string;
     readonly sessionId: string;
-    readonly eventId: string;
     readonly installationId: string;
-    readonly timestamp: string;
-    readonly accountId?: string;
     readonly region?: string;
 }
-interface Event {
-    readonly state: 'ABORTED' | 'FAILED' | 'SUCCEEDED';
-    readonly eventType: string;
-    readonly command: {
-        readonly path: string[];
-        readonly parameters: string[];
-        readonly config: {
-            [key: string]: any;
-        };
+export interface Identifiers extends SessionIdentifiers {
+    readonly eventId: string;
+    readonly timestamp: string;
+}
+type ConfigEntry = {
+    [key: string]: boolean;
+};
+export interface Command {
+    readonly path: string[];
+    readonly parameters: {
+        [key: string]: string;
+    };
+    readonly config: {
+        [key: string]: ConfigEntry;
     };
 }
-interface Environment {
+interface SessionEvent {
+    readonly command: Command;
+}
+export type EventType = 'SYNTH' | 'INVOKE' | 'DEPLOY';
+export type State = 'ABORTED' | 'FAILED' | 'SUCCEEDED';
+interface Event extends SessionEvent {
+    readonly state: State;
+    readonly eventType: EventType;
+}
+export interface SessionEnvironment {
     readonly os: {
         readonly platform: string;
         readonly release: string;
@@ -28,6 +39,8 @@ interface Environment {
     readonly ci: boolean;
     readonly nodeVersion: string;
 }
+interface Environment extends SessionEnvironment {
+}
 interface Duration {
     readonly total: number;
     readonly components?: {
@@ -37,19 +50,28 @@ interface Duration {
 type Counters = {
     [key: string]: number;
 };
-interface Error {
-    readonly name: string;
+export declare enum ErrorName {
+    TOOLKIT_ERROR = "ToolkitError",
+    AUTHENTICATION_ERROR = "AuthenticationError",
+    ASSEMBLY_ERROR = "AssemblyError",
+    CONTEXT_PROVIDER_ERROR = "ContextProviderError",
+    UNKNOWN_ERROR = "UnknownError"
+}
+export interface ErrorDetails {
+    readonly name: ErrorName;
     readonly message?: string;
-    readonly trace?: string;
+    readonly stackTrace?: string;
     readonly logs?: string;
 }
 interface Dependency {
     readonly name: string;
     readonly version: string;
 }
-interface Project {
+interface SessionProject {
     readonly dependencies?: Dependency[];
 }
+interface Project extends SessionProject {
+}
 export interface TelemetrySchema {
     readonly identifiers: Identifiers;
     readonly event: Event;
@@ -57,6 +79,12 @@ export interface TelemetrySchema {
     readonly project: Project;
     readonly duration: Duration;
     readonly counters?: Counters;
-    readonly error?: Error;
+    readonly error?: ErrorDetails;
+}
+export interface SessionSchema {
+    identifiers: SessionIdentifiers;
+    event: SessionEvent;
+    environment: SessionEnvironment;
+    project: SessionProject;
 }
 export {};

package/lib/cli/telemetry/schema.js

@@ -1,3 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+exports.ErrorName = void 0;
+var ErrorName;
+(function (ErrorName) {
+    ErrorName["TOOLKIT_ERROR"] = "ToolkitError";
+    ErrorName["AUTHENTICATION_ERROR"] = "AuthenticationError";
+    ErrorName["ASSEMBLY_ERROR"] = "AssemblyError";
+    ErrorName["CONTEXT_PROVIDER_ERROR"] = "ContextProviderError";
+    ErrorName["UNKNOWN_ERROR"] = "UnknownError";
+})(ErrorName || (exports.ErrorName = ErrorName = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/telemetry/session.d.ts

@@ -0,0 +1,33 @@
+import { type EventType, type ErrorDetails } from './schema';
+import type { ITelemetrySink } from './sink-interface';
+import type { Context } from '../../api/context';
+import type { CliIoHost } from '../io-host/cli-io-host';
+export interface TelemetrySessionProps {
+    readonly ioHost: CliIoHost;
+    readonly client: ITelemetrySink;
+    readonly arguments: any;
+    readonly context: Context;
+}
+export interface TelemetryEvent {
+    readonly eventType: EventType;
+    readonly duration: number;
+    readonly error?: ErrorDetails;
+}
+export declare class TelemetrySession {
+    private readonly props;
+    private ioHost;
+    private client;
+    private _sessionInfo?;
+    private span?;
+    private count;
+    constructor(props: TelemetrySessionProps);
+    begin(): Promise<void>;
+    attachRegion(region: string): Promise<void>;
+    /**
+     * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost
+     * and notifies with an optional error message in the data.
+     */
+    end(error?: ErrorDetails): Promise<void>;
+    emit(event: TelemetryEvent): Promise<void>;
+    private get sessionInfo();
+}

package/lib/cli/telemetry/session.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetrySession = void 0;
+const crypto_1 = require("crypto");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const installation_id_1 = require("./installation-id");
+const library_version_1 = require("./library-version");
+const sanitation_1 = require("./sanitation");
+const schema_1 = require("./schema");
+const ci_systems_1 = require("../ci-systems");
+const messages_1 = require("../telemetry/messages");
+const ci_1 = require("../util/ci");
+const version_1 = require("../version");
+const ABORTED_ERROR_MESSAGE = '__CDK-Toolkit__Aborted';
+class TelemetrySession {
+    constructor(props) {
+        this.props = props;
+        this.count = 0;
+        this.ioHost = props.ioHost;
+        this.client = props.client;
+    }
+    async begin() {
+        // sanitize the raw cli input
+        const { path, parameters } = (0, sanitation_1.sanitizeCommandLineArguments)(this.props.arguments);
+        this._sessionInfo = {
+            identifiers: {
+                installationId: await (0, installation_id_1.getOrCreateInstallationId)(this.ioHost.asIoHelper()),
+                sessionId: (0, crypto_1.randomUUID)(),
+                telemetryVersion: '1.0',
+                cdkCliVersion: (0, version_1.versionNumber)(),
+                cdkLibraryVersion: await (0, library_version_1.getLibraryVersion)(this.ioHost.asIoHelper()),
+            },
+            event: {
+                command: {
+                    path,
+                    parameters,
+                    config: {
+                        context: (0, sanitation_1.sanitizeContext)(this.props.context),
+                    },
+                },
+            },
+            environment: {
+                ci: (0, ci_1.isCI)() || Boolean((0, ci_systems_1.detectCiSystem)()),
+                os: {
+                    platform: process.platform,
+                    release: process.release.name,
+                },
+                nodeVersion: process.version,
+            },
+            project: {},
+        };
+        // If SIGINT has a listener installed, its default behavior will be removed (Node.js will no longer exit).
+        // This ensures that on SIGINT we process safely close the telemetry session before exiting.
+        process.on('SIGINT', async () => {
+            try {
+                await this.end({
+                    name: schema_1.ErrorName.TOOLKIT_ERROR,
+                    message: ABORTED_ERROR_MESSAGE,
+                });
+            }
+            catch (e) {
+                await this.ioHost.defaults.trace(`Ending Telemetry failed: ${e.message}`);
+            }
+            process.exit(1);
+        });
+        // Begin the session span
+        this.span = await this.ioHost.asIoHelper().span(messages_1.CLI_PRIVATE_SPAN.COMMAND).begin({});
+    }
+    async attachRegion(region) {
+        this.sessionInfo.identifiers = {
+            ...this.sessionInfo.identifiers,
+            region,
+        };
+    }
+    /**
+     * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost
+     * and notifies with an optional error message in the data.
+     */
+    async end(error) {
+        await this.span?.end({ error });
+        // Ideally span.end() should no-op if called twice, but that is not the case right now
+        this.span = undefined;
+        await this.client.flush();
+    }
+    async emit(event) {
+        this.count += 1;
+        return this.client.emit({
+            event: {
+                command: this.sessionInfo.event.command,
+                state: getState(event.error),
+                eventType: event.eventType,
+            },
+            identifiers: {
+                ...this.sessionInfo.identifiers,
+                eventId: `${this.sessionInfo.identifiers.sessionId}:${this.count}`,
+                timestamp: new Date().toISOString(),
+            },
+            environment: this.sessionInfo.environment,
+            project: this.sessionInfo.project,
+            duration: {
+                total: event.duration,
+            },
+            ...(event.error ? {
+                error: {
+                    name: event.error.name,
+                },
+            } : {}),
+        });
+    }
+    get sessionInfo() {
+        if (!this._sessionInfo) {
+            throw new toolkit_lib_1.ToolkitError('Session Info not initialized. Call begin() first.');
+        }
+        return this._sessionInfo;
+    }
+}
+exports.TelemetrySession = TelemetrySession;
+function getState(error) {
+    if (error) {
+        return isAbortedError(error) ? 'ABORTED' : 'FAILED';
+    }
+    return 'SUCCEEDED';
+}
+function isAbortedError(error) {
+    if (error?.name === 'ToolkitError' && error?.message?.includes(ABORTED_ERROR_MESSAGE)) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["session.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AACpC,sDAAoD;AACpD,uDAA8D;AAC9D,uDAAsD;AACtD,6CAA6E;AAC7E,qCAAwG;AAIxG,8CAA+C;AAG/C,oDAAyD;AACzD,mCAAkC;AAClC,wCAA2C;AAE3C,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAevD,MAAa,gBAAgB;IAO3B,YAA6B,KAA4B;QAA5B,UAAK,GAAL,KAAK,CAAuB;QAFjD,UAAK,GAAG,CAAC,CAAC;QAGhB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,6BAA6B;QAC7B,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,IAAA,yCAA4B,EAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChF,IAAI,CAAC,YAAY,GAAG;YAClB,WAAW,EAAE;gBACX,cAAc,EAAE,MAAM,IAAA,2CAAyB,EAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;gBACzE,SAAS,EAAE,IAAA,mBAAU,GAAE;gBACvB,gBAAgB,EAAE,KAAK;gBACvB,aAAa,EAAE,IAAA,uBAAa,GAAE;gBAC9B,iBAAiB,EAAE,MAAM,IAAA,mCAAiB,EAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;aACrE;YACD,KAAK,EAAE;gBACL,OAAO,EAAE;oBACP,IAAI;oBACJ,UAAU;oBACV,MAAM,EAAE;wBACN,OAAO,EAAE,IAAA,4BAAe,EAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;qBAC7C;iBACF;aACF;YACD,WAAW,EAAE;gBACX,EAAE,EAAE,IAAA,SAAI,GAAE,IAAI,OAAO,CAAC,IAAA,2BAAc,GAAE,CAAC;gBACvC,EAAE,EAAE;oBACF,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI;iBAC9B;gBACD,WAAW,EAAE,OAAO,CAAC,OAAO;aAC7B;YACD,OAAO,EAAE,EAAE;SACZ,CAAC;QAEF,0GAA0G;QAC1G,4FAA4F;QAC5F,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,GAAG,CAAC;oBACb,IAAI,EAAE,kBAAS,CAAC,aAAa;oBAC7B,OAAO,EAAE,qBAAqB;iBAC/B,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,CAAM,EAAE,CAAC;gBAChB,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;YAC5E,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,CAAC,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,2BAAgB,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACtF,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,MAAc;QACtC,IAAI,CAAC,WAAW,CAAC,WAAW,GAAG;YAC7B,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW;YAC/B,MAAM;SACP,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,GAAG,CAAC,KAAoB;QACnC,MAAM,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAChC,sFAAsF;QACtF,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,KAAqB;QACrC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;QAChB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACtB,KAAK,EAAE;gBACL,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO;gBACvC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;aAC3B;YACD,WAAW,EAAE;gBACX,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW;gBAC/B,OAAO,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,EAAE;gBAClE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;aACpC;YACD,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,WAAW;YACzC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;YACjC,QAAQ,EAAE;gBACR,KAAK,EAAE,KAAK,CAAC,QAAQ;aACtB;YACD,GAAG,CAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBACjB,KAAK,EAAE;oBACL,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI;iBACvB;aACF,CAAC,CAAC,CAAC,EAAE,CAAC;SACR,CAAC,CAAC;IACL,CAAC;IAED,IAAY,WAAW;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,IAAI,0BAAY,CAAC,mDAAmD,CAAC,CAAC;QAC9E,CAAC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF;AA/GD,4CA+GC;AAED,SAAS,QAAQ,CAAC,KAAoB;IACpC,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;IACtD,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED,SAAS,cAAc,CAAC,KAAoB;IAC1C,IAAI,KAAK,EAAE,IAAI,KAAK,cAAc,IAAI,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC;QACtF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import { randomUUID } from 'crypto';\nimport { ToolkitError } from '@aws-cdk/toolkit-lib';\nimport { getOrCreateInstallationId } from './installation-id';\nimport { getLibraryVersion } from './library-version';\nimport { sanitizeCommandLineArguments, sanitizeContext } from './sanitation';\nimport { type EventType, type SessionSchema, type State, type ErrorDetails, ErrorName } from './schema';\nimport type { ITelemetrySink } from './sink-interface';\nimport type { Context } from '../../api/context';\nimport type { IMessageSpan } from '../../api-private';\nimport { detectCiSystem } from '../ci-systems';\nimport type { CliIoHost } from '../io-host/cli-io-host';\nimport type { EventResult } from '../telemetry/messages';\nimport { CLI_PRIVATE_SPAN } from '../telemetry/messages';\nimport { isCI } from '../util/ci';\nimport { versionNumber } from '../version';\n\nconst ABORTED_ERROR_MESSAGE = '__CDK-Toolkit__Aborted';\n\nexport interface TelemetrySessionProps {\n  readonly ioHost: CliIoHost;\n  readonly client: ITelemetrySink;\n  readonly arguments: any;\n  readonly context: Context;\n}\n\nexport interface TelemetryEvent {\n  readonly eventType: EventType;\n  readonly duration: number;\n  readonly error?: ErrorDetails;\n}\n\nexport class TelemetrySession {\n  private ioHost: CliIoHost;\n  private client: ITelemetrySink;\n  private _sessionInfo?: SessionSchema;\n  private span?: IMessageSpan<EventResult>;\n  private count = 0;\n\n  constructor(private readonly props: TelemetrySessionProps) {\n    this.ioHost = props.ioHost;\n    this.client = props.client;\n  }\n\n  public async begin() {\n    // sanitize the raw cli input\n    const { path, parameters } = sanitizeCommandLineArguments(this.props.arguments);\n    this._sessionInfo = {\n      identifiers: {\n        installationId: await getOrCreateInstallationId(this.ioHost.asIoHelper()),\n        sessionId: randomUUID(),\n        telemetryVersion: '1.0',\n        cdkCliVersion: versionNumber(),\n        cdkLibraryVersion: await getLibraryVersion(this.ioHost.asIoHelper()),\n      },\n      event: {\n        command: {\n          path,\n          parameters,\n          config: {\n            context: sanitizeContext(this.props.context),\n          },\n        },\n      },\n      environment: {\n        ci: isCI() || Boolean(detectCiSystem()),\n        os: {\n          platform: process.platform,\n          release: process.release.name,\n        },\n        nodeVersion: process.version,\n      },\n      project: {},\n    };\n\n    // If SIGINT has a listener installed, its default behavior will be removed (Node.js will no longer exit).\n    // This ensures that on SIGINT we process safely close the telemetry session before exiting.\n    process.on('SIGINT', async () => {\n      try {\n        await this.end({\n          name: ErrorName.TOOLKIT_ERROR,\n          message: ABORTED_ERROR_MESSAGE,\n        });\n      } catch (e: any) {\n        await this.ioHost.defaults.trace(`Ending Telemetry failed: ${e.message}`);\n      }\n      process.exit(1);\n    });\n\n    // Begin the session span\n    this.span = await this.ioHost.asIoHelper().span(CLI_PRIVATE_SPAN.COMMAND).begin({});\n  }\n\n  public async attachRegion(region: string) {\n    this.sessionInfo.identifiers = {\n      ...this.sessionInfo.identifiers,\n      region,\n    };\n  }\n\n  /**\n   * When the command is complete, so is the CliIoHost. Ends the span of the entire CliIoHost\n   * and notifies with an optional error message in the data.\n   */\n  public async end(error?: ErrorDetails) {\n    await this.span?.end({ error });\n    // Ideally span.end() should no-op if called twice, but that is not the case right now\n    this.span = undefined;\n    await this.client.flush();\n  }\n\n  public async emit(event: TelemetryEvent): Promise<void> {\n    this.count += 1;\n    return this.client.emit({\n      event: {\n        command: this.sessionInfo.event.command,\n        state: getState(event.error),\n        eventType: event.eventType,\n      },\n      identifiers: {\n        ...this.sessionInfo.identifiers,\n        eventId: `${this.sessionInfo.identifiers.sessionId}:${this.count}`,\n        timestamp: new Date().toISOString(),\n      },\n      environment: this.sessionInfo.environment,\n      project: this.sessionInfo.project,\n      duration: {\n        total: event.duration,\n      },\n      ...( event.error ? {\n        error: {\n          name: event.error.name,\n        },\n      } : {}),\n    });\n  }\n\n  private get sessionInfo(): SessionSchema {\n    if (!this._sessionInfo) {\n      throw new ToolkitError('Session Info not initialized. Call begin() first.');\n    }\n    return this._sessionInfo;\n  }\n}\n\nfunction getState(error?: ErrorDetails): State {\n  if (error) {\n    return isAbortedError(error) ? 'ABORTED' : 'FAILED';\n  }\n  return 'SUCCEEDED';\n}\n\nfunction isAbortedError(error?: ErrorDetails) {\n  if (error?.name === 'ToolkitError' && error?.message?.includes(ABORTED_ERROR_MESSAGE)) {\n    return true;\n  }\n  return false;\n}\n"]}

package/lib/cli/user-input.d.ts

@@ -207,7 +207,7 @@ export interface GlobalOptions {
      */
     readonly ec2creds?: boolean;
     /**
-     * Include the "AWS::CDK::Metadata" resource in synthesized templates (enabled by default)
+     * Disable CLI telemetry and do not include the "AWS::CDK::Metadata" resource in synthesized templates (enabled by default)
      *
      * @default - undefined
      */
@@ -266,6 +266,12 @@ export interface GlobalOptions {
      * @default - []
      */
     readonly unstable?: Array<string>;
+    /**
+     * Send telemetry data to a local file.
+     *
+     * @default - undefined
+     */
+    readonly telemetryFile?: string;
 }
 /**
  * Lists all stacks in the app
@@ -1292,4 +1298,10 @@ export interface CliTelemetryOptions {
      * @default - undefined
      */
     readonly disable?: boolean;
+    /**
+     * Report telemetry opt-in/out status
+     *
+     * @default - undefined
+     */
+    readonly status?: boolean;
 }

package/lib/cli/user-input.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-input.js","sourceRoot":"","sources":["user-input.ts"],"names":[],"mappings":"","sourcesContent":["// -------------------------------------------------------------------------------------------\n// GENERATED FROM packages/aws-cdk/lib/cli/cli-config.ts.\n// Do not edit by hand; all changes will be overwritten at build time from the config file.\n// -------------------------------------------------------------------------------------------\n/* eslint-disable @stylistic/max-len, @typescript-eslint/consistent-type-imports */\nimport { Command } from './user-configuration';\n\n/**\n * The structure of the user input -- either CLI options or cdk.json -- generated from packages/aws-cdk/lib/config.ts\n *\n * @struct\n */\nexport interface UserInput {\n  /**\n   * The CLI command name\n   */\n  readonly command?: Command;\n\n  /**\n   * Global options available to all CLI commands\n   */\n  readonly globalOptions?: GlobalOptions;\n\n  /**\n   * Lists all stacks in the app\n   *\n   * aliases: ls\n   */\n  readonly list?: ListOptions;\n\n  /**\n   * Synthesizes and prints the CloudFormation template for this stack\n   *\n   * aliases: synthesize\n   */\n  readonly synth?: SynthOptions;\n\n  /**\n   * Deploys the CDK toolkit stack into an AWS environment\n   */\n  readonly bootstrap?: BootstrapOptions;\n\n  /**\n   * Garbage collect assets. Options detailed here: https://github.com/aws/aws-cdk-cli/tree/main/packages/aws-cdk#cdk-gc\n   */\n  readonly gc?: GcOptions;\n\n  /**\n   * View and toggle feature flags.\n   */\n  readonly flags?: {};\n\n  /**\n   * Deploys the stack(s) named STACKS into your AWS account\n   */\n  readonly deploy?: DeployOptions;\n\n  /**\n   * Rolls back the stack(s) named STACKS to their last stable state\n   */\n  readonly rollback?: RollbackOptions;\n\n  /**\n   * Import existing resource(s) into the given STACK\n   */\n  readonly import?: ImportOptions;\n\n  /**\n   * Shortcut for 'deploy --watch'\n   */\n  readonly watch?: WatchOptions;\n\n  /**\n   * Destroy the stack(s) named STACKS\n   */\n  readonly destroy?: DestroyOptions;\n\n  /**\n   * Compares the specified stack with the deployed stack or a local template file, and returns with status 1 if any difference is found\n   */\n  readonly diff?: DiffOptions;\n\n  /**\n   * Detect drifts in the given CloudFormation stack(s)\n   */\n  readonly drift?: DriftOptions;\n\n  /**\n   * Returns all metadata associated with this stack\n   */\n  readonly metadata?: MetadataOptions;\n\n  /**\n   * Acknowledge a notice so that it does not show up anymore\n   *\n   * aliases: ack\n   */\n  readonly acknowledge?: AcknowledgeOptions;\n\n  /**\n   * Returns a list of relevant notices\n   */\n  readonly notices?: NoticesOptions;\n\n  /**\n   * Create a new, empty CDK project from a template.\n   */\n  readonly init?: InitOptions;\n\n  /**\n   * Migrate existing AWS resources into a CDK app\n   */\n  readonly migrate?: MigrateOptions;\n\n  /**\n   * Manage cached context values\n   */\n  readonly context?: ContextOptions;\n\n  /**\n   * Opens the reference documentation in a browser\n   *\n   * aliases: doc\n   */\n  readonly docs?: DocsOptions;\n\n  /**\n   * Check your set-up for potential problems\n   */\n  readonly doctor?: {};\n\n  /**\n   * Moves resources between stacks or within the same stack\n   */\n  readonly refactor?: RefactorOptions;\n\n  /**\n   * Enable or disable anonymous telemetry\n   */\n  readonly cliTelemetry?: CliTelemetryOptions;\n}\n\n/**\n * Global options available to all CLI commands\n *\n * @struct\n */\nexport interface GlobalOptions {\n  /**\n   * REQUIRED WHEN RUNNING APP: command-line for executing your app or a cloud assembly directory (e.g. \"node bin/my-app.js\"). Can also be specified in cdk.json or ~/.cdk.json\n   *\n   * @default - undefined\n   */\n  readonly app?: string;\n\n  /**\n   * Command-line for a pre-synth build\n   *\n   * @default - undefined\n   */\n  readonly build?: string;\n\n  /**\n   * Add contextual string parameter (KEY=VALUE)\n   *\n   * @default - undefined\n   */\n  readonly context?: Array<string>;\n\n  /**\n   * Name or path of a node package that extend the CDK features. Can be specified multiple times\n   *\n   * @default - undefined\n   */\n  readonly plugin?: Array<string>;\n\n  /**\n   * Print trace for stack warnings\n   *\n   * @default - undefined\n   */\n  readonly trace?: boolean;\n\n  /**\n   * Do not construct stacks with warnings\n   *\n   * @default - undefined\n   */\n  readonly strict?: boolean;\n\n  /**\n   * Perform context lookups (synthesis fails if this is disabled and context lookups need to be performed)\n   *\n   * @default - true\n   */\n  readonly lookups?: boolean;\n\n  /**\n   * Ignores synthesis errors, which will likely produce an invalid output\n   *\n   * @default - false\n   */\n  readonly ignoreErrors?: 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   * Show debug logs (specify multiple times to increase verbosity)\n   *\n   * @default - false\n   */\n  readonly verbose?: number;\n\n  /**\n   * Debug the CDK app. Log additional information during synthesis, such as creation stack traces of tokens (sets CDK_DEBUG, will slow down synthesis)\n   *\n   * @default - false\n   */\n  readonly debug?: boolean;\n\n  /**\n   * Use the indicated AWS profile as the default environment\n   *\n   * @default - undefined\n   */\n  readonly profile?: string;\n\n  /**\n   * Use the indicated proxy. Will read from HTTPS_PROXY environment variable if not specified\n   *\n   * @default - undefined\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests. Will read from AWS_CA_BUNDLE environment variable if not specified\n   *\n   * @default - undefined\n   */\n  readonly caBundlePath?: string;\n\n  /**\n   * Force trying to fetch EC2 instance credentials. Default: guess EC2 instance status\n   *\n   * @default - undefined\n   */\n  readonly ec2creds?: boolean;\n\n  /**\n   * Include the \"AWS::CDK::Metadata\" resource in synthesized templates (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly versionReporting?: boolean;\n\n  /**\n   * Include \"aws:cdk:path\" CloudFormation metadata for each resource (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly pathMetadata?: boolean;\n\n  /**\n   * Include \"aws:asset:*\" CloudFormation metadata for resources that uses assets (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly assetMetadata?: boolean;\n\n  /**\n   * ARN of Role to use when invoking CloudFormation\n   *\n   * @default - undefined\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Copy assets to the output directory (use --no-staging to disable the copy of assets which allows local debugging via the SAM CLI to reference the original source files)\n   *\n   * @default - true\n   */\n  readonly staging?: boolean;\n\n  /**\n   * Emits the synthesized cloud assembly into a directory (default: cdk.out)\n   *\n   * @default - undefined\n   */\n  readonly output?: string;\n\n  /**\n   * Show relevant notices\n   *\n   * @default - undefined\n   */\n  readonly notices?: boolean;\n\n  /**\n   * Removes colors and other style from console output\n   *\n   * @default - false\n   */\n  readonly noColor?: boolean;\n\n  /**\n   * Force CI detection. If CI=true then logs will be sent to stdout instead of stderr\n   *\n   * @default - undefined\n   */\n  readonly ci?: boolean;\n\n  /**\n   * Opt in to unstable features. The flag indicates that the scope and API of a feature might still change. Otherwise the feature is generally production ready and fully supported. Can be specified multiple times.\n   *\n   * @default - []\n   */\n  readonly unstable?: Array<string>;\n}\n\n/**\n * Lists all stacks in the app\n *\n * aliases: ls\n *\n * @struct\n */\nexport interface ListOptions {\n  /**\n   * Display environment information for each stack\n   *\n   * aliases: l\n   *\n   * @default - false\n   */\n  readonly long?: boolean;\n\n  /**\n   * Display stack dependency information for each stack\n   *\n   * aliases: d\n   *\n   * @default - false\n   */\n  readonly showDependencies?: boolean;\n\n  /**\n   * Positional argument for list\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Synthesizes and prints the CloudFormation template for this stack\n *\n * aliases: synthesize\n *\n * @struct\n */\nexport interface SynthOptions {\n  /**\n   * Only synthesize requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * After synthesis, validate stacks with the \"validateOnSynth\" attribute set (can also be controlled with CDK_VALIDATION)\n   *\n   * @default - true\n   */\n  readonly validation?: boolean;\n\n  /**\n   * Do not output CloudFormation Template to stdout\n   *\n   * aliases: q\n   *\n   * @default - false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Positional argument for synth\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Deploys the CDK toolkit stack into an AWS environment\n *\n * @struct\n */\nexport interface BootstrapOptions {\n  /**\n   * The name of the CDK toolkit bucket; bucket will be created and must not exist\n   *\n   * aliases: b toolkit-bucket-name\n   *\n   * @default - undefined\n   */\n  readonly bootstrapBucketName?: string;\n\n  /**\n   * AWS KMS master key ID used for the SSE-KMS encryption (specify AWS_MANAGED_KEY to use an AWS-managed key)\n   *\n   * @default - undefined\n   */\n  readonly bootstrapKmsKeyId?: string;\n\n  /**\n   * Use the example permissions boundary.\n   *\n   * aliases: epb\n   *\n   * @default - undefined\n   */\n  readonly examplePermissionsBoundary?: boolean;\n\n  /**\n   * Use the permissions boundary specified by name.\n   *\n   * aliases: cpb\n   *\n   * @default - undefined\n   */\n  readonly customPermissionsBoundary?: string;\n\n  /**\n   * Create a Customer Master Key (CMK) for the bootstrap bucket (you will be charged but can customize permissions, modern bootstrapping only)\n   *\n   * @default - undefined\n   */\n  readonly bootstrapCustomerKey?: boolean;\n\n  /**\n   * String which must be unique for each bootstrap stack. You must configure it on your CDK app if you change this from the default.\n   *\n   * @default - undefined\n   */\n  readonly qualifier?: string;\n\n  /**\n   * Block public access configuration on CDK toolkit bucket (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly publicAccessBlockConfiguration?: boolean;\n\n  /**\n   * Tags to add for the stack (KEY=VALUE)\n   *\n   * aliases: t\n   *\n   * @default - []\n   */\n  readonly tags?: Array<string>;\n\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet)\n   *\n   * @default - true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * The AWS account IDs that should be trusted to perform deployments into this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly trust?: Array<string>;\n\n  /**\n   * The AWS account IDs that should be trusted to look up values in this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly trustForLookup?: Array<string>;\n\n  /**\n   * The AWS account IDs that should not be trusted by this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly untrust?: Array<string>;\n\n  /**\n   * The Managed Policy ARNs that should be attached to the role performing deployments into this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly cloudformationExecutionPolicies?: Array<string>;\n\n  /**\n   * Always bootstrap even if it would downgrade template version\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Toggle CloudFormation termination protection on the bootstrap stacks\n   *\n   * @default - undefined\n   */\n  readonly terminationProtection?: boolean;\n\n  /**\n   * Instead of actual bootstrapping, print the current CLI's bootstrapping template to stdout for customization\n   *\n   * @default - false\n   */\n  readonly showTemplate?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack to create\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Use the template from the given file instead of the built-in one (use --show-template to obtain an example)\n   *\n   * @default - undefined\n   */\n  readonly template?: string;\n\n  /**\n   * Use previous values for existing parameters (you must specify all parameters on every deployment if this is disabled)\n   *\n   * @default - true\n   */\n  readonly previousParameters?: boolean;\n\n  /**\n   * Positional argument for bootstrap\n   */\n  readonly ENVIRONMENTS?: Array<string>;\n}\n\n/**\n * Garbage collect assets. Options detailed here: https://github.com/aws/aws-cdk-cli/tree/main/packages/aws-cdk#cdk-gc\n *\n * @struct\n */\nexport interface GcOptions {\n  /**\n   * The action (or sub-action) you want to perform. Valid entires are \"print\", \"tag\", \"delete-tagged\", \"full\".\n   *\n   * @default - \"full\"\n   */\n  readonly action?: string;\n\n  /**\n   * Specify either ecr, s3, or all\n   *\n   * @default - \"all\"\n   */\n  readonly type?: string;\n\n  /**\n   * Delete assets that have been marked as isolated for this many days\n   *\n   * @default - 0\n   */\n  readonly rollbackBufferDays?: number;\n\n  /**\n   * Never delete assets younger than this (in days)\n   *\n   * @default - 1\n   */\n  readonly createdBufferDays?: number;\n\n  /**\n   * Confirm via manual prompt before deletion\n   *\n   * @default - true\n   */\n  readonly confirm?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack, if different from the default \"CDKToolkit\"\n   *\n   * @default - undefined\n   */\n  readonly bootstrapStackName?: string;\n\n  /**\n   * Positional argument for gc\n   */\n  readonly ENVIRONMENTS?: Array<string>;\n}\n\n/**\n * Deploys the stack(s) named STACKS into your AWS account\n *\n * @struct\n */\nexport interface DeployOptions {\n  /**\n   * Deploy all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * Do not rebuild asset with the given ID. Can be specified multiple times\n   *\n   * aliases: E\n   *\n   * @default - []\n   */\n  readonly buildExclude?: Array<string>;\n\n  /**\n   * Only deploy requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * What security-sensitive changes need manual approval\n   *\n   * @default - undefined\n   */\n  readonly requireApproval?: string;\n\n  /**\n   * ARNs of SNS topics that CloudFormation will notify with stack related events. These will be added to ARNs specified with the 'notificationArns' stack property.\n   *\n   * @default - undefined\n   */\n  readonly notificationArns?: Array<string>;\n\n  /**\n   * Tags to add to the stack (KEY=VALUE), overrides tags from Cloud Assembly (deprecated)\n   *\n   * aliases: t\n   *\n   * @default - undefined\n   */\n  readonly tags?: Array<string>;\n\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet) (deprecated)\n   *\n   * @deprecated true\n   * @default - undefined\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create (only if method is not direct)\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * How to perform the deployment. Direct is a bit faster but lacks progress information\n   *\n   * aliases: m\n   *\n   * @default - undefined\n   */\n  readonly method?: string;\n\n  /**\n   * Indicates if the stack set imports resources that already exist.\n   *\n   * @default - false\n   */\n  readonly importExistingResources?: boolean;\n\n  /**\n   * Always deploy stack even if templates are identical\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Additional parameters passed to CloudFormation at deploy time (STACK:KEY=VALUE)\n   *\n   * @default - {}\n   */\n  readonly parameters?: Array<string>;\n\n  /**\n   * Path to file where stack outputs will be written as JSON\n   *\n   * aliases: O\n   *\n   * @default - undefined\n   */\n  readonly outputsFile?: string;\n\n  /**\n   * Use previous values for existing parameters (you must specify all parameters on every deployment if this is disabled)\n   *\n   * @default - true\n   */\n  readonly previousParameters?: boolean;\n\n  /**\n   * The name of the existing CDK toolkit stack (only used for app using legacy synthesis)\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Display mode for stack activity events\n   *\n   * @default - undefined\n   */\n  readonly progress?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, but does not fall back to a full deployment if that is not possible. Instead, changes to any non-hotswappable properties are ignored.Do not use this in production environments\n   *\n   * @default - undefined\n   */\n  readonly hotswap?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, which skips CloudFormation and updates the resources directly, and falls back to a full deployment if that is not possible. Do not use this in production environments\n   *\n   * @default - undefined\n   */\n  readonly hotswapFallback?: boolean;\n\n  /**\n   * Lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMinimumHealthyPercent?: string;\n\n  /**\n   * Upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMaximumHealthyPercent?: string;\n\n  /**\n   * Number of seconds to wait for a single service to reach stable state, where the desiredCount is equal to the runningCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsStabilizationTimeoutSeconds?: string;\n\n  /**\n   * Continuously observe the project files, and deploy the given stack(s) automatically when changes are detected. Implies --hotswap by default\n   *\n   * @default - undefined\n   */\n  readonly watch?: boolean;\n\n  /**\n   * Show CloudWatch log events from all resources in the selected Stacks in the terminal. 'true' by default, use --no-logs to turn off. Only in effect if specified alongside the '--watch' option\n   *\n   * @default - true\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   *\n   * @default - 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Whether to build/publish assets in parallel\n   *\n   * @default - undefined\n   */\n  readonly assetParallelism?: boolean;\n\n  /**\n   * Whether to build all assets before deploying the first stack (useful for failing Docker builds)\n   *\n   * @default - true\n   */\n  readonly assetPrebuild?: boolean;\n\n  /**\n   * Whether to deploy if the app contains no stacks\n   *\n   * @default - false\n   */\n  readonly ignoreNoStacks?: boolean;\n\n  /**\n   * Positional argument for deploy\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Rolls back the stack(s) named STACKS to their last stable state\n *\n * @struct\n */\nexport interface RollbackOptions {\n  /**\n   * Roll back all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack the environment is bootstrapped with\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Orphan all resources for which the rollback operation fails.\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * Whether to validate the bootstrap stack version. Defaults to 'true', disable with --no-validate-bootstrap-version.\n   *\n   * @default - undefined\n   */\n  readonly validateBootstrapVersion?: boolean;\n\n  /**\n   * Orphan the given resources, identified by their logical ID (can be specified multiple times)\n   *\n   * @default - []\n   */\n  readonly orphan?: Array<string>;\n\n  /**\n   * Positional argument for rollback\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Import existing resource(s) into the given STACK\n *\n * @struct\n */\nexport interface ImportOptions {\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet)\n   *\n   * @default - true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * The name of the CDK toolkit stack to create\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Do not abort if the template diff includes updates or deletes. This is probably safe but we're not sure, let us know how it goes.\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * If specified, CDK will generate a mapping of existing physical resources to CDK resources to be imported as. The mapping will be written in the given file path. No actual import operation will be performed\n   *\n   * aliases: r\n   *\n   * @default - undefined\n   */\n  readonly recordResourceMapping?: string;\n\n  /**\n   * If specified, CDK will use the given file to map physical resources to CDK resources for import, instead of interactively asking the user. Can be run from scripts\n   *\n   * aliases: m\n   *\n   * @default - undefined\n   */\n  readonly resourceMapping?: string;\n\n  /**\n   * Positional argument for import\n   */\n  readonly STACK?: string;\n}\n\n/**\n * Shortcut for 'deploy --watch'\n *\n * @struct\n */\nexport interface WatchOptions {\n  /**\n   * Do not rebuild asset with the given ID. Can be specified multiple times\n   *\n   * aliases: E\n   *\n   * @default - []\n   */\n  readonly buildExclude?: Array<string>;\n\n  /**\n   * Only deploy requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * Always deploy stack even if templates are identical\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * The name of the existing CDK toolkit stack (only used for app using legacy synthesis)\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Display mode for stack activity events\n   *\n   * @default - undefined\n   */\n  readonly progress?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, but does not fall back to a full deployment if that is not possible. Instead, changes to any non-hotswappable properties are ignored.'true' by default, use --no-hotswap to turn off\n   *\n   * @default - undefined\n   */\n  readonly hotswap?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, which skips CloudFormation and updates the resources directly, and falls back to a full deployment if that is not possible.\n   *\n   * @default - undefined\n   */\n  readonly hotswapFallback?: boolean;\n\n  /**\n   * Lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMinimumHealthyPercent?: string;\n\n  /**\n   * Upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMaximumHealthyPercent?: string;\n\n  /**\n   * Number of seconds to wait for a single service to reach stable state, where the desiredCount is equal to the runningCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsStabilizationTimeoutSeconds?: string;\n\n  /**\n   * Show CloudWatch log events from all resources in the selected Stacks in the terminal. 'true' by default, use --no-logs to turn off\n   *\n   * @default - true\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   *\n   * @default - 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Positional argument for watch\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Destroy the stack(s) named STACKS\n *\n * @struct\n */\nexport interface DestroyOptions {\n  /**\n   * Destroy all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * Only destroy requested stacks, don't include dependees\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Do not ask for confirmation before destroying the stacks\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * Positional argument for destroy\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Compares the specified stack with the deployed stack or a local template file, and returns with status 1 if any difference is found\n *\n * @struct\n */\nexport interface DiffOptions {\n  /**\n   * Only diff requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Number of context lines to include in arbitrary JSON diff rendering\n   *\n   * @default - 3\n   */\n  readonly contextLines?: number;\n\n  /**\n   * The path to the CloudFormation template to compare with\n   *\n   * @default - undefined\n   */\n  readonly template?: string;\n\n  /**\n   * Do not filter out AWS::CDK::Metadata resources, mangled non-ASCII characters, or the CheckBootstrapVersionRule\n   *\n   * @default - false\n   */\n  readonly strict?: boolean;\n\n  /**\n   * Only diff for broadened security changes\n   *\n   * @default - false\n   */\n  readonly securityOnly?: boolean;\n\n  /**\n   * Fail with exit code 1 in case of diff\n   *\n   * @default - undefined\n   */\n  readonly fail?: boolean;\n\n  /**\n   * Whether to compare against the template with Transforms already processed\n   *\n   * @default - false\n   */\n  readonly processed?: boolean;\n\n  /**\n   * Do not print stack name and default message when there is no diff to stdout\n   *\n   * aliases: q\n   *\n   * @default - false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Whether to create a changeset to analyze resource replacements. In this mode, diff will use the deploy role instead of the lookup role.\n   *\n   * aliases: changeset\n   *\n   * @default - true\n   */\n  readonly changeSet?: boolean;\n\n  /**\n   * Whether or not the change set imports resources that already exist\n   *\n   * @default - false\n   */\n  readonly importExistingResources?: boolean;\n\n  /**\n   * Whether to include moves in the diff\n   *\n   * @default - false\n   */\n  readonly includeMoves?: boolean;\n\n  /**\n   * Positional argument for diff\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Detect drifts in the given CloudFormation stack(s)\n *\n * @struct\n */\nexport interface DriftOptions {\n  /**\n   * Fail with exit code 1 if drift is detected\n   *\n   * @default - undefined\n   */\n  readonly fail?: boolean;\n\n  /**\n   * Positional argument for drift\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Returns all metadata associated with this stack\n *\n * @struct\n */\nexport interface MetadataOptions {\n  /**\n   * Positional argument for metadata\n   */\n  readonly STACK?: string;\n}\n\n/**\n * Acknowledge a notice so that it does not show up anymore\n *\n * aliases: ack\n *\n * @struct\n */\nexport interface AcknowledgeOptions {\n  /**\n   * Positional argument for acknowledge\n   */\n  readonly ID?: string;\n}\n\n/**\n * Returns a list of relevant notices\n *\n * @struct\n */\nexport interface NoticesOptions {\n  /**\n   * Returns a list of unacknowledged notices\n   *\n   * aliases: u\n   *\n   * @default - false\n   */\n  readonly unacknowledged?: boolean;\n}\n\n/**\n * Create a new, empty CDK project from a template.\n *\n * @struct\n */\nexport interface InitOptions {\n  /**\n   * The language to be used for the new project (default can be configured in ~/.cdk.json)\n   *\n   * aliases: l\n   *\n   * @default - undefined\n   */\n  readonly language?: string;\n\n  /**\n   * List the available templates\n   *\n   * @default - undefined\n   */\n  readonly list?: boolean;\n\n  /**\n   * If true, only generates project files, without executing additional operations such as setting up a git repo, installing dependencies or compiling the project\n   *\n   * @default - false\n   */\n  readonly generateOnly?: boolean;\n\n  /**\n   * The version of the CDK library (aws-cdk-lib) to initialize the project with. Defaults to the version that was current when this CLI was built.\n   *\n   * aliases: V\n   *\n   * @default - undefined\n   */\n  readonly libVersion?: string;\n\n  /**\n   * Positional argument for init\n   */\n  readonly TEMPLATE?: string;\n}\n\n/**\n * Migrate existing AWS resources into a CDK app\n *\n * @struct\n */\nexport interface MigrateOptions {\n  /**\n   * The name assigned to the stack created in the new project. The name of the app will be based off this name as well.\n   *\n   * aliases: n\n   *\n   * @default - undefined\n   */\n  readonly stackName?: string;\n\n  /**\n   * The language to be used for the new project\n   *\n   * aliases: l\n   *\n   * @default - \"typescript\"\n   */\n  readonly language?: string;\n\n  /**\n   * The account to retrieve the CloudFormation stack template from\n   *\n   * @default - undefined\n   */\n  readonly account?: string;\n\n  /**\n   * The region to retrieve the CloudFormation stack template from\n   *\n   * @default - undefined\n   */\n  readonly region?: string;\n\n  /**\n   * The path to the CloudFormation template to migrate. Use this for locally stored templates\n   *\n   * @default - undefined\n   */\n  readonly fromPath?: string;\n\n  /**\n   * Use this flag to retrieve the template for an existing CloudFormation stack\n   *\n   * @default - undefined\n   */\n  readonly fromStack?: boolean;\n\n  /**\n   * The output path for the migrated CDK app\n   *\n   * @default - undefined\n   */\n  readonly outputPath?: string;\n\n  /**\n   * Determines if a new scan should be created, or the last successful existing scan should be used\n   *  options are \"new\" or \"most-recent\"\n   *\n   * @default - undefined\n   */\n  readonly fromScan?: string;\n\n  /**\n   * Filters the resource scan based on the provided criteria in the following format: \"key1=value1,key2=value2\"\n   *  This field can be passed multiple times for OR style filtering:\n   *  filtering options:\n   *  resource-identifier: A key-value pair that identifies the target resource. i.e. {\"ClusterName\", \"myCluster\"}\n   *  resource-type-prefix: A string that represents a type-name prefix. i.e. \"AWS::DynamoDB::\"\n   *  tag-key: a string that matches resources with at least one tag with the provided key. i.e. \"myTagKey\"\n   *  tag-value: a string that matches resources with at least one tag with the provided value. i.e. \"myTagValue\"\n   *\n   * @default - undefined\n   */\n  readonly filter?: Array<string>;\n\n  /**\n   * Use this flag to zip the generated CDK app\n   *\n   * @default - undefined\n   */\n  readonly compress?: boolean;\n}\n\n/**\n * Manage cached context values\n *\n * @struct\n */\nexport interface ContextOptions {\n  /**\n   * The context key (or its index) to reset\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly reset?: string;\n\n  /**\n   * Ignore missing key error\n   *\n   * aliases: f\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/**\n * Opens the reference documentation in a browser\n *\n * aliases: doc\n *\n * @struct\n */\nexport interface DocsOptions {\n  /**\n   * the command to use to open the browser, using %u as a placeholder for the path of the file to open\n   *\n   * aliases: b\n   *\n   * @default - undefined\n   */\n  readonly browser?: string;\n}\n\n/**\n * Moves resources between stacks or within the same stack\n *\n * @struct\n */\nexport interface RefactorOptions {\n  /**\n   * Names of deployed stacks to be considered for resource comparison.\n   *\n   * @default - undefined\n   */\n  readonly additionalStackName?: Array<string>;\n\n  /**\n   * Do not perform any changes, just show what would be done\n   *\n   * @default - false\n   */\n  readonly dryRun?: boolean;\n\n  /**\n   * A file that declares overrides to be applied to the list of mappings computed by the CLI.\n   *\n   * @default - undefined\n   */\n  readonly overrideFile?: string;\n\n  /**\n   * If specified, the command will revert the refactor operation. This is only valid if a mapping file was provided.\n   *\n   * @default - false\n   */\n  readonly revert?: boolean;\n}\n\n/**\n * Enable or disable anonymous telemetry\n *\n * @struct\n */\nexport interface CliTelemetryOptions {\n  /**\n   * Enable anonymous telemetry\n   *\n   * @default - undefined\n   */\n  readonly enable?: boolean;\n\n  /**\n   * Disable anonymous telemetry\n   *\n   * @default - undefined\n   */\n  readonly disable?: boolean;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-input.js","sourceRoot":"","sources":["user-input.ts"],"names":[],"mappings":"","sourcesContent":["// -------------------------------------------------------------------------------------------\n// GENERATED FROM packages/aws-cdk/lib/cli/cli-config.ts.\n// Do not edit by hand; all changes will be overwritten at build time from the config file.\n// -------------------------------------------------------------------------------------------\n/* eslint-disable @stylistic/max-len, @typescript-eslint/consistent-type-imports */\nimport { Command } from './user-configuration';\n\n/**\n * The structure of the user input -- either CLI options or cdk.json -- generated from packages/aws-cdk/lib/config.ts\n *\n * @struct\n */\nexport interface UserInput {\n  /**\n   * The CLI command name\n   */\n  readonly command?: Command;\n\n  /**\n   * Global options available to all CLI commands\n   */\n  readonly globalOptions?: GlobalOptions;\n\n  /**\n   * Lists all stacks in the app\n   *\n   * aliases: ls\n   */\n  readonly list?: ListOptions;\n\n  /**\n   * Synthesizes and prints the CloudFormation template for this stack\n   *\n   * aliases: synthesize\n   */\n  readonly synth?: SynthOptions;\n\n  /**\n   * Deploys the CDK toolkit stack into an AWS environment\n   */\n  readonly bootstrap?: BootstrapOptions;\n\n  /**\n   * Garbage collect assets. Options detailed here: https://github.com/aws/aws-cdk-cli/tree/main/packages/aws-cdk#cdk-gc\n   */\n  readonly gc?: GcOptions;\n\n  /**\n   * View and toggle feature flags.\n   */\n  readonly flags?: {};\n\n  /**\n   * Deploys the stack(s) named STACKS into your AWS account\n   */\n  readonly deploy?: DeployOptions;\n\n  /**\n   * Rolls back the stack(s) named STACKS to their last stable state\n   */\n  readonly rollback?: RollbackOptions;\n\n  /**\n   * Import existing resource(s) into the given STACK\n   */\n  readonly import?: ImportOptions;\n\n  /**\n   * Shortcut for 'deploy --watch'\n   */\n  readonly watch?: WatchOptions;\n\n  /**\n   * Destroy the stack(s) named STACKS\n   */\n  readonly destroy?: DestroyOptions;\n\n  /**\n   * Compares the specified stack with the deployed stack or a local template file, and returns with status 1 if any difference is found\n   */\n  readonly diff?: DiffOptions;\n\n  /**\n   * Detect drifts in the given CloudFormation stack(s)\n   */\n  readonly drift?: DriftOptions;\n\n  /**\n   * Returns all metadata associated with this stack\n   */\n  readonly metadata?: MetadataOptions;\n\n  /**\n   * Acknowledge a notice so that it does not show up anymore\n   *\n   * aliases: ack\n   */\n  readonly acknowledge?: AcknowledgeOptions;\n\n  /**\n   * Returns a list of relevant notices\n   */\n  readonly notices?: NoticesOptions;\n\n  /**\n   * Create a new, empty CDK project from a template.\n   */\n  readonly init?: InitOptions;\n\n  /**\n   * Migrate existing AWS resources into a CDK app\n   */\n  readonly migrate?: MigrateOptions;\n\n  /**\n   * Manage cached context values\n   */\n  readonly context?: ContextOptions;\n\n  /**\n   * Opens the reference documentation in a browser\n   *\n   * aliases: doc\n   */\n  readonly docs?: DocsOptions;\n\n  /**\n   * Check your set-up for potential problems\n   */\n  readonly doctor?: {};\n\n  /**\n   * Moves resources between stacks or within the same stack\n   */\n  readonly refactor?: RefactorOptions;\n\n  /**\n   * Enable or disable anonymous telemetry\n   */\n  readonly cliTelemetry?: CliTelemetryOptions;\n}\n\n/**\n * Global options available to all CLI commands\n *\n * @struct\n */\nexport interface GlobalOptions {\n  /**\n   * REQUIRED WHEN RUNNING APP: command-line for executing your app or a cloud assembly directory (e.g. \"node bin/my-app.js\"). Can also be specified in cdk.json or ~/.cdk.json\n   *\n   * @default - undefined\n   */\n  readonly app?: string;\n\n  /**\n   * Command-line for a pre-synth build\n   *\n   * @default - undefined\n   */\n  readonly build?: string;\n\n  /**\n   * Add contextual string parameter (KEY=VALUE)\n   *\n   * @default - undefined\n   */\n  readonly context?: Array<string>;\n\n  /**\n   * Name or path of a node package that extend the CDK features. Can be specified multiple times\n   *\n   * @default - undefined\n   */\n  readonly plugin?: Array<string>;\n\n  /**\n   * Print trace for stack warnings\n   *\n   * @default - undefined\n   */\n  readonly trace?: boolean;\n\n  /**\n   * Do not construct stacks with warnings\n   *\n   * @default - undefined\n   */\n  readonly strict?: boolean;\n\n  /**\n   * Perform context lookups (synthesis fails if this is disabled and context lookups need to be performed)\n   *\n   * @default - true\n   */\n  readonly lookups?: boolean;\n\n  /**\n   * Ignores synthesis errors, which will likely produce an invalid output\n   *\n   * @default - false\n   */\n  readonly ignoreErrors?: 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   * Show debug logs (specify multiple times to increase verbosity)\n   *\n   * @default - false\n   */\n  readonly verbose?: number;\n\n  /**\n   * Debug the CDK app. Log additional information during synthesis, such as creation stack traces of tokens (sets CDK_DEBUG, will slow down synthesis)\n   *\n   * @default - false\n   */\n  readonly debug?: boolean;\n\n  /**\n   * Use the indicated AWS profile as the default environment\n   *\n   * @default - undefined\n   */\n  readonly profile?: string;\n\n  /**\n   * Use the indicated proxy. Will read from HTTPS_PROXY environment variable if not specified\n   *\n   * @default - undefined\n   */\n  readonly proxy?: string;\n\n  /**\n   * Path to CA certificate to use when validating HTTPS requests. Will read from AWS_CA_BUNDLE environment variable if not specified\n   *\n   * @default - undefined\n   */\n  readonly caBundlePath?: string;\n\n  /**\n   * Force trying to fetch EC2 instance credentials. Default: guess EC2 instance status\n   *\n   * @default - undefined\n   */\n  readonly ec2creds?: boolean;\n\n  /**\n   * Disable CLI telemetry and do not include the \"AWS::CDK::Metadata\" resource in synthesized templates (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly versionReporting?: boolean;\n\n  /**\n   * Include \"aws:cdk:path\" CloudFormation metadata for each resource (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly pathMetadata?: boolean;\n\n  /**\n   * Include \"aws:asset:*\" CloudFormation metadata for resources that uses assets (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly assetMetadata?: boolean;\n\n  /**\n   * ARN of Role to use when invoking CloudFormation\n   *\n   * @default - undefined\n   */\n  readonly roleArn?: string;\n\n  /**\n   * Copy assets to the output directory (use --no-staging to disable the copy of assets which allows local debugging via the SAM CLI to reference the original source files)\n   *\n   * @default - true\n   */\n  readonly staging?: boolean;\n\n  /**\n   * Emits the synthesized cloud assembly into a directory (default: cdk.out)\n   *\n   * @default - undefined\n   */\n  readonly output?: string;\n\n  /**\n   * Show relevant notices\n   *\n   * @default - undefined\n   */\n  readonly notices?: boolean;\n\n  /**\n   * Removes colors and other style from console output\n   *\n   * @default - false\n   */\n  readonly noColor?: boolean;\n\n  /**\n   * Force CI detection. If CI=true then logs will be sent to stdout instead of stderr\n   *\n   * @default - undefined\n   */\n  readonly ci?: boolean;\n\n  /**\n   * Opt in to unstable features. The flag indicates that the scope and API of a feature might still change. Otherwise the feature is generally production ready and fully supported. Can be specified multiple times.\n   *\n   * @default - []\n   */\n  readonly unstable?: Array<string>;\n\n  /**\n   * Send telemetry data to a local file.\n   *\n   * @default - undefined\n   */\n  readonly telemetryFile?: string;\n}\n\n/**\n * Lists all stacks in the app\n *\n * aliases: ls\n *\n * @struct\n */\nexport interface ListOptions {\n  /**\n   * Display environment information for each stack\n   *\n   * aliases: l\n   *\n   * @default - false\n   */\n  readonly long?: boolean;\n\n  /**\n   * Display stack dependency information for each stack\n   *\n   * aliases: d\n   *\n   * @default - false\n   */\n  readonly showDependencies?: boolean;\n\n  /**\n   * Positional argument for list\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Synthesizes and prints the CloudFormation template for this stack\n *\n * aliases: synthesize\n *\n * @struct\n */\nexport interface SynthOptions {\n  /**\n   * Only synthesize requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * After synthesis, validate stacks with the \"validateOnSynth\" attribute set (can also be controlled with CDK_VALIDATION)\n   *\n   * @default - true\n   */\n  readonly validation?: boolean;\n\n  /**\n   * Do not output CloudFormation Template to stdout\n   *\n   * aliases: q\n   *\n   * @default - false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Positional argument for synth\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Deploys the CDK toolkit stack into an AWS environment\n *\n * @struct\n */\nexport interface BootstrapOptions {\n  /**\n   * The name of the CDK toolkit bucket; bucket will be created and must not exist\n   *\n   * aliases: b toolkit-bucket-name\n   *\n   * @default - undefined\n   */\n  readonly bootstrapBucketName?: string;\n\n  /**\n   * AWS KMS master key ID used for the SSE-KMS encryption (specify AWS_MANAGED_KEY to use an AWS-managed key)\n   *\n   * @default - undefined\n   */\n  readonly bootstrapKmsKeyId?: string;\n\n  /**\n   * Use the example permissions boundary.\n   *\n   * aliases: epb\n   *\n   * @default - undefined\n   */\n  readonly examplePermissionsBoundary?: boolean;\n\n  /**\n   * Use the permissions boundary specified by name.\n   *\n   * aliases: cpb\n   *\n   * @default - undefined\n   */\n  readonly customPermissionsBoundary?: string;\n\n  /**\n   * Create a Customer Master Key (CMK) for the bootstrap bucket (you will be charged but can customize permissions, modern bootstrapping only)\n   *\n   * @default - undefined\n   */\n  readonly bootstrapCustomerKey?: boolean;\n\n  /**\n   * String which must be unique for each bootstrap stack. You must configure it on your CDK app if you change this from the default.\n   *\n   * @default - undefined\n   */\n  readonly qualifier?: string;\n\n  /**\n   * Block public access configuration on CDK toolkit bucket (enabled by default)\n   *\n   * @default - undefined\n   */\n  readonly publicAccessBlockConfiguration?: boolean;\n\n  /**\n   * Tags to add for the stack (KEY=VALUE)\n   *\n   * aliases: t\n   *\n   * @default - []\n   */\n  readonly tags?: Array<string>;\n\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet)\n   *\n   * @default - true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * The AWS account IDs that should be trusted to perform deployments into this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly trust?: Array<string>;\n\n  /**\n   * The AWS account IDs that should be trusted to look up values in this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly trustForLookup?: Array<string>;\n\n  /**\n   * The AWS account IDs that should not be trusted by this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly untrust?: Array<string>;\n\n  /**\n   * The Managed Policy ARNs that should be attached to the role performing deployments into this environment (may be repeated, modern bootstrapping only)\n   *\n   * @default - []\n   */\n  readonly cloudformationExecutionPolicies?: Array<string>;\n\n  /**\n   * Always bootstrap even if it would downgrade template version\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Toggle CloudFormation termination protection on the bootstrap stacks\n   *\n   * @default - undefined\n   */\n  readonly terminationProtection?: boolean;\n\n  /**\n   * Instead of actual bootstrapping, print the current CLI's bootstrapping template to stdout for customization\n   *\n   * @default - false\n   */\n  readonly showTemplate?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack to create\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Use the template from the given file instead of the built-in one (use --show-template to obtain an example)\n   *\n   * @default - undefined\n   */\n  readonly template?: string;\n\n  /**\n   * Use previous values for existing parameters (you must specify all parameters on every deployment if this is disabled)\n   *\n   * @default - true\n   */\n  readonly previousParameters?: boolean;\n\n  /**\n   * Positional argument for bootstrap\n   */\n  readonly ENVIRONMENTS?: Array<string>;\n}\n\n/**\n * Garbage collect assets. Options detailed here: https://github.com/aws/aws-cdk-cli/tree/main/packages/aws-cdk#cdk-gc\n *\n * @struct\n */\nexport interface GcOptions {\n  /**\n   * The action (or sub-action) you want to perform. Valid entires are \"print\", \"tag\", \"delete-tagged\", \"full\".\n   *\n   * @default - \"full\"\n   */\n  readonly action?: string;\n\n  /**\n   * Specify either ecr, s3, or all\n   *\n   * @default - \"all\"\n   */\n  readonly type?: string;\n\n  /**\n   * Delete assets that have been marked as isolated for this many days\n   *\n   * @default - 0\n   */\n  readonly rollbackBufferDays?: number;\n\n  /**\n   * Never delete assets younger than this (in days)\n   *\n   * @default - 1\n   */\n  readonly createdBufferDays?: number;\n\n  /**\n   * Confirm via manual prompt before deletion\n   *\n   * @default - true\n   */\n  readonly confirm?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack, if different from the default \"CDKToolkit\"\n   *\n   * @default - undefined\n   */\n  readonly bootstrapStackName?: string;\n\n  /**\n   * Positional argument for gc\n   */\n  readonly ENVIRONMENTS?: Array<string>;\n}\n\n/**\n * Deploys the stack(s) named STACKS into your AWS account\n *\n * @struct\n */\nexport interface DeployOptions {\n  /**\n   * Deploy all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * Do not rebuild asset with the given ID. Can be specified multiple times\n   *\n   * aliases: E\n   *\n   * @default - []\n   */\n  readonly buildExclude?: Array<string>;\n\n  /**\n   * Only deploy requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * What security-sensitive changes need manual approval\n   *\n   * @default - undefined\n   */\n  readonly requireApproval?: string;\n\n  /**\n   * ARNs of SNS topics that CloudFormation will notify with stack related events. These will be added to ARNs specified with the 'notificationArns' stack property.\n   *\n   * @default - undefined\n   */\n  readonly notificationArns?: Array<string>;\n\n  /**\n   * Tags to add to the stack (KEY=VALUE), overrides tags from Cloud Assembly (deprecated)\n   *\n   * aliases: t\n   *\n   * @default - undefined\n   */\n  readonly tags?: Array<string>;\n\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet) (deprecated)\n   *\n   * @deprecated true\n   * @default - undefined\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create (only if method is not direct)\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * How to perform the deployment. Direct is a bit faster but lacks progress information\n   *\n   * aliases: m\n   *\n   * @default - undefined\n   */\n  readonly method?: string;\n\n  /**\n   * Indicates if the stack set imports resources that already exist.\n   *\n   * @default - false\n   */\n  readonly importExistingResources?: boolean;\n\n  /**\n   * Always deploy stack even if templates are identical\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * Additional parameters passed to CloudFormation at deploy time (STACK:KEY=VALUE)\n   *\n   * @default - {}\n   */\n  readonly parameters?: Array<string>;\n\n  /**\n   * Path to file where stack outputs will be written as JSON\n   *\n   * aliases: O\n   *\n   * @default - undefined\n   */\n  readonly outputsFile?: string;\n\n  /**\n   * Use previous values for existing parameters (you must specify all parameters on every deployment if this is disabled)\n   *\n   * @default - true\n   */\n  readonly previousParameters?: boolean;\n\n  /**\n   * The name of the existing CDK toolkit stack (only used for app using legacy synthesis)\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Display mode for stack activity events\n   *\n   * @default - undefined\n   */\n  readonly progress?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, but does not fall back to a full deployment if that is not possible. Instead, changes to any non-hotswappable properties are ignored.Do not use this in production environments\n   *\n   * @default - undefined\n   */\n  readonly hotswap?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, which skips CloudFormation and updates the resources directly, and falls back to a full deployment if that is not possible. Do not use this in production environments\n   *\n   * @default - undefined\n   */\n  readonly hotswapFallback?: boolean;\n\n  /**\n   * Lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMinimumHealthyPercent?: string;\n\n  /**\n   * Upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMaximumHealthyPercent?: string;\n\n  /**\n   * Number of seconds to wait for a single service to reach stable state, where the desiredCount is equal to the runningCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsStabilizationTimeoutSeconds?: string;\n\n  /**\n   * Continuously observe the project files, and deploy the given stack(s) automatically when changes are detected. Implies --hotswap by default\n   *\n   * @default - undefined\n   */\n  readonly watch?: boolean;\n\n  /**\n   * Show CloudWatch log events from all resources in the selected Stacks in the terminal. 'true' by default, use --no-logs to turn off. Only in effect if specified alongside the '--watch' option\n   *\n   * @default - true\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   *\n   * @default - 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Whether to build/publish assets in parallel\n   *\n   * @default - undefined\n   */\n  readonly assetParallelism?: boolean;\n\n  /**\n   * Whether to build all assets before deploying the first stack (useful for failing Docker builds)\n   *\n   * @default - true\n   */\n  readonly assetPrebuild?: boolean;\n\n  /**\n   * Whether to deploy if the app contains no stacks\n   *\n   * @default - false\n   */\n  readonly ignoreNoStacks?: boolean;\n\n  /**\n   * Positional argument for deploy\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Rolls back the stack(s) named STACKS to their last stable state\n *\n * @struct\n */\nexport interface RollbackOptions {\n  /**\n   * Roll back all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * The name of the CDK toolkit stack the environment is bootstrapped with\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Orphan all resources for which the rollback operation fails.\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * Whether to validate the bootstrap stack version. Defaults to 'true', disable with --no-validate-bootstrap-version.\n   *\n   * @default - undefined\n   */\n  readonly validateBootstrapVersion?: boolean;\n\n  /**\n   * Orphan the given resources, identified by their logical ID (can be specified multiple times)\n   *\n   * @default - []\n   */\n  readonly orphan?: Array<string>;\n\n  /**\n   * Positional argument for rollback\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Import existing resource(s) into the given STACK\n *\n * @struct\n */\nexport interface ImportOptions {\n  /**\n   * Whether to execute ChangeSet (--no-execute will NOT execute the ChangeSet)\n   *\n   * @default - true\n   */\n  readonly execute?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * The name of the CDK toolkit stack to create\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Do not abort if the template diff includes updates or deletes. This is probably safe but we're not sure, let us know how it goes.\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * If specified, CDK will generate a mapping of existing physical resources to CDK resources to be imported as. The mapping will be written in the given file path. No actual import operation will be performed\n   *\n   * aliases: r\n   *\n   * @default - undefined\n   */\n  readonly recordResourceMapping?: string;\n\n  /**\n   * If specified, CDK will use the given file to map physical resources to CDK resources for import, instead of interactively asking the user. Can be run from scripts\n   *\n   * aliases: m\n   *\n   * @default - undefined\n   */\n  readonly resourceMapping?: string;\n\n  /**\n   * Positional argument for import\n   */\n  readonly STACK?: string;\n}\n\n/**\n * Shortcut for 'deploy --watch'\n *\n * @struct\n */\nexport interface WatchOptions {\n  /**\n   * Do not rebuild asset with the given ID. Can be specified multiple times\n   *\n   * aliases: E\n   *\n   * @default - []\n   */\n  readonly buildExclude?: Array<string>;\n\n  /**\n   * Only deploy requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Name of the CloudFormation change set to create\n   *\n   * @default - undefined\n   */\n  readonly changeSetName?: string;\n\n  /**\n   * Always deploy stack even if templates are identical\n   *\n   * aliases: f\n   *\n   * @default - false\n   */\n  readonly force?: boolean;\n\n  /**\n   * The name of the existing CDK toolkit stack (only used for app using legacy synthesis)\n   *\n   * @default - undefined\n   */\n  readonly toolkitStackName?: string;\n\n  /**\n   * Display mode for stack activity events\n   *\n   * @default - undefined\n   */\n  readonly progress?: string;\n\n  /**\n   * Rollback stack to stable state on failure. Defaults to 'true', iterate more rapidly with --no-rollback or -R. Note: do **not** disable this flag for deployments with resource replacements, as that will always fail\n   *\n   * @default - undefined\n   */\n  readonly rollback?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, but does not fall back to a full deployment if that is not possible. Instead, changes to any non-hotswappable properties are ignored.'true' by default, use --no-hotswap to turn off\n   *\n   * @default - undefined\n   */\n  readonly hotswap?: boolean;\n\n  /**\n   * Attempts to perform a 'hotswap' deployment, which skips CloudFormation and updates the resources directly, and falls back to a full deployment if that is not possible.\n   *\n   * @default - undefined\n   */\n  readonly hotswapFallback?: boolean;\n\n  /**\n   * Lower limit on the number of your service's tasks that must remain in the RUNNING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMinimumHealthyPercent?: string;\n\n  /**\n   * Upper limit on the number of your service's tasks that are allowed in the RUNNING or PENDING state during a deployment, as a percentage of the desiredCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsMaximumHealthyPercent?: string;\n\n  /**\n   * Number of seconds to wait for a single service to reach stable state, where the desiredCount is equal to the runningCount\n   *\n   * @default - undefined\n   */\n  readonly hotswapEcsStabilizationTimeoutSeconds?: string;\n\n  /**\n   * Show CloudWatch log events from all resources in the selected Stacks in the terminal. 'true' by default, use --no-logs to turn off\n   *\n   * @default - true\n   */\n  readonly logs?: boolean;\n\n  /**\n   * Maximum number of simultaneous deployments (dependency permitting) to execute.\n   *\n   * @default - 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Positional argument for watch\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Destroy the stack(s) named STACKS\n *\n * @struct\n */\nexport interface DestroyOptions {\n  /**\n   * Destroy all available stacks\n   *\n   * @default - false\n   */\n  readonly all?: boolean;\n\n  /**\n   * Only destroy requested stacks, don't include dependees\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Do not ask for confirmation before destroying the stacks\n   *\n   * aliases: f\n   *\n   * @default - undefined\n   */\n  readonly force?: boolean;\n\n  /**\n   * Positional argument for destroy\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Compares the specified stack with the deployed stack or a local template file, and returns with status 1 if any difference is found\n *\n * @struct\n */\nexport interface DiffOptions {\n  /**\n   * Only diff requested stacks, don't include dependencies\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly exclusively?: boolean;\n\n  /**\n   * Number of context lines to include in arbitrary JSON diff rendering\n   *\n   * @default - 3\n   */\n  readonly contextLines?: number;\n\n  /**\n   * The path to the CloudFormation template to compare with\n   *\n   * @default - undefined\n   */\n  readonly template?: string;\n\n  /**\n   * Do not filter out AWS::CDK::Metadata resources, mangled non-ASCII characters, or the CheckBootstrapVersionRule\n   *\n   * @default - false\n   */\n  readonly strict?: boolean;\n\n  /**\n   * Only diff for broadened security changes\n   *\n   * @default - false\n   */\n  readonly securityOnly?: boolean;\n\n  /**\n   * Fail with exit code 1 in case of diff\n   *\n   * @default - undefined\n   */\n  readonly fail?: boolean;\n\n  /**\n   * Whether to compare against the template with Transforms already processed\n   *\n   * @default - false\n   */\n  readonly processed?: boolean;\n\n  /**\n   * Do not print stack name and default message when there is no diff to stdout\n   *\n   * aliases: q\n   *\n   * @default - false\n   */\n  readonly quiet?: boolean;\n\n  /**\n   * Whether to create a changeset to analyze resource replacements. In this mode, diff will use the deploy role instead of the lookup role.\n   *\n   * aliases: changeset\n   *\n   * @default - true\n   */\n  readonly changeSet?: boolean;\n\n  /**\n   * Whether or not the change set imports resources that already exist\n   *\n   * @default - false\n   */\n  readonly importExistingResources?: boolean;\n\n  /**\n   * Whether to include moves in the diff\n   *\n   * @default - false\n   */\n  readonly includeMoves?: boolean;\n\n  /**\n   * Positional argument for diff\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Detect drifts in the given CloudFormation stack(s)\n *\n * @struct\n */\nexport interface DriftOptions {\n  /**\n   * Fail with exit code 1 if drift is detected\n   *\n   * @default - undefined\n   */\n  readonly fail?: boolean;\n\n  /**\n   * Positional argument for drift\n   */\n  readonly STACKS?: Array<string>;\n}\n\n/**\n * Returns all metadata associated with this stack\n *\n * @struct\n */\nexport interface MetadataOptions {\n  /**\n   * Positional argument for metadata\n   */\n  readonly STACK?: string;\n}\n\n/**\n * Acknowledge a notice so that it does not show up anymore\n *\n * aliases: ack\n *\n * @struct\n */\nexport interface AcknowledgeOptions {\n  /**\n   * Positional argument for acknowledge\n   */\n  readonly ID?: string;\n}\n\n/**\n * Returns a list of relevant notices\n *\n * @struct\n */\nexport interface NoticesOptions {\n  /**\n   * Returns a list of unacknowledged notices\n   *\n   * aliases: u\n   *\n   * @default - false\n   */\n  readonly unacknowledged?: boolean;\n}\n\n/**\n * Create a new, empty CDK project from a template.\n *\n * @struct\n */\nexport interface InitOptions {\n  /**\n   * The language to be used for the new project (default can be configured in ~/.cdk.json)\n   *\n   * aliases: l\n   *\n   * @default - undefined\n   */\n  readonly language?: string;\n\n  /**\n   * List the available templates\n   *\n   * @default - undefined\n   */\n  readonly list?: boolean;\n\n  /**\n   * If true, only generates project files, without executing additional operations such as setting up a git repo, installing dependencies or compiling the project\n   *\n   * @default - false\n   */\n  readonly generateOnly?: boolean;\n\n  /**\n   * The version of the CDK library (aws-cdk-lib) to initialize the project with. Defaults to the version that was current when this CLI was built.\n   *\n   * aliases: V\n   *\n   * @default - undefined\n   */\n  readonly libVersion?: string;\n\n  /**\n   * Positional argument for init\n   */\n  readonly TEMPLATE?: string;\n}\n\n/**\n * Migrate existing AWS resources into a CDK app\n *\n * @struct\n */\nexport interface MigrateOptions {\n  /**\n   * The name assigned to the stack created in the new project. The name of the app will be based off this name as well.\n   *\n   * aliases: n\n   *\n   * @default - undefined\n   */\n  readonly stackName?: string;\n\n  /**\n   * The language to be used for the new project\n   *\n   * aliases: l\n   *\n   * @default - \"typescript\"\n   */\n  readonly language?: string;\n\n  /**\n   * The account to retrieve the CloudFormation stack template from\n   *\n   * @default - undefined\n   */\n  readonly account?: string;\n\n  /**\n   * The region to retrieve the CloudFormation stack template from\n   *\n   * @default - undefined\n   */\n  readonly region?: string;\n\n  /**\n   * The path to the CloudFormation template to migrate. Use this for locally stored templates\n   *\n   * @default - undefined\n   */\n  readonly fromPath?: string;\n\n  /**\n   * Use this flag to retrieve the template for an existing CloudFormation stack\n   *\n   * @default - undefined\n   */\n  readonly fromStack?: boolean;\n\n  /**\n   * The output path for the migrated CDK app\n   *\n   * @default - undefined\n   */\n  readonly outputPath?: string;\n\n  /**\n   * Determines if a new scan should be created, or the last successful existing scan should be used\n   *  options are \"new\" or \"most-recent\"\n   *\n   * @default - undefined\n   */\n  readonly fromScan?: string;\n\n  /**\n   * Filters the resource scan based on the provided criteria in the following format: \"key1=value1,key2=value2\"\n   *  This field can be passed multiple times for OR style filtering:\n   *  filtering options:\n   *  resource-identifier: A key-value pair that identifies the target resource. i.e. {\"ClusterName\", \"myCluster\"}\n   *  resource-type-prefix: A string that represents a type-name prefix. i.e. \"AWS::DynamoDB::\"\n   *  tag-key: a string that matches resources with at least one tag with the provided key. i.e. \"myTagKey\"\n   *  tag-value: a string that matches resources with at least one tag with the provided value. i.e. \"myTagValue\"\n   *\n   * @default - undefined\n   */\n  readonly filter?: Array<string>;\n\n  /**\n   * Use this flag to zip the generated CDK app\n   *\n   * @default - undefined\n   */\n  readonly compress?: boolean;\n}\n\n/**\n * Manage cached context values\n *\n * @struct\n */\nexport interface ContextOptions {\n  /**\n   * The context key (or its index) to reset\n   *\n   * aliases: e\n   *\n   * @default - undefined\n   */\n  readonly reset?: string;\n\n  /**\n   * Ignore missing key error\n   *\n   * aliases: f\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/**\n * Opens the reference documentation in a browser\n *\n * aliases: doc\n *\n * @struct\n */\nexport interface DocsOptions {\n  /**\n   * the command to use to open the browser, using %u as a placeholder for the path of the file to open\n   *\n   * aliases: b\n   *\n   * @default - undefined\n   */\n  readonly browser?: string;\n}\n\n/**\n * Moves resources between stacks or within the same stack\n *\n * @struct\n */\nexport interface RefactorOptions {\n  /**\n   * Names of deployed stacks to be considered for resource comparison.\n   *\n   * @default - undefined\n   */\n  readonly additionalStackName?: Array<string>;\n\n  /**\n   * Do not perform any changes, just show what would be done\n   *\n   * @default - false\n   */\n  readonly dryRun?: boolean;\n\n  /**\n   * A file that declares overrides to be applied to the list of mappings computed by the CLI.\n   *\n   * @default - undefined\n   */\n  readonly overrideFile?: string;\n\n  /**\n   * If specified, the command will revert the refactor operation. This is only valid if a mapping file was provided.\n   *\n   * @default - false\n   */\n  readonly revert?: boolean;\n}\n\n/**\n * Enable or disable anonymous telemetry\n *\n * @struct\n */\nexport interface CliTelemetryOptions {\n  /**\n   * Enable anonymous telemetry\n   *\n   * @default - undefined\n   */\n  readonly enable?: boolean;\n\n  /**\n   * Disable anonymous telemetry\n   *\n   * @default - undefined\n   */\n  readonly disable?: boolean;\n\n  /**\n   * Report telemetry opt-in/out status\n   *\n   * @default - undefined\n   */\n  readonly status?: boolean;\n}\n"]}

package/lib/cli/util/ci.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns true if the current process is running in a CI environment
+ * @returns true if the current process is running in a CI environment
+ */
+export declare function isCI(): boolean;

package/lib/cli/util/ci.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = isCI;
+/**
+ * Returns true if the current process is running in a CI environment
+ * @returns true if the current process is running in a CI environment
+ */
+function isCI() {
+    return process.env.CI !== undefined && process.env.CI !== 'false' && process.env.CI !== '0';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLG9CQUVDO0FBTkQ7OztHQUdHO0FBQ0gsU0FBZ0IsSUFBSTtJQUNsQixPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRSxLQUFLLFNBQVMsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsS0FBSyxPQUFPLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLEtBQUssR0FBRyxDQUFDO0FBQzlGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJldHVybnMgdHJ1ZSBpZiB0aGUgY3VycmVudCBwcm9jZXNzIGlzIHJ1bm5pbmcgaW4gYSBDSSBlbnZpcm9ubWVudFxuICogQHJldHVybnMgdHJ1ZSBpZiB0aGUgY3VycmVudCBwcm9jZXNzIGlzIHJ1bm5pbmcgaW4gYSBDSSBlbnZpcm9ubWVudFxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNDSSgpOiBib29sZWFuIHtcbiAgcmV0dXJuIHByb2Nlc3MuZW52LkNJICE9PSB1bmRlZmluZWQgJiYgcHJvY2Vzcy5lbnYuQ0kgIT09ICdmYWxzZScgJiYgcHJvY2Vzcy5lbnYuQ0kgIT09ICcwJztcbn1cbiJdfQ==

package/lib/cli/util/yargs-helpers.d.ts

@@ -1,4 +1,4 @@
-export { isCI } from '../io-host';
+export { isCI } from '../util/ci';
 /**
  * yargs middleware to negate an option if a negative alias is provided
  * E.g. `-R` will imply `--rollback=false`