@codeperfect/eslint-plugin 2.0.0 → 2.2.0

package/dist/domain/core/prefer-interface-types/rule.js

@@ -1,4 +1,3 @@
-import { createRuleDocumentation } from "../../custom-rule-documentation.js";
 /**
  * Gets a nested type annotation from parameter wrappers.
  * @param node Parameter wrapper node.
@@ -12,6 +11,9 @@ const getNestedTypeAnnotation = (node) => {
     if (node.argument !== void 0) {
         return getTypeAnnotationNode(node.argument);
     }
+    if (node.left !== void 0) {
+        return getTypeAnnotationNode(node.left);
+    }
     if (node.parameter !== void 0) {
         return getTypeAnnotationNode(node.parameter);
     }
@@ -70,15 +72,35 @@ const getParameters = (node) => {
     return Array.isArray(typedNode.params) ? typedNode.params : [];
 };
 /**
- * Checks whether the node represents a type literal.
- * @param node Type annotation node to check.
- * @returns True when the node is a type literal.
+ * Finds an inline object type literal within a type annotation node.
+ * @param node Type annotation node to inspect.
+ * @returns The first inline object type literal when present.
  * @example
  * ```typescript
- * const isLiteral = isTypeLiteral(annotation);
+ * const inlineObjectType = getInlineObjectTypeLiteral(annotation);
  * ```
  */
