@aws-amplify/graphql-api-construct 1.18.2 → 1.18.3

package/node_modules/@aws-cdk/cfnspec/lib/canned-metrics.d.ts

@@ -0,0 +1,41 @@
+export declare type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * A single canned service metric
+ *
+ * These are kindly provided to us by the good people of CloudWatch Explorer.
+ */
+export interface CannedMetric {
+    /**
+     * Metric namespace
+     */
+    readonly namespace: string;
+    /**
+     * Metric name
+     */
+    readonly metricName: string;
+    /**
+     * List of all possible dimension permutations for this metric
+     *
+     * Most metrics will have a single list of strings as their one set of
+     * allowed dimensions, but some metrics are emitted under multiple
+     * combinations of dimensions.
+     */
+    readonly dimensions: NonEmptyArray<string[]>;
+    /**
+     * Suggested default aggregration statistic
+     *
+     * Not always the most appropriate one to use! These defaults have
+     * been classified by people and they generally just pick "Average"
+     * as the default, even if it doesn't make sense.
+     *
+     * For example: for event-based metrics that only ever emit `1`
+     * (and never `0`) the better statistic would be `Sum`.
+     *
+     * Use your judgement based on the type of metric this is.
+     */
+    readonly defaultStat: string;
+}
+/**
+ * Return the list of canned metrics for the given service
+ */
+export declare function cannedMetricsForService(cloudFormationNamespace: string): CannedMetric[];

