@aws-amplify/graphql-api-construct 1.18.3-ai-next.0 → 1.18.3

package/node_modules/@aws-cdk/cfnspec/build-tools/spec-diff.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+const fs = require("fs-extra");
+/* eslint-disable @typescript-eslint/no-require-imports */
+const jsonDiff = require('json-diff').diff;
+/* eslint-enable */
+function line(fmt = '', ...param) {
+    process.stdout.write(util.format(fmt, ...param));
+    process.stdout.write('\n');
+}
+async function main() {
+    const title = process.argv[2];
+    const oldSpecFile = process.argv[3];
+    const newSpecFile = process.argv[4];
+    const newSpec = await fs.readJSON(newSpecFile);
+    const oldSpec = await fs.readJSON(oldSpecFile);
+    // Diff operates on PropertyTypes & ResourceTypes
+    // Ensure they always exist in the old spec
+    if (!oldSpec.PropertyTypes) {
+        oldSpec.PropertyTypes = {};
+    }
+    if (!oldSpec.ResourceTypes) {
+        oldSpec.ResourceTypes = {};
+    }
+    const out = jsonDiff(oldSpec, newSpec);
+    // Here's the magic output format of this thing
+    // If a key ends in __added, it got added, and the value
+    //   is the new value.
+    // If a key ends in __deleted, it got deleted, and the value
+    //   is the old value.
+    // If a value got changed, the value object will look like:
+    //   { __old: ..., __new: ... }
+    if (!out) {
+        return; // no diff
+    }
+    const resourceTypeAdditions = new Set();
+    const resourceTypeDeletions = new Set();
+    const attributeChanges = new Array();
+    const propertyChanges = new Array();
+    const propertyTypeChanges = new Array();
+    for (const key of Object.keys(out.ResourceTypes || {})) {
+        classifyResourceTypeUpdate(key, out.ResourceTypes[key]);
+    }
+    for (const key of Object.keys(out.PropertyTypes || {})) {
+        classifyPropertyTypeUpdate(key, out.PropertyTypes[key]);
+    }
+    line(`# ${title} v${newSpec.ResourceSpecificationVersion}`);
+    line();
+    line('## New Resource Types');
+    line();
+    resourceTypeAdditions.forEach(type => line(`* ${type}`));
+    line();
+    if (resourceTypeDeletions.size > 0) {
+        line('## Removed Resource Types');
+        line();
+        resourceTypeDeletions.forEach(type => line(`* ${type}`));
+        line();
+    }
+    line('## Attribute Changes');
+    line();
+    attributeChanges.forEach(x => line(x));
+    line();
+    line('## Property Changes');
+    line();
+    propertyChanges.forEach(x => line(x));
+    line();
+    line('## Property Type Changes');
+    line();
+    propertyTypeChanges.forEach(x => line(x));
+    function classifyResourceTypeUpdate(resourceType, update) {
+        const added = isAdded(resourceType);
+        if (added) {
+            resourceTypeAdditions.add(added);
+            return;
+        }
+        const deleted = isDeleted(resourceType);
+        if (deleted) {
+            resourceTypeDeletions.add(deleted);
+            return;
+        }
+        pushDownCompleteChanges(update);
+        for (const key of Object.keys(update)) {
+            switch (key) {
+                case 'Properties':
+                    for (const prop of Object.keys(update.Properties)) {
+                        describeChanges(resourceType, prop, update.Properties[prop]).forEach(change => {
+                            propertyChanges.push(change);
+                        });
+                    }
+                    break;
+                case 'Attributes':
+                    for (const attr of Object.keys(update.Attributes)) {
+                        describeChanges(resourceType, attr, update.Attributes[attr]).forEach(change => {
+                            attributeChanges.push(change);
+                        });
+                    }
+                    break;
+                case 'Documentation':
+                    describeChanges(resourceType, key, update.Documentation).forEach(change => {
+                        attributeChanges.push(change);
+                    });
+                    break;
+                default:
+                    throw new Error(`Unexpected update to ${resourceType}: ${key}`);
+            }
+        }
+    }
+    function classifyPropertyTypeUpdate(propertyType, update) {
+        const added = isAdded(propertyType);
+        if (added) {
+            const resourceType = added.split('.')[0];
+            if (resourceTypeAdditions.has(resourceType)) {
+                return; // skipping property for added resource types
+            }
+            propertyTypeChanges.push(`* ${added} (__added__)`);
+            return;
+        }
+        const deleted = isDeleted(propertyType);
+        if (deleted) {
+            const resourceType = deleted.split('.')[0];
+            if (resourceTypeDeletions.has(resourceType)) {
+                return; // skipping property for added resource types
+            }
+            propertyTypeChanges.push(`* ${deleted} (__removed__)`);
+            return;
+        }
+        if (Object.keys(update).length !== 1 && Object.keys(update)[0] === 'Properties') {
+            throw new Error('Unexpected update to a resource type. Expecting only "Properties" to change: ' + propertyType);
+        }
+        for (const prop of Object.keys(update.Properties ?? {})) {
+            describeChanges(propertyType, prop, update.Properties[prop]).forEach(change => {
+                propertyTypeChanges.push(change);
+            });
+        }
+    }
+    /**
+     * Push down mass changes to attributes or properties to the individual properties.
+     *
+     * An example will explain this best. JSON-diff will make the smallest diff, so if there
+     * are new properties it will report:
+     *
+     * "Properties__added": {
+     *    "Property1": { ... },
+     *    "Property2": { ... },
+     * }
+     *
+     * But we want to see this as:
+     *
+     * "Properties": {
+     *    "Property1__added": { ... },
+     *    "Property2__added": { ... },
+     * }
+     *
+     * Same (but in reverse) for deletions.
+     */
+    function pushDownCompleteChanges(update) {
+        for (const [category, entries] of Object.entries(update)) {
+            const addedKey = isAdded(category);
+            if (addedKey) {
+                delete update[category];
+                update[addedKey] = suffixKeys('__added', entries);
+            }
+            const deletedKey = isDeleted(category);
+            if (deletedKey) {
+                delete update[category];
+                update[deletedKey] = suffixKeys('__deleted', entries);
+            }
+        }
+    }
+    function isDeleted(key) {
+        return isSuffix(key, '__deleted');
+    }
+    function isAdded(key) {
+        return isSuffix(key, '__added');
+    }
+    function isSuffix(key, suffix) {
+        const index = key.indexOf(suffix);
+        return index === -1 ? undefined : key.slice(0, index);
+    }
+    function suffixKeys(suffix, xs) {
+        const ret = {};
+        for (const [key, value] of Object.entries(xs)) {
+            ret[key + suffix] = value;
+        }
+        return ret;
+    }
+    function describeChanges(namespace, prefix, update) {
+        const changes = new Array();
+        const added = isAdded(prefix);
+        if (added) {
+            changes.push(`* ${namespace} ${added} (__added__)`);
+            return changes;
+        }
+        const deleted = isDeleted(prefix);
+        if (deleted) {
+            changes.push(`* ${namespace} ${deleted} (__deleted__)`);
+            return changes;
+        }
+        if (typeof (update) !== 'object') {
+            throw new Error(`Unexpected change for ${namespace}.${prefix} ${JSON.stringify(update)}`);
+        }
+        if ('__old' in update && '__new' in update) {
+            changes.push(`* ${namespace} ${prefix} (__changed__)`);
+            changes.push(`  * Old: ${update.__old}`);
+            changes.push(`  * New: ${update.__new}`);
+            return changes;
+        }
+        if (Array.isArray(update)) {
+            changes.push(`* ${namespace} ${prefix} (__changed__)`);
+            for (const entry of update) {
+                if (entry.length === 1 && entry[0] === ' ') {
+                    // This means that this element of the array is unchanged
+                    continue;
+                }
+                if (entry.length !== 2) {
+                    throw new Error(`Unexpected array diff entry: ${JSON.stringify(entry)}`);
+                }
+                switch (entry[0]) {
+                    case '+':
+                        changes.push(`  * Added ${entry[1]}`);
+                        break;
+                    case '-':
+                        throw new Error(`Something awkward happened: ${entry[1]} was deleted from ${namespace} ${prefix}!`);
+                    case ' ':
+                        // This entry is "context"
+                        break;
+                    default:
+                        throw new Error(`Unexpected array diff entry: ${JSON.stringify(entry)}`);
+                }
+            }
+        }
+        else {
+            for (const key of Object.keys(update)) {
+                for (const change of describeChanges(namespace, `${prefix}.${key}`, update[key])) {
+                    changes.push(change);
+                }
+            }
+        }
+        return changes;
+    }
+}
+main().catch(e => {
+    process.stderr.write(e.stack);
+    process.stderr.write('\n');
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spec-diff.js","sourceRoot":"","sources":["spec-diff.ts"],"names":[],"mappings":";;AAAA,6BAA6B;AAC7B,+BAA+B;AAE/B,0DAA0D;AAC1D,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC;AAC3C,mBAAmB;AAEnB,SAAS,IAAI,CAAC,MAAc,EAAE,EAAE,GAAG,KAAY;IAC7C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC;IACjD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEpC,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAE/C,iDAAiD;IACjD,2CAA2C;IAC3C,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE;QAC1B,OAAO,CAAC,aAAa,GAAG,EAAE,CAAC;KAC5B;IACD,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE;QAC1B,OAAO,CAAC,aAAa,GAAG,EAAE,CAAC;KAC5B;IAED,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEvC,+CAA+C;IAC/C,wDAAwD;IACxD,sBAAsB;IACtB,4DAA4D;IAC5D,sBAAsB;IACtB,2DAA2D;IAC3D,+BAA+B;IAE/B,IAAI,CAAC,GAAG,EAAE;QACR,OAAO,CAAC,UAAU;KACnB;IAED,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;IAChD,MAAM,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;IAChD,MAAM,gBAAgB,GAAG,IAAI,KAAK,EAAU,CAAC;IAC7C,MAAM,eAAe,GAAG,IAAI,KAAK,EAAU,CAAC;IAC5C,MAAM,mBAAmB,GAAG,IAAI,KAAK,EAAU,CAAC;IAEhD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,IAAI,EAAE,CAAC,EAAE;QACtD,0BAA0B,CAAC,GAAG,EAAE,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;KACzD;IAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,IAAI,EAAE,CAAC,EAAE;QACtD,0BAA0B,CAAC,GAAG,EAAE,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;KACzD;IAED,IAAI,CAAC,KAAK,KAAK,KAAK,OAAO,CAAC,4BAA4B,EAAE,CAAC,CAAC;IAC5D,IAAI,EAAE,CAAC;IAEP,IAAI,CAAC,uBAAuB,CAAC,CAAC;IAC9B,IAAI,EAAE,CAAC;IACP,qBAAqB,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;IACzD,IAAI,EAAE,CAAC;IAEP,IAAI,qBAAqB,CAAC,IAAI,GAAG,CAAC,EAAE;QAClC,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAClC,IAAI,EAAE,CAAC;QACP,qBAAqB,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;QACzD,IAAI,EAAE,CAAC;KACR;IAED,IAAI,CAAC,sBAAsB,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC;IACP,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACvC,IAAI,EAAE,CAAC;IAEP,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAC5B,IAAI,EAAE,CAAC;IACP,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,IAAI,EAAE,CAAC;IAEP,IAAI,CAAC,0BAA0B,CAAC,CAAC;IACjC,IAAI,EAAE,CAAC;IACP,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAE1C,SAAS,0BAA0B,CAAC,YAAoB,EAAE,MAAW;QACnE,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;QACpC,IAAI,KAAK,EAAE;YACT,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACjC,OAAO;SACR;QAED,MAAM,OAAO,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACxC,IAAI,OAAO,EAAE;YACX,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACnC,OAAO;SACR;QAED,uBAAuB,CAAC,MAAM,CAAC,CAAC;QAEhC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACrC,QAAQ,GAAG,EAAE;gBACX,KAAK,YAAY;oBACf,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;wBACjD,eAAe,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;4BAC5E,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC/B,CAAC,CAAC,CAAC;qBACJ;oBACD,MAAM;gBACR,KAAK,YAAY;oBACf,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;wBACjD,eAAe,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;4BAC5E,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAChC,CAAC,CAAC,CAAC;qBACJ;oBACD,MAAM;gBACR,KAAK,eAAe;oBAClB,eAAe,CAAC,YAAY,EAAE,GAAG,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;wBACxE,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAChC,CAAC,CAAC,CAAC;oBACH,MAAM;gBACR;oBACE,MAAM,IAAI,KAAK,CAAC,wBAAwB,YAAY,KAAK,GAAG,EAAE,CAAC,CAAC;aACnE;SACF;IACH,CAAC;IAED,SAAS,0BAA0B,CAAC,YAAoB,EAAE,MAAW;QACnE,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;QACpC,IAAI,KAAK,EAAE;YACT,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,qBAAqB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBAC3C,OAAO,CAAC,6CAA6C;aACtD;YAED,mBAAmB,CAAC,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,CAAC;YACnD,OAAO;SACR;QAED,MAAM,OAAO,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC;QACxC,IAAI,OAAO,EAAE;YACX,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3C,IAAI,qBAAqB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBAC3C,OAAO,CAAC,6CAA6C;aACtD;YAED,mBAAmB,CAAC,IAAI,CAAC,KAAK,OAAO,gBAAgB,CAAC,CAAC;YACvD,OAAO;SACR;QAED,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,YAAY,EAAE;YAC/E,MAAM,IAAI,KAAK,CAAC,+EAA+E,GAAG,YAAY,CAAC,CAAC;SACjH;QAED,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE;YACvD,eAAe,CAAC,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC5E,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACnC,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,uBAAuB,CAAC,MAA2C;QAC1E,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACnC,IAAI,QAAQ,EAAE;gBACZ,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACxB,MAAM,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;aACnD;YAED,MAAM,UAAU,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,UAAU,EAAE;gBACd,OAAO,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACxB,MAAM,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;aACvD;SACF;IACH,CAAC;IAED,SAAS,SAAS,CAAC,GAAW;QAC5B,OAAO,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACpC,CAAC;IAED,SAAS,OAAO,CAAC,GAAW;QAC1B,OAAO,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAClC,CAAC;IAED,SAAS,QAAQ,CAAC,GAAW,EAAE,MAAc;QAC3C,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAClC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,SAAS,UAAU,CAAC,MAAc,EAAE,EAAuB;QACzD,MAAM,GAAG,GAAwB,EAAE,CAAC;QACpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YAC7C,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC;SAC3B;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,SAAS,eAAe,CAAC,SAAiB,EAAE,MAAc,EAAE,MAAW;QACrE,MAAM,OAAO,GAAG,IAAI,KAAK,EAAU,CAAC;QAEpC,MAAM,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9B,IAAI,KAAK,EAAE;YACT,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,KAAK,cAAc,CAAC,CAAC;YACpD,OAAO,OAAO,CAAC;SAChB;QAED,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,OAAO,EAAE;YACX,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,OAAO,gBAAgB,CAAC,CAAC;YACxD,OAAO,OAAO,CAAC;SAChB;QAED,IAAI,OAAM,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE;YAC/B,MAAM,IAAI,KAAK,CAAC,yBAAyB,SAAS,IAAI,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;SAC3F;QAED,IAAI,OAAO,IAAI,MAAM,IAAI,OAAO,IAAI,MAAM,EAAE;YAC1C,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,MAAM,gBAAgB,CAAC,CAAC;YACvD,OAAO,CAAC,IAAI,CAAC,YAAY,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YACzC,OAAO,CAAC,IAAI,CAAC,YAAY,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YACzC,OAAO,OAAO,CAAC;SAChB;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACzB,OAAO,CAAC,IAAI,CAAC,KAAK,SAAS,IAAI,MAAM,gBAAgB,CAAC,CAAC;YACvD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;gBAC1B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;oBAC1C,yDAAyD;oBACzD,SAAS;iBACV;gBACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;oBACtB,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;iBAC1E;gBACD,QAAQ,KAAK,CAAC,CAAC,CAAC,EAAE;oBAChB,KAAK,GAAG;wBACN,OAAO,CAAC,IAAI,CAAC,aAAa,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;wBACtC,MAAM;oBACR,KAAK,GAAG;wBACN,MAAM,IAAI,KAAK,CAAC,+BAA+B,KAAK,CAAC,CAAC,CAAC,qBAAqB,SAAS,IAAI,MAAM,GAAG,CAAC,CAAC;oBACtG,KAAK,GAAG;wBACN,0BAA0B;wBAC1B,MAAM;oBACR;wBACE,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;iBAC5E;aACF;SACF;aAAM;YACL,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;gBACrC,KAAK,MAAM,MAAM,IAAI,eAAe,CAAC,SAAS,EAAE,GAAG,MAAM,IAAI,GAAG,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE;oBAChF,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;iBACtB;aACF;SACF;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;IACf,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC9B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC","sourcesContent":["import * as util from 'util';\nimport * as fs from 'fs-extra';\n\n/* eslint-disable @typescript-eslint/no-require-imports */\nconst jsonDiff = require('json-diff').diff;\n/* eslint-enable */\n\nfunction line(fmt: string = '', ...param: any[]) {\n  process.stdout.write(util.format(fmt, ...param));\n  process.stdout.write('\\n');\n}\n\nasync function main() {\n  const title = process.argv[2];\n  const oldSpecFile = process.argv[3];\n  const newSpecFile = process.argv[4];\n\n  const newSpec = await fs.readJSON(newSpecFile);\n  const oldSpec = await fs.readJSON(oldSpecFile);\n\n  // Diff operates on PropertyTypes & ResourceTypes\n  // Ensure they always exist in the old spec\n  if (!oldSpec.PropertyTypes) {\n    oldSpec.PropertyTypes = {};\n  }\n  if (!oldSpec.ResourceTypes) {\n    oldSpec.ResourceTypes = {};\n  }\n\n  const out = jsonDiff(oldSpec, newSpec);\n\n  // Here's the magic output format of this thing\n  // If a key ends in __added, it got added, and the value\n  //   is the new value.\n  // If a key ends in __deleted, it got deleted, and the value\n  //   is the old value.\n  // If a value got changed, the value object will look like:\n  //   { __old: ..., __new: ... }\n\n  if (!out) {\n    return; // no diff\n  }\n\n  const resourceTypeAdditions = new Set<string>();\n  const resourceTypeDeletions = new Set<string>();\n  const attributeChanges = new Array<string>();\n  const propertyChanges = new Array<string>();\n  const propertyTypeChanges = new Array<string>();\n\n  for (const key of Object.keys(out.ResourceTypes || {})) {\n    classifyResourceTypeUpdate(key, out.ResourceTypes[key]);\n  }\n\n  for (const key of Object.keys(out.PropertyTypes || {})) {\n    classifyPropertyTypeUpdate(key, out.PropertyTypes[key]);\n  }\n\n  line(`# ${title} v${newSpec.ResourceSpecificationVersion}`);\n  line();\n\n  line('## New Resource Types');\n  line();\n  resourceTypeAdditions.forEach(type => line(`* ${type}`));\n  line();\n\n  if (resourceTypeDeletions.size > 0) {\n    line('## Removed Resource Types');\n    line();\n    resourceTypeDeletions.forEach(type => line(`* ${type}`));\n    line();\n  }\n\n  line('## Attribute Changes');\n  line();\n  attributeChanges.forEach(x => line(x));\n  line();\n\n  line('## Property Changes');\n  line();\n  propertyChanges.forEach(x => line(x));\n  line();\n\n  line('## Property Type Changes');\n  line();\n  propertyTypeChanges.forEach(x => line(x));\n\n  function classifyResourceTypeUpdate(resourceType: string, update: any) {\n    const added = isAdded(resourceType);\n    if (added) {\n      resourceTypeAdditions.add(added);\n      return;\n    }\n\n    const deleted = isDeleted(resourceType);\n    if (deleted) {\n      resourceTypeDeletions.add(deleted);\n      return;\n    }\n\n    pushDownCompleteChanges(update);\n\n    for (const key of Object.keys(update)) {\n      switch (key) {\n        case 'Properties':\n          for (const prop of Object.keys(update.Properties)) {\n            describeChanges(resourceType, prop, update.Properties[prop]).forEach(change => {\n              propertyChanges.push(change);\n            });\n          }\n          break;\n        case 'Attributes':\n          for (const attr of Object.keys(update.Attributes)) {\n            describeChanges(resourceType, attr, update.Attributes[attr]).forEach(change => {\n              attributeChanges.push(change);\n            });\n          }\n          break;\n        case 'Documentation':\n          describeChanges(resourceType, key, update.Documentation).forEach(change => {\n            attributeChanges.push(change);\n          });\n          break;\n        default:\n          throw new Error(`Unexpected update to ${resourceType}: ${key}`);\n      }\n    }\n  }\n\n  function classifyPropertyTypeUpdate(propertyType: string, update: any) {\n    const added = isAdded(propertyType);\n    if (added) {\n      const resourceType = added.split('.')[0];\n      if (resourceTypeAdditions.has(resourceType)) {\n        return; // skipping property for added resource types\n      }\n\n      propertyTypeChanges.push(`* ${added} (__added__)`);\n      return;\n    }\n\n    const deleted = isDeleted(propertyType);\n    if (deleted) {\n      const resourceType = deleted.split('.')[0];\n      if (resourceTypeDeletions.has(resourceType)) {\n        return; // skipping property for added resource types\n      }\n\n      propertyTypeChanges.push(`* ${deleted} (__removed__)`);\n      return;\n    }\n\n    if (Object.keys(update).length !== 1 && Object.keys(update)[0] === 'Properties') {\n      throw new Error('Unexpected update to a resource type. Expecting only \"Properties\" to change: ' + propertyType);\n    }\n\n    for (const prop of Object.keys(update.Properties ?? {})) {\n      describeChanges(propertyType, prop, update.Properties[prop]).forEach(change => {\n        propertyTypeChanges.push(change);\n      });\n    }\n  }\n\n  /**\n   * Push down mass changes to attributes or properties to the individual properties.\n   *\n   * An example will explain this best. JSON-diff will make the smallest diff, so if there\n   * are new properties it will report:\n   *\n   * \"Properties__added\": {\n   *    \"Property1\": { ... },\n   *    \"Property2\": { ... },\n   * }\n   *\n   * But we want to see this as:\n   *\n   * \"Properties\": {\n   *    \"Property1__added\": { ... },\n   *    \"Property2__added\": { ... },\n   * }\n   *\n   * Same (but in reverse) for deletions.\n   */\n  function pushDownCompleteChanges(update: Record<string, Record<string, any>>) {\n    for (const [category, entries] of Object.entries(update)) {\n      const addedKey = isAdded(category);\n      if (addedKey) {\n        delete update[category];\n        update[addedKey] = suffixKeys('__added', entries);\n      }\n\n      const deletedKey = isDeleted(category);\n      if (deletedKey) {\n        delete update[category];\n        update[deletedKey] = suffixKeys('__deleted', entries);\n      }\n    }\n  }\n\n  function isDeleted(key: string) {\n    return isSuffix(key, '__deleted');\n  }\n\n  function isAdded(key: string) {\n    return isSuffix(key, '__added');\n  }\n\n  function isSuffix(key: string, suffix: string) {\n    const index = key.indexOf(suffix);\n    return index === -1 ? undefined : key.slice(0, index);\n  }\n\n  function suffixKeys(suffix: string, xs: Record<string, any>): Record<string, any> {\n    const ret: Record<string, any> = {};\n    for (const [key, value] of Object.entries(xs)) {\n      ret[key + suffix] = value;\n    }\n    return ret;\n  }\n\n  function describeChanges(namespace: string, prefix: string, update: any) {\n    const changes = new Array<string>();\n\n    const added = isAdded(prefix);\n    if (added) {\n      changes.push(`* ${namespace} ${added} (__added__)`);\n      return changes;\n    }\n\n    const deleted = isDeleted(prefix);\n    if (deleted) {\n      changes.push(`* ${namespace} ${deleted} (__deleted__)`);\n      return changes;\n    }\n\n    if (typeof(update) !== 'object') {\n      throw new Error(`Unexpected change for ${namespace}.${prefix} ${JSON.stringify(update)}`);\n    }\n\n    if ('__old' in update && '__new' in update) {\n      changes.push(`* ${namespace} ${prefix} (__changed__)`);\n      changes.push(`  * Old: ${update.__old}`);\n      changes.push(`  * New: ${update.__new}`);\n      return changes;\n    }\n\n    if (Array.isArray(update)) {\n      changes.push(`* ${namespace} ${prefix} (__changed__)`);\n      for (const entry of update) {\n        if (entry.length === 1 && entry[0] === ' ') {\n          // This means that this element of the array is unchanged\n          continue;\n        }\n        if (entry.length !== 2) {\n          throw new Error(`Unexpected array diff entry: ${JSON.stringify(entry)}`);\n        }\n        switch (entry[0]) {\n          case '+':\n            changes.push(`  * Added ${entry[1]}`);\n            break;\n          case '-':\n            throw new Error(`Something awkward happened: ${entry[1]} was deleted from ${namespace} ${prefix}!`);\n          case ' ':\n            // This entry is \"context\"\n            break;\n          default:\n            throw new Error(`Unexpected array diff entry: ${JSON.stringify(entry)}`);\n        }\n      }\n    } else {\n      for (const key of Object.keys(update)) {\n        for (const change of describeChanges(namespace, `${prefix}.${key}`, update[key])) {\n          changes.push(change);\n        }\n      }\n    }\n\n    return changes;\n  }\n}\n\nmain().catch(e => {\n  process.stderr.write(e.stack);\n  process.stderr.write('\\n');\n  process.exit(1);\n});\n"]}

package/node_modules/@aws-cdk/cfnspec/build-tools/split-spec-by-service.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@aws-cdk/cfnspec/build-tools/split-spec-by-service.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+/**
+ * Split the given CloudFormation resource specification up into a patch set, by service
+ *
+ * After splitting, only write out those fragments that are valid.(*)
+ *
+ * The reason for this is that some service updates sometimes contain mistakes,
+ * and we want to be able to take partial upgrades. By splitting the spec, we can
+ * take updates to some services while leaving updates to other services behind.
+ *
+ * (*) If `NO_VALIDATE` is set, all pieces are written out. In normal operation this
+ *     should not be used.
+ */
+const path = require("path");
+const fs = require("fs-extra");
+const patch_set_1 = require("./patch-set");
+const validate_cfn_1 = require("./validate-cfn");
+async function main(args) {
+    if (args.length < 3) {
+        throw new Error('Usage: split-spec-by-service <SPECFILE> <DIRECTORY> [<SERVICES>]');
+    }
+    const [specFile, outDir, services] = args;
+    const allowedServices = services.trim().split(' ').filter(Boolean);
+    log(`Loading specification: ${specFile}`);
+    const spec = await fs.readJson(specFile);
+    // Split
+    log('Splitting');
+    const byService = {};
+    for (const [propTypeName, propType] of Object.entries(spec.PropertyTypes)) {
+        const svcName = serviceName(propTypeName);
+        serviceSpec(svcName).PropertyTypes[propTypeName] = propType;
+    }
+    for (const [resTypeName, resType] of Object.entries(spec.ResourceTypes)) {
+        const svcName = serviceName(resTypeName);
+        serviceSpec(svcName).ResourceTypes[resTypeName] = resType;
+    }
+    // Write out
+    if (allowedServices.length > 0) {
+        log(`Writing: ${allowedServices.join(' ')}`);
+    }
+    else {
+        log('Writing all services');
+    }
+    for (const [svcName, svcSpec] of Object.entries(byService)) {
+        // Skip services that are not explicitly allowed
+        if (allowedServices.length > 0 && !allowedServices.includes(svcName)) {
+            continue;
+        }
+        const successTarget = path.join(outDir, `000_${svcName}.json`);
+        const rejectedTarget = path.join(outDir, `.000_${svcName}.rejected.json`);
+        const errors = !process.env.NO_VALIDATE ? validate_cfn_1.CfnSpecValidator.validate(svcSpec) : [];
+        if (errors.length === 0) {
+            // Change 'ResourceSpecificationVersion' to '$version', otherwise they will all conflict
+            const toWrite = {
+                PropertyTypes: svcSpec.PropertyTypes,
+                ResourceTypes: svcSpec.ResourceTypes,
+                $version: svcSpec.ResourceSpecificationVersion,
+            };
+            await patch_set_1.writeSorted(successTarget, toWrite);
+            await ensureGone(rejectedTarget);
+        }
+        else {
+            console.warn('='.repeat(70));
+            console.warn(' '.repeat(Math.floor(35 - svcName.length / 2)) + svcName);
+            console.warn('='.repeat(70));
+            for (const error of errors) {
+                console.warn(validate_cfn_1.formatErrorInContext(error));
+            }
+            await patch_set_1.writeSorted(rejectedTarget, svcSpec);
+            // Make sure that the success file exists. If not, the initial import of a
+            // new service failed.
+            if (!await fs.pathExists(successTarget)) {
+                await patch_set_1.writeSorted(successTarget, {
+                    PropertyTypes: {},
+                    ResourceTypes: {},
+                    $version: '0.0.0',
+                });
+            }
+        }
+    }
+    await fs.writeJson(path.join(outDir, '001_Version.json'), {
+        ResourceSpecificationVersion: spec.ResourceSpecificationVersion,
+    }, { spaces: 2 });
+    function serviceSpec(svcName) {
+        if (!(svcName in byService)) {
+            byService[svcName] = {
+                PropertyTypes: {},
+                ResourceTypes: {},
+                ResourceSpecificationVersion: spec.ResourceSpecificationVersion,
+            };
+        }
+        return byService[svcName];
+    }
+}
+async function ensureGone(fileName) {
+    try {
+        await fs.unlink(fileName);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return;
+        }
+        throw e;
+    }
+}
+function serviceName(x) {
+    return x.split('::').slice(0, 2).join('_');
+}
+function log(x) {
+    // eslint-disable-next-line no-console
+    console.log(x);
+}
+main(process.argv.slice(2)).catch(e => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"split-spec-by-service.js","sourceRoot":"","sources":["split-spec-by-service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\n/**\n * Split the given CloudFormation resource specification up into a patch set, by service\n *\n * After splitting, only write out those fragments that are valid.(*)\n *\n * The reason for this is that some service updates sometimes contain mistakes,\n * and we want to be able to take partial upgrades. By splitting the spec, we can\n * take updates to some services while leaving updates to other services behind.\n *\n * (*) If `NO_VALIDATE` is set, all pieces are written out. In normal operation this\n *     should not be used.\n */\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\n\nimport { writeSorted } from './patch-set';\nimport { CfnSpec, CfnSpecValidator, formatErrorInContext } from './validate-cfn';\n\nasync function main(args: string[]) {\n  if (args.length < 3) {\n    throw new Error('Usage: split-spec-by-service <SPECFILE> <DIRECTORY> [<SERVICES>]');\n  }\n\n  const [specFile, outDir, services] = args;\n  const allowedServices = services.trim().split(' ').filter(Boolean);\n\n  log(`Loading specification: ${specFile}`);\n  const spec: CfnSpec = await fs.readJson(specFile);\n\n  // Split\n  log('Splitting');\n  const byService: Record<string, CfnSpec> = {};\n  for (const [propTypeName, propType] of Object.entries(spec.PropertyTypes)) {\n    const svcName = serviceName(propTypeName);\n    serviceSpec(svcName).PropertyTypes[propTypeName] = propType;\n  }\n  for (const [resTypeName, resType] of Object.entries(spec.ResourceTypes)) {\n    const svcName = serviceName(resTypeName);\n    serviceSpec(svcName).ResourceTypes[resTypeName] = resType;\n  }\n\n  // Write out\n  if (allowedServices.length > 0) {\n    log(`Writing: ${allowedServices.join(' ')}`);\n  } else {\n    log('Writing all services');\n  }\n  for (const [svcName, svcSpec] of Object.entries(byService)) {\n    // Skip services that are not explicitly allowed\n    if (allowedServices.length > 0 && !allowedServices.includes(svcName)) {\n      continue;\n    }\n\n    const successTarget = path.join(outDir, `000_${svcName}.json`);\n    const rejectedTarget = path.join(outDir, `.000_${svcName}.rejected.json`);\n\n    const errors = !process.env.NO_VALIDATE ? CfnSpecValidator.validate(svcSpec) : [];\n    if (errors.length === 0) {\n      // Change 'ResourceSpecificationVersion' to '$version', otherwise they will all conflict\n      const toWrite = {\n        PropertyTypes: svcSpec.PropertyTypes,\n        ResourceTypes: svcSpec.ResourceTypes,\n        $version: svcSpec.ResourceSpecificationVersion,\n      };\n\n      await writeSorted(successTarget, toWrite);\n      await ensureGone(rejectedTarget);\n    } else {\n      console.warn('='.repeat(70));\n      console.warn(' '.repeat(Math.floor(35 - svcName.length / 2)) + svcName);\n      console.warn('='.repeat(70));\n      for (const error of errors) {\n        console.warn(formatErrorInContext(error));\n      }\n\n      await writeSorted(rejectedTarget, svcSpec);\n\n      // Make sure that the success file exists. If not, the initial import of a\n      // new service failed.\n      if (!await fs.pathExists(successTarget)) {\n        await writeSorted(successTarget, {\n          PropertyTypes: {},\n          ResourceTypes: {},\n          $version: '0.0.0',\n        });\n      }\n    }\n  }\n  await fs.writeJson(path.join(outDir, '001_Version.json'), {\n    ResourceSpecificationVersion: spec.ResourceSpecificationVersion,\n  }, { spaces: 2 });\n\n  function serviceSpec(svcName: string) {\n    if (!(svcName in byService)) {\n      byService[svcName] = {\n        PropertyTypes: {},\n        ResourceTypes: {},\n        ResourceSpecificationVersion: spec.ResourceSpecificationVersion,\n      };\n    }\n    return byService[svcName];\n  }\n}\n\nasync function ensureGone(fileName: string) {\n  try {\n    await fs.unlink(fileName);\n  } catch (e) {\n    if (e.code === 'ENOENT') { return; }\n    throw e;\n  }\n}\n\nfunction serviceName(x: string) {\n  return x.split('::').slice(0, 2).join('_');\n}\n\nfunction log(x: string) {\n  // eslint-disable-next-line no-console\n  console.log(x);\n}\n\nmain(process.argv.slice(2)).catch(e => {\n  // eslint-disable-next-line no-console\n  console.error(e);\n  process.exitCode = 1;\n});\n"]}

package/node_modules/@aws-cdk/cfnspec/build-tools/template/LICENSE

@@ -0,0 +1,201 @@
+                                 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 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+   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.

package/node_modules/@aws-cdk/cfnspec/build-tools/template/NOTICE

@@ -0,0 +1,2 @@
+AWS Cloud Development Kit (AWS CDK)
+Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.

package/node_modules/@aws-cdk/cfnspec/build-tools/update-cfnlint.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+set -euo pipefail
+scriptdir=$(cd $(dirname $0) && pwd)
+
+# Download (parts of) the cfn-lint repo that we use to enhance our model
+intermediate="$(mktemp -d)/tmp.zip"
+
+url="https://github.com/aws-cloudformation/cfn-lint/archive/refs/heads/main.zip"
+echo >&2 "Downloading from ${url} ..."
+curl -sSfL "${url}" -o ${intermediate}
+
+for file in StatefulResources; do
+  echo >&2 "${file}.json"
+  mkdir -p "spec-source/cfn-lint/${file}"
+  unzip -p "${intermediate}" cfn-lint-main/src/cfnlint/data/AdditionalSpecs/${file}.json > spec-source/cfn-lint/${file}/000.json
+done
+
+echo >&2 "Done."