eslint-cdk-plugin 3.0.3 → 3.2.0

package/README.md

@@ -35,29 +35,34 @@ Note: This plugin uses typescript type information and must be used in conjuncti
 
 ```js
 // eslint.config.mjs
+import eslint from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
 import cdkPlugin from "eslint-cdk-plugin";
-import tsEslint from "typescript-eslint";
 
-export default [
-  ...tsEslint.configs.recommended,
-  // ✅ Add plugins
-  cdkPlugin.configs.recommended,
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
   {
     files: ["lib/**/*.ts", "bin/*.ts"],
-    // ... some configs
+    // ✅ Add plugins
+    extends: [cdkPlugin.configs.recommended],
   },
-];
+]);
 ```
 
 ### When using custom config
 
 ```js
 // eslint.config.mjs
-import tsEslint from "typescript-eslint";
+import eslint from "@eslint/js";
+import { defineConfig } from "eslint/config";
+import tseslint from "typescript-eslint";
 import cdkPlugin from "eslint-cdk-plugin";
 
-export default [
-  ...tsEslint.configs.recommended,
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
   {
     files: ["lib/**/*.ts", "bin/*.ts"],
     languageOptions: {
@@ -77,7 +82,7 @@ export default [
       "cdk/no-parent-name-construct-id-match": "error",
     },
   },
-];
+]);
 ```
 
 ## ❗ Issue

package/dist/index.cjs

@@ -26,12 +26,18 @@ function _interopNamespaceDefault(e) {
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 var name = "eslint-cdk-plugin";
-var version = "3.0.3";
+var version = "3.2.0";
 
 const createRule = utils.ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
 );
 
+const getConstructor = (node) => {
+  return node.body.body.find(
+    (member) => member.type === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+  );
+};
+
 const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
   if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(
@@ -46,7 +52,7 @@ const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
 };
 const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
   if (!type.symbol) return false;
-  if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
+  if (targetSuperClasses.some((suffix) => type.symbol.name === suffix)) {
     return true;
   }
   const baseTypes = type.getBaseTypes() ?? [];
@@ -61,7 +67,9 @@ const constructConstructorProperty = createRule({
       description: "Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'"
     },
     messages: {
-      invalidConstructorProperty: "Constructor of a class extending Construct must have the property names 'scope, id' or 'scope, id, props'"
+      invalidConstructorProperty: "Constructor of a class extending Construct must have the property names 'scope, id' or 'scope, id, props'",
+      invalidConstructorType: "Constructor of a class extending Construct must have the type 'Construct' for the first parameter",
+      invalidConstructorIdType: "Constructor of a class extending Construct must have the type 'string' for the second parameter"
     },
     schema: []
   },
@@ -72,16 +80,14 @@ const constructConstructorProperty = createRule({
       ClassDeclaration(node) {
         const type = parserServices.getTypeAtLocation(node);
         if (!isConstructType(type)) return;
-        const constructor = node.body.body.find(
-          (member) => member.type === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
-        );
+        const constructor = getConstructor(node);
         if (!constructor) return;
-        validateConstructorProperty(constructor, context);
+        validateConstructorProperty(constructor, context, parserServices);
       }
     };
   }
 });