package/node_modules/@aws-cdk/cfnspec/lib/canned-metrics.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cannedMetricsForService = void 0;
+const canned_metrics_schema_1 = require("./canned-metrics/canned-metrics-schema");
+/**
+ * Return the list of canned metrics for the given service
+ */
+function cannedMetricsForService(cloudFormationNamespace) {
+    // One metricTemplate has a single set of dimensions, but the same metric NAME
+    // may occur in multiple metricTemplates (if it has multiple sets of dimensions)
+    const metricTemplates = cannedMetricsIndex()[cloudFormationNamespace] ?? [];
+    // First construct almost what we need, but with a single dimension per metric
+    const metricsWithDuplicates = flatMap(metricTemplates, metricSet => {
+        const dimensions = metricSet.dimensions.map(d => d.dimensionName);
+        return metricSet.metrics.map(metric => ({
+            namespace: metricSet.namespace,
+            dimensions,
+            metricName: metric.name,
+            defaultStat: metric.defaultStat,
+        }));
+    });
+    // Then combine the dimensions for the same metrics into a single list
+    return groupBy(metricsWithDuplicates, m => `${m.namespace}/${m.metricName}`).map(metrics => ({
+        namespace: metrics[0].namespace,
+        metricName: metrics[0].metricName,
+        defaultStat: metrics[0].defaultStat,
+        dimensions: Array.from(dedupeStringLists(metrics.map(m => m.dimensions))),
+    }));
+}
+exports.cannedMetricsForService = cannedMetricsForService;
+let cannedMetricsCache;
+/**
+ * Load the canned metrics file and process it into an index, grouped by service namespace
+ */
+function cannedMetricsIndex() {
+    if (cannedMetricsCache === undefined) {
+        cannedMetricsCache = {};
+        for (const group of canned_metrics_schema_1.loadCannedMetricsFile()) {
+            for (const metricTemplate of group.metricTemplates) {
+                const [aws, service] = metricTemplate.resourceType.split('::');
+                const serviceKey = [aws, service].join('::');
+                (cannedMetricsCache[serviceKey] ?? (cannedMetricsCache[serviceKey] = [])).push(metricTemplate);
+            }
+        }
+    }
+    return cannedMetricsCache;
+}
+function flatMap(xs, fn) {
+    return Array.prototype.concat.apply([], xs.map(fn));
+}
+function groupBy(xs, keyFn) {
+    const obj = {};
+    for (const x of xs) {
+        const key = keyFn(x);
+        if (key in obj) {
+            obj[key].push(x);
+        }
+        else {
+            obj[key] = [x];
+        }
+    }
+    return Object.values(obj);
+}
+function* dedupeStringLists(xs) {
+    const seen = new Set();
+    for (const x of xs) {
+        x.sort();
+        const key = `${x.join(',')}`;
+        if (!seen.has(key)) {
+            yield x;
+        }
+        seen.add(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"canned-metrics.js","sourceRoot":"","sources":["canned-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["import { loadCannedMetricsFile, MetricTemplate } from './canned-metrics/canned-metrics-schema';\n\nexport type NonEmptyArray<T> = [T, ...T[]];\n\n/**\n * A single canned service metric\n *\n * These are kindly provided to us by the good people of CloudWatch Explorer.\n */\nexport interface CannedMetric {\n  /**\n   * Metric namespace\n   */\n  readonly namespace: string;\n\n  /**\n   * Metric name\n   */\n  readonly metricName: string;\n\n  /**\n   * List of all possible dimension permutations for this metric\n   *\n   * Most metrics will have a single list of strings as their one set of\n   * allowed dimensions, but some metrics are emitted under multiple\n   * combinations of dimensions.\n   */\n  readonly dimensions: NonEmptyArray<string[]>;\n\n  /**\n   * Suggested default aggregration statistic\n   *\n   * Not always the most appropriate one to use! These defaults have\n   * been classified by people and they generally just pick \"Average\"\n   * as the default, even if it doesn't make sense.\n   *\n   * For example: for event-based metrics that only ever emit `1`\n   * (and never `0`) the better statistic would be `Sum`.\n   *\n   * Use your judgement based on the type of metric this is.\n   */\n  readonly defaultStat: string;\n}\n\n/**\n * Return the list of canned metrics for the given service\n */\nexport function cannedMetricsForService(cloudFormationNamespace: string): CannedMetric[] {\n  // One metricTemplate has a single set of dimensions, but the same metric NAME\n  // may occur in multiple metricTemplates (if it has multiple sets of dimensions)\n  const metricTemplates = cannedMetricsIndex()[cloudFormationNamespace] ?? [];\n\n  // First construct almost what we need, but with a single dimension per metric\n  const metricsWithDuplicates = flatMap(metricTemplates, metricSet => {\n    const dimensions = metricSet.dimensions.map(d => d.dimensionName);\n    return metricSet.metrics.map(metric => ({\n      namespace: metricSet.namespace,\n      dimensions,\n      metricName: metric.name,\n      defaultStat: metric.defaultStat,\n    }));\n  });\n\n  // Then combine the dimensions for the same metrics into a single list\n  return groupBy(metricsWithDuplicates, m => `${m.namespace}/${m.metricName}`).map(metrics => ({\n    namespace: metrics[0].namespace,\n    metricName: metrics[0].metricName,\n    defaultStat: metrics[0].defaultStat,\n    dimensions: Array.from(dedupeStringLists(metrics.map(m => m.dimensions))) as any,\n  }));\n}\n\ntype CannedMetricsIndex = Record<string, MetricTemplate[]>;\n\nlet cannedMetricsCache: CannedMetricsIndex | undefined;\n\n/**\n * Load the canned metrics file and process it into an index, grouped by service namespace\n */\nfunction cannedMetricsIndex() {\n  if (cannedMetricsCache === undefined) {\n    cannedMetricsCache = {};\n    for (const group of loadCannedMetricsFile()) {\n      for (const metricTemplate of group.metricTemplates) {\n        const [aws, service] = metricTemplate.resourceType.split('::');\n        const serviceKey = [aws, service].join('::');\n        (cannedMetricsCache[serviceKey] ?? (cannedMetricsCache[serviceKey] = [])).push(metricTemplate);\n      }\n    }\n  }\n  return cannedMetricsCache;\n}\n\nfunction flatMap<A, B>(xs: A[], fn: (x: A) => B[]): B[] {\n  return Array.prototype.concat.apply([], xs.map(fn));\n}\n\nfunction groupBy<A>(xs: A[], keyFn: (x: A) => string): Array<NonEmptyArray<A>> {\n  const obj: Record<string, NonEmptyArray<A>> = {};\n  for (const x of xs) {\n    const key = keyFn(x);\n    if (key in obj) {\n      obj[key].push(x);\n    } else {\n      obj[key] = [x];\n    }\n  }\n  return Object.values(obj);\n}\n\nfunction* dedupeStringLists(xs: string[][]): IterableIterator<string[]> {\n  const seen = new Set<string>();\n  for (const x of xs) {\n    x.sort();\n    const key = `${x.join(',')}`;\n    if (!seen.has(key)) {\n      yield x;\n    }\n    seen.add(key);\n  }\n}"]}

package/node_modules/@aws-cdk/cfnspec/lib/index.d.ts

@@ -0,0 +1,63 @@
+import * as schema from './schema';
+export { schema };
+export * from './canned-metrics';
+/**
+ * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.
+ */
+export declare function specification(): schema.Specification;
+/**
+ * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.
+ */
+export declare function docs(): schema.CloudFormationDocsFile;
+/**
+ * Return the resource specification for the given typename
+ *
+ * Validates that the resource exists. If you don't want this validating behavior, read from
+ * specification() directly.
+ */
+export declare function resourceSpecification(typeName: string): schema.ResourceType;
+/**
+ * Return documentation for the given type
+ */
+export declare function typeDocs(resourceName: string, propertyTypeName?: string): schema.CloudFormationTypeDocs;
+/**
+ * Get the resource augmentations for a given type
+ */
+export declare function resourceAugmentation(typeName: string): schema.ResourceAugmentation;
+/**
+ * Get the resource augmentations for a given type
+ */
+export declare function cfnLintAnnotations(typeName: string): schema.CfnLintResourceAnnotations;
+/**
+ * Return the property specification for the given resource's property
+ */
+export declare function propertySpecification(typeName: string, propertyName: string): schema.Property;
+/**
+ * The list of resource type names defined in the ``specification``.
+ */
+export declare function resourceTypes(): string[];
+/**
+ * The list of namespaces defined in the ``specification``, that is resource name prefixes down to the second ``::``.
+ */
+export declare function namespaces(): string[];
+/**
+ * Obtain a filtered version of the AWS CloudFormation specification.
+ *
+ * @param filter the predicate to be used in order to filter which resource types from the ``Specification`` to extract.
+ *         When passed as a ``string``, only the specified resource type will be extracted. When passed as a
+ *         ``RegExp``, all matching resource types will be extracted. When passed as a ``function``, all resource
+ *         types for which the function returned ``true`` will be extracted.
+ *
+ * @return a coherent sub-set of the AWS CloudFormation Resource specification, including all property types related
+ *     to the selected resource types.
+ */
+export declare function filteredSpecification(filter: string | RegExp | Filter): schema.Specification;
+export declare type Filter = (name: string) => boolean;
+/**
+ * Return the properties of the given type that require the given scrutiny type
+ */
+export declare function scrutinizablePropertyNames(resourceType: string, scrutinyTypes: schema.PropertyScrutinyType[]): string[];
+/**
+ * Return the names of the resource types that need to be subjected to additional scrutiny
+ */
+export declare function scrutinizableResourceTypes(scrutinyTypes: schema.ResourceScrutinyType[]): string[];

package/node_modules/@aws-cdk/cfnspec/lib/index.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrutinizableResourceTypes = exports.scrutinizablePropertyNames = exports.filteredSpecification = exports.namespaces = exports.resourceTypes = exports.propertySpecification = exports.cfnLintAnnotations = exports.resourceAugmentation = exports.typeDocs = exports.resourceSpecification = exports.docs = exports.specification = exports.schema = void 0;
+const crypto = require("crypto");
+const schema = require("./schema");
+exports.schema = schema;
+const schema_1 = require("./schema");
+__exportStar(require("./canned-metrics"), exports);
+/**
+ * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.
+ */
+function specification() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const spec = require('../spec/specification.json');
+    // Modify spec in place, remove complex attributes
+    for (const resource of Object.values(spec.ResourceTypes)) {
+        resource.Attributes = Object.fromEntries(Object.entries(resource.Attributes ?? [])
+            .filter(([_, attr]) => schema_1.isPrimitiveAttribute(attr) || schema_1.isListAttribute(attr) || schema_1.isMapAttribute(attr)));
+    }
+    return spec;
+}
+exports.specification = specification;
+/**
+ * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.
+ */
+function docs() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('../spec/cfn-docs.json');
+}
+exports.docs = docs;
+/**
+ * Return the resource specification for the given typename
+ *
+ * Validates that the resource exists. If you don't want this validating behavior, read from
+ * specification() directly.
+ */
+function resourceSpecification(typeName) {
+    const ret = specification().ResourceTypes[typeName];
+    if (!ret) {
+        throw new Error(`No such resource type: ${typeName}`);
+    }
+    return ret;
+}
+exports.resourceSpecification = resourceSpecification;
+/**
+ * Return documentation for the given type
+ */
+function typeDocs(resourceName, propertyTypeName) {
+    const key = propertyTypeName ? `${resourceName}.${propertyTypeName}` : resourceName;
+    const ret = docs().Types[key];
+    if (!ret) {
+        return {
+            description: '',
+            properties: {},
+        };
+    }
+    return ret;
+}
+exports.typeDocs = typeDocs;
+/**
+ * Get the resource augmentations for a given type
+ */
+function resourceAugmentation(typeName) {
+    const fileName = typeName.replace(/::/g, '_');
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(`./augmentations/${fileName}.json`);
+    }
+    catch (e) {
+        return {};
+    }
+}
+exports.resourceAugmentation = resourceAugmentation;
+/**
+ * Get the resource augmentations for a given type
+ */
+function cfnLintAnnotations(typeName) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const allAnnotations = require('../spec/cfn-lint.json');
+    return {
+        stateful: !!allAnnotations.StatefulResources.ResourceTypes[typeName],
+        mustBeEmptyToDelete: allAnnotations.StatefulResources.ResourceTypes[typeName]?.DeleteRequiresEmptyResource ?? false,
+    };
+}
+exports.cfnLintAnnotations = cfnLintAnnotations;
+/**
+ * Return the property specification for the given resource's property
+ */
+function propertySpecification(typeName, propertyName) {
+    const ret = resourceSpecification(typeName).Properties[propertyName];
+    if (!ret) {
+        throw new Error(`Resource ${typeName} has no property: ${propertyName}`);
+    }
+    return ret;
+}
+exports.propertySpecification = propertySpecification;
+/**
+ * The list of resource type names defined in the ``specification``.
+ */
+function resourceTypes() {
+    return Object.keys(specification().ResourceTypes);
+}
+exports.resourceTypes = resourceTypes;
+/**
+ * The list of namespaces defined in the ``specification``, that is resource name prefixes down to the second ``::``.
+ */
+function namespaces() {
+    return Array.from(new Set(resourceTypes().map(n => n.split('::', 2).join('::'))));
+}
+exports.namespaces = namespaces;
+/**
+ * Obtain a filtered version of the AWS CloudFormation specification.
+ *
+ * @param filter the predicate to be used in order to filter which resource types from the ``Specification`` to extract.
+ *         When passed as a ``string``, only the specified resource type will be extracted. When passed as a
+ *         ``RegExp``, all matching resource types will be extracted. When passed as a ``function``, all resource
+ *         types for which the function returned ``true`` will be extracted.
+ *
+ * @return a coherent sub-set of the AWS CloudFormation Resource specification, including all property types related
+ *     to the selected resource types.
+ */
+function filteredSpecification(filter) {
+    const spec = specification();
+    const result = { ResourceTypes: {}, PropertyTypes: {}, Fingerprint: spec.Fingerprint };
+    const predicate = makePredicate(filter);
+    for (const type of resourceTypes()) {
+        if (!predicate(type)) {
+            continue;
+        }
+        result.ResourceTypes[type] = spec.ResourceTypes[type];
+        const prefix = `${type}.`;
+        for (const propType of Object.keys(spec.PropertyTypes).filter(n => n.startsWith(prefix))) {
+            result.PropertyTypes[propType] = spec.PropertyTypes[propType];
+        }
+    }
+    result.Fingerprint = crypto.createHash('sha256').update(JSON.stringify(result)).digest('base64');
+    return result;
+}
+exports.filteredSpecification = filteredSpecification;
+/**
+ * Creates a predicate function from a given filter.
+ *
+ * @param filter when provided as a ``string``, performs an exact match comparison.
+ *         when provided as a ``RegExp``, performs uses ``str.match(RegExp)``.
+ *         when provided as a ``function``, use the function as-is.
+ *
+ * @returns a predicate function.
+ */
+function makePredicate(filter) {
+    if (typeof filter === 'string') {
+        return s => s === filter;
+    }
+    else if (typeof filter === 'function') {
+        return filter;
+    }
+    else {
+        return s => s.match(filter) != null;
+    }
+}
+/**
+ * Return the properties of the given type that require the given scrutiny type
+ */
+function scrutinizablePropertyNames(resourceType, scrutinyTypes) {
+    const impl = specification().ResourceTypes[resourceType];
+    if (!impl) {
+        return [];
+    }
+    const ret = new Array();
+    for (const [propertyName, propertySpec] of Object.entries(impl.Properties || {})) {
+        if (scrutinyTypes.includes(propertySpec.ScrutinyType || schema.PropertyScrutinyType.None)) {
+            ret.push(propertyName);
+        }
+    }
+    return ret;
+}
+exports.scrutinizablePropertyNames = scrutinizablePropertyNames;
+/**
+ * Return the names of the resource types that need to be subjected to additional scrutiny
+ */
+function scrutinizableResourceTypes(scrutinyTypes) {
+    const ret = new Array();
+    for (const [resourceType, resourceSpec] of Object.entries(specification().ResourceTypes)) {
+        if (scrutinyTypes.includes(resourceSpec.ScrutinyType || schema.ResourceScrutinyType.None)) {
+            ret.push(resourceType);
+        }
+    }
+    return ret;
+}
+exports.scrutinizableResourceTypes = scrutinizableResourceTypes;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport { CfnLintFileSchema } from './_private_schema/cfn-lint';\nimport * as schema from './schema';\nimport { isPrimitiveAttribute, isListAttribute, isMapAttribute } from './schema';\nexport { schema };\nexport * from './canned-metrics';\n\n/**\n * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.\n */\nexport function specification(): schema.Specification {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const spec: schema.Specification = require('../spec/specification.json');\n\n  // Modify spec in place, remove complex attributes\n  for (const resource of Object.values(spec.ResourceTypes)) {\n    resource.Attributes = Object.fromEntries(Object.entries(resource.Attributes ?? [])\n      .filter(([_, attr]) => isPrimitiveAttribute(attr) || isListAttribute(attr) || isMapAttribute(attr) ));\n  }\n\n  return spec;\n}\n\n/**\n * The complete AWS CloudFormation Resource specification, having any CDK patches and enhancements included in it.\n */\nexport function docs(): schema.CloudFormationDocsFile {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  return require('../spec/cfn-docs.json');\n}\n\n\n/**\n * Return the resource specification for the given typename\n *\n * Validates that the resource exists. If you don't want this validating behavior, read from\n * specification() directly.\n */\nexport function resourceSpecification(typeName: string): schema.ResourceType {\n  const ret = specification().ResourceTypes[typeName];\n  if (!ret) {\n    throw new Error(`No such resource type: ${typeName}`);\n  }\n  return ret;\n}\n\n/**\n * Return documentation for the given type\n */\nexport function typeDocs(resourceName: string, propertyTypeName?: string): schema.CloudFormationTypeDocs {\n  const key = propertyTypeName ? `${resourceName}.${propertyTypeName}` : resourceName;\n  const ret = docs().Types[key];\n  if (!ret) {\n    return {\n      description: '',\n      properties: {},\n    };\n  }\n  return ret;\n}\n\n/**\n * Get the resource augmentations for a given type\n */\nexport function resourceAugmentation(typeName: string): schema.ResourceAugmentation {\n  const fileName = typeName.replace(/::/g, '_');\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    return require(`./augmentations/${fileName}.json`);\n  } catch (e) {\n    return {};\n  }\n}\n\n/**\n * Get the resource augmentations for a given type\n */\nexport function cfnLintAnnotations(typeName: string): schema.CfnLintResourceAnnotations {\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const allAnnotations: CfnLintFileSchema = require('../spec/cfn-lint.json');\n\n  return {\n    stateful: !!allAnnotations.StatefulResources.ResourceTypes[typeName],\n    mustBeEmptyToDelete: allAnnotations.StatefulResources.ResourceTypes[typeName]?.DeleteRequiresEmptyResource ?? false,\n  };\n}\n\n/**\n * Return the property specification for the given resource's property\n */\nexport function propertySpecification(typeName: string, propertyName: string): schema.Property {\n  const ret = resourceSpecification(typeName).Properties![propertyName];\n  if (!ret) {\n    throw new Error(`Resource ${typeName} has no property: ${propertyName}`);\n  }\n  return ret;\n}\n\n/**\n * The list of resource type names defined in the ``specification``.\n */\nexport function resourceTypes() {\n  return Object.keys(specification().ResourceTypes);\n}\n\n/**\n * The list of namespaces defined in the ``specification``, that is resource name prefixes down to the second ``::``.\n */\nexport function namespaces() {\n  return Array.from(new Set(resourceTypes().map(n => n.split('::', 2).join('::'))));\n}\n\n/**\n * Obtain a filtered version of the AWS CloudFormation specification.\n *\n * @param filter the predicate to be used in order to filter which resource types from the ``Specification`` to extract.\n *         When passed as a ``string``, only the specified resource type will be extracted. When passed as a\n *         ``RegExp``, all matching resource types will be extracted. When passed as a ``function``, all resource\n *         types for which the function returned ``true`` will be extracted.\n *\n * @return a coherent sub-set of the AWS CloudFormation Resource specification, including all property types related\n *     to the selected resource types.\n */\nexport function filteredSpecification(filter: string | RegExp | Filter): schema.Specification {\n  const spec = specification();\n\n  const result: schema.Specification = { ResourceTypes: {}, PropertyTypes: {}, Fingerprint: spec.Fingerprint };\n  const predicate: Filter = makePredicate(filter);\n  for (const type of resourceTypes()) {\n    if (!predicate(type)) { continue; }\n    result.ResourceTypes[type] = spec.ResourceTypes[type];\n    const prefix = `${type}.`;\n    for (const propType of Object.keys(spec.PropertyTypes!).filter(n => n.startsWith(prefix))) {\n      result.PropertyTypes[propType] = spec.PropertyTypes![propType];\n    }\n  }\n  result.Fingerprint = crypto.createHash('sha256').update(JSON.stringify(result)).digest('base64');\n  return result;\n}\n\nexport type Filter = (name: string) => boolean;\n\n/**\n * Creates a predicate function from a given filter.\n *\n * @param filter when provided as a ``string``, performs an exact match comparison.\n *         when provided as a ``RegExp``, performs uses ``str.match(RegExp)``.\n *         when provided as a ``function``, use the function as-is.\n *\n * @returns a predicate function.\n */\nfunction makePredicate(filter: string | RegExp | Filter): Filter {\n  if (typeof filter === 'string') {\n    return s => s === filter;\n  } else if (typeof filter === 'function') {\n    return filter as Filter;\n  } else {\n    return s => s.match(filter) != null;\n  }\n}\n\n/**\n * Return the properties of the given type that require the given scrutiny type\n */\nexport function scrutinizablePropertyNames(resourceType: string, scrutinyTypes: schema.PropertyScrutinyType[]): string[] {\n  const impl = specification().ResourceTypes[resourceType];\n  if (!impl) { return []; }\n\n  const ret = new Array<string>();\n\n  for (const [propertyName, propertySpec] of Object.entries(impl.Properties || {})) {\n    if (scrutinyTypes.includes(propertySpec.ScrutinyType || schema.PropertyScrutinyType.None)) {\n      ret.push(propertyName);\n    }\n  }\n\n  return ret;\n}\n\n/**\n * Return the names of the resource types that need to be subjected to additional scrutiny\n */\nexport function scrutinizableResourceTypes(scrutinyTypes: schema.ResourceScrutinyType[]): string[] {\n  const ret = new Array<string>();\n  for (const [resourceType, resourceSpec] of Object.entries(specification().ResourceTypes)) {\n    if (scrutinyTypes.includes(resourceSpec.ScrutinyType || schema.ResourceScrutinyType.None)) {\n      ret.push(resourceType);\n    }\n  }\n\n  return ret;\n}\n"]}

package/node_modules/@aws-cdk/cfnspec/lib/schema/augmentation.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Augmentations for a CloudFormation resource type
+ */
+export interface ResourceAugmentation {
+    /**
+     * Metric augmentations for this resource type
+     */
+    metrics?: ResourceMetricAugmentations;
+    /**
+     * Options for this resource augmentation
+     *
+     * @default no options
+     */
+    options?: AugmentationOptions;
+}
+export interface AugmentationOptions {
+    /**
+     * The name of the file containing the class to be "augmented".
+     *
+     * @default kebab cased CloudFormation resource name + '-base'
+     */
+    classFile?: string;
+    /**
+     * The name of the class to be "augmented".
+     *
+     * @default CloudFormation resource name + 'Base'
+     */
+    class?: string;
+    /**
+     * The name of the file containing the interface to be "augmented".
+     *
+     * @default - same as ``classFile``.
+     */
+    interfaceFile?: string;
+    /**
+     * The name of the interface to be "augmented".
+     *
+     * @default 'I' + CloudFormation resource name
+     */
+    interface?: string;
+}
+export interface ResourceMetricAugmentations {
+    namespace: string;
+    dimensions: {
+        [key: string]: string;
+    };
+    metrics: ResourceMetric[];
+}
+export interface ResourceMetric {
+    /**
+     * Uppercase-first metric name
+     */
+    name: string;
+    /**
+     * Documentation line
+     */
+    documentation: string;
+    /**
+     * Whether this is an even count (1 gets emitted every time something occurs)
+     *
+     * @default MetricType.Attrib
+     */
+    type?: MetricType;
+}
+export declare enum MetricType {
+    /**
+     * This metric measures an attribute of events
+     *
+     * It could be time, or request size, or similar. The default
+     * aggregate for this type of event is "Avg".
+     */
+    Attrib = "attrib",
+    /**
+     * This metric is counting events.
+     *
+     * This means the metric "1" is emitted every time an event occurs.
+     * Only "Sum" is a meaningful aggregate of this type of metric.
+     */
+    Count = "count",
+    /**
+     * This metric is emitting a size.
+     *
+     * The metric is not event-based, but measures some global ever-changing
+     * property. The most useful aggregate of this type of metric is "Max".
+     */
+    Gauge = "gauge"
+}

package/node_modules/@aws-cdk/cfnspec/lib/schema/augmentation.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricType = void 0;
+var MetricType;
+(function (MetricType) {
+    /**
+     * This metric measures an attribute of events
+     *
+     * It could be time, or request size, or similar. The default
+     * aggregate for this type of event is "Avg".
+     */
+    MetricType["Attrib"] = "attrib";
+    /**
+     * This metric is counting events.
+     *
+     * This means the metric "1" is emitted every time an event occurs.
+     * Only "Sum" is a meaningful aggregate of this type of metric.
+     */
+    MetricType["Count"] = "count";
+    /**
+     * This metric is emitting a size.
+     *
+     * The metric is not event-based, but measures some global ever-changing
+     * property. The most useful aggregate of this type of metric is "Max".
+     */
+    MetricType["Gauge"] = "gauge";
+})(MetricType = exports.MetricType || (exports.MetricType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/node_modules/@aws-cdk/cfnspec/lib/schema/base-types.d.ts

@@ -0,0 +1,14 @@
+export interface Documented {
+    /** A link to the AWS CloudFormation User Guide that provides informations about the entity. */
+    Documentation?: string;
+}
+export declare enum PrimitiveType {
+    String = "String",
+    Long = "Long",
+    Integer = "Integer",
+    Double = "Double",
+    Boolean = "Boolean",
+    Timestamp = "Timestamp",
+    Json = "Json"
+}
+export declare function isPrimitiveType(str: string): str is PrimitiveType;

package/node_modules/@aws-cdk/cfnspec/lib/schema/base-types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimitiveType = exports.PrimitiveType = void 0;
+var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType["String"] = "String";
+    PrimitiveType["Long"] = "Long";
+    PrimitiveType["Integer"] = "Integer";
+    PrimitiveType["Double"] = "Double";
+    PrimitiveType["Boolean"] = "Boolean";
+    PrimitiveType["Timestamp"] = "Timestamp";
+    PrimitiveType["Json"] = "Json";
+})(PrimitiveType = exports.PrimitiveType || (exports.PrimitiveType = {}));
+function isPrimitiveType(str) {
+    switch (str) {
+        case PrimitiveType.String:
+        case PrimitiveType.Long:
+        case PrimitiveType.Integer:
+        case PrimitiveType.Double:
+        case PrimitiveType.Boolean:
+        case PrimitiveType.Timestamp:
+        case PrimitiveType.Json:
+            return true;
+        default:
+            return false;
+    }
+}
+exports.isPrimitiveType = isPrimitiveType;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbImJhc2UtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBS0EsSUFBWSxhQVFYO0FBUkQsV0FBWSxhQUFhO0lBQ3ZCLGtDQUFpQixDQUFBO0lBQ2pCLDhCQUFhLENBQUE7SUFDYixvQ0FBbUIsQ0FBQTtJQUNuQixrQ0FBaUIsQ0FBQTtJQUNqQixvQ0FBbUIsQ0FBQTtJQUNuQix3Q0FBdUIsQ0FBQTtJQUN2Qiw4QkFBYSxDQUFBO0FBQ2YsQ0FBQyxFQVJXLGFBQWEsR0FBYixxQkFBYSxLQUFiLHFCQUFhLFFBUXhCO0FBRUQsU0FBZ0IsZUFBZSxDQUFDLEdBQVc7SUFDekMsUUFBUSxHQUFHLEVBQUU7UUFDWCxLQUFLLGFBQWEsQ0FBQyxNQUFNLENBQUM7UUFDMUIsS0FBSyxhQUFhLENBQUMsSUFBSSxDQUFDO1FBQ3hCLEtBQUssYUFBYSxDQUFDLE9BQU8sQ0FBQztRQUMzQixLQUFLLGFBQWEsQ0FBQyxNQUFNLENBQUM7UUFDMUIsS0FBSyxhQUFhLENBQUMsT0FBTyxDQUFDO1FBQzNCLEtBQUssYUFBYSxDQUFDLFNBQVMsQ0FBQztRQUM3QixLQUFLLGFBQWEsQ0FBQyxJQUFJO1lBQ3JCLE9BQU8sSUFBSSxDQUFDO1FBQ2Q7WUFDRSxPQUFPLEtBQUssQ0FBQztLQUNoQjtBQUNILENBQUM7QUFiRCwwQ0FhQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRG9jdW1lbnRlZCB7XG4gIC8qKiBBIGxpbmsgdG8gdGhlIEFXUyBDbG91ZEZvcm1hdGlvbiBVc2VyIEd1aWRlIHRoYXQgcHJvdmlkZXMgaW5mb3JtYXRpb25zIGFib3V0IHRoZSBlbnRpdHkuICovXG4gIERvY3VtZW50YXRpb24/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBlbnVtIFByaW1pdGl2ZVR5cGUge1xuICBTdHJpbmcgPSAnU3RyaW5nJyxcbiAgTG9uZyA9ICdMb25nJyxcbiAgSW50ZWdlciA9ICdJbnRlZ2VyJyxcbiAgRG91YmxlID0gJ0RvdWJsZScsXG4gIEJvb2xlYW4gPSAnQm9vbGVhbicsXG4gIFRpbWVzdGFtcCA9ICdUaW1lc3RhbXAnLFxuICBKc29uID0gJ0pzb24nXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1ByaW1pdGl2ZVR5cGUoc3RyOiBzdHJpbmcpOiBzdHIgaXMgUHJpbWl0aXZlVHlwZSB7XG4gIHN3aXRjaCAoc3RyKSB7XG4gICAgY2FzZSBQcmltaXRpdmVUeXBlLlN0cmluZzpcbiAgICBjYXNlIFByaW1pdGl2ZVR5cGUuTG9uZzpcbiAgICBjYXNlIFByaW1pdGl2ZVR5cGUuSW50ZWdlcjpcbiAgICBjYXNlIFByaW1pdGl2ZVR5cGUuRG91YmxlOlxuICAgIGNhc2UgUHJpbWl0aXZlVHlwZS5Cb29sZWFuOlxuICAgIGNhc2UgUHJpbWl0aXZlVHlwZS5UaW1lc3RhbXA6XG4gICAgY2FzZSBQcmltaXRpdmVUeXBlLkpzb246XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICBkZWZhdWx0OlxuICAgICAgcmV0dXJuIGZhbHNlO1xuICB9XG59XG4iXX0=

package/node_modules/@aws-cdk/cfnspec/lib/schema/cfn-lint.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Additional resource information obtained from cfn-lint
+ */
+export interface CfnLintResourceAnnotations {
+    /**
+     * Whether or not the given resource is stateful
+     */
+    readonly stateful: boolean;
+    /**
+     * Whether or not a Delete operation requires the resource to be empty
+     */
+    readonly mustBeEmptyToDelete: boolean;
+}

package/node_modules/@aws-cdk/cfnspec/lib/schema/cfn-lint.js

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

package/node_modules/@aws-cdk/cfnspec/lib/schema/docs.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Docs for a CloudFormation resource or property type
+ */
+export interface CloudFormationTypeDocs {
+    /**
+     * Description for this type
+     */
+    readonly description: string;
+    /**
+     * Descriptions for each of the type's properties
+     */
+    readonly properties: Record<string, string>;
+    /**
+     * Descriptions for each of the resource's attributes
+     */
+    readonly attributes?: Record<string, string>;
+}
+export interface CloudFormationDocsFile {
+    readonly Types: Record<string, CloudFormationTypeDocs>;
+}

package/node_modules/@aws-cdk/cfnspec/lib/schema/docs.js

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

package/node_modules/@aws-cdk/cfnspec/lib/schema/index.d.ts

@@ -0,0 +1,7 @@
+export * from './base-types';
+export * from './property';
+export * from './resource-type';
+export * from './specification';
+export * from './augmentation';
+export * from './cfn-lint';
+export * from './docs';