eslint-cdk-plugin 1.1.1 → 2.0.1

package/README.md

@@ -35,27 +35,16 @@ Note: This plugin uses typescript type information and must be used in conjuncti
 
 ```js
 // eslint.config.mjs
-import eslintCdkPlugin from "eslint-cdk-plugin";
+import cdkPlugin from "eslint-cdk-plugin";
 import tsEslint from "typescript-eslint";
 
 export default [
   ...tsEslint.configs.recommended,
+  // ✅ Add plugins
+  cdkPlugin.configs.recommended,
   {
     files: ["lib/**/*.ts", "bin/*.ts"],
-    languageOptions: {
-      parserOptions: {
-        projectService: true,
-        project: "./tsconfig.json",
-      },
-    },
-    // ✅ Add plugins
-    plugins: {
-      cdk: eslintCdkPlugin,
-    },
-    // ✅ Add rules (use recommended rules)
-    rules: {
-      ...eslintCdkPlugin.configs.recommended.rules,
-    },
+    // ... some configs
   },
 ];
 ```
@@ -65,7 +54,7 @@ export default [
 ```js
 // eslint.config.mjs
 import tsEslint from "typescript-eslint";
-import eslintCdkPlugin from "eslint-cdk-plugin";
+import cdkPlugin from "eslint-cdk-plugin";
 
 export default [
   ...tsEslint.configs.recommended,
@@ -79,7 +68,7 @@ export default [
     },
     // ✅ Add plugins
     plugins: {
-      cdk: eslintCdkPlugin,
+      cdk: cdkPlugin,
     },
     // ✅ Add rules (use custom rules)
     rules: {

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var tsParser = require('@typescript-eslint/parser');
 var utils = require('@typescript-eslint/utils');
 var path = require('path');
 
@@ -24,15 +25,102 @@ function _interopNamespaceDefault(e) {
 
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
-var SymbolFlags = /* @__PURE__ */ ((SymbolFlags2) => {
-  SymbolFlags2[SymbolFlags2["Class"] = 32] = "Class";
-  return SymbolFlags2;
-})(SymbolFlags || {});
-var SyntaxKind = /* @__PURE__ */ ((SyntaxKind2) => {
-  SyntaxKind2[SyntaxKind2["ClassDeclaration"] = 263] = "ClassDeclaration";
-  SyntaxKind2[SyntaxKind2["Constructor"] = 176] = "Constructor";
-  return SyntaxKind2;
-})(SyntaxKind || {});
+var name = "eslint-cdk-plugin";
+var version = "2.0.0";
+
+const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(
+    type,
+    ["Construct", "Stack"],
+    isConstructOrStackType
+  );
+};
+const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(type, ["Construct"], isConstructType);
+};
+const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
+  if (!type.symbol) return false;
+  if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
+    return true;
+  }
+  const baseTypes = type.getBaseTypes() ?? [];
+  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+};
+
+const constructConstructorProperty = utils.ESLintUtils.RuleCreator.withoutDocs(
+  {
+    meta: {
+      type: "problem",
+      docs: {
+        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'"
+      },
+      schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+      const parserServices = utils.ESLintUtils.getParserServices(context);
+      return {
+        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"
+          );
+          if (!constructor) return;
+          validateConstructorProperty(constructor, context);
+        }
+      };
+    }
+  }
+);
+const validateConstructorProperty = (constructor, context) => {
+  const params = constructor.value.params;
+  if (params.length < 2) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  const firstParam = params[0];
+  if (firstParam.type === utils.AST_NODE_TYPES.Identifier && firstParam.name !== "scope") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  const secondParam = params[1];
+  if (secondParam.type === utils.AST_NODE_TYPES.Identifier && secondParam.name !== "id") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  if (params.length < 3) return;
+  const thirdParam = params[2];
+  if (thirdParam.type === utils.AST_NODE_TYPES.Identifier && thirdParam.name !== "props") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+};
+
+const SYMBOL_FLAGS = {
+  CLASS: 32
+};
+const SYNTAX_KIND = {
+  CLASS_DECLARATION: 263,
+  CONSTRUCTOR: 176
+};
 
 const noClassInInterface = utils.ESLintUtils.RuleCreator.withoutDocs({
   meta: {
@@ -56,7 +144,7 @@ const noClassInInterface = utils.ESLintUtils.RuleCreator.withoutDocs({
           }
           const type = parserServices.getTypeAtLocation(property);
           if (!type.symbol) continue;
-          const isClass = type.symbol.flags === SymbolFlags.Class;
+          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
           if (!isClass) continue;
           context.report({
             node: property,
@@ -92,33 +180,16 @@ const getConstructorPropertyNames = (type) => {
   return constructor.parameters.map((param) => param.name.getText());
 };
 const isClassDeclaration = (declaration) => {
-  return declaration.kind === SyntaxKind.ClassDeclaration;
+  return declaration.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
 const isConstructorDeclaration = (node) => {
-  return node.kind === SyntaxKind.Constructor;
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(
-    type,
-    ["Construct", "Stack"],
-    isConstructOrStackType
-  );
-};
-const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(type, ["Construct"], isConstructType);
-};
-const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
-  if (!type.symbol) return false;
-  if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
-    return true;
-  }
-  const baseTypes = type.getBaseTypes() || [];
-  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+const SUFFIX_TYPE = {
+  CONSTRUCT: "Construct",
+  STACK: "Stack"
 };
-
 const noConstructStackSuffix = utils.ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
@@ -128,11 +199,33 @@ const noConstructStackSuffix = utils.ESLintUtils.RuleCreator.withoutDocs({
     messages: {
       noConstructStackSuffix: "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix."
     },
-    schema: []
+    schema: [
+      {
+        type: "object",
+        properties: {
+          disallowedSuffixes: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+            },
+            uniqueItems: true
+          }
+        },
+        additionalProperties: false
+      }
+    ]
   },
-  defaultOptions: [],
+  defaultOptions: [
+    {
+      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+    }
+  ],
   create(context) {
     const parserServices = utils.ESLintUtils.getParserServices(context);
+    const options = context.options[0] ?? {
+      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+    };
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
@@ -141,35 +234,36 @@ const noConstructStackSuffix = utils.ESLintUtils.RuleCreator.withoutDocs({
         }
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
-        validateConstructId$3(node, context);
+        validateConstructId$3(node, context, options);
       }
     };
   }
 });
-const validateConstructId$3 = (node, context) => {
+const validateConstructId$3 = (node, context, options) => {
   const secondArg = node.arguments[1];
   if (secondArg.type !== utils.AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
     return;
   }
   const formattedConstructId = toPascalCase(secondArg.value);
-  if (formattedConstructId.endsWith("Construct")) {
+  const disallowedSuffixes = options.disallowedSuffixes;
+  if (disallowedSuffixes.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
     context.report({
       node,
       messageId: "noConstructStackSuffix",
       data: {
         classType: "Construct",
         id: secondArg.value,
-        suffix: "Construct"
+        suffix: SUFFIX_TYPE.CONSTRUCT
       }
     });
-  } else if (formattedConstructId.endsWith("Stack")) {
+  } else if (disallowedSuffixes.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
     context.report({
       node,
       messageId: "noConstructStackSuffix",
       data: {
         classType: "Stack",
         id: secondArg.value,
-        suffix: "Stack"
+        suffix: SUFFIX_TYPE.STACK
       }
     });
   }
@@ -582,7 +676,7 @@ const validateClassMember = (node, context, parserServices) => {
     if (!member.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(member);
     if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
     context.report({
       node: member,
@@ -605,7 +699,7 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
     if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
     context.report({
       node: param,
@@ -663,6 +757,17 @@ const isInsideLoop = (node) => {
     if (current.type === utils.AST_NODE_TYPES.ForStatement || current.type === utils.AST_NODE_TYPES.ForInStatement || current.type === utils.AST_NODE_TYPES.ForOfStatement || current.type === utils.AST_NODE_TYPES.WhileStatement || current.type === utils.AST_NODE_TYPES.DoWhileStatement) {
       return true;
     }
+    if (current.type === utils.AST_NODE_TYPES.CallExpression && current.callee.type === utils.AST_NODE_TYPES.MemberExpression && current.callee.property.type === utils.AST_NODE_TYPES.Identifier && [
+      "forEach",
+      "map",
+      "filter",
+      "reduce",
+      "flatMap",
+      "some",
+      "every"
+    ].includes(current.callee.property.name)) {
+      return true;
+    }
     current = current.parent;
   }
   return false;
@@ -842,11 +947,29 @@ const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
     messages: {
       requirePassingThis: "Require passing `this` in a constructor."
     },
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowNonThisAndDisallowScope: {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
     fixable: "code"
   },
-  defaultOptions: [],
+  defaultOptions: [
+    {
+      allowNonThisAndDisallowScope: false
+    }
+  ],
   create(context) {
+    const options = context.options[0] || {
+      allowNonThisAndDisallowScope: false
+    };
     const parserServices = utils.ESLintUtils.getParserServices(context);
     return {
       NewExpression(node) {
@@ -856,13 +979,25 @@ const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
         if (argument.type === utils.AST_NODE_TYPES.ThisExpression) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[0] !== "scope") return;
-        context.report({
-          node,
-          messageId: "requirePassingThis",
-          fix: (fixer) => {
-            return fixer.replaceText(argument, "this");
-          }
-        });
+        if (!options.allowNonThisAndDisallowScope) {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            }
+          });
+          return;
+        }
+        if (argument.type === utils.AST_NODE_TYPES.Identifier && argument.name === "scope") {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            }
+          });
+        }
       }
     };
   }
@@ -916,49 +1051,65 @@ const rules = {
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
   "no-public-class-fields": noPublicClassFields,
   "pascal-case-construct-id": pascalCaseConstructId,
-  "no-mutable-public-fields": noMutablePublicFields,
-  "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "no-mutable-public-fields": noMutablePublicFields,
+  "no-mutable-props-interface": noMutablePropsInterface,
+  "construct-constructor-property": constructConstructorProperty,
   "require-jsdoc": requireJSDoc,
   "require-props-default-doc": requirePropsDefaultDoc,
   "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate
 };
+const cdkPlugin = {
+  meta: { name, version },
+  rules
+};
+const createFlatConfig = (rules2) => {
+  return {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true
+      }
+    },
+    plugins: {
+      cdk: cdkPlugin
+    },
+    rules: rules2
+  };
+};
+const recommended = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "warn",
+  "cdk/no-mutable-props-interface": "warn",
+  "cdk/construct-constructor-property": "error"
+});
+const strict = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": "error",
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "error",
+  "cdk/no-mutable-props-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/require-jsdoc": "error",
+  "cdk/require-props-default-doc": "error",
+  "cdk/props-name-convention": "error",
+  "cdk/no-import-private": "error"
+});
 const configs = {
-  recommended: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "warn",
-      "cdk/no-mutable-props-interface": "warn",
-      "cdk/props-name-convention": "warn"
-    }
-  },
-  strict: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "error",
-      "cdk/no-mutable-props-interface": "error",
-      "cdk/no-import-private": "error",
-      "cdk/require-props-default-doc": "error",
-      "cdk/props-name-convention": "error",
-      "cdk/require-jsdoc": "error"
-    }
-  }
+  recommended,
+  strict
 };
 const eslintCdkPlugin = {
   rules,

package/dist/index.d.ts

@@ -1,13 +1,19 @@
+import tsParser from "@typescript-eslint/parser";
 declare const rules: {
     "no-class-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noClassInInterfaceProps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstructStackSuffix", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstructStackSuffix", [{
+        disallowedSuffixes: ("Construct" | "Stack")[];
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noParentNameConstructIdMatch", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-public-class-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noPublicClassFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"pascalCaseConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requirePassingThis", [{
+        allowNonThisAndDisallowScope?: boolean;
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVariableConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-mutable-public-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePublicFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-mutable-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requirePassingThis", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVariableConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], 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-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], 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>;
@@ -15,37 +21,78 @@ declare const rules: {
 };
 declare const configs: {
     recommended: {
-        plugins: string[];
-        rules: {
-            "cdk/no-class-in-interface": string;
-            "cdk/no-construct-stack-suffix": string;
-            "cdk/no-parent-name-construct-id-match": string;
-            "cdk/no-public-class-fields": string;
-            "cdk/pascal-case-construct-id": string;
-            "cdk/require-passing-this": string;
-            "cdk/no-variable-construct-id": string;
-            "cdk/no-mutable-public-fields": string;
-            "cdk/no-mutable-props-interface": string;
-            "cdk/props-name-convention": string;
+        languageOptions: {
+            parser: typeof tsParser;
+            parserOptions: {
+                projectService: boolean;
+            };
         };
+        plugins: {
+            cdk: {
+                meta: {
+                    name: string;
+                    version: string;
+                };
+                rules: {
+                    "no-class-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noClassInInterfaceProps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstructStackSuffix", [{
+                        disallowedSuffixes: ("Construct" | "Stack")[];
+                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noParentNameConstructIdMatch", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-public-class-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noPublicClassFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"pascalCaseConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requirePassingThis", [{
+                        allowNonThisAndDisallowScope?: boolean;
+                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVariableConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-mutable-public-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePublicFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-mutable-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], 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-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], 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>;
+                    "no-import-private": import("eslint").Rule.RuleModule;
+                };
+            };
+        };
+        rules: Record<string, unknown>;
     };
     strict: {
-        plugins: string[];
-        rules: {
-            "cdk/no-class-in-interface": string;
-            "cdk/no-construct-stack-suffix": string;
-            "cdk/no-parent-name-construct-id-match": string;
-            "cdk/no-public-class-fields": string;
-            "cdk/pascal-case-construct-id": string;
-            "cdk/require-passing-this": string;
-            "cdk/no-variable-construct-id": string;
-            "cdk/no-mutable-public-fields": string;
-            "cdk/no-mutable-props-interface": string;
-            "cdk/no-import-private": string;
-            "cdk/require-props-default-doc": string;
-            "cdk/props-name-convention": string;
-            "cdk/require-jsdoc": string;
+        languageOptions: {
+            parser: typeof tsParser;
+            parserOptions: {
+                projectService: boolean;
+            };
+        };
+        plugins: {
+            cdk: {
+                meta: {
+                    name: string;
+                    version: string;
+                };
+                rules: {
+                    "no-class-in-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noClassInInterfaceProps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-construct-stack-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstructStackSuffix", [{
+                        disallowedSuffixes: ("Construct" | "Stack")[];
+                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-parent-name-construct-id-match": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noParentNameConstructIdMatch", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-public-class-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noPublicClassFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "pascal-case-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"pascalCaseConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requirePassingThis", [{
+                        allowNonThisAndDisallowScope?: boolean;
+                    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVariableConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-mutable-public-fields": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePublicFields", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "no-mutable-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+                    "construct-constructor-property": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidConstructorProperty", [], 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-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], 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>;
+                    "no-import-private": import("eslint").Rule.RuleModule;
+                };
+            };
         };
+        rules: Record<string, unknown>;
     };
 };
 export { configs, rules };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;CAcV,CAAC;AAEF,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCZ,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":"AAAA,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AAmBjD,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;CAeV,CAAC;AAoDF,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"}