agent-claw: automated task changes

cdk/node_modules/aws-cdk/lib/cli/cdk-toolkit.d.ts

@@ -0,0 +1,715 @@
+import { RequireApproval } from '@aws-cdk/cloud-assembly-schema';
+import type { DeploymentMethod, DiagnoseOptions, PublishAssetsOptions, ToolkitOptions } from '@aws-cdk/toolkit-lib';
+import { Toolkit } from '@aws-cdk/toolkit-lib';
+import { CliIoHost } from './io-host';
+import type { Configuration } from './user-configuration';
+import type { IoHelper } from '../../lib/api-private';
+import { CloudWatchLogEventMonitor } from '../api';
+import type { SdkProvider } from '../api/aws-auth';
+import type { BootstrapEnvironmentOptions } from '../api/bootstrap';
+import type { Deployments } from '../api/deployments';
+import { type Tag } from '../api/tags';
+import { StackActivityProgress } from '../commands/deploy';
+import type { FromScan } from '../commands/migrate';
+import type { CloudAssembly, CloudExecutable, StackSelector } from '../cxapp';
+export interface CdkToolkitProps {
+    /**
+     * The Cloud Executable
+     */
+    cloudExecutable: CloudExecutable;
+    /**
+     * The provisioning engine used to apply changes to the cloud
+     */
+    deployments: Deployments;
+    /**
+     * The CliIoHost that's used for I/O operations
+     */
+    ioHost?: CliIoHost;
+    /**
+     * Name of the toolkit stack to use/deploy
+     *
+     * @default CDKToolkit
+     */
+    toolkitStackName?: string;
+    /**
+     * Whether to be verbose
+     *
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Don't stop on error metadata
+     *
+     * @default false
+     */
+    ignoreErrors?: boolean;
+    /**
+     * Treat warnings in metadata as errors
+     *
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * Application configuration (settings and context)
+     */
+    configuration: Configuration;
+    /**
+     * AWS object (used by synthesizer and contextprovider)
+     */
+    sdkProvider: SdkProvider;
+}
+/**
+ * When to build assets
+ */
+export declare enum AssetBuildTime {
+    /**
+     * Build all assets before deploying the first stack
+     *
+     * This is intended for expensive Docker image builds; so that if the Docker image build
+     * fails, no stacks are unnecessarily deployed (with the attendant wait time).
+     */
+    ALL_BEFORE_DEPLOY = "all-before-deploy",
+    /**
+     * Build assets just-in-time, before publishing
+     */
+    JUST_IN_TIME = "just-in-time"
+}
+/**
+ * Custom implementation of the public Toolkit to integrate with the legacy CdkToolkit
+ *
+ * This overwrites how an sdkProvider is acquired
+ * in favor of the one provided directly to CdkToolkit.
+ */
+declare class InternalToolkit extends Toolkit {
+    private readonly _sdkProvider;
+    constructor(sdkProvider: SdkProvider, options: Omit<ToolkitOptions, 'sdkConfig'>);
+}
+/**
+ * Toolkit logic
+ *
+ * The toolkit runs the `cloudExecutable` to obtain a cloud assembly and
+ * deploys applies them to `cloudFormation`.
+ */
+export declare class CdkToolkit {
+    private readonly props;
+    private ioHost;
+    private toolkitStackName;
+    private toolkit;
+    constructor(props: CdkToolkitProps);
+    metadata(stackName: string, json: boolean): Promise<void>;
+    acknowledge(noticeId: string): Promise<void>;
+    cliTelemetryStatus(args: any): Promise<void>;
+    cliTelemetry(enable: boolean): Promise<void>;
+    diff(options: DiffOptions): Promise<number>;
+    /**
+     * Try to create a diff changeset for the given stack.
+     * Returns undefined if the stack cannot be accessed and changeSetOnly is not set.
+     */
+    private tryCreateDiffChangeSet;
+    deploy(options: DeployOptions): Promise<void>;
+    /**
+     * Detect infrastructure drift for the given stack(s)
+     */
+    drift(options: DriftOptions): Promise<number>;
+    /**
+     * Diagnose errors
+     */
+    diagnose(options: DiagnoseOptions): Promise<number>;
+    /**
+     * Roll back the given stack or stacks.
+     */
+    rollback(options: RollbackOptions): Promise<void>;
+    publishAssets(options: PublishAssetsOptions): Promise<void>;
+    watch(options: WatchOptions): Promise<void>;
+    orphan(options: OrphanOptions): Promise<void>;
+    import(options: ImportOptions): Promise<void>;
+    destroy(options: DestroyOptions): Promise<void>;
+    list(selectors: string[], options?: {
+        long?: boolean;
+        json?: boolean;
+        showDeps?: boolean;
+    }): Promise<number>;
+    /**
+     * Synthesize the given set of stacks (called when the user runs 'cdk synth')
+     *
+     * INPUT: Stack names can be supplied using a glob filter. If no stacks are
+     * given, all stacks from the application are implicitly selected.
+     *
+     * OUTPUT: If more than one stack ends up being selected, an output directory
+     * should be supplied, where the templates will be written.
+     */
+    synth(stackNames: string[], exclusively: boolean, quiet: boolean, autoValidate?: boolean, json?: boolean): Promise<any>;
+    /**
+     * Bootstrap the CDK Toolkit stack in the accounts used by the specified stack(s).
+     *
+     * @param userEnvironmentSpecs - environment names that need to have toolkit support
+     *             provisioned, as a glob filter. If none is provided, all stacks are implicitly selected.
+     * @param options - The name, role ARN, bootstrapping parameters, etc. to be used for the CDK Toolkit stack.
+     */
+    bootstrap(userEnvironmentSpecs: string[], options: BootstrapEnvironmentOptions): Promise<void>;
+    /**
+     * Garbage collects assets from a CDK app's environment
+     * @param options - Options for Garbage Collection
+     */
+    garbageCollect(userEnvironmentSpecs: string[], options: GarbageCollectionOptions): Promise<void>;
+    private defineEnvironments;
+    /**
+     * Migrates a CloudFormation stack/template to a CDK app
+     * @param options - Options for CDK app creation
+     */
+    migrate(options: MigrateOptions): Promise<void>;
+    refactor(options: RefactorOptions): Promise<number>;
+    private selectStacksForList;
+    private selectStacksForDeploy;
+    private selectStacksForDiff;
+    private selectStacksForDestroy;
+    /**
+     * Validate the stacks for errors and warnings according to the CLI's current settings
+     */
+    private validateStacks;
+    private validateMetadataFailAt;
+    /**
+     * Validate that if a user specified a stack name there exists at least 1 stack selected
+     */
+    private validateStacksSelected;
+    /**
+     * Select a single stack by its name
+     */
+    private selectSingleStackByName;
+    assembly(cacheCloudAssembly?: boolean): Promise<CloudAssembly>;
+    private patternsArrayForWatch;
+    private invokeDeployFromWatch;
+    /**
+     * Remove the asset publishing and building from the work graph for assets that are already in place
+     */
+    private removePublishedAssets;
+}
+/**
+ * Options for the diff command
+ */
+export interface DiffOptions {
+    /**
+     * Stack names to diff
+     */
+    readonly stackNames: string[];
+    /**
+     * Name of the toolkit stack, if not the default name
+     *
+     * @default 'CDKToolkit'
+     */
+    readonly toolkitStackName?: string;
+    /**
+     * Only select the given stack
+     *
+     * @default false
+     */
+    readonly exclusively?: boolean;
+    /**
+     * Used a template from disk instead of from the server
+     *
+     * @default Use from the server
+     */
+    readonly templatePath?: string;
+    /**
+     * Strict diff mode
+     *
+     * @default false
+     */
+    readonly strict?: boolean;
+    /**
+     * How many lines of context to show in the diff
+     *
+     * @default 3
+     */
+    readonly contextLines?: number;
+    /**
+     * Whether to fail with exit code 1 in case of diff
+     *
+     * @default false
+     */
+    readonly fail?: boolean;
+    /**
+     * Only run diff on broadened security changes
+     *
+     * @default false
+     */
+    readonly securityOnly?: boolean;
+    /**
+     * Whether to run the diff against the template after the CloudFormation Transforms inside it have been executed
+     * (as opposed to the original template, the default, which contains the unprocessed Transforms).
+     *
+     * @default false
+     */
+    readonly compareAgainstProcessedTemplate?: boolean;
+    readonly quiet?: boolean;
+    /**
+     * Additional parameters for CloudFormation at diff time, used to create a change set
+     * @default {}
+     */
+    readonly parameters?: {
+        [name: string]: string | undefined;
+    };
+    /**
+     * How to compute the diff.
+     * - 'change-set': always use a changeset, fail if it cannot be created
+     * - 'template': skip changeset, compare templates directly
+     * - 'auto': try changeset, fall back to template on failure
+     *
+     * @default 'auto'
+     */
+    readonly method?: 'auto' | 'change-set' | 'template';
+    /**
+     * Whether or not the change set imports resources that already exist.
+     *
+     * @default false
+     */
+    readonly importExistingResources?: boolean;
+    /**
+     * Whether to include resource moves in the diff
+     *
+     * @default false
+     */
+    readonly includeMoves?: boolean;
+}
+interface CfnDeployOptions {
+    /**
+     * Criteria for selecting stacks to deploy
+     */
+    selector: StackSelector;
+    /**
+     * Name of the toolkit stack to use/deploy
+     *
+     * @default CDKToolkit
+     */
+    toolkitStackName?: string;
+    /**
+     * Role to pass to CloudFormation for deployment
+     */
+    roleArn?: string;
+    /**
+     * Deployment method
+     */
+    readonly deploymentMethod?: DeploymentMethod;
+    /**
+     * Display mode for stack deployment progress.
+     *
+     * @default - StackActivityProgress.Bar - stack events will be displayed for
+     *   the resource currently being deployed.
+     */
+    progress?: StackActivityProgress;
+    /**
+     * Rollback failed deployments
+     *
+     * @default true
+     */
+    readonly rollback?: boolean;
+}
+interface WatchOptions extends Omit<CfnDeployOptions, 'execute'> {
+    /**
+     * Only select the given stack
+     *
+     * @default false
+     */
+    exclusively?: boolean;
+    /**
+     * Reuse the assets with the given asset IDs
+     */
+    reuseAssets?: string[];
+    /**
+     * Always deploy, even if templates are identical.
+     * @default false
+     */
+    force?: boolean;
+    /**
+     * The extra string to append to the User-Agent header when performing AWS SDK calls.
+     *
+     * @default - nothing extra is appended to the User-Agent header
+     */
+    readonly extraUserAgent?: string;
+    /**
+     * Whether to show CloudWatch logs for hotswapped resources
+     * locally in the users terminal
+     *
+     * @default - false
+     */
+    readonly traceLogs?: boolean;
+    /**
+     * Maximum number of simultaneous deployments (dependency permitting) to execute.
+     * The default is '1', which executes all deployments serially.
+     *
+     * @default 1
+     */
+    readonly concurrency?: number;
+}
+export interface DeployOptions extends CfnDeployOptions, WatchOptions {
+    /**
+     * ARNs of SNS topics that CloudFormation will notify with stack related events
+     */
+    notificationArns?: string[];
+    /**
+     * What kind of security changes require approval
+     *
+     * @default RequireApproval.Broadening
+     */
+    requireApproval?: RequireApproval;
+    /**
+     * Tags to pass to CloudFormation for deployment
+     */
+    tags?: Tag[];
+    /**
+     * Additional parameters for CloudFormation at deploy time
+     * @default {}
+     */
+    parameters?: {
+        [name: string]: string | undefined;
+    };
+    /**
+     * Use previous values for unspecified parameters
+     *
+     * If not set, all parameters must be specified for every deployment.
+     *
+     * @default true
+     */
+    usePreviousParameters?: boolean;
+    /**
+     * Path to file where stack outputs will be written after a successful deploy as JSON
+     * @default - Outputs are not written to any file
+     */
+    outputsFile?: string;
+    /**
+     * Whether we are on a CI system
+     *
+     * @default false
+     */
+    readonly ci?: boolean;
+    /**
+     * Whether this 'deploy' command should actually delegate to the 'watch' command.
+     *
+     * @default false
+     */
+    readonly watch?: boolean;
+    /**
+     * Whether we should cache the Cloud Assembly after the first time it has been synthesized.
+     * The default is 'true', we only don't want to do it in case the deployment is triggered by
+     * 'cdk watch'.
+     *
+     * @default true
+     */
+    readonly cacheCloudAssembly?: boolean;
+    /**
+     * Allows adding CloudWatch log groups to the log monitor via
+     * cloudWatchLogMonitor.setLogGroups();
+     *
+     * @default - not monitoring CloudWatch logs
+     */
+    readonly cloudWatchLogMonitor?: CloudWatchLogEventMonitor;
+    /**
+     * Maximum number of simultaneous deployments (dependency permitting) to execute.
+     * The default is '1', which executes all deployments serially.
+     *
+     * @default 1
+     */
+    readonly concurrency?: number;
+    /**
+     * Build/publish assets for a single stack in parallel
+     *
+     * Independent of whether stacks are being done in parallel or no.
+     *
+     * @default true
+     */
+    readonly assetParallelism?: boolean;
+    /**
+     * Maximum number of asset builds to run in parallel
+     *
+     * This setting only has an effect if `assetParallelism` is set to `true`.
+     *
+     * @default 1
+     */
+    readonly assetBuildConcurrency?: number;
+    /**
+     * When to build assets
+     *
+     * The default is the Docker-friendly default.
+     *
+     * @default AssetBuildTime.ALL_BEFORE_DEPLOY
+     */
+    readonly assetBuildTime?: AssetBuildTime;
+    /**
+     * Whether to deploy if the app contains no stacks.
+     *
+     * @default false
+     */
+    readonly ignoreNoStacks?: boolean;
+}
+export interface RollbackOptions {
+    /**
+     * Criteria for selecting stacks to deploy
+     */
+    readonly selector: StackSelector;
+    /**
+     * Name of the toolkit stack to use/deploy
+     *
+     * @default CDKToolkit
+     */
+    readonly toolkitStackName?: string;
+    /**
+     * Role to pass to CloudFormation for deployment
+     *
+     * @default - Default stack role
+     */
+    readonly roleArn?: string;
+    /**
+     * Whether to force the rollback or not
+     *
+     * @default false
+     */
+    readonly force?: boolean;
+    /**
+     * Logical IDs of resources to orphan
+     *
+     * @default - No orphaning
+     */
+    readonly orphanLogicalIds?: string[];
+    /**
+     * Whether to validate the version of the bootstrap stack permissions
+     *
+     * @default true
+     */
+    readonly validateBootstrapStackVersion?: boolean;
+}
+export interface OrphanOptions {
+    readonly constructPath: string[];
+    readonly roleArn?: string;
+    readonly toolkitStackName?: string;
+}
+export interface ImportOptions extends CfnDeployOptions {
+    /**
+     * Build a physical resource mapping and write it to the given file, without performing the actual import operation
+     *
+     * @default - No file
+     */
+    readonly recordResourceMapping?: string;
+    /**
+     * Path to a file with the physical resource mapping to CDK constructs in JSON format
+     *
+     * @default - No mapping file
+     */
+    readonly resourceMappingFile?: string;
+    /**
+     * Inline JSON string with the physical resource mapping
+     *
+     * @default - No inline mapping
+     */
+    readonly resourceMappingInline?: string;
+    /**
+     * Allow non-addition changes to the template
+     *
+     * @default false
+     */
+    readonly force?: boolean;
+}
+export interface DestroyOptions {
+    /**
+     * Criteria for selecting stacks to deploy
+     */
+    selector: StackSelector;
+    /**
+     * Whether to exclude stacks that depend on the stacks to be deleted
+     */
+    exclusively: boolean;
+    /**
+     * Whether to skip prompting for confirmation
+     */
+    force: boolean;
+    /**
+     * The arn of the IAM role to use
+     */
+    roleArn?: string;
+    /**
+     * Whether the destroy request came from a deploy.
+     */
+    fromDeploy?: boolean;
+    /**
+     * Maximum number of simultaneous destroys (dependency permitting) to execute.
+     */
+    concurrency?: number;
+}
+/**
+ * Options for the garbage collection
+ */
+export interface GarbageCollectionOptions {
+    /**
+     * The action to perform.
+     *
+     * @default 'full'
+     */
+    readonly action: 'print' | 'tag' | 'delete-tagged' | 'full';
+    /**
+     * The type of the assets to be garbage collected.
+     *
+     * @default 'all'
+     */
+    readonly type: 's3' | 'ecr' | 'all';
+    /**
+     * Elapsed time between an asset being marked as isolated and actually deleted.
+     *
+     * @default 0
+     */
+    readonly rollbackBufferDays: number;
+    /**
+     * Refuse deletion of any assets younger than this number of days.
+     */
+    readonly createdBufferDays: number;
+    /**
+     * The stack name of the bootstrap stack.
+     *
+     * @default DEFAULT_TOOLKIT_STACK_NAME
+     */
+    readonly bootstrapStackName?: string;
+    /**
+     * Skips the prompt before actual deletion begins
+     *
+     * @default false
+     */
+    readonly confirm?: boolean;
+}
+export interface MigrateOptions {
+    /**
+     * The name assigned to the generated stack. This is also used to get
+     * the stack from the user's account if `--from-stack` is used.
+     */
+    readonly stackName: string;
+    /**
+     * The target language for the generated the CDK app.
+     *
+     * @default typescript
+     */
+    readonly language?: string;
+    /**
+     * The local path of the template used to generate the CDK app.
+     *
+     * @default - Local path is not used for the template source.
+     */
+    readonly fromPath?: string;
+    /**
+     * Whether to get the template from an existing CloudFormation stack.
+     *
+     * @default false
+     */
+    readonly fromStack?: boolean;
+    /**
+     * The output path at which to create the CDK app.
+     *
+     * @default - The current directory
+     */
+    readonly outputPath?: string;
+    /**
+     * The account from which to retrieve the template of the CloudFormation stack.
+     *
+     * @default - Uses the account for the credentials in use by the user.
+     */
+    readonly account?: string;
+    /**
+     * The region from which to retrieve the template of the CloudFormation stack.
+     *
+     * @default - Uses the default region for the credentials in use by the user.
+     */
+    readonly region?: string;
+    /**
+     * Filtering criteria used to select the resources to be included in the generated CDK app.
+     *
+     * @default - Include all resources
+     */
+    readonly filter?: string[];
+    /**
+     * Whether to initiate a new account scan for generating the CDK app.
+     *
+     * @default false
+     */
+    readonly fromScan?: FromScan;
+    /**
+     * Whether to zip the generated cdk app folder.
+     *
+     * @default false
+     */
+    readonly compress?: boolean;
+}
+export interface RefactorOptions {
+    /**
+     * Whether to only show the proposed refactor, without applying it
+     */
+    readonly dryRun: boolean;
+    /**
+     * The absolute path to a file that contains overrides to the mappings
+     * computed by the CLI. This file should contain a JSON object with
+     * the following format:
+     *
+     *     {
+     *       "environments": [
+     *         {
+     *           "account": "123456789012",
+     *           "region": "us-east-1",
+     *           "resources": {
+     *             "Foo.OldName": "Bar.NewName",
+     *           }
+     *         },
+     *       ]
+     *     }
+     *
+     * where mappings are grouped by environment. The `resources` object contains
+     * a mapping where each key is the source location and the value is the
+     * destination location. Locations must be in the format `StackName.LogicalId`.
+     * The source must refer to a location where there is a resource currently
+     * deployed, while the destination must refer to a location that is not already
+     * occupied by any resource.
+     */
+    overrideFile?: string;
+    /**
+     * Modifies the behavior of the `overrideFile` option by swapping source and
+     * destination locations. This is useful when you want to undo a refactor
+     * that was previously applied.
+     */
+    revert?: boolean;
+    /**
+     * Whether to do the refactor without prompting the user for confirmation.
+     */
+    force?: boolean;
+    /**
+     * Criteria for selecting stacks to compare with the deployed stacks in the
+     * target environment.
+     */
+    stacks?: StackSelector;
+    /**
+     * A list of names of additional deployed stacks to be included in the comparison.
+     */
+    additionalStackNames?: string[];
+    /**
+     * Role to assume in the target environment before performing the refactor.
+     */
+    roleArn?: string;
+}
+/**
+ * Options for the drift command
+ */
+export interface DriftOptions {
+    /**
+     * Criteria for selecting stacks to detect drift on
+     */
+    readonly selector: StackSelector;
+    /**
+     * Whether to fail with exit code 1 if drift is detected
+     *
+     * @default false
+     */
+    readonly fail?: boolean;
+}
+/**
+ * Display a warning if there are flags that are different from the recommended value
+ *
+ * This happens if both of the following are true:
+ *
+ * - The user didn't configure the value
+ * - The default value for the flag (unconfiguredBehavesLike) is different from the recommended value
+ */
+export declare function displayFlagsMessage(ioHost: IoHelper, toolkit: InternalToolkit, cloudExecutable: CloudExecutable): Promise<void>;
+export {};