-const validateConstructorProperty = (constructor, context) => {
+const validateConstructorProperty = (constructor, context, parserServices) => {
   const params = constructor.value.params;
   if (params.length < 2) {
     context.report({
@@ -91,24 +97,35 @@ const validateConstructorProperty = (constructor, context) => {
     return;
   }
   const firstParam = params[0];
-  if (firstParam.type === utils.AST_NODE_TYPES.Identifier && firstParam.name !== "scope") {
+  if (firstParam.type !== utils.AST_NODE_TYPES.Identifier || firstParam.name !== "scope") {
     context.report({
       node: firstParam,
       messageId: "invalidConstructorProperty"
     });
-    return;
+  } else if (!isConstructType(parserServices.getTypeAtLocation(firstParam))) {
+    context.report({
+      node: firstParam,
+      messageId: "invalidConstructorType"
+    });
   }
   const secondParam = params[1];
-  if (secondParam.type === utils.AST_NODE_TYPES.Identifier && secondParam.name !== "id") {
+  if (secondParam.type !== utils.AST_NODE_TYPES.Identifier || secondParam.name !== "id") {
     context.report({
       node: secondParam,
       messageId: "invalidConstructorProperty"
     });
     return;
+  } else if (secondParam.typeAnnotation?.typeAnnotation.type !== utils.AST_NODE_TYPES.TSStringKeyword) {
+    context.report({
+      node: secondParam,
+      messageId: "invalidConstructorIdType"
+    });
+    return;
   }
-  if (params.length < 3) return;
+  if (params.length < 3)
+    return;
   const thirdParam = params[2];
-  if (thirdParam.type === utils.AST_NODE_TYPES.Identifier && thirdParam.name !== "props") {
+  if (thirdParam.type !== utils.AST_NODE_TYPES.Identifier || thirdParam.name !== "props") {
     context.report({
       node: thirdParam,
       messageId: "invalidConstructorProperty"
@@ -184,9 +201,7 @@ const noConstructInPublicPropertyOfConstruct = createRule({
         const type = parserServices.getTypeAtLocation(node);
         if (!isConstructOrStackType(type)) return;
         validatePublicPropertyOfConstruct(node, context, parserServices);
-        const constructor = node.body.body.find(
-          (member) => member.type === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
-        );
+        const constructor = getConstructor(node);
         if (!constructor || constructor.value.type !== utils.AST_NODE_TYPES.FunctionExpression) {
           return;
         }
@@ -254,6 +269,12 @@ const toPascalCase = (str) => {
   }).join("");
 };
 
+const getPropertyNames = (properties) => {
+  return properties.reduce(
+    (acc, prop) => prop.type === utils.AST_NODE_TYPES.Property && prop.key.type === utils.AST_NODE_TYPES.Identifier ? [...acc, prop.key.name] : acc,
+    []
+  );
+};
 const getConstructorPropertyNames = (type) => {
   const declarations = type.symbol?.declarations;
   if (!declarations?.length) return [];
@@ -775,6 +796,176 @@ const validateConstructId$2 = ({
   }
 };
 
+const propsUsageTrackerFactory = (propsType) => {
+  const getPropsPropertyNames = (propsType2) => {
+    const typeProperties = propsType2.getProperties();
+    if (typeProperties.length) {
+      return typeProperties.reduce(
+        (acc, prop) => !isInternalProperty(prop.name) ? [...acc, prop.name] : acc,
+        []
+      );
+    }
+    const symbol = propsType2.getSymbol();
+    if (!symbol?.members) return [];
+    return Array.from(symbol.members.keys()).reduce((acc, key) => {
+      const name = String(key);
+      return !isInternalProperty(name) ? [...acc, name] : acc;
+    }, []);
+  };
+  const isInternalProperty = (propertyName) => {
+    return propertyName.startsWith("_") || propertyName === "constructor" || propertyName === "prototype";
+  };
+  const markAsUsed = (propertyName) => {
+    if (propUsages.has(propertyName)) propUsages.set(propertyName, true);
+  };
+  const propUsages = new Map(
+    getPropsPropertyNames(propsType).map((name) => [name, false])
+  );
+  const getUnusedProperties = () => {
+    return Array.from(propUsages.entries()).reduce(
+      (acc, [name, used]) => !used ? [...acc, name] : acc,
+      []
+    );
+  };
+  const markAsUsedForMemberExpression = (node, propsParamName) => {
+    if (node.object.type === utils.AST_NODE_TYPES.Identifier && node.object.name === propsParamName && node.property.type === utils.AST_NODE_TYPES.Identifier) {
+      markAsUsed(node.property.name);
+      return;
+    }
+    if (node.object.type === utils.AST_NODE_TYPES.MemberExpression && node.object.object.type === utils.AST_NODE_TYPES.ThisExpression && node.object.property.type === utils.AST_NODE_TYPES.Identifier && node.object.property.name === "props" && node.property.type === utils.AST_NODE_TYPES.Identifier) {
+      markAsUsed(node.property.name);
+      return;
+    }
+  };
+  const markAsUsedForVariableDeclarator = (node, propsParamName) => {
+    if (node.id.type !== utils.AST_NODE_TYPES.ObjectPattern || node.init?.type !== utils.AST_NODE_TYPES.Identifier || node.init.name !== propsParamName) {
+      return;
+    }
+    const propertyNames = getPropertyNames(node.id.properties);
+    for (const name of propertyNames) {
+      markAsUsed(name);
+    }
+  };
+  const markAsUsedForAssignmentExpression = (node, propsParamName) => {
+    if (node.right.type !== utils.AST_NODE_TYPES.MemberExpression || node.right.object.type !== utils.AST_NODE_TYPES.Identifier || node.right.object.name !== propsParamName || node.right.property.type !== utils.AST_NODE_TYPES.Identifier) {
+      return;
+    }
+    markAsUsed(node.right.property.name);
+  };
+  const markAsUsedForObjectPattern = (node) => {
+    for (const propName of getPropertyNames(node.properties)) {
+      markAsUsed(propName);
+    }
+  };
+  if (!propUsages.size) return null;
+  return {
+    getUnusedProperties,
+    markAsUsedForMemberExpression,
+    markAsUsedForVariableDeclarator,
+    markAsUsedForAssignmentExpression,
+    markAsUsedForObjectPattern
+  };
+};
+
+const noUnusedProps = createRule({
+  name: "no-unused-props",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforces that all properties defined in props type are used within the constructor"
+    },
+    messages: {
+      unusedProp: "Property '{{propName}}' is defined in props but never used"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructType(type)) return;
+        const constructor = getConstructor(node);
+        if (!constructor) return;
+        analyzePropsUsage(constructor, context, parserServices);
+      }
+    };
+  }
+});
+const analyzePropsUsage = (constructor, context, parserServices) => {
+  const params = constructor.value.params;
+  if (params.length < 3) return;
+  const propsParam = params[2];
+  switch (propsParam.type) {
+    case utils.AST_NODE_TYPES.Identifier: {
+      const propsType = parserServices.getTypeAtLocation(propsParam);
+      const tracker = propsUsageTrackerFactory(propsType);
+      if (!tracker || !constructor.value.body) return;
+      analyzeConstructorBody(constructor.value.body, propsParam.name, tracker);
+      reportUnusedProperties(tracker, propsParam, context);
+      return;
+    }
+    case utils.AST_NODE_TYPES.ObjectPattern: {
+      const typeAnnotation = propsParam.typeAnnotation?.typeAnnotation;
+      if (!typeAnnotation) return;
+      const propsType = parserServices.getTypeAtLocation(typeAnnotation);
+      const tracker = propsUsageTrackerFactory(propsType);
+      if (!tracker) return;
+      tracker.markAsUsedForObjectPattern(propsParam);
+      reportUnusedProperties(tracker, propsParam, context);
+      return;
+    }
+    default:
+      return;
+  }
+};
+const analyzeConstructorBody = (body, propsParamName, tracker) => {
+  const visited = /* @__PURE__ */ new Set();
+  const visitNode = (node) => {
+    if (visited.has(node)) return;
+    visited.add(node);
+    switch (node.type) {
+      case utils.AST_NODE_TYPES.MemberExpression:
+        tracker.markAsUsedForMemberExpression(node, propsParamName);
+        break;
+      case utils.AST_NODE_TYPES.VariableDeclarator:
+        tracker.markAsUsedForVariableDeclarator(node, propsParamName);
+        break;
+      case utils.AST_NODE_TYPES.AssignmentExpression:
+        tracker.markAsUsedForAssignmentExpression(node, propsParamName);
+        break;
+    }
+    const children = getChildNodes(node);
+    for (const child of children) {
+      visitNode(child);
+    }
+  };
+  visitNode(body);
+};
+const reportUnusedProperties = (tracker, propsParam, context) => {
+  for (const propName of tracker.getUnusedProperties()) {
+    context.report({
+      node: propsParam,
+      messageId: "unusedProp",
+      data: {
+        propName
+      }
+    });
+  }
+};
+const getChildNodes = (node) => {
+  return Object.entries(node).reduce((acc, [key, value]) => {
+    if (["parent", "range", "loc"].includes(key)) return acc;
+    if (isESTreeNode(value)) return [...acc, value];
+    if (Array.isArray(value)) return [...acc, ...value.filter(isESTreeNode)];
+    return acc;
+  }, []);
+};
+const isESTreeNode = (value) => {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+};
+
 const noVariableConstructId = createRule({
   name: "no-variable-construct-id",
   meta: {
@@ -911,10 +1102,9 @@ const propsNameConvention = createRule({
         if (!node.id || !node.superClass) return;
         const type = parserServices.getTypeAtLocation(node.superClass);
         if (!isConstructType(type)) return;
-        const constructor = node.body.body.find(
-          (member) => member.type === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
-        );
-        const propsParam = constructor?.value.params?.[2];
+        const constructor = getConstructor(node);
+        if (!constructor) return;
+        const propsParam = constructor.value.params?.[2];
         if (propsParam?.type !== utils.AST_NODE_TYPES.Identifier) return;
         const typeAnnotation = propsParam.typeAnnotation;
         if (typeAnnotation?.type !== utils.AST_NODE_TYPES.TSTypeAnnotation) return;
@@ -956,9 +1146,10 @@ const requireJSDoc = createRule({
     const parserServices = utils.ESLintUtils.getParserServices(context);
     return {
       TSPropertySignature(node) {
-        if (node.key.type !== utils.AST_NODE_TYPES.Identifier || node.parent?.type !== utils.AST_NODE_TYPES.TSInterfaceBody) {
-          return;
-        }
+        if (node.key.type !== utils.AST_NODE_TYPES.Identifier) return;
+        const parent = node.parent.parent;
+        if (parent.type !== utils.AST_NODE_TYPES.TSInterfaceDeclaration) return;
+        if (!parent.id.name.endsWith("Props")) return;
         const sourceCode = context.sourceCode;
         const comments = sourceCode.getCommentsBefore(node);
         const hasJSDoc = comments.some(
@@ -1087,14 +1278,11 @@ const requirePropsDefaultDoc = createRule({
   create(context) {
     return {
       TSPropertySignature(node) {
+        if (node.key.type !== utils.AST_NODE_TYPES.Identifier) return;
         if (!node.optional) return;
-        const parent = node.parent?.parent;
-        if (parent?.type !== utils.AST_NODE_TYPES.TSInterfaceDeclaration) {
-          return;
-        }
-        if (parent.id.type !== utils.AST_NODE_TYPES.Identifier || !parent.id.name.endsWith("Props")) {
-          return;
-        }
+        const parent = node.parent.parent;
+        if (parent.type !== utils.AST_NODE_TYPES.TSInterfaceDeclaration) return;
+        if (!parent.id.name.endsWith("Props")) return;
         const sourceCode = context.sourceCode;
         const comments = sourceCode.getCommentsBefore(node);
         const hasDefaultDoc = comments.some(
@@ -1105,7 +1293,7 @@ const requirePropsDefaultDoc = createRule({
             node,
             messageId: "missingDefaultDoc",
             data: {
-              propertyName: node.key.type === utils.AST_NODE_TYPES.Identifier ? node.key.name : "unknown"
+              propertyName: node.key.name
             }
           });
         }
@@ -1123,6 +1311,7 @@ const rules = {
   "no-mutable-property-of-props-interface": noMutablePropertyOfPropsInterface,
   "no-mutable-public-property-of-construct": noMutablePublicPropertyOfConstruct,
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
+  "no-unused-props": noUnusedProps,
   "no-variable-construct-id": noVariableConstructId,
   "pascal-case-construct-id": pascalCaseConstructId,
   "props-name-convention": propsNameConvention,
@@ -1159,6 +1348,8 @@ const recommended = createFlatConfig({
     "error",
     { disallowContainingParentName: false }
   ],
+  // TODO: Enable this rule at v4.0.0
+  // "cdk/no-unused-props": "error",
   "cdk/no-variable-construct-id": "error",
   "cdk/pascal-case-construct-id": "error",
   "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }]
@@ -1175,6 +1366,7 @@ const strict = createFlatConfig({
     "error",
     { disallowContainingParentName: true }
   ],
+  "cdk/no-unused-props": "error",
   "cdk/no-variable-construct-id": "error",
   "cdk/pascal-case-construct-id": "error",
   "cdk/props-name-convention": "error",

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import tsParser from "@typescript-eslint/parser";
+import { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
 declare const rules: {
-    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty" | "invalidConstructorType" | "invalidConstructorIdType", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-construct-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidInterfaceProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-construct-in-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
@@ -12,6 +12,7 @@ declare const rules: {
     "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
         disallowContainingParentName?: boolean;
     }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-unused-props": import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedProp", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
@@ -23,88 +24,23 @@ declare const rules: {
 };
 declare const configs: {
     recommended: {
-        languageOptions: {
-            parser: typeof tsParser;
-            parserOptions: {
-                projectService: boolean;
-            };
-        };
-        plugins: {
-            cdk: {
-                meta: {
-                    name: string;
-                    version: string;
-                };
-                rules: {
-                    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidInterfaceProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-in-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-                        disallowedSuffixes: ("Construct" | "Stack")[];
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-import-private": import("eslint").Rule.RuleModule;
-                    "no-mutable-property-of-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropertyOfPropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-mutable-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-                        disallowContainingParentName?: boolean;
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingJSDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingPassingThis", [{
-                        allowNonThisAndDisallowScope?: boolean;
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                };
-            };
-        };
-        rules: Record<string, unknown>;
+        languageOptions: FlatConfig.LanguageOptions;
+        plugins: FlatConfig.Plugins;
+        rules: FlatConfig.Rules;
     };
     strict: {
-        languageOptions: {
-            parser: typeof tsParser;
-            parserOptions: {
-                projectService: boolean;
-            };
-        };
-        plugins: {
-            cdk: {
-                meta: {
-                    name: string;
-                    version: string;
-                };
-                rules: {
-                    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidInterfaceProperty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-in-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-                        disallowedSuffixes: ("Construct" | "Stack")[];
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-import-private": import("eslint").Rule.RuleModule;
-                    "no-mutable-property-of-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropertyOfPropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-mutable-public-property-of-construct": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPublicPropertyOfConstruct", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [{
-                        disallowContainingParentName?: boolean;
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingJSDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingPassingThis", [{
-                        allowNonThisAndDisallowScope?: boolean;
-                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                    "require-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-                };
-            };
-        };
-        rules: Record<string, unknown>;
+        languageOptions: FlatConfig.LanguageOptions;
+        plugins: FlatConfig.Plugins;
+        rules: FlatConfig.Rules;
     };
 };
 export { configs, rules };
 export interface EslintCdkPlugin {
     rules: typeof rules;
-    configs: typeof configs;
+    configs: Readonly<{
+        recommended: FlatConfig.Config;
+        strict: FlatConfig.Config;
+    }>;
 }
 declare const eslintCdkPlugin: EslintCdkPlugin;
 export default eslintCdkPlugin;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AAmBjD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;CAgBV,CAAC;AA0DF,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGZ,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC;CACzB;AAED,QAAA,MAAM,eAAe,EAAE,eAGtB,CAAC;AAEF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAoBhE,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;CAiBV,CAAC;AAmEF,QAAA,MAAM,OAAO;;yBAzDM,UAAU,CAAC,eAAe;iBAClC,UAAU,CAAC,OAAO;eACpB,UAAU,CAAC,KAAK;;;yBAFN,UAAU,CAAC,eAAe;iBAClC,UAAU,CAAC,OAAO;eACpB,UAAU,CAAC,KAAK;;CA0DxB,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,OAAO,EAAE,QAAQ,CAAC;QAChB,WAAW,EAAE,UAAU,CAAC,MAAM,CAAC;QAC/B,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC;KAC3B,CAAC,CAAC;CACJ;AAED,QAAA,MAAM,eAAe,EAAE,eAGtB,CAAC;AAEF,eAAe,eAAe,CAAC"}