-const isTypeLiteral = (node) => node?.type === "TSTypeLiteral";
+const getInlineObjectTypeLiteral = (node) => {
+    if (node === void 0) {
+        return void 0;
+    }
+    if (node.type === "TSTypeLiteral") {
+        return node;
+    }
+    if (node.type === "TSParenthesizedType") {
+        return getInlineObjectTypeLiteral(node.typeAnnotation);
+    }
+    if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
+        const nestedTypes = Array.isArray(node.types) ? node.types : [];
+        for (const nestedType of nestedTypes) {
+            const nestedInlineObjectType = getInlineObjectTypeLiteral(nestedType);
+            if (nestedInlineObjectType !== void 0) {
+                return nestedInlineObjectType;
+            }
+        }
+    }
+    return void 0;
+};
 /**
  * Reports an inline object type annotation.
  * @param context Rule execution context.
@@ -105,35 +127,84 @@ const reportTypeLiteral = (context, typeAnnotation) => {
  */
 const checkFunctionLike = (context, node) => {
     for (const parameter of getParameters(node)) {
-        const typeAnnotation = getTypeAnnotationNode(parameter);
-        if (isTypeLiteral(typeAnnotation)) {
-            reportTypeLiteral(context, typeAnnotation);
+        const inlineObjectType = getInlineObjectTypeLiteral(getTypeAnnotationNode(parameter));
+        if (inlineObjectType !== void 0) {
+            reportTypeLiteral(context, inlineObjectType);
         }
     }
-    const returnTypeAnnotation = getReturnTypeAnnotation(node);
-    if (isTypeLiteral(returnTypeAnnotation)) {
-        reportTypeLiteral(context, returnTypeAnnotation);
+    const inlineReturnObjectType = getInlineObjectTypeLiteral(getReturnTypeAnnotation(node));
+    if (inlineReturnObjectType !== void 0) {
+        reportTypeLiteral(context, inlineReturnObjectType);
+    }
+};
+/**
+ * Checks variable declarators for inline object types.
+ * @param context Rule execution context.
+ * @param node Variable declarator to check.
+ * @example
+ * ```typescript
+ * checkVariableDeclarator(context, node);
+ * ```
+ */
+const checkVariableDeclarator = (context, node) => {
+    const typedNode = node;
+    const inlineObjectType = getInlineObjectTypeLiteral(getTypeAnnotationNode(typedNode.id));
+    if (inlineObjectType !== void 0) {
+        reportTypeLiteral(context, inlineObjectType);
     }
 };
 /** ESLint rule requiring named interface/type aliases for object types. */
 const preferInterfaceTypesRule = {
+    /**
+     * Creates listeners that validate function-like and variable annotations.
+     * @param context Rule execution context.
+     * @returns Rule listener map.
+     * @example
+     * ```typescript
+     * const listeners = preferInterfaceTypesRule.create(context);
+     * ```
+     */
     create(context) {
-        const listener = (node) => {
+        /**
+         * Checks function-like nodes for inline object types.
+         * @param node Function-like node to inspect.
+         * @example
+         * ```typescript
+         * functionLikeListener(node);
+         * ```
+         */
+        const functionLikeListener = (node) => {
             checkFunctionLike(context, node);
         };
+        /**
+         * Checks variable declarators for inline object types.
+         * @param node Variable declarator to inspect.
+         * @example
+         * ```typescript
+         * variableDeclaratorListener(node);
+         * ```
+         */
+        const variableDeclaratorListener = (node) => {
+            checkVariableDeclarator(context, node);
+        };
         return {
-            ArrowFunctionExpression: listener,
-            FunctionDeclaration: listener,
-            FunctionExpression: listener,
-            TSCallSignatureDeclaration: listener,
-            TSConstructSignatureDeclaration: listener,
-            TSDeclareFunction: listener,
-            TSFunctionType: listener,
-            TSMethodSignature: listener,
+            ArrowFunctionExpression: functionLikeListener,
+            FunctionDeclaration: functionLikeListener,
+            FunctionExpression: functionLikeListener,
+            TSCallSignatureDeclaration: functionLikeListener,
+            TSConstructSignatureDeclaration: functionLikeListener,
+            TSDeclareFunction: functionLikeListener,
+            TSFunctionType: functionLikeListener,
+            TSMethodSignature: functionLikeListener,
+            VariableDeclarator: variableDeclaratorListener,
         };
     },
     meta: {
-        docs: createRuleDocumentation("prefer-interface-types", "Require named interfaces or type aliases for object types in parameters and return types."),
+        docs: {
+            description: "Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md",
+        },
         messages: {
             preferNamedObject: "Use a named interface or type alias instead of an inline object type.",
         },
@@ -142,4 +213,4 @@ const preferInterfaceTypesRule = {
     },
 };
 export { preferInterfaceTypesRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n\n  /** ReturnType helper value. */\n  returnType?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationContainer {\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationNode {\n  /** Type field value. */\n  type: string;\n}\n\n/**\n * Gets a nested type annotation from parameter wrappers.\n * @param node Parameter wrapper node.\n * @returns The nested type annotation when present.\n * @example\n * ```typescript\n * const annotation = getNestedTypeAnnotation({ argument: node });\n * ```\n */\nconst getNestedTypeAnnotation = (\n  node: ParameterContainer,\n): TypeAnnotationNode | undefined => {\n  if (node.argument !== void 0) {\n    return getTypeAnnotationNode(node.argument);\n  }\n\n  if (node.parameter !== void 0) {\n    return getTypeAnnotationNode(node.parameter);\n  }\n\n  return void 0;\n};\n\n/**\n * Extracts the type annotation from a node.\n * @param node Node that may contain a type annotation.\n * @returns The type annotation when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(node);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const directTypeAnnotation = (node as TypeAnnotationContainer).typeAnnotation\n    ?.typeAnnotation;\n\n  if (directTypeAnnotation !== void 0) {\n    return directTypeAnnotation;\n  }\n\n  return getNestedTypeAnnotation(node as ParameterContainer);\n};\n\n/**\n * Gets the return type annotation for a function-like node.\n * @param node Node that may contain a return type.\n * @returns The return type annotation when present.\n * @example\n * ```typescript\n * const annotation = getReturnTypeAnnotation(node);\n * ```\n */\nconst getReturnTypeAnnotation = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return typedNode.returnType?.typeAnnotation;\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Checks whether the node represents a type literal.\n * @param node Type annotation node to check.\n * @returns True when the node is a type literal.\n * @example\n * ```typescript\n * const isLiteral = isTypeLiteral(annotation);\n * ```\n */\nconst isTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): node is TypeAnnotationNode => node?.type === \"TSTypeLiteral\";\n\n/**\n * Reports an inline object type annotation.\n * @param context Rule execution context.\n * @param typeAnnotation Type annotation node to report.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst reportTypeLiteral = (\n  context: Rule.RuleContext,\n  typeAnnotation: TypeAnnotationNode,\n): void => {\n  context.report({\n    messageId: \"preferNamedObject\",\n    node: typeAnnotation as unknown as Rule.Node,\n  });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param context Rule execution context.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const typeAnnotation = getTypeAnnotationNode(parameter);\n\n    if (isTypeLiteral(typeAnnotation)) {\n      reportTypeLiteral(context, typeAnnotation);\n    }\n  }\n\n  const returnTypeAnnotation = getReturnTypeAnnotation(node);\n\n  if (isTypeLiteral(returnTypeAnnotation)) {\n    reportTypeLiteral(context, returnTypeAnnotation);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const listener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: listener,\n      FunctionDeclaration: listener,\n      FunctionExpression: listener,\n      TSCallSignatureDeclaration: listener,\n      TSConstructSignatureDeclaration: listener,\n      TSDeclareFunction: listener,\n      TSFunctionType: listener,\n      TSMethodSignature: listener,\n    };\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"prefer-interface-types\",\n      \"Require named interfaces or type aliases for object types in parameters and return types.\",\n    ),\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n\n  /** ReturnType helper value. */\n  returnType?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left-side helper value used by assignment patterns. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationContainer {\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationNode {\n  /** Type field value. */\n  type: string;\n\n  /** Nested annotation for parenthesized types. */\n  typeAnnotation?: unknown;\n\n  /** Nested member annotations for union/intersection types. */\n  types?: unknown[];\n}\n\n/** Type definition for variable declarator nodes with optional identifiers. */\ninterface VariableDeclaratorNode {\n  /** Identifier or binding pattern for the variable declarator. */\n  id?: unknown;\n}\n\n/**\n * Gets a nested type annotation from parameter wrappers.\n * @param node Parameter wrapper node.\n * @returns The nested type annotation when present.\n * @example\n * ```typescript\n * const annotation = getNestedTypeAnnotation({ argument: node });\n * ```\n */\nconst getNestedTypeAnnotation = (\n  node: ParameterContainer,\n): TypeAnnotationNode | undefined => {\n  if (node.argument !== void 0) {\n    return getTypeAnnotationNode(node.argument);\n  }\n\n  if (node.left !== void 0) {\n    return getTypeAnnotationNode(node.left);\n  }\n\n  if (node.parameter !== void 0) {\n    return getTypeAnnotationNode(node.parameter);\n  }\n\n  return void 0;\n};\n\n/**\n * Extracts the type annotation from a node.\n * @param node Node that may contain a type annotation.\n * @returns The type annotation when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(node);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const directTypeAnnotation = (node as TypeAnnotationContainer).typeAnnotation\n    ?.typeAnnotation;\n\n  if (directTypeAnnotation !== void 0) {\n    return directTypeAnnotation;\n  }\n\n  return getNestedTypeAnnotation(node);\n};\n\n/**\n * Gets the return type annotation for a function-like node.\n * @param node Node that may contain a return type.\n * @returns The return type annotation when present.\n * @example\n * ```typescript\n * const annotation = getReturnTypeAnnotation(node);\n * ```\n */\nconst getReturnTypeAnnotation = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return typedNode.returnType?.typeAnnotation;\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Finds an inline object type literal within a type annotation node.\n * @param node Type annotation node to inspect.\n * @returns The first inline object type literal when present.\n * @example\n * ```typescript\n * const inlineObjectType = getInlineObjectTypeLiteral(annotation);\n * ```\n */\nconst getInlineObjectTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): TypeAnnotationNode | undefined => {\n  if (node === void 0) {\n    return void 0;\n  }\n\n  if (node.type === \"TSTypeLiteral\") {\n    return node;\n  }\n\n  if (node.type === \"TSParenthesizedType\") {\n    return getInlineObjectTypeLiteral(\n      node.typeAnnotation as TypeAnnotationNode | undefined,\n    );\n  }\n\n  if (node.type === \"TSUnionType\" || node.type === \"TSIntersectionType\") {\n    const nestedTypes = Array.isArray(node.types) ? node.types : [];\n\n    for (const nestedType of nestedTypes) {\n      const nestedInlineObjectType = getInlineObjectTypeLiteral(\n        nestedType as TypeAnnotationNode | undefined,\n      );\n\n      if (nestedInlineObjectType !== void 0) {\n        return nestedInlineObjectType;\n      }\n    }\n  }\n\n  return void 0;\n};\n\n/**\n * Reports an inline object type annotation.\n * @param context Rule execution context.\n * @param typeAnnotation Type annotation node to report.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst reportTypeLiteral = (\n  context: Rule.RuleContext,\n  typeAnnotation: TypeAnnotationNode,\n): void => {\n  context.report({\n    messageId: \"preferNamedObject\",\n    node: typeAnnotation as unknown as Rule.Node,\n  });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param context Rule execution context.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const inlineObjectType = getInlineObjectTypeLiteral(\n      getTypeAnnotationNode(parameter),\n    );\n\n    if (inlineObjectType !== void 0) {\n      reportTypeLiteral(context, inlineObjectType);\n    }\n  }\n\n  const inlineReturnObjectType = getInlineObjectTypeLiteral(\n    getReturnTypeAnnotation(node),\n  );\n\n  if (inlineReturnObjectType !== void 0) {\n    reportTypeLiteral(context, inlineReturnObjectType);\n  }\n};\n\n/**\n * Checks variable declarators for inline object types.\n * @param context Rule execution context.\n * @param node Variable declarator to check.\n * @example\n * ```typescript\n * checkVariableDeclarator(context, node);\n * ```\n */\nconst checkVariableDeclarator = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const typedNode = node as VariableDeclaratorNode;\n\n  const inlineObjectType = getInlineObjectTypeLiteral(\n    getTypeAnnotationNode(typedNode.id),\n  );\n\n  if (inlineObjectType !== void 0) {\n    reportTypeLiteral(context, inlineObjectType);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  /**\n   * Creates listeners that validate function-like and variable annotations.\n   * @param context Rule execution context.\n   * @returns Rule listener map.\n   * @example\n   * ```typescript\n   * const listeners = preferInterfaceTypesRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    /**\n     * Checks function-like nodes for inline object types.\n     * @param node Function-like node to inspect.\n     * @example\n     * ```typescript\n     * functionLikeListener(node);\n     * ```\n     */\n    const functionLikeListener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    /**\n     * Checks variable declarators for inline object types.\n     * @param node Variable declarator to inspect.\n     * @example\n     * ```typescript\n     * variableDeclaratorListener(node);\n     * ```\n     */\n    const variableDeclaratorListener = (node: Rule.Node): void => {\n      checkVariableDeclarator(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: functionLikeListener,\n      FunctionDeclaration: functionLikeListener,\n      FunctionExpression: functionLikeListener,\n      TSCallSignatureDeclaration: functionLikeListener,\n      TSConstructSignatureDeclaration: functionLikeListener,\n      TSDeclareFunction: functionLikeListener,\n      TSFunctionType: functionLikeListener,\n      TSMethodSignature: functionLikeListener,\n      VariableDeclarator: variableDeclaratorListener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md\",\n    },\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}

package/dist/domain/custom-rule-documentation.d.ts

@@ -2,11 +2,11 @@
 interface CustomRuleDocumentation {
     /** Human-readable rule description. */
     description: string;
+    /** Whether the rule is part of a recommended preset. */
+    recommended: boolean;
     /** Canonical documentation URL for the rule. */
     url: string;
 }
-/** Base URL for published custom rule documentation pages. */
-declare const customRuleDocumentationBaseUrl = "https://github.com/parloti/eslint-plugin/blob/main/docs/rules";
 /**
  * Creates shared docs metadata for a package-owned custom rule.
  * @param ruleName ESLint rule name without the plugin prefix.
@@ -21,16 +21,5 @@ declare const customRuleDocumentationBaseUrl = "https://github.com/parloti/eslin
  * ```
  */
 declare function createRuleDocumentation(ruleName: string, description: string): CustomRuleDocumentation;
-/**
- * Builds the canonical documentation URL for a package-owned custom rule.
- * @param ruleName ESLint rule name without the plugin prefix.
- * @returns Return value output.
- * @example
- * ```typescript
- * const url = getCustomRuleDocumentationUrl("prefer-interface-types");
- * ```
- */
-declare function getCustomRuleDocumentationUrl(ruleName: string): string;
-export { createRuleDocumentation, customRuleDocumentationBaseUrl, getCustomRuleDocumentationUrl, };
-export type { CustomRuleDocumentation };
+export { createRuleDocumentation };
 //# sourceMappingURL=custom-rule-documentation.d.ts.map

package/dist/domain/custom-rule-documentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom-rule-documentation.d.ts","sourceRoot":"","sources":["../../src/domain/custom-rule-documentation.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,UAAU,uBAAuB;IAC/B,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IAEpB,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,8DAA8D;AAC9D,QAAA,MAAM,8BAA8B,kEAC6B,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,iBAAS,uBAAuB,CAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAKzB;AAED;;;;;;;;GAQG;AACH,iBAAS,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,6BAA6B,GAC9B,CAAC;AACF,YAAY,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"custom-rule-documentation.d.ts","sourceRoot":"","sources":["../../src/domain/custom-rule-documentation.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,UAAU,uBAAuB;IAC/B,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IAEpB,wDAAwD;IACxD,WAAW,EAAE,OAAO,CAAC;IAErB,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;CACb;AAMD;;;;;;;;;;;;GAYG;AACH,iBAAS,uBAAuB,CAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAMzB;AAeD,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/domain/custom-rule-documentation.js

@@ -16,6 +16,7 @@ const customRuleDocumentationBaseUrl = "https://github.com/parloti/eslint-plugin
 function createRuleDocumentation(ruleName, description) {
     return {
         description,
+        recommended: false,
         url: getCustomRuleDocumentationUrl(ruleName),
     };
 }
@@ -31,5 +32,5 @@ function createRuleDocumentation(ruleName, description) {
 function getCustomRuleDocumentationUrl(ruleName) {
     return `${customRuleDocumentationBaseUrl}/${ruleName}.md`;
 }
-export { createRuleDocumentation, customRuleDocumentationBaseUrl, getCustomRuleDocumentationUrl, };
-//# sourceMappingURL=data:application/json;base64,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
+export { createRuleDocumentation };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/comment-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comment-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA2DpD;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,GACnB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,MAAM,IAAI,CAAC,IAAI,KACd,OAAO,GAAG,SASZ,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,SAAS,OAAO,KACf,MASF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,WAAW,EAyBzD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,cAAc,MAAM,EACpB,aAAa,MAAM,EACnB,MAAM,WAAW,KAChB,CAAC,MAAM,EAAE,MAAM,CAuBjB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"comment-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA2DpD;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,GACnB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,MAAM,IAAI,CAAC,IAAI,KACd,OAAO,GAAG,SAuBZ,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,SAAS,OAAO,KACf,MASF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,WAAW,EAyBzD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,cAAc,MAAM,EACpB,aAAa,MAAM,EACnB,MAAM,WAAW,KAChB,CAAC,MAAM,EAAE,MAAM,CAuBjB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/comment-utilities.js

@@ -60,7 +60,16 @@ const getJsdocComment = (sourceCode, node) => {
     if (comments.length === 0 || typeof nodeStart !== "number") {
         return void 0;
     }
-    return findClosestComment(comments, nodeStart);
+    const comment = findClosestComment(comments, nodeStart);
+    if (comment === void 0) {
+        return void 0;
+    }
+    const commentEnd = comment.range?.[1];
+    if (typeof commentEnd !== "number") {
+        return void 0;
+    }
+    const betweenCommentAndNode = sourceCode.text.slice(commentEnd, nodeStart);
+    return betweenCommentAndNode.trim().length === 0 ? comment : void 0;
 };
 /**
  * Extracts the full text for a comment range.
@@ -143,4 +152,4 @@ const buildRemovalRange = (commentStart, commentText, line) => {
     return [commentStart + line.start, commentStart + line.end];
 };
 export { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comment-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, CommentLine } from \"./types\";\n\n/**\n * Checks isJsdocComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isJsdocComment();\n * ```\n */\nconst isJsdocComment = (comment: Comment): boolean =>\n  comment.type === \"Block\" && comment.value.startsWith(\"*\");\n\n/**\n * Gets getCommentEnd.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentEnd();\n * ```\n */\nconst getCommentEnd = (comment: Comment): number | undefined => {\n  const commentEnd = comment.range?.[1];\n\n  return typeof commentEnd === \"number\" ? commentEnd : void 0;\n};\n\n/**\n * Finds the closest JSDoc comment before a node.\n * @param comments Comment list to search.\n * @param nodeStart Start offset of the node.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = findClosestComment(comments, nodeStart);\n * ```\n */\nconst findClosestComment = (\n  comments: Comment[],\n  nodeStart: number,\n): Comment | undefined => {\n  let closest: Comment | undefined = void 0;\n  let closestEnd = -1;\n\n  for (const comment of comments) {\n    const commentEnd = getCommentEnd(comment);\n    const shouldConsider = isJsdocComment(comment) && commentEnd !== void 0;\n\n    if (shouldConsider && commentEnd <= nodeStart && commentEnd > closestEnd) {\n      closest = comment;\n      closestEnd = commentEnd;\n    }\n  }\n\n  return closest;\n};\n\n/**\n * Gets the closest JSDoc comment for a node.\n * @param sourceCode Source code wrapper.\n * @param node Node to inspect.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = getJsdocComment(sourceCode, node);\n * ```\n */\nconst getJsdocComment = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n): Comment | undefined => {\n  const comments = sourceCode.getAllComments();\n  const nodeStart = node.range?.[0];\n\n  if (comments.length === 0 || typeof nodeStart !== \"number\") {\n    return void 0;\n  }\n\n  return findClosestComment(comments, nodeStart);\n};\n\n/**\n * Extracts the full text for a comment range.\n * @param sourceCode Source code wrapper.\n * @param comment Comment to read.\n * @returns Comment contents from the source.\n * @example\n * ```typescript\n * const text = getCommentText(sourceCode, comment);\n * ```\n */\nconst getCommentText = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  comment: Comment,\n): string => {\n  const start = comment.range?.[0];\n  const end = comment.range?.[1];\n\n  if (typeof start !== \"number\" || typeof end !== \"number\") {\n    return \"\";\n  }\n\n  return sourceCode.text.slice(start, end);\n};\n\n/**\n * Gets getCommentLines.\n * @param commentText Input commentText value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentLines();\n * ```\n */\nconst getCommentLines = (commentText: string): CommentLine[] => {\n  const lines = commentText.split(/\\r?\\n/u);\n  const results: CommentLine[] = [];\n  let offset = 0;\n\n  for (const line of lines) {\n    const lineEnd = offset + line.length;\n    const nextSlice = commentText.slice(lineEnd, lineEnd + 2);\n    const lineBreakLength = nextSlice.startsWith(\"\\r\\n\")\n      ? 2\n      : nextSlice.startsWith(\"\\n\")\n        ? 1\n        : 0;\n\n    results.push({\n      end: lineEnd,\n      lineBreakLength,\n      start: offset,\n      text: line,\n    });\n\n    offset = lineEnd + lineBreakLength;\n  }\n\n  return results;\n};\n\n/**\n * Builds a removal range for the specified comment line.\n * @param commentStart Comment start offset in the source.\n * @param commentText Full comment text.\n * @param line Line metadata for the comment.\n * @returns The range to remove.\n * @example\n * ```typescript\n * const range = buildRemovalRange(0, commentText, line);\n * ```\n */\nconst buildRemovalRange = (\n  commentStart: number,\n  commentText: string,\n  line: CommentLine,\n): [number, number] => {\n  if (line.lineBreakLength > 0) {\n    return [\n      commentStart + line.start,\n      commentStart + line.end + line.lineBreakLength,\n    ];\n  }\n\n  if (line.start > 0) {\n    const previousChar = commentText[line.start - 1];\n    const previousIsLineBreak = previousChar === \"\\n\";\n\n    if (previousIsLineBreak) {\n      const lineBreakLength =\n        line.start > 1 && commentText[line.start - 2] === \"\\r\" ? 2 : 1;\n      return [\n        commentStart + line.start - lineBreakLength,\n        commentStart + line.end,\n      ];\n    }\n  }\n\n  return [commentStart + line.start, commentStart + line.end];\n};\n\nexport { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comment-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, CommentLine } from \"./types\";\n\n/**\n * Checks isJsdocComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isJsdocComment();\n * ```\n */\nconst isJsdocComment = (comment: Comment): boolean =>\n  comment.type === \"Block\" && comment.value.startsWith(\"*\");\n\n/**\n * Gets getCommentEnd.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentEnd();\n * ```\n */\nconst getCommentEnd = (comment: Comment): number | undefined => {\n  const commentEnd = comment.range?.[1];\n\n  return typeof commentEnd === \"number\" ? commentEnd : void 0;\n};\n\n/**\n * Finds the closest JSDoc comment before a node.\n * @param comments Comment list to search.\n * @param nodeStart Start offset of the node.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = findClosestComment(comments, nodeStart);\n * ```\n */\nconst findClosestComment = (\n  comments: Comment[],\n  nodeStart: number,\n): Comment | undefined => {\n  let closest: Comment | undefined = void 0;\n  let closestEnd = -1;\n\n  for (const comment of comments) {\n    const commentEnd = getCommentEnd(comment);\n    const shouldConsider = isJsdocComment(comment) && commentEnd !== void 0;\n\n    if (shouldConsider && commentEnd <= nodeStart && commentEnd > closestEnd) {\n      closest = comment;\n      closestEnd = commentEnd;\n    }\n  }\n\n  return closest;\n};\n\n/**\n * Gets the closest JSDoc comment for a node.\n * @param sourceCode Source code wrapper.\n * @param node Node to inspect.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = getJsdocComment(sourceCode, node);\n * ```\n */\nconst getJsdocComment = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n): Comment | undefined => {\n  const comments = sourceCode.getAllComments();\n  const nodeStart = node.range?.[0];\n\n  if (comments.length === 0 || typeof nodeStart !== \"number\") {\n    return void 0;\n  }\n\n  const comment = findClosestComment(comments, nodeStart);\n\n  if (comment === void 0) {\n    return void 0;\n  }\n\n  const commentEnd = comment.range?.[1];\n\n  if (typeof commentEnd !== \"number\") {\n    return void 0;\n  }\n\n  const betweenCommentAndNode = sourceCode.text.slice(commentEnd, nodeStart);\n\n  return betweenCommentAndNode.trim().length === 0 ? comment : void 0;\n};\n\n/**\n * Extracts the full text for a comment range.\n * @param sourceCode Source code wrapper.\n * @param comment Comment to read.\n * @returns Comment contents from the source.\n * @example\n * ```typescript\n * const text = getCommentText(sourceCode, comment);\n * ```\n */\nconst getCommentText = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  comment: Comment,\n): string => {\n  const start = comment.range?.[0];\n  const end = comment.range?.[1];\n\n  if (typeof start !== \"number\" || typeof end !== \"number\") {\n    return \"\";\n  }\n\n  return sourceCode.text.slice(start, end);\n};\n\n/**\n * Gets getCommentLines.\n * @param commentText Input commentText value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentLines();\n * ```\n */\nconst getCommentLines = (commentText: string): CommentLine[] => {\n  const lines = commentText.split(/\\r?\\n/u);\n  const results: CommentLine[] = [];\n  let offset = 0;\n\n  for (const line of lines) {\n    const lineEnd = offset + line.length;\n    const nextSlice = commentText.slice(lineEnd, lineEnd + 2);\n    const lineBreakLength = nextSlice.startsWith(\"\\r\\n\")\n      ? 2\n      : nextSlice.startsWith(\"\\n\")\n        ? 1\n        : 0;\n\n    results.push({\n      end: lineEnd,\n      lineBreakLength,\n      start: offset,\n      text: line,\n    });\n\n    offset = lineEnd + lineBreakLength;\n  }\n\n  return results;\n};\n\n/**\n * Builds a removal range for the specified comment line.\n * @param commentStart Comment start offset in the source.\n * @param commentText Full comment text.\n * @param line Line metadata for the comment.\n * @returns The range to remove.\n * @example\n * ```typescript\n * const range = buildRemovalRange(0, commentText, line);\n * ```\n */\nconst buildRemovalRange = (\n  commentStart: number,\n  commentText: string,\n  line: CommentLine,\n): [number, number] => {\n  if (line.lineBreakLength > 0) {\n    return [\n      commentStart + line.start,\n      commentStart + line.end + line.lineBreakLength,\n    ];\n  }\n\n  if (line.start > 0) {\n    const previousChar = commentText[line.start - 1];\n    const previousIsLineBreak = previousChar === \"\\n\";\n\n    if (previousIsLineBreak) {\n      const lineBreakLength =\n        line.start > 1 && commentText[line.start - 2] === \"\\r\" ? 2 : 1;\n      return [\n        commentStart + line.start - lineBreakLength,\n        commentStart + line.end,\n      ];\n    }\n  }\n\n  return [commentStart + line.start, commentStart + line.end];\n};\n\nexport { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment };\n"]}

package/dist/domain/docs/no-interface-member-docs/parameter-tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAoG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAmBvB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAmG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAmBvB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/parameter-tags.js

@@ -98,4 +98,4 @@ const parseParameterTagLine = (line) => {
     };
 };
 export { parseParameterTagLine };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/parameter-utilities.js

@@ -122,4 +122,4 @@ const getParameterTypeLookup = (node) => {
  */
 const isNamedTypeReference = (typeAnnotation) => typeAnnotation?.type === "TSTypeReference";
 export { getParameterTypeLookup, isNamedTypeReference };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { TypeAnnotationNode } from \"./types\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n}\n\n/** Type definition for rule data. */\ninterface IdentifierNode {\n  /** Name helper value. */\n  name?: string;\n\n  /** Type helper value. */\n  type?: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface NamedIdentifierNode extends IdentifierNode {\n  /** Name field value. */\n  name: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left helper value. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n\n  /** Type helper value. */\n  type?: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterInfo {\n  /** Name field value. */\n  name: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: TypeAnnotationNode;\n}\n\n/**\n * Gets a type annotation node from an identifier.\n * @param node Identifier node to inspect.\n * @returns The type annotation node when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(identifier);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: IdentifierNode,\n): TypeAnnotationNode | undefined => node.typeAnnotation?.typeAnnotation;\n\n/**\n * Defines resolveParameterNode.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * resolveParameterNode();\n * ```\n */\nconst resolveParameterNode = (node: unknown): unknown => {\n  if (node === null || typeof node !== \"object\") {\n    return node;\n  }\n\n  const container = node as ParameterContainer;\n\n  if (container.argument !== void 0) {\n    return container.argument;\n  }\n\n  if (container.parameter !== void 0) {\n    return container.parameter;\n  }\n\n  if (container.type === \"AssignmentPattern\" && container.left !== void 0) {\n    return container.left;\n  }\n\n  return node;\n};\n\n/**\n * Gets the parameter identifier for a parameter node.\n * @param node Parameter node to inspect.\n * @returns The identifier node when present.\n * @example\n * ```typescript\n * const identifier = getParameterIdentifier(node);\n * ```\n */\nconst getParameterIdentifier = (\n  node: unknown,\n): NamedIdentifierNode | undefined => {\n  const resolved = resolveParameterNode(node);\n\n  if (resolved === null || typeof resolved !== \"object\") {\n    return void 0;\n  }\n\n  const identifier = resolved as IdentifierNode;\n  const { name } = identifier;\n\n  if (identifier.type !== \"Identifier\" || typeof name !== \"string\") {\n    return void 0;\n  }\n\n  return { ...identifier, name } as NamedIdentifierNode;\n};\n\n/**\n * Gets parameter info for the given node.\n * @param node Parameter node to inspect.\n * @returns Parameter info when available.\n * @example\n * ```typescript\n * const info = getParameterInfo(node);\n * ```\n */\nconst getParameterInfo = (node: unknown): ParameterInfo | undefined => {\n  const identifier = getParameterIdentifier(node);\n\n  if (identifier === void 0) {\n    return void 0;\n  }\n\n  const typeAnnotation = getTypeAnnotationNode(identifier);\n\n  return typeAnnotation === void 0\n    ? { name: identifier.name }\n    : {\n        name: identifier.name,\n        typeAnnotation,\n      };\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Builds a lookup of parameter names to type annotations.\n * @param node Function-like node.\n * @returns Lookup of parameter names to annotations.\n * @example\n * ```typescript\n * const lookup = getParameterTypeLookup(node);\n * ```\n */\nconst getParameterTypeLookup = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> => {\n  const lookup = new Map<string, TypeAnnotationNode>();\n\n  for (const parameter of getParameters(node)) {\n    const info = getParameterInfo(parameter);\n\n    if (info !== void 0 && info.typeAnnotation !== void 0) {\n      lookup.set(info.name, info.typeAnnotation);\n    }\n  }\n\n  return lookup;\n};\n\n/**\n * Checks whether a type annotation is a named type reference.\n * @param typeAnnotation Type annotation to inspect.\n * @returns True when the annotation is a named reference.\n * @example\n * ```typescript\n * const ok = isNamedTypeReference(annotation);\n * ```\n */\nconst isNamedTypeReference = (\n  typeAnnotation: TypeAnnotationNode | undefined,\n): boolean => typeAnnotation?.type === \"TSTypeReference\";\n\nexport { getParameterTypeLookup, isNamedTypeReference };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { TypeAnnotationNode } from \"./types\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n}\n\n/** Type definition for rule data. */\ninterface IdentifierNode {\n  /** Name helper value. */\n  name?: string;\n\n  /** Type helper value. */\n  type?: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface NamedIdentifierNode extends IdentifierNode {\n  /** Name field value. */\n  name: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left helper value. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n\n  /** Type helper value. */\n  type?: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterInfo {\n  /** Name field value. */\n  name: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: TypeAnnotationNode;\n}\n\n/**\n * Gets a type annotation node from an identifier.\n * @param node Identifier node to inspect.\n * @returns The type annotation node when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(identifier);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: IdentifierNode,\n): TypeAnnotationNode | undefined => node.typeAnnotation?.typeAnnotation;\n\n/**\n * Defines resolveParameterNode.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * resolveParameterNode();\n * ```\n */\nconst resolveParameterNode = (node: unknown): unknown => {\n  if (node === null || typeof node !== \"object\") {\n    return node;\n  }\n\n  const container = node as ParameterContainer;\n\n  if (container.argument !== void 0) {\n    return container.argument;\n  }\n\n  if (container.parameter !== void 0) {\n    return container.parameter;\n  }\n\n  if (container.type === \"AssignmentPattern\" && container.left !== void 0) {\n    return container.left;\n  }\n\n  return node;\n};\n\n/**\n * Gets the parameter identifier for a parameter node.\n * @param node Parameter node to inspect.\n * @returns The identifier node when present.\n * @example\n * ```typescript\n * const identifier = getParameterIdentifier(node);\n * ```\n */\nconst getParameterIdentifier = (\n  node: unknown,\n): NamedIdentifierNode | undefined => {\n  const resolved = resolveParameterNode(node);\n\n  if (resolved === null || typeof resolved !== \"object\") {\n    return void 0;\n  }\n\n  const identifier = resolved as IdentifierNode;\n  const { name } = identifier;\n\n  if (identifier.type !== \"Identifier\" || typeof name !== \"string\") {\n    return void 0;\n  }\n\n  return { ...identifier, name };\n};\n\n/**\n * Gets parameter info for the given node.\n * @param node Parameter node to inspect.\n * @returns Parameter info when available.\n * @example\n * ```typescript\n * const info = getParameterInfo(node);\n * ```\n */\nconst getParameterInfo = (node: unknown): ParameterInfo | undefined => {\n  const identifier = getParameterIdentifier(node);\n\n  if (identifier === void 0) {\n    return void 0;\n  }\n\n  const typeAnnotation = getTypeAnnotationNode(identifier);\n\n  return typeAnnotation === void 0\n    ? { name: identifier.name }\n    : {\n        name: identifier.name,\n        typeAnnotation,\n      };\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Builds a lookup of parameter names to type annotations.\n * @param node Function-like node.\n * @returns Lookup of parameter names to annotations.\n * @example\n * ```typescript\n * const lookup = getParameterTypeLookup(node);\n * ```\n */\nconst getParameterTypeLookup = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> => {\n  const lookup = new Map<string, TypeAnnotationNode>();\n\n  for (const parameter of getParameters(node)) {\n    const info = getParameterInfo(parameter);\n\n    if (info !== void 0 && info.typeAnnotation !== void 0) {\n      lookup.set(info.name, info.typeAnnotation);\n    }\n  }\n\n  return lookup;\n};\n\n/**\n * Checks whether a type annotation is a named type reference.\n * @param typeAnnotation Type annotation to inspect.\n * @returns True when the annotation is a named reference.\n * @example\n * ```typescript\n * const ok = isNamedTypeReference(annotation);\n * ```\n */\nconst isNamedTypeReference = (\n  typeAnnotation: TypeAnnotationNode | undefined,\n): boolean => typeAnnotation?.type === \"TSTypeReference\";\n\nexport { getParameterTypeLookup, isNamedTypeReference };\n"]}

package/dist/domain/docs/no-interface-member-docs/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiPnC,+EAA+E;AAC/E,QAAA,MAAM,kCAAkC,EAAE,IAAI,CAAC,UA8B9C,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA+PnC,+EAA+E;AAC/E,QAAA,MAAM,kCAAkC,EAAE,IAAI,CAAC,UAkC9C,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/rule.js

@@ -1,4 +1,3 @@
-import { createRuleDocumentation } from "../../custom-rule-documentation.js";
 import { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment, } from "./comment-utilities.js";
 import { parseParameterTagLine } from "./parameter-tags.js";
 import { getParameterTypeLookup, isNamedTypeReference, } from "./parameter-utilities.js";
@@ -124,7 +123,10 @@ const resolveMemberTagContext = (context, node) => {
  * ```
  */
 const handleFunctionLike = (context, node) => {
-    const resolved = resolveMemberTagContext(context, node);
+    const functionLikeNode = node.type === "MethodDefinition"
+        ? (node.value ?? node)
+        : node;
+    const resolved = resolveMemberTagContext(context, functionLikeNode);
     if (resolved === void 0) {
         return;
     }
@@ -147,6 +149,8 @@ const noInterfaceMemberDocumentationRule = {
             ArrowFunctionExpression: listener,
             FunctionDeclaration: listener,
             FunctionExpression: listener,
+            MethodDefinition: listener,
+            TSAbstractMethodDefinition: listener,
             TSCallSignatureDeclaration: listener,
             TSConstructSignatureDeclaration: listener,
             TSDeclareFunction: listener,
@@ -155,7 +159,11 @@ const noInterfaceMemberDocumentationRule = {
         };
     },
     meta: {
-        docs: createRuleDocumentation("no-interface-member-docs", "Disallow documenting interface members in @param tags; document them on the interface instead."),
+        docs: {
+            description: "Disallow documenting interface members in @param tags; document them on the interface instead.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-interface-member-docs.md",
+        },
         fixable: "code",
         messages: {
             interfaceMemberDoc: "Document interface members on the interface instead of using @param for {{parameterName}}.",
@@ -165,4 +173,4 @@ const noInterfaceMemberDocumentationRule = {
     },
 };
 export { noInterfaceMemberDocumentationRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, ParameterMemberTag, TypeAnnotationNode } from \"./types\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport {\n  buildRemovalRange,\n  getCommentLines,\n  getCommentText,\n  getJsdocComment,\n} from \"./comment-utilities\";\nimport { parseParameterTagLine } from \"./parameter-tags\";\nimport {\n  getParameterTypeLookup,\n  isNamedTypeReference,\n} from \"./parameter-utilities\";\n\n/** Type definition for rule data. */\ninterface ReportMemberDocumentationContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** CommentStart field value. */\n  commentStart: number;\n\n  /** CommentText field value. */\n  commentText: string;\n\n  /** MemberTags field value. */\n  memberTags: ParameterMemberTag[];\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/**\n * Checks whether a parameter member tag matches a named type reference.\n * @param tag Parsed parameter member tag.\n * @param parameterTypes Parameter type lookup.\n * @returns True when the tag matches a named type reference.\n * @example\n * ```typescript\n * const ok = isMatchingMemberTag(tag, parameterTypes);\n * ```\n */\nconst isMatchingMemberTag = (\n  tag: ParameterMemberTag | undefined,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): tag is ParameterMemberTag => {\n  if (tag === void 0) {\n    return false;\n  }\n\n  const parameterType = parameterTypes.get(tag.basename);\n\n  return isNamedTypeReference(parameterType);\n};\n\n/**\n * Collects member tags from a JSDoc comment.\n * @param commentText Full comment text.\n * @param parameterTypes Parameter type lookup.\n * @returns Member tags that match named type references.\n * @example\n * ```typescript\n * const tags = collectMemberTags(commentText, parameterTypes);\n * ```\n */\nconst collectMemberTags = (\n  commentText: string,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): ParameterMemberTag[] =>\n  getCommentLines(commentText)\n    .map((line) => parseParameterTagLine(line))\n    .filter((tag) => isMatchingMemberTag(tag, parameterTypes));\n\n/**\n * Reports interface member documentation entries for removal.\n * @param context Rule execution context.\n * @param details Collected rule details.\n * @example\n * ```typescript\n * reportMemberDocumentation(context, details);\n * ```\n */\nconst reportMemberDocumentation = (\n  context: Rule.RuleContext,\n  details: ReportMemberDocumentationContext,\n): void => {\n  const { commentStart, commentText, memberTags, node } = details;\n\n  for (const tag of memberTags) {\n    const removalRange = buildRemovalRange(commentStart, commentText, tag.line);\n\n    context.report({\n      data: { parameterName: tag.fullName },\n      fix: (fixer: Rule.RuleFixer): Rule.Fix => fixer.removeRange(removalRange),\n      messageId: \"interfaceMemberDoc\",\n      node,\n    });\n  }\n};\n\n/**\n * Gets parameter type references for a node.\n * @param node Function-like node to inspect.\n * @returns Parameter type lookup when present.\n * @example\n * ```typescript\n * const lookup = getParameterTypes(node);\n * ```\n */\nconst getParameterTypes = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> | undefined => {\n  const parameterTypes = getParameterTypeLookup(node);\n\n  return parameterTypes.size > 0 ? parameterTypes : void 0;\n};\n\n/**\n * Resolves the JSDoc comment data for a node.\n * @param sourceCode SourceCode wrapper.\n * @param node Node to inspect.\n * @returns JSDoc data when available.\n * @example\n * ```typescript\n * const data = getJsdocData(sourceCode, node);\n * ```\n */\nconst getJsdocData = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n):\n  | undefined\n  | {\n      /** Comment field value. */\n      comment: Comment;\n\n      /** CommentStart field value. */\n      commentStart: number;\n\n      /** Text field value. */\n      text: string;\n    } => {\n  const comment = getJsdocComment(sourceCode, node);\n\n  if (comment === void 0) {\n    return void 0;\n  }\n\n  const commentStart = comment.range?.[0];\n\n  if (typeof commentStart !== \"number\") {\n    return void 0;\n  }\n\n  const text = getCommentText(sourceCode, comment);\n\n  return { comment, commentStart, text };\n};\n\n/**\n * Resolves the member tag context for a node.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @returns Member tag context when available.\n * @example\n * ```typescript\n * const context = resolveMemberTagContext(context, node);\n * ```\n */\nconst resolveMemberTagContext = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n):\n  | undefined\n  | {\n      /** Comment field value. */\n      comment: Comment;\n\n      /** CommentStart field value. */\n      commentStart: number;\n\n      /** CommentText field value. */\n      commentText: string;\n\n      /** MemberTags field value. */\n      memberTags: ParameterMemberTag[];\n    } => {\n  const parameterTypes = getParameterTypes(node);\n  const jsdocData = getJsdocData(context.sourceCode, node);\n\n  if (parameterTypes === void 0 || jsdocData === void 0) {\n    return void 0;\n  }\n\n  const memberTags = collectMemberTags(jsdocData.text, parameterTypes);\n\n  return memberTags.length > 0\n    ? {\n        comment: jsdocData.comment,\n        commentStart: jsdocData.commentStart,\n        commentText: jsdocData.text,\n        memberTags,\n      }\n    : void 0;\n};\n\n/**\n * Handles function-like nodes for this rule.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @example\n * ```typescript\n * handleFunctionLike(context, node);\n * ```\n */\nconst handleFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const resolved = resolveMemberTagContext(context, node);\n\n  if (resolved === void 0) {\n    return;\n  }\n\n  reportMemberDocumentation(context, {\n    comment: resolved.comment,\n    commentStart: resolved.commentStart,\n    commentText: resolved.commentText,\n    memberTags: resolved.memberTags,\n    node,\n    sourceCode: context.sourceCode,\n  });\n};\n\n/** ESLint rule disallowing interface member documentation in `@param` tags. */\nconst noInterfaceMemberDocumentationRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const listener = (node: Rule.Node): void => {\n      handleFunctionLike(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: listener,\n      FunctionDeclaration: listener,\n      FunctionExpression: listener,\n      TSCallSignatureDeclaration: listener,\n      TSConstructSignatureDeclaration: listener,\n      TSDeclareFunction: listener,\n      TSFunctionType: listener,\n      TSMethodSignature: listener,\n    };\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"no-interface-member-docs\",\n      \"Disallow documenting interface members in @param tags; document them on the interface instead.\",\n    ),\n    fixable: \"code\",\n    messages: {\n      interfaceMemberDoc:\n        \"Document interface members on the interface instead of using @param for {{parameterName}}.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { noInterfaceMemberDocumentationRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, ParameterMemberTag, TypeAnnotationNode } from \"./types\";\n\nimport {\n  buildRemovalRange,\n  getCommentLines,\n  getCommentText,\n  getJsdocComment,\n} from \"./comment-utilities\";\nimport { parseParameterTagLine } from \"./parameter-tags\";\nimport {\n  getParameterTypeLookup,\n  isNamedTypeReference,\n} from \"./parameter-utilities\";\n\n/** JSDoc data extracted from a function-like node. */\ninterface JsdocData {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** CommentStart field value. */\n  commentStart: number;\n\n  /** Text field value. */\n  text: string;\n}\n\n/** Member-tag context resolved for reporting. */\ninterface MemberTagContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** CommentStart field value. */\n  commentStart: number;\n\n  /** CommentText field value. */\n  commentText: string;\n\n  /** MemberTags field value. */\n  memberTags: ParameterMemberTag[];\n}\n\n/** Type definition for rule data. */\ninterface ReportMemberDocumentationContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** CommentStart field value. */\n  commentStart: number;\n\n  /** CommentText field value. */\n  commentText: string;\n\n  /** MemberTags field value. */\n  memberTags: ParameterMemberTag[];\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/**\n * Checks whether a parameter member tag matches a named type reference.\n * @param tag Parsed parameter member tag.\n * @param parameterTypes Parameter type lookup.\n * @returns True when the tag matches a named type reference.\n * @example\n * ```typescript\n * const ok = isMatchingMemberTag(tag, parameterTypes);\n * ```\n */\nconst isMatchingMemberTag = (\n  tag: ParameterMemberTag | undefined,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): tag is ParameterMemberTag => {\n  if (tag === void 0) {\n    return false;\n  }\n\n  const parameterType = parameterTypes.get(tag.basename);\n\n  return isNamedTypeReference(parameterType);\n};\n\n/**\n * Collects member tags from a JSDoc comment.\n * @param commentText Full comment text.\n * @param parameterTypes Parameter type lookup.\n * @returns Member tags that match named type references.\n * @example\n * ```typescript\n * const tags = collectMemberTags(commentText, parameterTypes);\n * ```\n */\nconst collectMemberTags = (\n  commentText: string,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): ParameterMemberTag[] =>\n  getCommentLines(commentText)\n    .map((line) => parseParameterTagLine(line))\n    .filter((tag) => isMatchingMemberTag(tag, parameterTypes));\n\n/**\n * Reports interface member documentation entries for removal.\n * @param context Rule execution context.\n * @param details Collected rule details.\n * @example\n * ```typescript\n * reportMemberDocumentation(context, details);\n * ```\n */\nconst reportMemberDocumentation = (\n  context: Rule.RuleContext,\n  details: ReportMemberDocumentationContext,\n): void => {\n  const { commentStart, commentText, memberTags, node } = details;\n\n  for (const tag of memberTags) {\n    const removalRange = buildRemovalRange(commentStart, commentText, tag.line);\n\n    context.report({\n      data: { parameterName: tag.fullName },\n      fix: (fixer: Rule.RuleFixer): Rule.Fix => fixer.removeRange(removalRange),\n      messageId: \"interfaceMemberDoc\",\n      node,\n    });\n  }\n};\n\n/**\n * Gets parameter type references for a node.\n * @param node Function-like node to inspect.\n * @returns Parameter type lookup when present.\n * @example\n * ```typescript\n * const lookup = getParameterTypes(node);\n * ```\n */\nconst getParameterTypes = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> | undefined => {\n  const parameterTypes = getParameterTypeLookup(node);\n\n  return parameterTypes.size > 0 ? parameterTypes : void 0;\n};\n\n/**\n * Resolves the JSDoc comment data for a node.\n * @param sourceCode SourceCode wrapper.\n * @param node Node to inspect.\n * @returns JSDoc data when available.\n * @example\n * ```typescript\n * const data = getJsdocData(sourceCode, node);\n * ```\n */\nconst getJsdocData = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n): JsdocData | undefined => {\n  const comment = getJsdocComment(sourceCode, node);\n\n  if (comment === void 0) {\n    return void 0;\n  }\n\n  const commentStart = comment.range?.[0];\n\n  if (typeof commentStart !== \"number\") {\n    return void 0;\n  }\n\n  const text = getCommentText(sourceCode, comment);\n\n  return { comment, commentStart, text };\n};\n\n/**\n * Resolves the member tag context for a node.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @returns Member tag context when available.\n * @example\n * ```typescript\n * const context = resolveMemberTagContext(context, node);\n * ```\n */\nconst resolveMemberTagContext = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): MemberTagContext | undefined => {\n  const parameterTypes = getParameterTypes(node);\n  const jsdocData = getJsdocData(context.sourceCode, node);\n\n  if (parameterTypes === void 0 || jsdocData === void 0) {\n    return void 0;\n  }\n\n  const memberTags = collectMemberTags(jsdocData.text, parameterTypes);\n\n  return memberTags.length > 0\n    ? {\n        comment: jsdocData.comment,\n        commentStart: jsdocData.commentStart,\n        commentText: jsdocData.text,\n        memberTags,\n      }\n    : void 0;\n};\n\n/** Handles function-like nodes for the no-interface-member-docs rule. */\ninterface NodeValue {\n  /**\n   * Value field for method definitions; function-like nodes have no value field, so this is optional.\n   */\n  value?: Rule.Node;\n}\n\n/**\n * Handles function-like nodes for this rule.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @example\n * ```typescript\n * handleFunctionLike(context, node);\n * ```\n */\nconst handleFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const functionLikeNode =\n    node.type === \"MethodDefinition\"\n      ? ((node as unknown as NodeValue).value ?? node)\n      : node;\n\n  const resolved = resolveMemberTagContext(context, functionLikeNode);\n\n  if (resolved === void 0) {\n    return;\n  }\n\n  reportMemberDocumentation(context, {\n    comment: resolved.comment,\n    commentStart: resolved.commentStart,\n    commentText: resolved.commentText,\n    memberTags: resolved.memberTags,\n    node,\n    sourceCode: context.sourceCode,\n  });\n};\n\n/** ESLint rule disallowing interface member documentation in `@param` tags. */\nconst noInterfaceMemberDocumentationRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const listener = (node: Rule.Node): void => {\n      handleFunctionLike(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: listener,\n      FunctionDeclaration: listener,\n      FunctionExpression: listener,\n      MethodDefinition: listener,\n      TSAbstractMethodDefinition: listener,\n      TSCallSignatureDeclaration: listener,\n      TSConstructSignatureDeclaration: listener,\n      TSDeclareFunction: listener,\n      TSFunctionType: listener,\n      TSMethodSignature: listener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Disallow documenting interface members in @param tags; document them on the interface instead.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-interface-member-docs.md\",\n    },\n    fixable: \"code\",\n    messages: {\n      interfaceMemberDoc:\n        \"Document interface members on the interface instead of using @param for {{parameterName}}.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { noInterfaceMemberDocumentationRule };\n"]}