cdk/node_modules/aws-cdk/lib/cli/ci-systems.d.ts

@@ -0,0 +1,29 @@
+interface CiSystem {
+    /**
+     * What's the name?
+     */
+    readonly name: string;
+    /**
+     * What environment variable indicates that we are running on this system?
+     */
+    readonly detectEnvVar: string;
+    /**
+     * Whether or not this CI system can be configured to fail on messages written to stderr
+     *
+     * With "can be configured", what we mean is that a checkbox or configuration
+     * flag to enable this behavior comes out of the box with the CI system and (judgement
+     * call), this flag is "commonly" used.
+     *
+     * Of course every CI system can be scripted to have this behavior, but that's
+     * not what we mean.
+     */
+    readonly canBeConfiguredToFailOnStdErr: boolean;
+}
+export declare function detectCiSystem(): CiSystem | undefined;
+/**
+ * Return whether the CI system we're detecting is safe to write to stderr on
+ *
+ * Returns `undefined` if the current CI system cannot be recognized.
+ */
+export declare function ciSystemIsStdErrSafe(): boolean | undefined;
+export {};

cdk/node_modules/aws-cdk/lib/cli/cli-config.d.ts

@@ -0,0 +1,10 @@
+import { CliHelpers, type CliConfig } from '@aws-cdk/user-input-gen';
+export declare const YARGS_HELPERS: CliHelpers;
+/**
+ * Source of truth for all CDK CLI commands. `user-input-gen` translates this into:
+ *
+ * - the `yargs` definition in `lib/parse-command-line-arguments.ts`.
+ * - the `UserInput` type in `lib/user-input.ts`.
+ * - the `convertXxxToUserInput` functions in `lib/convert-to-user-input.ts`.
+ */
+export declare function makeConfig(): Promise<CliConfig>;

cdk/node_modules/aws-cdk/lib/cli/cli.d.ts

@@ -0,0 +1,3 @@
+import type { Synthesizer } from '../cxapp';
+export declare function exec(args: string[], synthesizer?: Synthesizer): Promise<number | void>;
+export declare function cli(args?: string[]): void;

cdk/node_modules/aws-cdk/lib/cli/convert-to-user-input.d.ts

@@ -0,0 +1,3 @@
+import { UserInput } from './user-input';
+export declare function convertYargsToUserInput(args: any): UserInput;
+export declare function convertConfigToUserInput(config: any): UserInput;

cdk/node_modules/aws-cdk/lib/cli/display-version.d.ts

@@ -0,0 +1,11 @@
+import type { IoHelper } from '../api-private';
+export declare class VersionCheckTTL {
+    static timestampFilePath(): string;
+    private readonly file;
+    private readonly ttlSecs;
+    constructor(file?: string, ttlSecs?: number);
+    hasExpired(): Promise<boolean>;
+    update(latestVersion?: string): Promise<void>;
+}
+export declare function getVersionMessages(currentVersion: string, cacheFile: VersionCheckTTL): Promise<string[]>;
+export declare function displayVersionMessage(ioHelper: IoHelper, currentVersion?: string, versionCheckCache?: VersionCheckTTL): Promise<void>;

cdk/node_modules/aws-cdk/lib/cli/io-host/cli-io-host.d.ts

@@ -0,0 +1,191 @@
+import type { Agent } from 'node:https';
+import { RequireApproval } from '@aws-cdk/cloud-assembly-schema';
+import type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest, ToolkitAction } from '@aws-cdk/toolkit-lib';
+import type { Context } from '@aws-cdk/toolkit-lib/lib/api';
+import type { IoHelper } from '../../../lib/api-private';
+import { StackActivityProgress } from '../../commands/deploy';
+import { TelemetrySession } from '../telemetry/session';
+export type { IIoHost, IoMessage, IoMessageCode, IoMessageLevel, IoRequest };
+/**
+ * The current action being performed by the CLI. 'none' represents the absence of an action.
+ */
+type CliAction = ToolkitAction | 'context' | 'docs' | 'flags' | 'notices' | 'version' | 'cli-telemetry' | 'none';
+export interface CliIoHostProps {
+    /**
+     * The initial Toolkit action the hosts starts with.
+     *
+     * @default 'none'
+     */
+    readonly currentAction?: CliAction;
+    /**
+     * Determines the verbosity of the output.
+     *
+     * The CliIoHost will still receive all messages and requests,
+     * but only the messages included in this level will be printed.
+     *
+     * @default 'info'
+     */
+    readonly logLevel?: IoMessageLevel;
+    /**
+     * Overrides the automatic TTY detection.
+     *
+     * When TTY is disabled, the CLI will have no interactions or color.
+     *
+     * @default - determined from the current process
+     */
+    readonly isTTY?: boolean;
+    /**
+     * Whether the CliIoHost is running in CI mode.
+     *
+     * In CI mode, all non-error output goes to stdout instead of stderr.
+     * Set to false in the CliIoHost constructor it will be overwritten if the CLI CI argument is passed
+     *
+     * @default - determined from the environment, specifically based on `process.env.CI`
+     */
+    readonly isCI?: boolean;
+    /**
+     * In what scenarios should the CliIoHost ask for approval
+     *
+     * @default RequireApproval.BROADENING
+     */
+    readonly requireDeployApproval?: RequireApproval;
+    /**
+     * The initial Toolkit action the hosts starts with.
+     *
+     * @default StackActivityProgress.BAR
+     */
+    readonly stackProgress?: StackActivityProgress;
+    /**
+     * Whether the CLI should attempt to automatically respond to prompts.
+     *
+     * When true, operation will usually proceed without interactive confirmation.
+     * Confirmations are responded to with yes. Other prompts will respond with the default value.
+     *
+     * @default false
+     */
+    readonly autoRespond?: boolean;
+}
+/**
+ * A type for configuring a target stream
+ */
+export type TargetStream = 'stdout' | 'stderr' | 'drop';
+/**
+ * A simple IO host for the CLI that writes messages to the console.
+ */
+export declare class CliIoHost implements IIoHost {
+    /**
+     * Returns the singleton instance
+     */
+    static instance(props?: CliIoHostProps, forceNew?: boolean): CliIoHost;
+    /**
+     * Returns the singleton instance if it exists
+     */
+    static get(): CliIoHost | undefined;
+    /**
+     * Singleton instance of the CliIoHost
+     */
+    private static _instance;
+    /**
+     * The current action being performed by the CLI.
+     */
+    currentAction: CliAction;
+    /**
+     * Whether the CliIoHost is running in CI mode.
+     *
+     * In CI mode, all non-error output goes to stdout instead of stderr.
+     */
+    isCI: boolean;
+    /**
+     * Whether the host can use interactions and message styling.
+     */
+    isTTY: boolean;
+    /**
+     * The current threshold.
+     *
+     * Messages with a lower priority level will be ignored.
+     */
+    logLevel: IoMessageLevel;
+    /**
+     * The conditions for requiring approval in this CliIoHost.
+     */
+    requireDeployApproval: RequireApproval;
+    /**
+     * Configure the target stream for notices
+     *
+     * (Not a setter because there's no need for additional logic when this value
+     * is changed yet)
+     */
+    noticesDestination: TargetStream;
+    private _progress;
+    private activityPrinter?;
+    private corkedCounter;
+    private readonly corkedLoggingBuffer;
+    private readonly autoRespond;
+    telemetry?: TelemetrySession;
+    private constructor();
+    startTelemetry(args: any, context: Context, proxyAgent?: Agent): Promise<void>;
+    /**
+     * Update the stackProgress preference.
+     */
+    set stackProgress(type: StackActivityProgress);
+    /**
+     * Gets the stackProgress value.
+     *
+     * This takes into account other state of the ioHost,
+     * like if isTTY and isCI.
+     */
+    get stackProgress(): StackActivityProgress;
+    get defaults(): import("@aws-cdk/toolkit-lib/lib/api/io/private/io-default-messages").IoDefaultMessages;
+    asIoHelper(): IoHelper;
+    /**
+     * Executes a block of code with corked logging. All log messages during execution
+     * are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
+     * The corking is bound to the specific instance of the CliIoHost.
+     *
+     * @param block - Async function to execute with corked logging
+     * @returns Promise that resolves with the block's return value
+     */
+    withCorkedLogging<T>(block: () => Promise<T>): Promise<T>;
+    /**
+     * Notifies the host of a message.
+     * The caller waits until the notification completes.
+     */
+    notify(msg: IoMessage<unknown>): Promise<void>;
+    private maybeEmitTelemetry;
+    /**
+     * Detect stack activity messages so they can be send to the printer.
+     */
+    private isStackActivity;
+    /**
+     * Detect special messages encode information about whether or not
+     * they require approval
+     */
+    private skipApprovalStep;
+    /**
+     * Determines the output stream, based on message and configuration.
+     */
+    private selectStream;
+    /**
+     * Determines the output stream, based on message level and configuration.
+     */
+    private selectStreamFromLevel;
+    /**
+     * Notifies the host of a message that requires a response.
+     *
+     * If the host does not return a response the suggested
+     * default response from the input message will be used.
+     */
+    requestResponse<DataType, ResponseType>(msg: IoRequest<DataType, ResponseType>): Promise<ResponseType>;
+    /**
+     * Formats a message for console output with optional color support
+     */
+    private formatMessage;
+    /**
+     * Formats date to HH:MM:SS
+     */
+    private formatTime;
+    /**
+     * Get an instance of the ActivityPrinter
+     */
+    private makeActivityPrinter;
+}

