agent-claw: automated task changes

cdk/node_modules/constructs/.compatignore

@@ -0,0 +1,23 @@
+# 10.x BREAKING CHANGES
+removed-argument:constructs.Construct.<initializer>
+removed:constructs.Construct.onPrepare
+removed:constructs.Construct.onSynthesize
+removed:constructs.Construct.onValidate
+removed:constructs.ConstructMetadata
+removed:constructs.Node.addError
+removed:constructs.Node.addInfo
+incompatible-argument:constructs.Node.addMetadata
+removed:constructs.Node.addWarning
+removed:constructs.Node.applyAspect
+removed:constructs.Node.prepare
+removed:constructs.Node.synthesize
+change-return-type:constructs.Node.validate
+removed:constructs.ValidationError
+changed-type:constructs.Node.dependencies
+removed:constructs.ConstructOptions
+removed:constructs.Dependency
+removed:constructs.IAspect
+removed:constructs.INodeFactory
+removed:constructs.ISynthesisSession
+removed:constructs.SynthesisOptions
+removed:constructs.Node.uniqueId

cdk/node_modules/constructs/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.

cdk/node_modules/constructs/CONTRIBUTING.md

@@ -0,0 +1,146 @@
+# Contributing Guidelines
+
+Thank you for your interest in contributing to our project. Whether it's a bug
+report, new feature, correction, or additional documentation, we greatly value
+feedback and contributions from our community.
+
+Please read through this document before submitting any issues or pull requests
+to ensure we have all the necessary information to effectively respond to your
+bug report or contribution.
+
+## Development
+
+To setup a development environment, you'll need
+[Node.js](https://nodejs.org/en/) and [yarn](https://yarnpkg.com/).
+
+Fresh full build:
+
+1. Clone the repo
+2. Run `yarn install`
+3. Run `yarn build`
+
+You can also use these more granular scripts:
+
+- `yarn compile`: compile code to JavaScript
+- `yarn watch`: watch in the background and compile
+- `yarn test`: run all tests and linters
+- `yarn compat`: check that APIs do not introduce breaking changes
+- `yarn lint`: run eslint and API compatibility
+
+### Docker Build
+
+If you want to use docker to build, test and package your work use the following:
+
+```shell script
+docker build -t constructs .
+```
+
+### Using a local version of this library in a dependency
+
+If you're doing changes to this library,
+you often want to test them being used in a real dependency
+(for example, the [AWS CDK](https://github.com/aws/aws-cdk))
+to verify the changes work like expected.
+To make that easier,
+this repository includes a script in the `scripts`
+directory that overwrites the version of `constructs`
+in a dependency's `node_modules`
+with a symbolic link to the local version of `constructs`:
+
+```shell script
+cd my/project/that/uses/constructs/library
+/path/to/source/of/constructs/scripts/link.sh
+```
+
+## Reporting Bugs/Feature Requests
+
+We welcome you to use the GitHub issue tracker to report bugs or suggest
+features.
+
+When filing an issue, please check existing open, or recently closed, issues to
+make sure somebody else hasn't already reported the issue. Please try to include
+as much information as you can. Details like these are incredibly useful:
+
+* A reproducible test case or series of steps
+* The version of our code being used
+* Any modifications you've made relevant to the bug
+* Anything unusual about your environment or deployment
+
+## Contributing via Pull Requests
+
+Contributions via pull requests are much appreciated. Before sending us a pull
+request, please ensure that:
+
+1. You are working against the latest source on the *master* branch.
+2. You check existing open, and recently merged, pull requests to make sure
+   someone else hasn't addressed the problem already.
+3. You open an issue to discuss any significant work - we would hate for your
+   time to be wasted.
+
+To send us a pull request, please:
+
+1. Fork the repository.
+2. Modify the source; please focus on the specific change you are contributing.
+   If you also reformat all the code, it will be hard for us to focus on your
+   change.
+3. Ensure local tests pass.
+4. Commit to your fork using clear commit messages.
+5. Send us a pull request, answering any default questions in the pull request
+   interface.
+6. Pay attention to any automated CI failures reported in the pull request, and
+   stay involved in the conversation.
+
+GitHub provides additional document on [forking a
+repository](https://help.github.com/articles/fork-a-repo/) and [creating a pull
+request](https://help.github.com/articles/creating-a-pull-request/).
+
+
+## Finding contributions to work on
+
+Looking at the existing issues is a great way to find something to contribute
+on. As our projects, by default, use the default GitHub issue labels
+(enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any
+'help wanted' issues is a great place to start.
+
+
+## Code of Conduct
+
+This project has adopted the [Amazon Open Source Code of
+Conduct](https://aws.github.io/code-of-conduct). For more information see the
+[Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.
+
+## Security issue notifications
+
+If you discover a potential security issue in this project we ask that you
+notify AWS/Amazon Security via our [vulnerability reporting
+page](http://aws.amazon.com/security/vulnerability-reporting/). Please do
+**not** create a public github issue.
+
+## Releasing a New Version
+
+To release a new version, run `yarn bump` which will:"
+
+- Calculate the next version (minor/patch) based on [conventional
+  commits](https://www.conventionalcommits.org/en/v1.0.0/).
+- Update the [CHANGELOG](./CHANGELOG.md).
+- Create a git commit and tag.
+
+Then, execute:
+
+```shell
+git push --follow-tags origin main
+```
+
+Once the commit is pushed to master, the [release
+workflow](./.github/workflows/release.yml) will be triggered and the new version
+will be published to all package managers.
+
+## Licensing
+
+See the [LICENSE](LICENSE) file for our project's licensing. We will ask you to
+confirm the licensing of your contribution.
+
+We may ask you to sign a [Contributor License Agreement
+(CLA)](http://en.wikipedia.org/wiki/Contributor_License_Agreement) for larger
+changes.

cdk/node_modules/constructs/Dockerfile

@@ -0,0 +1,10 @@
+FROM jsii/superchain:1-bookworm-slim
+
+WORKDIR /app
+
+ARG BUILD_ARGS
+
+COPY . .
+
+RUN yarn install && yarn build ${BUILD_ARGS}
+

cdk/node_modules/constructs/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cdk/node_modules/constructs/NOTICE

@@ -0,0 +1 @@
+Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.

cdk/node_modules/constructs/README.md

@@ -0,0 +1,32 @@
+# Constructs
+
+> Software-defined persistent state
+
+[![Release](https://github.com/aws/constructs/actions/workflows/release.yml/badge.svg)](https://github.com/aws/constructs/actions/workflows/release.yml)
+[![npm version](https://badge.fury.io/js/constructs.svg)](https://badge.fury.io/js/constructs)
+[![PyPI version](https://badge.fury.io/py/constructs.svg)](https://badge.fury.io/py/constructs)
+[![NuGet version](https://badge.fury.io/nu/Constructs.svg)](https://badge.fury.io/nu/Constructs)
+[![Maven Central](https://maven-badges.sml.io/maven-central/software.constructs/constructs/badge.svg?style=plastic)](https://maven-badges.sml.io/maven-central/software.constructs/constructs)
+
+## What are constructs?
+
+Constructs are classes which define a "piece of system state". Constructs can be composed together to form higher-level building blocks which represent more complex state.
+
+Constructs are often used to represent the _desired state_ of cloud applications. For example, in the AWS CDK, which is used to define the desired state for AWS infrastructure using CloudFormation, the lowest-level construct represents a _resource definition_ in a CloudFormation template. These resources are composed to represent higher-level logical units of a cloud application, etc.
+
+## Support policy
+
+All [maintained Node.js versions](https://nodejs.org/en/about/previous-releases#release-schedule) are supported by this package.
+
+## Contributing
+
+This project has adopted the [Amazon Open Source Code of
+Conduct](https://aws.github.io/code-of-conduct).
+
+We welcome community contributions and pull requests. See our [contribution
+guide](./CONTRIBUTING.md) for more information on how to report issues, set up a
+development environment and submit code.
+
+## License
+
+This project is distributed under the [Apache License, Version 2.0](./LICENSE).

cdk/node_modules/constructs/lib/construct.d.ts

@@ -0,0 +1,381 @@
+import type { IDependable } from './dependency';
+import type { MetadataEntry } from './metadata';
+import type { IMixin } from './mixin';
+/**
+ * Represents a construct.
+ */
+export interface IConstruct extends IDependable {
+    /**
+     * The tree node.
+     */
+    readonly node: Node;
+    /**
+     * Applies one or more mixins to this construct.
+     *
+     * Mixins are applied in order. The list of constructs is captured at the
+     * start of the call, so constructs added by a mixin will not be visited.
+     *
+     * @param mixins The mixins to apply
+     * @returns This construct for chaining
+     */
+    with(...mixins: IMixin[]): IConstruct;
+}
+/**
+ * Represents the construct node in the scope tree.
+ */
+export declare class Node {
+    private readonly host;
+    /**
+     * Separator used to delimit construct path components.
+     */
+    static readonly PATH_SEP = "/";
+    /**
+     * Returns the node associated with a construct.
+     * @param construct the construct
+     *
+     * @deprecated use `construct.node` instead
+     */
+    static of(construct: IConstruct): Node;
+    /**
+     * Returns the scope in which this construct is defined.
+     *
+     * The value is `undefined` at the root of the construct scope tree.
+     */
+    readonly scope?: IConstruct;
+    /**
+     * The id of this construct within the current scope.
+     *
+     * This is a scope-unique id. To obtain an app-unique id for this construct, use `addr`.
+     */
+    readonly id: string;
+    private _locked;
+    private _children;
+    private _context;
+    private _metadata;
+    private _dependencies;
+    private _defaultChild;
+    private _validations;
+    private _addr?;
+    constructor(host: Construct, scope: IConstruct, id: string);
+    /**
+     * The full, absolute path of this construct in the tree.
+     *
+     * Components are separated by '/'.
+     */
+    get path(): string;
+    /**
+     * Returns an opaque tree-unique address for this construct.
+     *
+     * Addresses are 42 characters hexadecimal strings. They begin with "c8"
+     * followed by 40 lowercase hexadecimal characters (0-9a-f).
+     *
+     * Addresses are calculated using a SHA-1 of the components of the construct
+     * path.
+     *
+     * To enable refactoring of construct trees, constructs with the ID `Default`
+     * will be excluded from the calculation. In those cases constructs in the
+     * same tree may have the same address.
+     *
+     * @example c83a2846e506bcc5f10682b564084bca2d275709ee
+     */
+    get addr(): string;
+    /**
+     * Return a direct child by id, or undefined
+     *
+     * @param id Identifier of direct child
+     * @returns the child if found, or undefined
+     */
+    tryFindChild(id: string): IConstruct | undefined;
+    /**
+     * Return a direct child by id
+     *
+     * Throws an error if the child is not found.
+     *
+     * @param id Identifier of direct child
+     * @returns Child with the given id.
+     */
+    findChild(id: string): IConstruct;
+    /**
+     * Returns the child construct that has the id `Default` or `Resource`.
+     * This is usually the construct that provides the bulk of the underlying functionality.
+     * Useful for modifications of the underlying construct that are not available at the higher levels.
+     *
+     * @throws if there is more than one child
+     * @returns a construct or undefined if there is no default child
+     */
+    get defaultChild(): IConstruct | undefined;
+    /**
+     * Override the defaultChild property.
+     *
+     * This should only be used in the cases where the correct
+     * default child is not named 'Resource' or 'Default' as it
+     * should be.
+     *
+     * If you set this to undefined, the default behavior of finding
+     * the child named 'Resource' or 'Default' will be used.
+     */
+    set defaultChild(value: IConstruct | undefined);
+    /**
+     * All direct children of this construct.
+     */
+    get children(): IConstruct[];
+    /**
+     * Return this construct and all of its children in the given order
+     */
+    findAll(order?: ConstructOrder): IConstruct[];
+    /**
+     * This can be used to set contextual values.
+     * Context must be set before any children are added, since children may consult context info during construction.
+     * If the key already exists, it will be overridden.
+     * @param key The context key
+     * @param value The context value
+     */
+    setContext(key: string, value: any): void;
+    /**
+     * Retrieves a value from tree context if present. Otherwise, would throw an error.
+     *
+     * Context is usually initialized at the root, but can be overridden at any point in the tree.
+     *
+     * @param key The context key
+     * @returns The context value or throws error if there is no context value for this key
+     */
+    getContext(key: string): any;
+    /**
+     * Retrieves the all context of a node from tree context.
+     *
+     * Context is usually initialized at the root, but can be overridden at any point in the tree.
+     *
+     * @param defaults Any keys to override the retrieved context
+     * @returns The context object or an empty object if there is discovered context
+     */
+    getAllContext(defaults?: object): any;
+    /**
+     * Retrieves a value from tree context.
+     *
+     * Context is usually initialized at the root, but can be overridden at any point in the tree.
+     *
+     * @param key The context key
+     * @returns The context value or `undefined` if there is no context value for this key.
+     */
+    tryGetContext(key: string): any;
+    /**
+     * An immutable array of metadata objects associated with this construct.
+     * This can be used, for example, to implement support for deprecation notices, source mapping, etc.
+     */
+    get metadata(): MetadataEntry[];
+    /**
+     * Adds a metadata entry to this construct.
+     * Entries are arbitrary values and will also include a stack trace to allow tracing back to
+     * the code location for when the entry was added. It can be used, for example, to include source
+     * mapping in CloudFormation templates to improve diagnostics.
+     * Note that construct metadata is not the same as CloudFormation resource metadata and is never written to the CloudFormation template.
+     * The metadata entries are written to the Cloud Assembly Manifest if the `treeMetadata` property is specified in the props of the App that contains this Construct.
+     *
+     * @param type a string denoting the type of metadata
+     * @param data the value of the metadata (can be a Token). If null/undefined, metadata will not be added.
+     * @param options options
+     */
+    addMetadata(type: string, data: any, options?: MetadataOptions): void;
+    /**
+     * All parent scopes of this construct.
+     *
+     * @returns a list of parent scopes. The last element in the list will always
+     * be the current construct and the first element will be the root of the
+     * tree.
+     */
+    get scopes(): IConstruct[];
+    /**
+     * Returns the root of the construct tree.
+     * @returns The root of the construct tree.
+     */
+    get root(): IConstruct;
+    /**
+     * Returns true if this construct or the scopes in which it is defined are
+     * locked.
+     */
+    get locked(): boolean;
+    /**
+     * Add an ordering dependency on another construct.
+     *
+     * An `IDependable`
+     */
+    addDependency(...deps: IDependable[]): void;
+    /**
+     * Return all dependencies registered on this node (non-recursive).
+     */
+    get dependencies(): IConstruct[];
+    /**
+     * Remove the child with the given name, if present.
+     *
+     * @returns Whether a child with the given name was deleted.
+     */
+    tryRemoveChild(childName: string): boolean;
+    /**
+     * Adds a validation to this construct.
+     *
+     * When `node.validate()` is called, the `validate()` method will be called on
+     * all validations and all errors will be returned.
+     *
+     * @param validation The validation object
+     */
+    addValidation(validation: IValidation): void;
+    /**
+     * Validates this construct.
+     *
+     * Invokes the `validate()` method on all validations added through
+     * `addValidation()`.
+     *
+     * @returns an array of validation error messages associated with this
+     * construct.
+     */
+    validate(): string[];
+    /**
+     * Locks this construct from allowing more children to be added. After this
+     * call, no more children can be added to this construct or to any children.
+     */
+    lock(): void;
+    /**
+     * Applies one or more mixins to this construct.
+     *
+     * Mixins are applied in order. The list of constructs is captured at the
+     * start of the call, so constructs added by a mixin will not be visited.
+     * Use multiple `with()` calls if subsequent mixins should apply to added
+     * constructs.
+     *
+     * @param mixins The mixins to apply
+     * @returns This construct for chaining
+     */
+    with(...mixins: IMixin[]): IConstruct;
+    /**
+     * Adds a child construct to this node.
+     *
+     * @param child The child construct
+     * @param childName The type name of the child construct.
+     * @returns The resolved path part name of the child
+     */
+    private addChild;
+}
+/**
+ * Represents the building block of the construct graph.
+ *
+ * All constructs besides the root construct must be created within the scope of
+ * another construct.
+ */
+export declare class Construct implements IConstruct {
+    /**
+     * Checks if `x` is a construct.
+     *
+     * Use this method instead of `instanceof` to properly detect `Construct`
+     * instances, even when the construct library is symlinked.
+     *
+     * Explanation: in JavaScript, multiple copies of the `constructs` library on
+     * disk are seen as independent, completely different libraries. As a
+     * consequence, the class `Construct` in each copy of the `constructs` library
+     * is seen as a different class, and an instance of one class will not test as
+     * `instanceof` the other class. `npm install` will not create installations
+     * like this, but users may manually symlink construct libraries together or
+     * use a monorepo tool: in those cases, multiple copies of the `constructs`
+     * library can be accidentally installed, and `instanceof` will behave
+     * unpredictably. It is safest to avoid using `instanceof`, and using
+     * this type-testing method instead.
+     *
+     * @returns true if `x` is an object created from a class which extends `Construct`.
+     * @param x Any object
+     */
+    static isConstruct(x: any): x is Construct;
+    /**
+     * The tree node.
+     */
+    readonly node: Node;
+    /**
+     * Creates a new construct node.
+     *
+     * @param scope The scope in which to define this construct
+     * @param id The scoped construct ID. Must be unique amongst siblings. If
+     * the ID includes a path separator (`/`), then it will be replaced by double
+     * dash `--`.
+     */
+    constructor(scope: Construct, id: string);
+    /**
+     * Applies one or more mixins to this construct.
+     *
+     * Mixins are applied in order. The list of constructs is captured at the
+     * start of the call, so constructs added by a mixin will not be visited.
+     * Use multiple `with()` calls if subsequent mixins should apply to added
+     * constructs.
+     *
+     * @param mixins The mixins to apply
+     * @returns This construct for chaining
+     */
+    with(...mixins: IMixin[]): IConstruct;
+    /**
+     * Returns a string representation of this construct.
+     */
+    toString(): string;
+}
+/**
+ * Implement this interface in order for the construct to be able to validate itself.
+ */
+export interface IValidation {
+    /**
+     * Validate the current construct.
+     *
+     * This method can be implemented by derived constructs in order to perform
+     * validation logic. It is called on all constructs before synthesis.
+     *
+     * @returns An array of validation error messages, or an empty array if there the construct is valid.
+     */
+    validate(): string[];
+}
+/**
+ * In what order to return constructs
+ */
+export declare enum ConstructOrder {
+    /**
+     * Depth-first, pre-order
+     */
+    PREORDER = 0,
+    /**
+     * Depth-first, post-order (leaf nodes first)
+     */
+    POSTORDER = 1
+}
+/**
+ * Options for `construct.addMetadata()`.
+ */
+export interface MetadataOptions {
+    /**
+     * Include stack trace with metadata entry.
+     * @default false
+     */
+    readonly stackTrace?: boolean;
+    /**
+     * A JavaScript function to begin tracing from.
+     *
+     * This option is ignored unless `stackTrace` is `true`.
+     *
+     * @default addMetadata()
+     */
+    readonly traceFromFunction?: any;
+    /**
+     * The actual stack trace to be added to the metadata. If this
+     * parameter is passed, the stackTrace parameter is ignored.
+     */
+    readonly stackTraceOverride?: string[];
+}
+/**
+ * Creates a new root construct node.
+ *
+ * The root construct represents the top of the construct tree and is not contained within a parent scope itself.
+ * For root constructs, the id is optional.
+ */
+export declare class RootConstruct extends Construct {
+    /**
+     * Creates a new root construct node.
+     *
+     * @param id The scoped construct ID. Must be unique amongst siblings. If
+     * the ID includes a path separator (`/`), then it will be replaced by double
+     * dash `--`.
+     */
+    constructor(id?: string);
+}

cdk/node_modules/constructs/lib/dependency.d.ts

@@ -0,0 +1,69 @@
+import type { IConstruct } from './construct';
+/**
+ * Trait marker for classes that can be depended upon
+ *
+ * The presence of this interface indicates that an object has
+ * an `IDependable` implementation.
+ *
+ * This interface can be used to take an (ordering) dependency on a set of
+ * constructs. An ordering dependency implies that the resources represented by
+ * those constructs are deployed before the resources depending ON them are
+ * deployed.
+ */
+export interface IDependable {
+}
+/**
+ * A set of constructs to be used as a dependable
+ *
+ * This class can be used when a set of constructs which are disjoint in the
+ * construct tree needs to be combined to be used as a single dependable.
+ */
+export declare class DependencyGroup implements IDependable {
+    private readonly _deps;
+    constructor(...deps: IDependable[]);
+    /**
+     * Add a construct to the dependency roots
+     */
+    add(...scopes: IDependable[]): void;
+}
+/**
+ * Trait for IDependable
+ *
+ * Traits are interfaces that are privately implemented by objects. Instead of
+ * showing up in the public interface of a class, they need to be queried
+ * explicitly. This is used to implement certain framework features that are
+ * not intended to be used by Construct consumers, and so should be hidden
+ * from accidental use.
+ *
+ * @example
+ *
+ * // Usage
+ * const roots = Dependable.of(construct).dependencyRoots;
+ *
+ * // Definition
+ * Dependable.implement(construct, {
+ *       dependencyRoots: [construct],
+ * });
+ */
+export declare abstract class Dependable {
+    /**
+     * Turn any object into an IDependable.
+     */
+    static implement(instance: IDependable, trait: Dependable): void;
+    /**
+     * Return the matching Dependable for the given class instance.
+     */
+    static of(instance: IDependable): Dependable;
+    /**
+     * Return the matching Dependable for the given class instance.
+     * @deprecated use `of`
+     */
+    static get(instance: IDependable): Dependable;
+    /**
+     * The set of constructs that form the root of this dependable
+     *
+     * All resources under all returned constructs are included in the ordering
+     * dependency.
+     */
+    abstract readonly dependencyRoots: IConstruct[];
+}

cdk/node_modules/constructs/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './construct';
+export type * from './metadata';
+export type * from './mixin';
+export * from './dependency';

cdk/node_modules/constructs/lib/index.js

@@ -0,0 +1,19 @@
+"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("./construct"), exports);
+__exportStar(require("./dependency"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhDQUE0QjtBQUc1QiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdCc7XG5leHBvcnQgdHlwZSAqIGZyb20gJy4vbWV0YWRhdGEnO1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL21peGluJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwZW5kZW5jeSc7XG4iXX0=

cdk/node_modules/constructs/lib/metadata.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An entry in the construct metadata table.
+ */
+export interface MetadataEntry {
+    /**
+     * The metadata entry type.
+     */
+    readonly type: string;
+    /**
+     * The data.
+     */
+    readonly data: any;
+    /**
+     * Stack trace at the point of adding the metadata.
+     *
+     * Only available if `addMetadata()` is called with `stackTrace: true`.
+     *
+     * @default - no trace information
+     */
+    readonly trace?: string[];
+}

cdk/node_modules/constructs/lib/metadata.js

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

cdk/node_modules/constructs/lib/mixin.d.ts

@@ -0,0 +1,15 @@
+import type { IConstruct } from './construct';
+/**
+ * A mixin is a reusable piece of functionality that can be applied to constructs
+ * to add behavior, properties, or modify existing functionality without inheritance.
+ */
+export interface IMixin {
+    /**
+     * Determines whether this mixin can be applied to the given construct.
+     */
+    supports(construct: IConstruct): boolean;
+    /**
+     * Applies the mixin functionality to the target construct.
+     */
+    applyTo(construct: IConstruct): void;
+}

cdk/node_modules/constructs/lib/mixin.js

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

cdk/node_modules/constructs/lib/private/stack-trace.d.ts

@@ -0,0 +1 @@
+export declare function captureStackTrace(below?: Function): string[];

cdk/node_modules/constructs/lib/private/stack-trace.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureStackTrace = captureStackTrace;
+// tslint:disable-next-line:ban-types
+function captureStackTrace(below) {
+    below = below || captureStackTrace; // hide myself if nothing else
+    const object = { stack: '' };
+    const previousLimit = Error.stackTraceLimit;
+    try {
+        Error.stackTraceLimit = Number.MAX_SAFE_INTEGER;
+        Error.captureStackTrace(object, below);
+    }
+    finally {
+        Error.stackTraceLimit = previousLimit;
+    }
+    if (!object.stack) {
+        return [];
+    }
+    return object.stack.split('\n').slice(1).map(s => s.replace(/^\s*at\s+/, ''));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stdHJhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS9zdGFjay10cmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUNBLDhDQWNDO0FBZkQscUNBQXFDO0FBQ3JDLFNBQWdCLGlCQUFpQixDQUFDLEtBQWdCO0lBQ2hELEtBQUssR0FBRyxLQUFLLElBQUksaUJBQWlCLENBQUMsQ0FBQyw4QkFBOEI7SUFDbEUsTUFBTSxNQUFNLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFDN0IsTUFBTSxhQUFhLEdBQUcsS0FBSyxDQUFDLGVBQWUsQ0FBQztJQUM1QyxJQUFJLENBQUM7UUFDSCxLQUFLLENBQUMsZUFBZSxHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQztRQUNoRCxLQUFLLENBQUMsaUJBQWlCLENBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBQ3pDLENBQUM7WUFBUyxDQUFDO1FBQ1QsS0FBSyxDQUFDLGVBQWUsR0FBRyxhQUFhLENBQUM7SUFDeEMsQ0FBQztJQUNELElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDbEIsT0FBTyxFQUFFLENBQUM7SUFDWixDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQztBQUNoRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOmJhbi10eXBlc1xuZXhwb3J0IGZ1bmN0aW9uIGNhcHR1cmVTdGFja1RyYWNlKGJlbG93PzogRnVuY3Rpb24pOiBzdHJpbmdbXSB7XG4gIGJlbG93ID0gYmVsb3cgfHwgY2FwdHVyZVN0YWNrVHJhY2U7IC8vIGhpZGUgbXlzZWxmIGlmIG5vdGhpbmcgZWxzZVxuICBjb25zdCBvYmplY3QgPSB7IHN0YWNrOiAnJyB9O1xuICBjb25zdCBwcmV2aW91c0xpbWl0ID0gRXJyb3Iuc3RhY2tUcmFjZUxpbWl0O1xuICB0cnkge1xuICAgIEVycm9yLnN0YWNrVHJhY2VMaW1pdCA9IE51bWJlci5NQVhfU0FGRV9JTlRFR0VSO1xuICAgIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKG9iamVjdCwgYmVsb3cpO1xuICB9IGZpbmFsbHkge1xuICAgIEVycm9yLnN0YWNrVHJhY2VMaW1pdCA9IHByZXZpb3VzTGltaXQ7XG4gIH1cbiAgaWYgKCFvYmplY3Quc3RhY2spIHtcbiAgICByZXR1cm4gW107XG4gIH1cbiAgcmV0dXJuIG9iamVjdC5zdGFjay5zcGxpdCgnXFxuJykuc2xpY2UoMSkubWFwKHMgPT4gcy5yZXBsYWNlKC9eXFxzKmF0XFxzKy8sICcnKSk7XG59XG4iXX0=

cdk/node_modules/constructs/lib/private/uniqueid.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Calculates the construct uid based on path components.
+ *
+ * Components named `Default` (case sensitive) are excluded from uid calculation
+ * to allow tree refactorings.
+ *
+ * @param components path components
+ */
+export declare function addressOf(components: string[]): string;

cdk/node_modules/constructs/lib/private/uniqueid.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressOf = addressOf;
+const crypto = require("crypto");
+/**
+ * Resources with this ID are complete hidden from the logical ID calculation.
+ */
+const HIDDEN_ID = 'Default';
+/**
+ * Calculates the construct uid based on path components.
+ *
+ * Components named `Default` (case sensitive) are excluded from uid calculation
+ * to allow tree refactorings.
+ *
+ * @param components path components
+ */
+function addressOf(components) {
+    const hash = crypto.createHash('sha1');
+    for (const c of components) {
+        // skip components called "Default" to enable refactorings
+        if (c === HIDDEN_ID) {
+            continue;
+        }
+        hash.update(c);
+        hash.update('\n');
+    }
+    // prefix with "c8" so to ensure it starts with non-digit.
+    return 'c8' + hash.digest('hex');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlaWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJpdmF0ZS91bmlxdWVpZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQWVBLDhCQVlDO0FBM0JELGlDQUFpQztBQUVqQzs7R0FFRztBQUNILE1BQU0sU0FBUyxHQUFHLFNBQVMsQ0FBQztBQUU1Qjs7Ozs7OztHQU9HO0FBQ0gsU0FBZ0IsU0FBUyxDQUFDLFVBQW9CO0lBQzVDLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDdkMsS0FBSyxNQUFNLENBQUMsSUFBSSxVQUFVLEVBQUUsQ0FBQztRQUMzQiwwREFBMEQ7UUFDMUQsSUFBSSxDQUFDLEtBQUssU0FBUyxFQUFFLENBQUM7WUFBQyxTQUFTO1FBQUMsQ0FBQztRQUVsQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNwQixDQUFDO0lBRUQsMERBQTBEO0lBQzFELE9BQU8sSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDbkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGNyeXB0byBmcm9tICdjcnlwdG8nO1xuXG4vKipcbiAqIFJlc291cmNlcyB3aXRoIHRoaXMgSUQgYXJlIGNvbXBsZXRlIGhpZGRlbiBmcm9tIHRoZSBsb2dpY2FsIElEIGNhbGN1bGF0aW9uLlxuICovXG5jb25zdCBISURERU5fSUQgPSAnRGVmYXVsdCc7XG5cbi8qKlxuICogQ2FsY3VsYXRlcyB0aGUgY29uc3RydWN0IHVpZCBiYXNlZCBvbiBwYXRoIGNvbXBvbmVudHMuXG4gKlxuICogQ29tcG9uZW50cyBuYW1lZCBgRGVmYXVsdGAgKGNhc2Ugc2Vuc2l0aXZlKSBhcmUgZXhjbHVkZWQgZnJvbSB1aWQgY2FsY3VsYXRpb25cbiAqIHRvIGFsbG93IHRyZWUgcmVmYWN0b3JpbmdzLlxuICpcbiAqIEBwYXJhbSBjb21wb25lbnRzIHBhdGggY29tcG9uZW50c1xuICovXG5leHBvcnQgZnVuY3Rpb24gYWRkcmVzc09mKGNvbXBvbmVudHM6IHN0cmluZ1tdKSB7XG4gIGNvbnN0IGhhc2ggPSBjcnlwdG8uY3JlYXRlSGFzaCgnc2hhMScpO1xuICBmb3IgKGNvbnN0IGMgb2YgY29tcG9uZW50cykge1xuICAgIC8vIHNraXAgY29tcG9uZW50cyBjYWxsZWQgXCJEZWZhdWx0XCIgdG8gZW5hYmxlIHJlZmFjdG9yaW5nc1xuICAgIGlmIChjID09PSBISURERU5fSUQpIHsgY29udGludWU7IH1cblxuICAgIGhhc2gudXBkYXRlKGMpO1xuICAgIGhhc2gudXBkYXRlKCdcXG4nKTtcbiAgfVxuXG4gIC8vIHByZWZpeCB3aXRoIFwiYzhcIiBzbyB0byBlbnN1cmUgaXQgc3RhcnRzIHdpdGggbm9uLWRpZ2l0LlxuICByZXR1cm4gJ2M4JyArIGhhc2guZGlnZXN0KCdoZXgnKTtcbn1cbiJdfQ==

cdk/node_modules/constructs/package.json

@@ -0,0 +1,154 @@
+{
+  "name": "constructs",
+  "description": "A programming model for software-defined state",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/constructs.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:dotnet": "npx projen package:dotnet",
+    "package:go": "npx projen package:go",
+    "package:java": "npx projen package:java",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release:10.x": "npx projen release:10.x",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "upgrade-cdklabs-projen-project-types": "npx projen upgrade-cdklabs-projen-project-types",
+    "upgrade-dev-deps": "npx projen upgrade-dev-deps",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Amazon Web Services",
+    "email": "aws-cdk-dev@amazon.com",
+    "organization": true
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^29",
+    "@types/node": "^18",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "cdklabs-projen-project-types": "^0.3.7",
+    "commit-and-tag-version": "^12",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^29",
+    "jest-junit": "^16",
+    "jsii": "5.9.x",
+    "jsii-diff": "^1.127.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.127.0",
+    "jsii-rosetta": "5.9.x",
+    "projen": "^0.98.4",
+    "ts-jest": "^29",
+    "ts-node": "^10.9.2",
+    "typescript": "5.9.x"
+  },
+  "keywords": [
+    "aws",
+    "cdk",
+    "constructs",
+    "jsii"
+  ],
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/aws/constructs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "10.6.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "java": {
+        "package": "software.constructs",
+        "maven": {
+          "groupId": "software.constructs",
+          "artifactId": "constructs"
+        }
+      },
+      "python": {
+        "distName": "constructs",
+        "module": "constructs"
+      },
+      "dotnet": {
+        "namespace": "Constructs",
+        "packageId": "Constructs"
+      },
+      "go": {
+        "moduleName": "github.com/aws/constructs-go"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}

cdk/node_modules/constructs/version.json

@@ -0,0 +1,3 @@
+{
+  "version": "10.0.0"
+}