cdk/node_modules/aws-cdk/lib/cli/io-host/index.d.ts

@@ -0,0 +1 @@
+export * from './cli-io-host';

cdk/node_modules/aws-cdk/lib/cli/io-host/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cli-io-host"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQThCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGktaW8taG9zdCc7XG4iXX0=

cdk/node_modules/aws-cdk/lib/cli/parse-command-line-arguments.d.ts

@@ -0,0 +1 @@
+export declare function parseCommandLineArguments(args: Array<string>): any;

cdk/node_modules/aws-cdk/lib/cli/platform-warnings.d.ts

@@ -0,0 +1,3 @@
+import type { IoHelper } from '../api-private';
+export declare function checkForPlatformWarnings(ioHelper: IoHelper): Promise<void>;
+export declare function isVersionBetween(version: string, lower: string, upper: string): boolean;

cdk/node_modules/aws-cdk/lib/cli/platform-warnings.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForPlatformWarnings = checkForPlatformWarnings;
+exports.isVersionBetween = isVersionBetween;
+const os = require("os");
+const fs = require("fs-extra");
+async function checkForPlatformWarnings(ioHelper) {
+    if (await hasDockerCopyBug()) {
+        await ioHelper.defaults.warn('`cdk synth` may hang in Docker on Linux 5.6-5.10. See https://github.com/aws/aws-cdk/issues/21379 for workarounds.');
+    }
+}
+async function hasDockerCopyBug() {
+    return await runningInDocker() && os.platform() === 'linux' && isVersionBetween(os.release(), '5.6', '5.10');
+}
+async function runningInDocker() {
+    return fs.pathExists('/.dockerenv');
+}
+function isVersionBetween(version, lower, upper) {
+    const ver = splitVersion(version);
+    const lo = splitVersion(lower);
+    const up = splitVersion(upper);
+    while (lo.length < ver.length) {
+        lo.push(0);
+    }
+    while (up.length < ver.length) {
+        up.push(9999999);
+    }
+    let n = ver.length;
+    for (let i = 0; i < n; i++) {
+        if (lo[i] < ver[i] && ver[i] < up[i]) {
+            return true;
+        }
+        if (lo[i] > ver[i] || ver[i] > up[i]) {
+            return false;
+        }
+    }
+    return false;
+}
+function splitVersion(version) {
+    return `${version}`.split('.')
+        .map(x => parseInt(x, 10))
+        .map(x => isNaN(x) ? 0 : x);
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/pretty-print-error.d.ts

@@ -0,0 +1 @@
+export declare function prettyPrintError(error: unknown, debug?: boolean): void;

cdk/node_modules/aws-cdk/lib/cli/pretty-print-error.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrintError = prettyPrintError;
+/* eslint-disable no-console */
+const chalk = require("chalk");
+/* c8 ignore start */
+function prettyPrintError(error, debug = false) {
+    const err = ensureError(error);
+    console.error(chalk.red(err.message));
+    if (err.cause) {
+        const cause = ensureError(err.cause);
+        console.error(chalk.yellow(cause.message));
+        printTrace(cause, debug);
+    }
+    printTrace(err, debug);
+}
+function printTrace(err, debug = false) {
+    // Log the stack trace if we're on a developer workstation. Otherwise this will be into a minified
+    // file and the printed code line and stack trace are huge and useless.
+    if (err.stack && debug) {
+        console.debug(chalk.gray(err.stack));
+    }
+}
+function ensureError(value) {
+    if (value instanceof Error)
+        return value;
+    let stringified = '[Unable to stringify the thrown value]';
+    try {
+        stringified = JSON.stringify(value);
+    }
+    catch {
+    }
+    const error = new Error(`An unexpected error was thrown: ${stringified}`);
+    return error;
+}
+/* c8 ignore stop */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldHR5LXByaW50LWVycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsicHJldHR5LXByaW50LWVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBSUEsNENBV0M7QUFmRCwrQkFBK0I7QUFDL0IsK0JBQStCO0FBRS9CLHFCQUFxQjtBQUNyQixTQUFnQixnQkFBZ0IsQ0FBQyxLQUFjLEVBQUUsS0FBSyxHQUFHLEtBQUs7SUFDNUQsTUFBTSxHQUFHLEdBQUcsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQy9CLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztJQUV0QyxJQUFJLEdBQUcsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNkLE1BQU0sS0FBSyxHQUFHLFdBQVcsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDckMsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1FBQzNDLFVBQVUsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVELFVBQVUsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDekIsQ0FBQztBQUVELFNBQVMsVUFBVSxDQUFDLEdBQVUsRUFBRSxLQUFLLEdBQUcsS0FBSztJQUMzQyxrR0FBa0c7SUFDbEcsdUVBQXVFO0lBQ3ZFLElBQUksR0FBRyxDQUFDLEtBQUssSUFBSSxLQUFLLEVBQUUsQ0FBQztRQUN2QixPQUFPLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDdkMsQ0FBQztBQUNILENBQUM7QUFFRCxTQUFTLFdBQVcsQ0FBQyxLQUFjO0lBQ2pDLElBQUksS0FBSyxZQUFZLEtBQUs7UUFBRSxPQUFPLEtBQUssQ0FBQztJQUV6QyxJQUFJLFdBQVcsR0FBRyx3Q0FBd0MsQ0FBQztJQUMzRCxJQUFJLENBQUM7UUFDSCxXQUFXLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBQUMsTUFBTSxDQUFDO0lBQ1QsQ0FBQztJQUVELE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLG1DQUFtQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO0lBQzFFLE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUNELG9CQUFvQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIG5vLWNvbnNvbGUgKi9cbmltcG9ydCAqIGFzIGNoYWxrIGZyb20gJ2NoYWxrJztcblxuLyogYzggaWdub3JlIHN0YXJ0ICovXG5leHBvcnQgZnVuY3Rpb24gcHJldHR5UHJpbnRFcnJvcihlcnJvcjogdW5rbm93biwgZGVidWcgPSBmYWxzZSkge1xuICBjb25zdCBlcnIgPSBlbnN1cmVFcnJvcihlcnJvcik7XG4gIGNvbnNvbGUuZXJyb3IoY2hhbGsucmVkKGVyci5tZXNzYWdlKSk7XG5cbiAgaWYgKGVyci5jYXVzZSkge1xuICAgIGNvbnN0IGNhdXNlID0gZW5zdXJlRXJyb3IoZXJyLmNhdXNlKTtcbiAgICBjb25zb2xlLmVycm9yKGNoYWxrLnllbGxvdyhjYXVzZS5tZXNzYWdlKSk7XG4gICAgcHJpbnRUcmFjZShjYXVzZSwgZGVidWcpO1xuICB9XG5cbiAgcHJpbnRUcmFjZShlcnIsIGRlYnVnKTtcbn1cblxuZnVuY3Rpb24gcHJpbnRUcmFjZShlcnI6IEVycm9yLCBkZWJ1ZyA9IGZhbHNlKSB7XG4gIC8vIExvZyB0aGUgc3RhY2sgdHJhY2UgaWYgd2UncmUgb24gYSBkZXZlbG9wZXIgd29ya3N0YXRpb24uIE90aGVyd2lzZSB0aGlzIHdpbGwgYmUgaW50byBhIG1pbmlmaWVkXG4gIC8vIGZpbGUgYW5kIHRoZSBwcmludGVkIGNvZGUgbGluZSBhbmQgc3RhY2sgdHJhY2UgYXJlIGh1Z2UgYW5kIHVzZWxlc3MuXG4gIGlmIChlcnIuc3RhY2sgJiYgZGVidWcpIHtcbiAgICBjb25zb2xlLmRlYnVnKGNoYWxrLmdyYXkoZXJyLnN0YWNrKSk7XG4gIH1cbn1cblxuZnVuY3Rpb24gZW5zdXJlRXJyb3IodmFsdWU6IHVua25vd24pOiBFcnJvciB7XG4gIGlmICh2YWx1ZSBpbnN0YW5jZW9mIEVycm9yKSByZXR1cm4gdmFsdWU7XG5cbiAgbGV0IHN0cmluZ2lmaWVkID0gJ1tVbmFibGUgdG8gc3RyaW5naWZ5IHRoZSB0aHJvd24gdmFsdWVdJztcbiAgdHJ5IHtcbiAgICBzdHJpbmdpZmllZCA9IEpTT04uc3RyaW5naWZ5KHZhbHVlKTtcbiAgfSBjYXRjaCB7XG4gIH1cblxuICBjb25zdCBlcnJvciA9IG5ldyBFcnJvcihgQW4gdW5leHBlY3RlZCBlcnJvciB3YXMgdGhyb3duOiAke3N0cmluZ2lmaWVkfWApO1xuICByZXR1cm4gZXJyb3I7XG59XG4vKiBjOCBpZ25vcmUgc3RvcCAqL1xuIl19

cdk/node_modules/aws-cdk/lib/cli/proxy-agent.d.ts

@@ -0,0 +1,30 @@
+import { ProxyAgent } from 'proxy-agent';
+import type { IoHelper } from '../api-private';
+/**
+ * Options for proxy-agent SDKs
+ */
+interface ProxyAgentOptions {
+    /**
+     * Proxy address to use
+     *
+     * @default No proxy
+     */
+    readonly proxyAddress?: string;
+    /**
+     * A path to a certificate bundle that contains a cert to be trusted.
+     *
+     * @default No certificate bundle
+     */
+    readonly caBundlePath?: string;
+}
+export declare class ProxyAgentProvider {
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper);
+    create(options: ProxyAgentOptions): Promise<ProxyAgent>;
+    private tryGetCACert;
+    /**
+     * Find and return a CA certificate bundle path to be passed into the SDK.
+     */
+    private caBundlePathFromEnvironment;
+}
+export {};

cdk/node_modules/aws-cdk/lib/cli/proxy-agent.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyAgentProvider = void 0;
+const fs = require("fs-extra");
+const proxy_agent_1 = require("proxy-agent");
+class ProxyAgentProvider {
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    async create(options) {
+        // Force it to use the proxy provided through the command line.
+        // Otherwise, let the ProxyAgent auto-detect the proxy using environment variables.
+        const getProxyForUrl = options.proxyAddress != null
+            ? () => Promise.resolve(options.proxyAddress)
+            : undefined;
+        return new proxy_agent_1.ProxyAgent({
+            ca: await this.tryGetCACert(options.caBundlePath),
+            getProxyForUrl,
+        });
+    }
+    async tryGetCACert(bundlePath) {
+        const path = bundlePath || this.caBundlePathFromEnvironment();
+        if (path) {
+            await this.ioHelper.defaults.debug(`Using CA bundle path: ${path}`);
+            try {
+                if (!fs.pathExistsSync(path)) {
+                    return undefined;
+                }
+                return fs.readFileSync(path, { encoding: 'utf-8' });
+            }
+            catch (e) {
+                await this.ioHelper.defaults.debug(String(e));
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Find and return a CA certificate bundle path to be passed into the SDK.
+     */
+    caBundlePathFromEnvironment() {
+        if (process.env.aws_ca_bundle) {
+            return process.env.aws_ca_bundle;
+        }
+        if (process.env.AWS_CA_BUNDLE) {
+            return process.env.AWS_CA_BUNDLE;
+        }
+        return undefined;
+    }
+}
+exports.ProxyAgentProvider = ProxyAgentProvider;
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/root-dir.d.ts

@@ -0,0 +1,10 @@
+/**
+ * From the current file, find the directory that contains the CLI's package.json
+ *
+ * Can't use `__dirname` in production code, as the CLI will get bundled as it's
+ * released and `__dirname` will refer to a different location in the `.ts` form
+ * as it will in the final executing form.
+ */
+export declare function cliRootDir(): string;
+export declare function cliRootDir(fail: true): string;
+export declare function cliRootDir(fail: false): string | undefined;

cdk/node_modules/aws-cdk/lib/cli/root-dir.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliRootDir = cliRootDir;
+const fs = require("fs");
+const path = require("path");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+function cliRootDir(fail) {
+    function _rootDir(dirname) {
+        const manifestPath = path.join(dirname, 'package.json');
+        if (fs.existsSync(manifestPath)) {
+            return dirname;
+        }
+        if (path.dirname(dirname) === dirname) {
+            if (fail ?? true) {
+                throw new toolkit_lib_1.ToolkitError('PackageManifestNotFound', 'Unable to find package manifest');
+            }
+            return undefined;
+        }
+        return _rootDir(path.dirname(dirname));
+    }
+    return _rootDir(__dirname);
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/singleton-plugin-host.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The singleton plugin host
+ *
+ * This is only a concept in the CLI, not in the toolkit library.
+ */
+import { PluginHost } from '../api/plugin';
+export declare const GLOBAL_PLUGIN_HOST: PluginHost;

cdk/node_modules/aws-cdk/lib/cli/singleton-plugin-host.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * The singleton plugin host
+ *
+ * This is only a concept in the CLI, not in the toolkit library.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBAL_PLUGIN_HOST = void 0;
+const plugin_1 = require("../api/plugin");
+exports.GLOBAL_PLUGIN_HOST = new plugin_1.PluginHost();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xldG9uLXBsdWdpbi1ob3N0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsic2luZ2xldG9uLXBsdWdpbi1ob3N0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOzs7QUFFSCwwQ0FBMkM7QUFFOUIsUUFBQSxrQkFBa0IsR0FBRyxJQUFJLG1CQUFVLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhlIHNpbmdsZXRvbiBwbHVnaW4gaG9zdFxuICpcbiAqIFRoaXMgaXMgb25seSBhIGNvbmNlcHQgaW4gdGhlIENMSSwgbm90IGluIHRoZSB0b29sa2l0IGxpYnJhcnkuXG4gKi9cblxuaW1wb3J0IHsgUGx1Z2luSG9zdCB9IGZyb20gJy4uL2FwaS9wbHVnaW4nO1xuXG5leHBvcnQgY29uc3QgR0xPQkFMX1BMVUdJTl9IT1NUID0gbmV3IFBsdWdpbkhvc3QoKTtcbiJdfQ==

cdk/node_modules/aws-cdk/lib/cli/tables.d.ts

@@ -0,0 +1 @@
+export declare function renderTable(cells: string[][], columns?: number): string;

cdk/node_modules/aws-cdk/lib/cli/tables.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTable = renderTable;
+const cfnDiff = require("@aws-cdk/cloudformation-diff");
+function renderTable(cells, columns) {
+    // The cfnDiff module has logic for terminal-width aware table
+    // formatting (and nice colors), let's just reuse that.
+    return cfnDiff.formatTable(cells, columns);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsidGFibGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsa0NBSUM7QUFORCx3REFBd0Q7QUFFeEQsU0FBZ0IsV0FBVyxDQUFDLEtBQWlCLEVBQUUsT0FBZ0I7SUFDN0QsOERBQThEO0lBQzlELHVEQUF1RDtJQUN2RCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQzdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjZm5EaWZmIGZyb20gJ0Bhd3MtY2RrL2Nsb3VkZm9ybWF0aW9uLWRpZmYnO1xuXG5leHBvcnQgZnVuY3Rpb24gcmVuZGVyVGFibGUoY2VsbHM6IHN0cmluZ1tdW10sIGNvbHVtbnM/OiBudW1iZXIpIHtcbiAgLy8gVGhlIGNmbkRpZmYgbW9kdWxlIGhhcyBsb2dpYyBmb3IgdGVybWluYWwtd2lkdGggYXdhcmUgdGFibGVcbiAgLy8gZm9ybWF0dGluZyAoYW5kIG5pY2UgY29sb3JzKSwgbGV0J3MganVzdCByZXVzZSB0aGF0LlxuICByZXR1cm4gY2ZuRGlmZi5mb3JtYXRUYWJsZShjZWxscywgY29sdW1ucyk7XG59XG4iXX0=

cdk/node_modules/aws-cdk/lib/cli/telemetry/collect-telemetry.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '../../api/context';
+/**
+ * Whether or not we collect telemetry
+ */
+export declare function canCollectTelemetry(args: any, context: Context): boolean;

cdk/node_modules/aws-cdk/lib/cli/telemetry/collect-telemetry.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canCollectTelemetry = canCollectTelemetry;
+/**
+ * Whether or not we collect telemetry
+ */
+function canCollectTelemetry(args, context) {
+    if ((['true', '1'].includes(process.env.CDK_DISABLE_CLI_TELEMETRY ?? '')) ||
+        ['false', false].includes(context.get('cli-telemetry')) ||
+        (args['version-reporting'] !== undefined && !args['version-reporting']) || /* aliased with telemetry option */
+        (args._[0] === 'cli-telemetry' && args.disable)) /* special case for `cdk cli-telemetry --disable` */ {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdC10ZWxlbWV0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjb2xsZWN0LXRlbGVtZXRyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUtBLGtEQVNDO0FBWkQ7O0dBRUc7QUFDSCxTQUFnQixtQkFBbUIsQ0FBQyxJQUFTLEVBQUUsT0FBZ0I7SUFDN0QsSUFBSSxDQUFDLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLHlCQUF5QixJQUFJLEVBQUUsQ0FBQyxDQUFDO1FBQ3ZFLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ3ZELENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLEtBQUssU0FBUyxJQUFJLENBQUMsSUFBSSxDQUFDLG1CQUFtQixDQUFDLENBQUMsSUFBSSxtQ0FBbUM7UUFDOUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLGVBQWUsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsb0RBQW9ELENBQUMsQ0FBQztRQUN2RyxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IENvbnRleHQgfSBmcm9tICcuLi8uLi9hcGkvY29udGV4dCc7XG5cbi8qKlxuICogV2hldGhlciBvciBub3Qgd2UgY29sbGVjdCB0ZWxlbWV0cnlcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNhbkNvbGxlY3RUZWxlbWV0cnkoYXJnczogYW55LCBjb250ZXh0OiBDb250ZXh0KTogYm9vbGVhbiB7XG4gIGlmICgoWyd0cnVlJywgJzEnXS5pbmNsdWRlcyhwcm9jZXNzLmVudi5DREtfRElTQUJMRV9DTElfVEVMRU1FVFJZID8/ICcnKSkgfHxcbiAgICBbJ2ZhbHNlJywgZmFsc2VdLmluY2x1ZGVzKGNvbnRleHQuZ2V0KCdjbGktdGVsZW1ldHJ5JykpIHx8XG4gICAgKGFyZ3NbJ3ZlcnNpb24tcmVwb3J0aW5nJ10gIT09IHVuZGVmaW5lZCAmJiAhYXJnc1sndmVyc2lvbi1yZXBvcnRpbmcnXSkgfHwgLyogYWxpYXNlZCB3aXRoIHRlbGVtZXRyeSBvcHRpb24gKi9cbiAgICAoYXJncy5fWzBdID09PSAnY2xpLXRlbGVtZXRyeScgJiYgYXJncy5kaXNhYmxlKSkgLyogc3BlY2lhbCBjYXNlIGZvciBgY2RrIGNsaS10ZWxlbWV0cnkgLS1kaXNhYmxlYCAqLyB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgcmV0dXJuIHRydWU7XG59XG4iXX0=

cdk/node_modules/aws-cdk/lib/cli/telemetry/error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The error code when a user hits Ctrl-C
+ */
+export declare const USER_INTERRUPTED_CODE = "UserInterrupted";
+/**
+ * If we can't find a specific error code
+ */
+export declare const UNKNOWN_ERROR_CODE = "UnknownError";
+/**
+ * Return the transmitted error code for this error object
+ *
+ * We are taking care to only transmit errors that originate from AWS systems
+ * (this toolkit itself, the CDK construct library, the AWS SDK, AWS services).
+ */
+export declare function cdkCliErrorName(err: Error): string;

cdk/node_modules/aws-cdk/lib/cli/telemetry/feature-flags.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Enum of all valid CDK feature flag names.
+ *
+ * These flags are used to control behavior changes in the CDK.
+ * For more information, see: https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/cx-api/FEATURE_FLAGS.md
+ */
+export declare enum FeatureFlag {
+    CORE_NEW_STYLE_STACK_SYNTHESIS = "@aws-cdk/core:newStyleStackSynthesis",
+    CORE_STACK_RELATIVE_EXPORTS = "@aws-cdk/core:stackRelativeExports",
+    RDS_LOWERCASE_DB_IDENTIFIER = "@aws-cdk/aws-rds:lowercaseDbIdentifier",
+    APIGATEWAY_USAGE_PLAN_KEY_ORDER_INSENSITIVE_ID = "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId",
+    LAMBDA_RECOGNIZE_VERSION_PROPS = "@aws-cdk/aws-lambda:recognizeVersionProps",
+    CLOUDFRONT_DEFAULT_SECURITY_POLICY_TLS_V1_2_2021 = "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021",
+    CORE_TARGET_PARTITIONS = "@aws-cdk/core:target-partitions",
+    ECS_SERVICE_EXTENSIONS_ENABLE_DEFAULT_LOG_DRIVER = "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver",
+    EC2_UNIQUE_IMDSV2_TEMPLATE_NAME = "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName",
+    IAM_MINIMIZE_POLICIES = "@aws-cdk/aws-iam:minimizePolicies",
+    CORE_CHECK_SECRET_USAGE = "@aws-cdk/core:checkSecretUsage",
+    LAMBDA_RECOGNIZE_LAYER_VERSION = "@aws-cdk/aws-lambda:recognizeLayerVersion",
+    CORE_VALIDATE_SNAPSHOT_REMOVAL_POLICY = "@aws-cdk/core:validateSnapshotRemovalPolicy",
+    CODEPIPELINE_CROSS_ACCOUNT_KEY_ALIAS_STACK_SAFE_RESOURCE_NAME = "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName",
+    S3_CREATE_DEFAULT_LOGGING_POLICY = "@aws-cdk/aws-s3:createDefaultLoggingPolicy",
+    SNS_SUBSCRIPTIONS_RESTRICT_SQS_DECRYPTION = "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption",
+    ECS_ARN_FORMAT_INCLUDES_CLUSTER_NAME = "@aws-cdk/aws-ecs:arnFormatIncludesClusterName",
+    APIGATEWAY_DISABLE_CLOUD_WATCH_ROLE = "@aws-cdk/aws-apigateway:disableCloudWatchRole",
+    CORE_ENABLE_PARTITION_LITERALS = "@aws-cdk/core:enablePartitionLiterals",
+    ECS_DISABLE_EXPLICIT_DEPLOYMENT_CONTROLLER_FOR_CIRCUIT_BREAKER = "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker",
+    EVENTS_EVENTS_TARGET_QUEUE_SAME_ACCOUNT = "@aws-cdk/aws-events:eventsTargetQueueSameAccount",
+    IAM_IMPORTED_ROLE_STACK_SAFE_DEFAULT_POLICY_NAME = "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName",
+    S3_SERVER_ACCESS_LOGS_USE_BUCKET_POLICY = "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy",
+    CUSTOMRESOURCES_INSTALL_LATEST_AWS_SDK_DEFAULT = "@aws-cdk/customresources:installLatestAwsSdkDefault",
+    ROUTE53_PATTERNS_USE_CERTIFICATE = "@aws-cdk/aws-route53-patterns:useCertificate",
+    CODEDEPLOY_REMOVE_ALARMS_FROM_DEPLOYMENT_GROUP = "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup",
+    RDS_DATABASE_PROXY_UNIQUE_RESOURCE_NAME = "@aws-cdk/aws-rds:databaseProxyUniqueResourceName",
+    APIGATEWAY_AUTHORIZER_CHANGE_DEPLOYMENT_LOGICAL_ID = "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId",
+    EC2_LAUNCH_TEMPLATE_DEFAULT_USER_DATA = "@aws-cdk/aws-ec2:launchTemplateDefaultUserData",
+    SECRETSMANAGER_USE_ATTACHED_SECRET_RESOURCE_POLICY_FOR_SECRET_TARGET_ATTACHMENTS = "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments",
+    REDSHIFT_COLUMN_ID = "@aws-cdk/aws-redshift:columnId",
+    STEPFUNCTIONS_TASKS_ENABLE_EMR_SERVICE_POLICY_V2 = "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2",
+    APIGATEWAY_REQUEST_VALIDATOR_UNIQUE_ID = "@aws-cdk/aws-apigateway:requestValidatorUniqueId",
+    EC2_RESTRICT_DEFAULT_SECURITY_GROUP = "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup",
+    KMS_ALIAS_NAME_REF = "@aws-cdk/aws-kms:aliasNameRef",
+    CORE_INCLUDE_PREFIX_IN_UNIQUE_NAME_GENERATION = "@aws-cdk/core:includePrefixInUniqueNameGeneration",
+    AUTOSCALING_GENERATE_LAUNCH_TEMPLATE_INSTEAD_OF_LAUNCH_CONFIG = "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig",
+    OPENSEARCHSERVICE_ENABLE_OPENSEARCH_MULTI_AZ_WITH_STANDBY = "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby",
+    EFS_DENY_ANONYMOUS_ACCESS = "@aws-cdk/aws-efs:denyAnonymousAccess",
+    EFS_MOUNT_TARGET_ORDER_INSENSITIVE_LOGICAL_ID = "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId",
+    LAMBDA_NODEJS_USE_LATEST_RUNTIME_VERSION = "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion",
+    APPSYNC_USE_ARN_FOR_SOURCE_API_ASSOCIATION_IDENTIFIER = "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier",
+    RDS_AURORA_CLUSTER_CHANGE_SCOPE_OF_INSTANCE_PARAMETER_GROUP_WITH_EACH_PARAMETERS = "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters",
+    RDS_PREVENT_RENDERING_DEPRECATED_CREDENTIALS = "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials",
+    CODEPIPELINE_ACTIONS_USE_NEW_DEFAULT_BRANCH_FOR_CODE_COMMIT_SOURCE = "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource",
+    CLOUDWATCH_ACTIONS_CHANGE_LAMBDA_PERMISSION_LOGICAL_ID_FOR_LAMBDA_ACTION = "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction",
+    CODEPIPELINE_CROSS_ACCOUNT_KEYS_DEFAULT_VALUE_TO_FALSE = "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse",
+    CODEPIPELINE_DEFAULT_PIPELINE_TYPE_TO_V2 = "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2",
+    KMS_REDUCE_CROSS_ACCOUNT_REGION_POLICY_SCOPE = "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope",
+    EKS_NODEGROUP_NAME_ATTRIBUTE = "@aws-cdk/aws-eks:nodegroupNameAttribute",
+    EC2_EBS_DEFAULT_GP3_VOLUME = "@aws-cdk/aws-ec2:ebsDefaultGp3Volume",
+    PIPELINES_REDUCE_ASSET_ROLE_TRUST_SCOPE = "@aws-cdk/pipelines:reduceAssetRoleTrustScope",
+    ECS_REMOVE_DEFAULT_DEPLOYMENT_ALARM = "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm",
+    CUSTOM_RESOURCES_LOG_API_RESPONSE_DATA_PROPERTY_TRUE_DEFAULT = "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault",
+    S3_KEEP_NOTIFICATION_IN_IMPORTED_BUCKET = "@aws-cdk/aws-s3:keepNotificationInImportedBucket",
+    STEPFUNCTIONS_TASKS_USE_NEW_S3_URI_PARAMETERS_FOR_BEDROCK_INVOKE_MODEL_TASK = "@aws-cdk/aws-stepfunctions-tasks:useNewS3UriParametersForBedrockInvokeModelTask",
+    ECS_REDUCE_EC2_FARGATE_CLOUD_WATCH_PERMISSIONS = "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions",
+    EC2_EC2_SUM_TIMEOUT_ENABLED = "@aws-cdk/aws-ec2:ec2SumTimeoutEnabled",
+    APPSYNC_APP_SYNC_GRAPHQL_API_SCOPE_LAMBDA_PERMISSION = "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission",
+    LAMBDA_NODEJS_SDK_V3_EXCLUDE_SMITHY_PACKAGES = "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages",
+    RDS_SET_CORRECT_VALUE_FOR_DATABASE_INSTANCE_READ_REPLICA_INSTANCE_RESOURCE_ID = "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId",
+    CORE_CFN_INCLUDE_REJECT_COMPLEX_RESOURCE_UPDATE_CREATE_POLICY_INTRINSICS = "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics",
+    STEPFUNCTIONS_TASKS_FIX_RUN_ECS_TASK_POLICY = "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy",
+    DYNAMODB_RESOURCE_POLICY_PER_REPLICA = "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica",
+    EC2_BASTION_HOST_USE_AMAZON_LINUX_2023_BY_DEFAULT = "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault",
+    CORE_ASPECT_STABILIZATION = "@aws-cdk/core:aspectStabilization",
+    ROUTE53_TARGETS_USER_POOL_DOMAIN_NAME_METHOD_WITHOUT_CUSTOM_RESOURCE = "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource",
+    ECS_DISABLE_ECS_IMDS_BLOCKING = "@aws-cdk/aws-ecs:disableEcsImdsBlocking",
+    ECS_ENABLE_IMDS_BLOCKING_DEPRECATED_FEATURE = "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature",
+    ELASTICLOADBALANCINGV2_ALB_DUALSTACK_WITHOUT_PUBLIC_IPV4_SECURITY_GROUP_RULES_DEFAULT = "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault",
+    IAM_OIDC_REJECT_UNAUTHORIZED_CONNECTIONS = "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections",
+    CORE_ENABLE_ADDITIONAL_METADATA_COLLECTION = "@aws-cdk/core:enableAdditionalMetadataCollection",
+    LAMBDA_CREATE_NEW_POLICIES_WITH_ADD_TO_ROLE_POLICY = "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy",
+    S3_SET_UNIQUE_REPLICATION_ROLE_NAME = "@aws-cdk/aws-s3:setUniqueReplicationRoleName",
+    PIPELINES_REDUCE_STAGE_ROLE_TRUST_SCOPE = "@aws-cdk/pipelines:reduceStageRoleTrustScope",
+    EVENTS_REQUIRE_EVENT_BUS_POLICY_SID = "@aws-cdk/aws-events:requireEventBusPolicySid",
+    DYNAMODB_RETAIN_TABLE_REPLICA = "@aws-cdk/aws-dynamodb:retainTableReplica",
+    COGNITO_LOG_USER_POOL_CLIENT_SECRET_VALUE = "@aws-cdk/cognito:logUserPoolClientSecretValue",
+    STEPFUNCTIONS_USE_DISTRIBUTED_MAP_RESULT_WRITER_V2 = "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2",
+    PIPELINES_REDUCE_CROSS_ACCOUNT_ACTION_ROLE_TRUST_SCOPE = "@aws-cdk/pipelines:reduceCrossAccountActionRoleTrustScope",
+    CORE_ASPECT_PRIORITIES_MUTATING = "@aws-cdk/core:aspectPrioritiesMutating",
+    S3_NOTIFICATIONS_ADD_S3_TRUST_KEY_POLICY_FOR_SNS_SUBSCRIPTIONS = "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions",
+    EC2_ALPHA_USE_RESOURCE_ID_FOR_VPC_V2_MIGRATION = "@aws-cdk/aws-ec2-alpha:useResourceIdForVpcV2Migration",
+    EC2_REQUIRE_PRIVATE_SUBNETS_FOR_EGRESS_ONLY_INTERNET_GATEWAY = "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway",
+    S3_PUBLIC_ACCESS_BLOCKED_BY_DEFAULT = "@aws-cdk/aws-s3:publicAccessBlockedByDefault",
+    LAMBDA_USE_CDK_MANAGED_LOG_GROUP = "@aws-cdk/aws-lambda:useCdkManagedLogGroup",
+    KMS_APPLY_IMPORTED_ALIAS_PERMISSIONS_TO_PRINCIPAL = "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal",
+    CORE_EXPLICIT_STACK_TAGS = "@aws-cdk/core:explicitStackTags"
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/installation-id.d.ts

@@ -0,0 +1,5 @@
+import type { IoHelper } from '../../api-private';
+/**
+ * Get or create installation id
+ */
+export declare function getOrCreateInstallationId(ioHelper: IoHelper): Promise<string>;

cdk/node_modules/aws-cdk/lib/cli/telemetry/installation-id.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateInstallationId = getOrCreateInstallationId;
+const crypto_1 = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const util_1 = require("../../util");
+const INSTALLATION_ID_PATH = path.join((0, util_1.cdkCacheDir)(), 'installation-id.json');
+/**
+ * Get or create installation id
+ */
+async function getOrCreateInstallationId(ioHelper) {
+    try {
+        // Create the cache directory if it doesn't exist
+        if (!fs.existsSync(path.dirname(INSTALLATION_ID_PATH))) {
+            fs.mkdirSync(path.dirname(INSTALLATION_ID_PATH), { recursive: true });
+        }
+        // Check if the installation ID file exists
+        if (fs.existsSync(INSTALLATION_ID_PATH)) {
+            const cachedId = fs.readFileSync(INSTALLATION_ID_PATH, 'utf-8').trim();
+            // Validate that the cached ID is a valid UUID
+            const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+            if (UUID_REGEX.test(cachedId)) {
+                return cachedId;
+            }
+            // If invalid, fall through to create a new one
+        }
+        // Create a new installation ID
+        const newId = (0, crypto_1.randomUUID)();
+        try {
+            fs.writeFileSync(INSTALLATION_ID_PATH, newId);
+        }
+        catch (e) {
+            // If we can't write the file, still return the generated ID
+            // but log a trace message about the failure
+            await ioHelper.defaults.trace(`Failed to write installation ID to ${INSTALLATION_ID_PATH}: ${e}`);
+        }
+        return newId;
+    }
+    catch (e) {
+        // If anything goes wrong, generate a temporary ID for this session
+        // and log a trace message about the failure
+        await ioHelper.defaults.trace(`Error getting installation ID: ${e}`);
+        return (0, crypto_1.randomUUID)();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/library-version.d.ts

@@ -0,0 +1,2 @@
+import type { IoHelper } from '../../api-private';
+export declare function getLibraryVersion(ioHelper: IoHelper): Promise<string | undefined>;

cdk/node_modules/aws-cdk/lib/cli/telemetry/library-version.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibraryVersion = getLibraryVersion;
+const child_process_1 = require("child_process");
+const path = require("path");
+const util_1 = require("util");
+const fs = require("fs-extra");
+async function getLibraryVersion(ioHelper) {
+    try {
+        const command = "node -e 'process.stdout.write(require.resolve(\"aws-cdk-lib\"))'";
+        const { stdout } = await (0, util_1.promisify)(child_process_1.exec)(command);
+        // stdout should be a file path but lets double check
+        if (!fs.existsSync(stdout)) {
+            await ioHelper.defaults.trace('Could not get CDK Library Version: require.resolve("aws-cdk-lib") did not return a file path');
+            return;
+        }
+        const pathToPackageJson = path.join(path.dirname(stdout), 'package.json');
+        const packageJson = fs.readJSONSync(pathToPackageJson);
+        if (!packageJson.version) {
+            await ioHelper.defaults.trace('Could not get CDK Library Version: package.json does not have version field');
+            return;
+        }
+        return packageJson.version;
+    }
+    catch (e) {
+        await ioHelper.defaults.trace(`Could not get CDK Library Version: ${e}`);
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/messages.d.ts

@@ -0,0 +1,43 @@
+import type { Duration } from '@aws-cdk/toolkit-lib';
+import type { ErrorDetails } from './schema';
+import * as make from '../../api-private';
+export interface EventResult extends Duration {
+    error?: ErrorDetails;
+    /**
+     * Counts of noteworthy things in this event
+     */
+    counters?: Record<string, number>;
+}
+export interface EventStart {
+}
+/**
+ * Private message types specific to the CLI
+ */
+export declare const CLI_PRIVATE_IO: {
+    CDK_CLI_I1000: make.IoMessageMaker<EventStart>;
+    CDK_CLI_I1001: make.IoMessageMaker<EventResult>;
+    CDK_CLI_I2000: make.IoMessageMaker<EventStart>;
+    CDK_CLI_I2001: make.IoMessageMaker<EventResult>;
+    CDK_CLI_I3000: make.IoMessageMaker<EventStart>;
+    CDK_CLI_I3001: make.IoMessageMaker<EventResult>;
+};
+/**
+ * Payload type of the end message must extend Duration
+ */
+export declare const CLI_PRIVATE_SPAN: {
+    SYNTH_ASSEMBLY: {
+        name: string;
+        start: make.IoMessageMaker<EventStart>;
+        end: make.IoMessageMaker<EventResult>;
+    };
+    COMMAND: {
+        name: string;
+        start: make.IoMessageMaker<EventStart>;
+        end: make.IoMessageMaker<EventResult>;
+    };
+    DEPLOY: {
+        name: string;
+        start: make.IoMessageMaker<EventStart>;
+        end: make.IoMessageMaker<EventResult>;
+    };
+};

cdk/node_modules/aws-cdk/lib/cli/telemetry/messages.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_PRIVATE_SPAN = exports.CLI_PRIVATE_IO = void 0;
+const make = require("../../api-private");
+/**
+ * Private message types specific to the CLI
+ */
+exports.CLI_PRIVATE_IO = {
+    CDK_CLI_I1000: make.trace({
+        code: 'CDK_CLI_I1000',
+        description: 'Cloud Execution is starting',
+        interface: 'EventStart',
+    }),
+    CDK_CLI_I1001: make.trace({
+        code: 'CDK_CLI_I1001',
+        description: 'Cloud Executable Result',
+        interface: 'EventResult',
+    }),
+    CDK_CLI_I2000: make.trace({
+        code: 'CDK_CLI_I2000',
+        description: 'Command has started',
+        interface: 'EventStart',
+    }),
+    CDK_CLI_I2001: make.trace({
+        code: 'CDK_CLI_I2001',
+        description: 'Command has finished executing',
+        interface: 'EventResult',
+    }),
+    CDK_CLI_I3000: make.trace({
+        code: 'CDK_CLI_I3000',
+        description: 'Deploy has started',
+        interface: 'EventStart',
+    }),
+    CDK_CLI_I3001: make.trace({
+        code: 'CDK_CLI_I3001',
+        description: 'Deploy has finished',
+        interface: 'EventResult',
+    }),
+};
+/**
+ * Payload type of the end message must extend Duration
+ */
+exports.CLI_PRIVATE_SPAN = {
+    SYNTH_ASSEMBLY: {
+        name: 'Synthesis',
+        start: exports.CLI_PRIVATE_IO.CDK_CLI_I1000,
+        end: exports.CLI_PRIVATE_IO.CDK_CLI_I1001,
+    },
+    COMMAND: {
+        name: 'Command',
+        start: exports.CLI_PRIVATE_IO.CDK_CLI_I2000,
+        end: exports.CLI_PRIVATE_IO.CDK_CLI_I2001,
+    },
+    DEPLOY: {
+        name: 'Deploy',
+        start: exports.CLI_PRIVATE_IO.CDK_CLI_I3000,
+        end: exports.CLI_PRIVATE_IO.CDK_CLI_I3001,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/sanitation.d.ts

@@ -0,0 +1,100 @@
+import type { Context } from '../../api/context';
+/**
+ * argv is the output of yargs
+ */
+export declare function sanitizeCommandLineArguments(argv: any): {
+    path: string[];
+    parameters: {
+        [key: string]: string;
+    };
+};
+export declare function sanitizeContext(context: Context): {
+    "@aws-cdk/core:newStyleStackSynthesis": boolean;
+    "@aws-cdk/core:stackRelativeExports": boolean;
+    "@aws-cdk/aws-rds:lowercaseDbIdentifier": boolean;
+    "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId": boolean;
+    "@aws-cdk/aws-lambda:recognizeVersionProps": boolean;
+    "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021": boolean;
+    "@aws-cdk/core:target-partitions": boolean;
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": boolean;
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": boolean;
+    "@aws-cdk/aws-iam:minimizePolicies": boolean;
+    "@aws-cdk/core:checkSecretUsage": boolean;
+    "@aws-cdk/aws-lambda:recognizeLayerVersion": boolean;
+    "@aws-cdk/core:validateSnapshotRemovalPolicy": boolean;
+    "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": boolean;
+    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": boolean;
+    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": boolean;
+    "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": boolean;
+    "@aws-cdk/aws-apigateway:disableCloudWatchRole": boolean;
+    "@aws-cdk/core:enablePartitionLiterals": boolean;
+    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": boolean;
+    "@aws-cdk/aws-events:eventsTargetQueueSameAccount": boolean;
+    "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": boolean;
+    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": boolean;
+    "@aws-cdk/customresources:installLatestAwsSdkDefault": boolean;
+    "@aws-cdk/aws-route53-patterns:useCertificate": boolean;
+    "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": boolean;
+    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": boolean;
+    "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": boolean;
+    "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": boolean;
+    "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": boolean;
+    "@aws-cdk/aws-redshift:columnId": boolean;
+    "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": boolean;
+    "@aws-cdk/aws-apigateway:requestValidatorUniqueId": boolean;
+    "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": boolean;
+    "@aws-cdk/aws-kms:aliasNameRef": boolean;
+    "@aws-cdk/core:includePrefixInUniqueNameGeneration": boolean;
+    "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": boolean;
+    "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": boolean;
+    "@aws-cdk/aws-efs:denyAnonymousAccess": boolean;
+    "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": boolean;
+    "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": boolean;
+    "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": boolean;
+    "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": boolean;
+    "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": boolean;
+    "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": boolean;
+    "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": boolean;
+    "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": boolean;
+    "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": boolean;
+    "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": boolean;
+    "@aws-cdk/aws-eks:nodegroupNameAttribute": boolean;
+    "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": boolean;
+    "@aws-cdk/pipelines:reduceAssetRoleTrustScope": boolean;
+    "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": boolean;
+    "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": boolean;
+    "@aws-cdk/aws-s3:keepNotificationInImportedBucket": boolean;
+    "@aws-cdk/aws-stepfunctions-tasks:useNewS3UriParametersForBedrockInvokeModelTask": boolean;
+    "@aws-cdk/aws-ecs:reduceEc2FargateCloudWatchPermissions": boolean;
+    "@aws-cdk/aws-ec2:ec2SumTimeoutEnabled": boolean;
+    "@aws-cdk/aws-appsync:appSyncGraphQLAPIScopeLambdaPermission": boolean;
+    "@aws-cdk/aws-lambda-nodejs:sdkV3ExcludeSmithyPackages": boolean;
+    "@aws-cdk/aws-rds:setCorrectValueForDatabaseInstanceReadReplicaInstanceResourceId": boolean;
+    "@aws-cdk/core:cfnIncludeRejectComplexResourceUpdateCreatePolicyIntrinsics": boolean;
+    "@aws-cdk/aws-stepfunctions-tasks:fixRunEcsTaskPolicy": boolean;
+    "@aws-cdk/aws-dynamodb:resourcePolicyPerReplica": boolean;
+    "@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault": boolean;
+    "@aws-cdk/core:aspectStabilization": boolean;
+    "@aws-cdk/aws-route53-targets:userPoolDomainNameMethodWithoutCustomResource": boolean;
+    "@aws-cdk/aws-ecs:disableEcsImdsBlocking": boolean;
+    "@aws-cdk/aws-ecs:enableImdsBlockingDeprecatedFeature": boolean;
+    "@aws-cdk/aws-elasticloadbalancingV2:albDualstackWithoutPublicIpv4SecurityGroupRulesDefault": boolean;
+    "@aws-cdk/aws-iam:oidcRejectUnauthorizedConnections": boolean;
+    "@aws-cdk/core:enableAdditionalMetadataCollection": boolean;
+    "@aws-cdk/aws-lambda:createNewPoliciesWithAddToRolePolicy": boolean;
+    "@aws-cdk/aws-s3:setUniqueReplicationRoleName": boolean;
+    "@aws-cdk/pipelines:reduceStageRoleTrustScope": boolean;
+    "@aws-cdk/aws-events:requireEventBusPolicySid": boolean;
+    "@aws-cdk/aws-dynamodb:retainTableReplica": boolean;
+    "@aws-cdk/cognito:logUserPoolClientSecretValue": boolean;
+    "@aws-cdk/aws-stepfunctions:useDistributedMapResultWriterV2": boolean;
+    "@aws-cdk/pipelines:reduceCrossAccountActionRoleTrustScope": boolean;
+    "@aws-cdk/core:aspectPrioritiesMutating": boolean;
+    "@aws-cdk/s3-notifications:addS3TrustKeyPolicyForSnsSubscriptions": boolean;
+    "@aws-cdk/aws-ec2-alpha:useResourceIdForVpcV2Migration": boolean;
+    "@aws-cdk/aws-ec2:requirePrivateSubnetsForEgressOnlyInternetGateway": boolean;
+    "@aws-cdk/aws-s3:publicAccessBlockedByDefault": boolean;
+    "@aws-cdk/aws-lambda:useCdkManagedLogGroup": boolean;
+    "@aws-cdk/aws-kms:applyImportedAliasPermissionsToPrincipal": boolean;
+    "@aws-cdk/core:explicitStackTags": boolean;
+};

cdk/node_modules/aws-cdk/lib/cli/telemetry/schema.d.ts

@@ -0,0 +1,85 @@
+interface SessionIdentifiers {
+    readonly cdkCliVersion: string;
+    readonly cdkLibraryVersion?: string;
+    readonly telemetryVersion: string;
+    readonly sessionId: string;
+    readonly installationId: string;
+    readonly region?: string;
+}
+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 SessionEvent {
+    readonly command: Command;
+}
+export type EventType = 'SYNTH' | 'INVOKE' | 'DEPLOY' | 'HOTSWAP';
+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;
+    };
+    readonly ci: boolean;
+    readonly nodeVersion: string;
+    readonly agent?: boolean;
+}
+interface Environment extends SessionEnvironment {
+}
+interface Duration {
+    readonly total: number;
+    readonly components?: {
+        [key: string]: number;
+    };
+}
+type Counters = {
+    [key: string]: number;
+};
+export interface ErrorDetails {
+    readonly name: string;
+    readonly message?: string;
+    readonly stackTrace?: string;
+    readonly logs?: string;
+}
+interface Dependency {
+    readonly name: string;
+    readonly version: string;
+}
+interface SessionProject {
+    readonly dependencies?: Dependency[];
+    readonly language?: string;
+}
+interface Project extends SessionProject {
+}
+export interface TelemetrySchema {
+    readonly identifiers: Identifiers;
+    readonly event: Event;
+    readonly environment: Environment;
+    readonly project: Project;
+    readonly duration: Duration;
+    readonly counters?: Counters;
+    readonly error?: ErrorDetails;
+}
+export interface SessionSchema {
+    identifiers: SessionIdentifiers;
+    event: SessionEvent;
+    environment: SessionEnvironment;
+    project: SessionProject;
+}
+export {};

cdk/node_modules/aws-cdk/lib/cli/telemetry/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/session.d.ts

@@ -0,0 +1,67 @@
+import { type EventType, type ErrorDetails } from './schema';
+import type { ITelemetrySink } from './sink/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;
+    readonly counters?: Record<string, number>;
+}
+/**
+ * Timer of a single event
+ */
+export interface Timing {
+    /**
+     * Total time spent in this operation
+     */
+    totalMs: number;
+    /**
+     * Count of operations that together took `totalMs`.
+     */
+    count: number;
+}
+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>;
+    /**
+     * Attach a language guess
+     */
+    attachLanguage(language: string | undefined): void;
+    /**
+     * Attach our best guess at running under an agent or not
+     */
+    attachAgent(isAgent: boolean | undefined): void;
+    /**
+     * Attach the CDK library version
+     *
+     * By default the telemetry will guess at the CDK library version if it so
+     * happens that the CDK project is an NPM project and the CDK CLI is executed
+     * in the root of NPM project with `aws-cdk-lib` available in `node_modules`.
+     * This may succeed or may fail.
+     *
+     * Once we have produced and loaded the cloud assembly more accurate
+     * information becomes available that we can add in.
+     */
+    attachCdkLibVersion(libVersion: string): 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();
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/endpoint-sink.d.ts

@@ -0,0 +1,44 @@
+import type { Agent } from 'https';
+import type { IIoHost } from '../../io-host';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the Endpoint Telemetry Client
+ */
+export interface EndpointTelemetrySinkProps {
+    /**
+     * The external endpoint to hit
+     */
+    readonly endpoint: string;
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * The agent responsible for making the network requests.
+     *
+     * Use this to set up a proxy connection.
+     *
+     * @default - Uses the shared global node agent
+     */
+    readonly agent?: Agent;
+}
+/**
+ * The telemetry client that hits an external endpoint.
+ */
+export declare class EndpointTelemetrySink implements ITelemetrySink {
+    private events;
+    private endpoint;
+    private ioHelper;
+    private agent?;
+    constructor(props: EndpointTelemetrySinkProps);
+    /**
+     * Add an event to the collection.
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+    /**
+     * Returns true if telemetry successfully posted, false otherwise.
+     */
+    private https;
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/file-sink.d.ts

@@ -0,0 +1,32 @@
+import { type IIoHost } from '@aws-cdk/toolkit-lib';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the FileTelemetryClient
+ */
+export interface FileTelemetrySinkProps {
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+    /**
+     * The local file to log telemetry data to.
+     */
+    readonly logFilePath: string;
+}
+/**
+ * A telemetry client that collects events writes them to a file
+ */
+export declare class FileTelemetrySink implements ITelemetrySink {
+    private ioHelper;
+    private logFilePath;
+    /**
+     * Create a new FileTelemetryClient
+     */
+    constructor(props: FileTelemetrySinkProps);
+    /**
+     * Emit an event.
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/file-sink.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTelemetrySink = void 0;
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const fs = require("fs-extra");
+const api_private_1 = require("../../../api-private");
+/**
+ * A telemetry client that collects events writes them to a file
+ */
+class FileTelemetrySink {
+    /**
+     * Create a new FileTelemetryClient
+     */
+    constructor(props) {
+        this.ioHelper = api_private_1.IoHelper.fromActionAwareIoHost(props.ioHost);
+        this.logFilePath = props.logFilePath;
+        if (fs.existsSync(this.logFilePath)) {
+            throw new toolkit_lib_1.ToolkitError('TelemetryFileExists', `Telemetry file already exists at ${this.logFilePath}`);
+        }
+        // Create the file
+        fs.ensureFileSync(this.logFilePath);
+        fs.writeJsonSync(this.logFilePath, []);
+    }
+    /**
+     * Emit an event.
+     */
+    async emit(event) {
+        try {
+            const json = fs.readJsonSync(this.logFilePath);
+            json.push(event);
+            fs.writeJSONSync(this.logFilePath, json, { spaces: 2 });
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);
+        }
+    }
+    async flush() {
+        return;
+    }
+}
+exports.FileTelemetrySink = FileTelemetrySink;
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/funnel.d.ts

@@ -0,0 +1,16 @@
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+export interface FunnelProps {
+    readonly sinks: ITelemetrySink[];
+}
+/**
+ * A funnel is a combination of one or more sinks.
+ * The sink functions are executed in parallel, and a maximum of 5
+ * sinks are supported per funnel.
+ */
+export declare class Funnel {
+    private readonly sinks;
+    constructor(props: FunnelProps);
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/funnel.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Funnel = void 0;
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+/**
+ * A funnel is a combination of one or more sinks.
+ * The sink functions are executed in parallel, and a maximum of 5
+ * sinks are supported per funnel.
+ */
+class Funnel {
+    constructor(props) {
+        if (props.sinks.length > 5) {
+            throw new toolkit_lib_1.ToolkitError('MaxSinksExceeded', `Funnel class supports a maximum of 5 parallel sinks, got ${props.sinks.length} sinks.`);
+        }
+        this.sinks = props.sinks;
+    }
+    async emit(event) {
+        // Funnel class enforces a maximum of 5 parallel sinks
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        await Promise.all(this.sinks.map(sink => sink.emit(event)));
+    }
+    async flush() {
+        // Funnel class enforces a maximum of 5 parallel sinks
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        await Promise.all(this.sinks.map(sink => sink.flush()));
+    }
+}
+exports.Funnel = Funnel;
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/io-host-sink.d.ts

@@ -0,0 +1,27 @@
+import type { IIoHost } from '@aws-cdk/toolkit-lib';
+import type { TelemetrySchema } from '../schema';
+import type { ITelemetrySink } from './sink-interface';
+/**
+ * Properties for the StdoutTelemetryClient
+ */
+export interface IoHostTelemetrySinkProps {
+    /**
+     * Where messages are going to be sent
+     */
+    readonly ioHost: IIoHost;
+}
+/**
+ * A telemetry client that collects events and flushes them to stdout.
+ */
+export declare class IoHostTelemetrySink implements ITelemetrySink {
+    private ioHelper;
+    /**
+     * Create a new StdoutTelemetryClient
+     */
+    constructor(props: IoHostTelemetrySinkProps);
+    /**
+     * Emit an event
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    flush(): Promise<void>;
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/io-host-sink.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoHostTelemetrySink = void 0;
+const api_private_1 = require("../../../api-private");
+/**
+ * A telemetry client that collects events and flushes them to stdout.
+ */
+class IoHostTelemetrySink {
+    /**
+     * Create a new StdoutTelemetryClient
+     */
+    constructor(props) {
+        this.ioHelper = api_private_1.IoHelper.fromActionAwareIoHost(props.ioHost);
+    }
+    /**
+     * Emit an event
+     */
+    async emit(event) {
+        try {
+            // Format the events as a JSON string with pretty printing
+            const output = JSON.stringify(event, null, 2);
+            // Write to IoHost
+            await this.ioHelper.defaults.trace(`--- TELEMETRY EVENT ---\n${output}\n-----------------------\n`);
+        }
+        catch (e) {
+            // Never throw errors, just log them via ioHost
+            await this.ioHelper.defaults.trace(`Failed to add telemetry event: ${e.message}`);
+        }
+    }
+    async flush() {
+        return;
+    }
+}
+exports.IoHostTelemetrySink = IoHostTelemetrySink;
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/sink-interface.d.ts

@@ -0,0 +1,18 @@
+import type { TelemetrySchema } from '../schema';
+/**
+ * All Telemetry Clients are Sinks.
+ *
+ * A telemtry client receives event data via 'emit'
+ * and sends batched events via 'flush'
+ */
+export interface ITelemetrySink {
+    /**
+     * Recieve an event
+     */
+    emit(event: TelemetrySchema): Promise<void>;
+    /**
+     * If the implementer of ITelemetrySink batches events,
+     * flush sends the data and clears the cache.
+     */
+    flush(): Promise<void>;
+}

cdk/node_modules/aws-cdk/lib/cli/telemetry/sink/sink-interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luay1pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzaW5rLWludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUZWxlbWV0cnlTY2hlbWEgfSBmcm9tICcuLi9zY2hlbWEnO1xuXG4vKipcbiAqIEFsbCBUZWxlbWV0cnkgQ2xpZW50cyBhcmUgU2lua3MuXG4gKlxuICogQSB0ZWxlbXRyeSBjbGllbnQgcmVjZWl2ZXMgZXZlbnQgZGF0YSB2aWEgJ2VtaXQnXG4gKiBhbmQgc2VuZHMgYmF0Y2hlZCBldmVudHMgdmlhICdmbHVzaCdcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJVGVsZW1ldHJ5U2luayB7XG4gIC8qKlxuICAgKiBSZWNpZXZlIGFuIGV2ZW50XG4gICAqL1xuICBlbWl0KGV2ZW50OiBUZWxlbWV0cnlTY2hlbWEpOiBQcm9taXNlPHZvaWQ+O1xuXG4gIC8qKlxuICAgKiBJZiB0aGUgaW1wbGVtZW50ZXIgb2YgSVRlbGVtZXRyeVNpbmsgYmF0Y2hlcyBldmVudHMsXG4gICAqIGZsdXNoIHNlbmRzIHRoZSBkYXRhIGFuZCBjbGVhcnMgdGhlIGNhY2hlLlxuICAgKi9cbiAgZmx1c2goKTogUHJvbWlzZTx2b2lkPjtcbn1cbiJdfQ==

cdk/node_modules/aws-cdk/lib/cli/user-configuration.d.ts

@@ -0,0 +1,106 @@
+import { Context } from '../api/context';
+import { Settings } from '../api/settings';
+import type { IoHelper } from '../api-private';
+export declare const PROJECT_CONFIG = "cdk.json";
+export { PROJECT_CONTEXT } from '../api/context';
+export declare const USER_DEFAULTS = "~/.cdk.json";
+export declare enum Command {
+    LS = "ls",
+    LIST = "list",
+    DIFF = "diff",
+    BOOTSTRAP = "bootstrap",
+    DEPLOY = "deploy",
+    DESTROY = "destroy",
+    SYNTHESIZE = "synthesize",
+    SYNTH = "synth",
+    METADATA = "metadata",
+    INIT = "init",
+    VERSION = "version",
+    WATCH = "watch",
+    GC = "gc",
+    FLAGS = "flags",
+    ROLLBACK = "rollback",
+    PUBLISH_ASSETS = "publish-assets",
+    IMPORT = "import",
+    ACKNOWLEDGE = "acknowledge",
+    ACK = "ack",
+    NOTICES = "notices",
+    MIGRATE = "migrate",
+    CONTEXT = "context",
+    DOCS = "docs",
+    DOC = "doc",
+    DOCTOR = "doctor",
+    ORPHAN = "orphan",
+    REFACTOR = "refactor",
+    DRIFT = "drift",
+    CLI_TELEMETRY = "cli-telemetry",
+    DIAGNOSE = "diagnose"
+}
+export type Arguments = {
+    readonly _: [Command, ...string[]];
+    readonly exclusively?: boolean;
+    readonly STACKS?: string[];
+    readonly lookups?: boolean;
+    readonly [name: string]: unknown;
+};
+export interface ConfigurationProps {
+    /**
+     * Configuration passed via command line arguments
+     *
+     * @default - Nothing passed
+     */
+    readonly commandLineArguments?: Arguments;
+    /**
+     * Whether or not to use context from `.cdk.json` in user home directory
+     *
+     * @default true
+     */
+    readonly readUserContext?: boolean;
+}
+/**
+ * All sources of settings combined
+ */
+export declare class Configuration {
+    /**
+     * Creates user configuration from commandLineArguments
+     */
+    static fromArgs(ioHelper: IoHelper, args?: Arguments): Promise<Configuration>;
+    /**
+     * Creates user configuration from commandLineArguments and loads
+     */
+    static fromArgsAndFiles(ioHelper: IoHelper, props?: ConfigurationProps): Promise<Configuration>;
+    settings: Settings;
+    context: Context;
+    readonly defaultConfig: Settings;
+    private readonly commandLineArguments;
+    private readonly commandLineContext;
+    private _projectConfig?;
+    private _projectContext?;
+    private loaded;
+    private ioHelper;
+    private constructor();
+    private get projectConfig();
+    get projectContext(): Settings;
+    /**
+     * Load all config
+     */
+    private loadConfigFiles;
+    /**
+     * Save the project context
+     */
+    saveContext(): Promise<this>;
+}
+/**
+ * Parse CLI arguments into Settings
+ *
+ * CLI arguments in must be accessed in the CLI code via
+ * `configuration.settings.get(['argName'])` instead of via `args.argName`.
+ *
+ * The advantage is that they can be configured via `cdk.json` and
+ * `$HOME/.cdk.json`. Arguments not listed below and accessed via this object
+ * can only be specified on the command line.
+ *
+ * @param argv - the received CLI arguments.
+ * @returns a new Settings object.
+ */
+export declare function commandLineArgumentsToSettings(ioHelper: IoHelper, argv: Arguments): Promise<Settings>;

cdk/node_modules/aws-cdk/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;

cdk/node_modules/aws-cdk/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==

cdk/node_modules/aws-cdk/lib/cli/util/console-formatters.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns a set of strings when printed on the console produces a banner msg. The message is in the following format -
+ * ********************
+ * *** msg line x   ***
+ * *** msg line xyz ***
+ * ********************
+ *
+ * Spec:
+ * - The width of every line is equal, dictated by the longest message string
+ * - The first and last lines are '*'s for the full length of the line
+ * - Each line in between is prepended with '*** ' and appended with ' ***'
+ * - The text is indented left, i.e. whitespace is right-padded when the length is shorter than the longest.
+ *
+ * @param msgs - array of strings containing the message lines to be printed in the banner. Returns empty string if array
+ * is empty.
+ * @returns array of strings containing the message formatted as a banner
+ */
+export declare function formatAsBanner(msgs: string[]): string[];

cdk/node_modules/aws-cdk/lib/cli/util/console-formatters.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAsBanner = formatAsBanner;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const stripAnsi = require('strip-ansi');
+/**
+ * Returns a set of strings when printed on the console produces a banner msg. The message is in the following format -
+ * ********************
+ * *** msg line x   ***
+ * *** msg line xyz ***
+ * ********************
+ *
+ * Spec:
+ * - The width of every line is equal, dictated by the longest message string
+ * - The first and last lines are '*'s for the full length of the line
+ * - Each line in between is prepended with '*** ' and appended with ' ***'
+ * - The text is indented left, i.e. whitespace is right-padded when the length is shorter than the longest.
+ *
+ * @param msgs - array of strings containing the message lines to be printed in the banner. Returns empty string if array
+ * is empty.
+ * @returns array of strings containing the message formatted as a banner
+ */
+function formatAsBanner(msgs) {
+    const printLen = (str) => stripAnsi(str).length;
+    if (msgs.length === 0) {
+        return [];
+    }
+    const leftPad = '*** ';
+    const rightPad = ' ***';
+    const bannerWidth = printLen(leftPad) + printLen(rightPad) +
+        msgs.reduce((acc, msg) => Math.max(acc, printLen(msg)), 0);
+    const bannerLines = [];
+    bannerLines.push('*'.repeat(bannerWidth));
+    // Improvement: If any 'msg' is wider than the terminal width, wrap message across lines.
+    msgs.forEach((msg) => {
+        const padding = ' '.repeat(bannerWidth - (printLen(msg) + printLen(leftPad) + printLen(rightPad)));
+        bannerLines.push(''.concat(leftPad, msg, padding, rightPad));
+    });
+    bannerLines.push('*'.repeat(bannerWidth));
+    return bannerLines;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS1mb3JtYXR0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY29uc29sZS1mb3JtYXR0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBb0JBLHdDQXVCQztBQTNDRCxpRUFBaUU7QUFDakUsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO0FBRXhDOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsU0FBZ0IsY0FBYyxDQUFDLElBQWM7SUFDM0MsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFXLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFFeEQsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQ3RCLE9BQU8sRUFBRSxDQUFDO0lBQ1osQ0FBQztJQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN2QixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUM7SUFDeEIsTUFBTSxXQUFXLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxHQUFHLFFBQVEsQ0FBQyxRQUFRLENBQUM7UUFDeEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBRTdELE1BQU0sV0FBVyxHQUFhLEVBQUUsQ0FBQztJQUNqQyxXQUFXLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztJQUUxQyx5RkFBeUY7SUFDekYsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1FBQ25CLE1BQU0sT0FBTyxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsV0FBVyxHQUFHLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsR0FBRyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25HLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDO0lBQy9ELENBQUMsQ0FBQyxDQUFDO0lBRUgsV0FBVyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFDMUMsT0FBTyxXQUFXLENBQUM7QUFDckIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG5jb25zdCBzdHJpcEFuc2kgPSByZXF1aXJlKCdzdHJpcC1hbnNpJyk7XG5cbi8qKlxuICogUmV0dXJucyBhIHNldCBvZiBzdHJpbmdzIHdoZW4gcHJpbnRlZCBvbiB0aGUgY29uc29sZSBwcm9kdWNlcyBhIGJhbm5lciBtc2cuIFRoZSBtZXNzYWdlIGlzIGluIHRoZSBmb2xsb3dpbmcgZm9ybWF0IC1cbiAqICoqKioqKioqKioqKioqKioqKioqXG4gKiAqKiogbXNnIGxpbmUgeCAgICoqKlxuICogKioqIG1zZyBsaW5lIHh5eiAqKipcbiAqICoqKioqKioqKioqKioqKioqKioqXG4gKlxuICogU3BlYzpcbiAqIC0gVGhlIHdpZHRoIG9mIGV2ZXJ5IGxpbmUgaXMgZXF1YWwsIGRpY3RhdGVkIGJ5IHRoZSBsb25nZXN0IG1lc3NhZ2Ugc3RyaW5nXG4gKiAtIFRoZSBmaXJzdCBhbmQgbGFzdCBsaW5lcyBhcmUgJyoncyBmb3IgdGhlIGZ1bGwgbGVuZ3RoIG9mIHRoZSBsaW5lXG4gKiAtIEVhY2ggbGluZSBpbiBiZXR3ZWVuIGlzIHByZXBlbmRlZCB3aXRoICcqKiogJyBhbmQgYXBwZW5kZWQgd2l0aCAnICoqKidcbiAqIC0gVGhlIHRleHQgaXMgaW5kZW50ZWQgbGVmdCwgaS5lLiB3aGl0ZXNwYWNlIGlzIHJpZ2h0LXBhZGRlZCB3aGVuIHRoZSBsZW5ndGggaXMgc2hvcnRlciB0aGFuIHRoZSBsb25nZXN0LlxuICpcbiAqIEBwYXJhbSBtc2dzIC0gYXJyYXkgb2Ygc3RyaW5ncyBjb250YWluaW5nIHRoZSBtZXNzYWdlIGxpbmVzIHRvIGJlIHByaW50ZWQgaW4gdGhlIGJhbm5lci4gUmV0dXJucyBlbXB0eSBzdHJpbmcgaWYgYXJyYXlcbiAqIGlzIGVtcHR5LlxuICogQHJldHVybnMgYXJyYXkgb2Ygc3RyaW5ncyBjb250YWluaW5nIHRoZSBtZXNzYWdlIGZvcm1hdHRlZCBhcyBhIGJhbm5lclxuICovXG5leHBvcnQgZnVuY3Rpb24gZm9ybWF0QXNCYW5uZXIobXNnczogc3RyaW5nW10pOiBzdHJpbmdbXSB7XG4gIGNvbnN0IHByaW50TGVuID0gKHN0cjogc3RyaW5nKSA9PiBzdHJpcEFuc2koc3RyKS5sZW5ndGg7XG5cbiAgaWYgKG1zZ3MubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIFtdO1xuICB9XG5cbiAgY29uc3QgbGVmdFBhZCA9ICcqKiogJztcbiAgY29uc3QgcmlnaHRQYWQgPSAnICoqKic7XG4gIGNvbnN0IGJhbm5lcldpZHRoID0gcHJpbnRMZW4obGVmdFBhZCkgKyBwcmludExlbihyaWdodFBhZCkgK1xuICAgIG1zZ3MucmVkdWNlKChhY2MsIG1zZykgPT4gTWF0aC5tYXgoYWNjLCBwcmludExlbihtc2cpKSwgMCk7XG5cbiAgY29uc3QgYmFubmVyTGluZXM6IHN0cmluZ1tdID0gW107XG4gIGJhbm5lckxpbmVzLnB1c2goJyonLnJlcGVhdChiYW5uZXJXaWR0aCkpO1xuXG4gIC8vIEltcHJvdmVtZW50OiBJZiBhbnkgJ21zZycgaXMgd2lkZXIgdGhhbiB0aGUgdGVybWluYWwgd2lkdGgsIHdyYXAgbWVzc2FnZSBhY3Jvc3MgbGluZXMuXG4gIG1zZ3MuZm9yRWFjaCgobXNnKSA9PiB7XG4gICAgY29uc3QgcGFkZGluZyA9ICcgJy5yZXBlYXQoYmFubmVyV2lkdGggLSAocHJpbnRMZW4obXNnKSArIHByaW50TGVuKGxlZnRQYWQpICsgcHJpbnRMZW4ocmlnaHRQYWQpKSk7XG4gICAgYmFubmVyTGluZXMucHVzaCgnJy5jb25jYXQobGVmdFBhZCwgbXNnLCBwYWRkaW5nLCByaWdodFBhZCkpO1xuICB9KTtcblxuICBiYW5uZXJMaW5lcy5wdXNoKCcqJy5yZXBlYXQoYmFubmVyV2lkdGgpKTtcbiAgcmV0dXJuIGJhbm5lckxpbmVzO1xufVxuIl19

cdk/node_modules/aws-cdk/lib/cli/util/guess-agent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Guess whether we're being executed by an AI agent
+ *
+ * It's hard for us to say `false` for sure, so we only respond
+ * with `yes` or `don't know`.
+ */
+export declare function guessAgent(): true | undefined;

cdk/node_modules/aws-cdk/lib/cli/util/guess-agent.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessAgent = guessAgent;
+/**
+ * Guess whether we're being executed by an AI agent
+ *
+ * It's hard for us to say `false` for sure, so we only respond
+ * with `yes` or `don't know`.
+ */
+function guessAgent() {
+    const awsExecutionEnv = (process.env.AWS_EXECUTION_ENV ?? '').toLocaleLowerCase();
+    if (awsExecutionEnv.includes('amazonq') || awsExecutionEnv.includes('kiro')) {
+        return true;
+    }
+    if (process.env.CLAUDECODE) {
+        return true;
+    }
+    // Expecting CODEX_SANDBOX, CODEX_THREAD_ID
+    if (Object.keys(process.env).some(x => x.startsWith('CODEX_'))) {
+        return true;
+    }
+    if (process.env.CURSOR_AGENT) {
+        return true;
+    }
+    // Cline -- not sure if it sets these, but users might to configure Cline.
+    if (Object.keys(process.env).some(x => x.startsWith('CLINE_'))) {
+        return true;
+    }
+    // Copilot doesn't set an envvar (at least not in VS Code)
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/util/npm.d.ts

@@ -0,0 +1,4 @@
+export declare function execNpmView(currentVersion: string): Promise<{
+    latestVersion: string;
+    deprecated: any;
+}>;

cdk/node_modules/aws-cdk/lib/cli/util/npm.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execNpmView = execNpmView;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
+const exec = (0, util_1.promisify)(child_process_1.exec);
+/* c8 ignore start */
+async function execNpmView(currentVersion) {
+    try {
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        const [latestResult, currentResult] = await Promise.all([
+            exec('npm view aws-cdk@latest version', { timeout: 3000 }),
+            exec(`npm view aws-cdk@${currentVersion} name version deprecated --json`, { timeout: 3000 }),
+        ]);
+        if (latestResult.stderr && latestResult.stderr.trim().length > 0) {
+            throw new toolkit_lib_1.ToolkitError('NpmViewLatestFailed', `npm view command for latest version failed: ${latestResult.stderr.trim()}`);
+        }
+        if (currentResult.stderr && currentResult.stderr.trim().length > 0) {
+            throw new toolkit_lib_1.ToolkitError('NpmViewCurrentFailed', `npm view command for current version failed: ${currentResult.stderr.trim()}`);
+        }
+        const latestVersion = latestResult.stdout;
+        const currentInfo = JSON.parse(currentResult.stdout);
+        return {
+            latestVersion: latestVersion,
+            deprecated: currentInfo.deprecated,
+        };
+    }
+    catch (err) {
+        throw err;
+    }
+}
+/* c8 ignore stop */
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/util/trap-errors.d.ts

@@ -0,0 +1,6 @@
+import type { IoHelper } from '../../api-private';
+/**
+ * Run an async callback, swallowing any errors and logging them as debug messages.
+ * Use this for code paths that must never break CLI execution.
+ */
+export declare function trapErrors<T>(ioHelper: IoHelper, message: string, cb: () => Promise<T>): Promise<T | undefined>;

cdk/node_modules/aws-cdk/lib/cli/util/trap-errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trapErrors = trapErrors;
+/**
+ * Run an async callback, swallowing any errors and logging them as debug messages.
+ * Use this for code paths that must never break CLI execution.
+ */
+async function trapErrors(ioHelper, message, cb) {
+    try {
+        return await cb();
+    }
+    catch (e) {
+        await ioHelper.defaults.debug(`${message}: ${e}`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhcC1lcnJvcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ0cmFwLWVycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLGdDQU9DO0FBWEQ7OztHQUdHO0FBQ0ksS0FBSyxVQUFVLFVBQVUsQ0FBSSxRQUFrQixFQUFFLE9BQWUsRUFBRSxFQUFvQjtJQUMzRixJQUFJLENBQUM7UUFDSCxPQUFPLE1BQU0sRUFBRSxFQUFFLENBQUM7SUFDcEIsQ0FBQztJQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7UUFDWCxNQUFNLFFBQVEsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEdBQUcsT0FBTyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDbEQsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IElvSGVscGVyIH0gZnJvbSAnLi4vLi4vYXBpLXByaXZhdGUnO1xuXG4vKipcbiAqIFJ1biBhbiBhc3luYyBjYWxsYmFjaywgc3dhbGxvd2luZyBhbnkgZXJyb3JzIGFuZCBsb2dnaW5nIHRoZW0gYXMgZGVidWcgbWVzc2FnZXMuXG4gKiBVc2UgdGhpcyBmb3IgY29kZSBwYXRocyB0aGF0IG11c3QgbmV2ZXIgYnJlYWsgQ0xJIGV4ZWN1dGlvbi5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHRyYXBFcnJvcnM8VD4oaW9IZWxwZXI6IElvSGVscGVyLCBtZXNzYWdlOiBzdHJpbmcsIGNiOiAoKSA9PiBQcm9taXNlPFQ+KTogUHJvbWlzZTxUIHwgdW5kZWZpbmVkPiB7XG4gIHRyeSB7XG4gICAgcmV0dXJuIGF3YWl0IGNiKCk7XG4gIH0gY2F0Y2ggKGUpIHtcbiAgICBhd2FpdCBpb0hlbHBlci5kZWZhdWx0cy5kZWJ1ZyhgJHttZXNzYWdlfTogJHtlfWApO1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cbn1cbiJdfQ==

cdk/node_modules/aws-cdk/lib/cli/util/yargs-helpers.d.ts

@@ -0,0 +1,22 @@
+export { isCI } from '../util/ci';
+/**
+ * yargs middleware to negate an option if a negative alias is provided
+ * E.g. `-R` will imply `--rollback=false`
+ *
+ * @param optionToNegate - The name of the option to negate, e.g. `rollback`
+ * @param negativeAlias - The alias that should negate the option, e.g. `R`
+ * @returns a middleware function that can be passed to yargs
+ */
+export declare function yargsNegativeAlias<T extends {
+    [x in S | L]: boolean | undefined;
+}, S extends string, L extends string>(negativeAlias: S, optionToNegate: L): (argv: T) => T;
+/**
+ * Returns the current version of the CLI
+ * @returns the current version of the CLI
+ */
+export declare function cliVersion(): string;
+/**
+ * Returns the default browser command for the current platform
+ * @returns the default browser command for the current platform
+ */
+export declare function browserForPlatform(): string;

cdk/node_modules/aws-cdk/lib/cli/util/yargs-helpers.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCI = void 0;
+exports.yargsNegativeAlias = yargsNegativeAlias;
+exports.cliVersion = cliVersion;
+exports.browserForPlatform = browserForPlatform;
+const version_1 = require("../version");
+var ci_1 = require("../util/ci");
+Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return ci_1.isCI; } });
+/**
+ * yargs middleware to negate an option if a negative alias is provided
+ * E.g. `-R` will imply `--rollback=false`
+ *
+ * @param optionToNegate - The name of the option to negate, e.g. `rollback`
+ * @param negativeAlias - The alias that should negate the option, e.g. `R`
+ * @returns a middleware function that can be passed to yargs
+ */
+function yargsNegativeAlias(negativeAlias, optionToNegate) {
+    return (argv) => {
+        // if R in argv && argv[R]
+        // then argv[rollback] = false
+        if (negativeAlias in argv && argv[negativeAlias]) {
+            argv[optionToNegate] = false;
+        }
+        return argv;
+    };
+}
+/**
+ * Returns the current version of the CLI
+ * @returns the current version of the CLI
+ */
+function cliVersion() {
+    return (0, version_1.versionWithBuild)();
+}
+/**
+ * Returns the default browser command for the current platform
+ * @returns the default browser command for the current platform
+ */
+function browserForPlatform() {
+    switch (process.platform) {
+        case 'darwin':
+            return 'open %u';
+        case 'win32':
+            return 'start %u';
+        default:
+            return 'xdg-open %u';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

cdk/node_modules/aws-cdk/lib/cli/version.d.ts

@@ -0,0 +1,3 @@
+export declare function versionWithBuild(): string;
+export declare function isDeveloperBuildVersion(): boolean;
+export declare function versionNumber(): string;

cdk/node_modules/aws-cdk/lib/cli/version.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionWithBuild = versionWithBuild;
+exports.isDeveloperBuildVersion = isDeveloperBuildVersion;
+exports.versionNumber = versionNumber;
+const path = require("path");
+const root_dir_1 = require("./root-dir");
+function versionWithBuild() {
+    return `${versionNumber()} (build ${commit()})`;
+}
+function isDeveloperBuildVersion() {
+    return versionNumber() === '0.0.0';
+}
+function versionNumber() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path.join((0, root_dir_1.cliRootDir)(), 'package.json')).version.replace(/\+[0-9a-f]+$/, '');
+}
+function commit() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path.join((0, root_dir_1.cliRootDir)(), 'build-info.json')).commit;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSw0Q0FFQztBQUVELDBEQUVDO0FBRUQsc0NBR0M7QUFkRCw2QkFBNkI7QUFDN0IseUNBQXdDO0FBRXhDLFNBQWdCLGdCQUFnQjtJQUM5QixPQUFPLEdBQUcsYUFBYSxFQUFFLFdBQVcsTUFBTSxFQUFFLEdBQUcsQ0FBQztBQUNsRCxDQUFDO0FBRUQsU0FBZ0IsdUJBQXVCO0lBQ3JDLE9BQU8sYUFBYSxFQUFFLEtBQUssT0FBTyxDQUFDO0FBQ3JDLENBQUM7QUFFRCxTQUFnQixhQUFhO0lBQzNCLGlFQUFpRTtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUEscUJBQVUsR0FBRSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxjQUFjLEVBQUUsRUFBRSxDQUFDLENBQUM7QUFDOUYsQ0FBQztBQUVELFNBQVMsTUFBTTtJQUNiLGlFQUFpRTtJQUNqRSxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUEscUJBQVUsR0FBRSxFQUFFLGlCQUFpQixDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7QUFDcEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBjbGlSb290RGlyIH0gZnJvbSAnLi9yb290LWRpcic7XG5cbmV4cG9ydCBmdW5jdGlvbiB2ZXJzaW9uV2l0aEJ1aWxkKCkge1xuICByZXR1cm4gYCR7dmVyc2lvbk51bWJlcigpfSAoYnVpbGQgJHtjb21taXQoKX0pYDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlzRGV2ZWxvcGVyQnVpbGRWZXJzaW9uKCk6IGJvb2xlYW4ge1xuICByZXR1cm4gdmVyc2lvbk51bWJlcigpID09PSAnMC4wLjAnO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gdmVyc2lvbk51bWJlcigpOiBzdHJpbmcge1xuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXJlcXVpcmUtaW1wb3J0c1xuICByZXR1cm4gcmVxdWlyZShwYXRoLmpvaW4oY2xpUm9vdERpcigpLCAncGFja2FnZS5qc29uJykpLnZlcnNpb24ucmVwbGFjZSgvXFwrWzAtOWEtZl0rJC8sICcnKTtcbn1cblxuZnVuY3Rpb24gY29tbWl0KCk6IHN0cmluZyB7XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tcmVxdWlyZS1pbXBvcnRzXG4gIHJldHVybiByZXF1aXJlKHBhdGguam9pbihjbGlSb290RGlyKCksICdidWlsZC1pbmZvLmpzb24nKSkuY29tbWl0O1xufVxuIl19