eslint-plugin-jsdoc 44.2.1 → 44.2.3

package/dist/iterateJsdoc.js

@@ -15,6 +15,10 @@ var _jsdoccomment = require("@es-joy/jsdoccomment");
 var _commentParser = require("comment-parser");
 var _jsdocUtils = _interopRequireDefault(require("./jsdocUtils"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * @typedef {number} Integer
+ */
+
 const {
   rewireSpecs,
   seedTokens
@@ -49,14 +53,31 @@ const {
 */
 
 const globalState = new Map();
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {{
+ *   tagNamePreference?: import('./jsdocUtils.js').TagNamePreference,
+ *   mode?: import('./jsdocUtils.js').ParserMode
+ * }} cfg
+ * @returns {Utils}
+ */
 const getBasicUtils = (context, {
   tagNamePreference,
   mode
 }) => {
   const utils = {};
+
+  /**
+   * @param {string} message
+   * @returns {void}
+   */
   utils.reportSettings = message => {
     context.report({
       loc: {
+        end: {
+          column: 1,
+          line: 1
+        },
         start: {
           column: 1,
           line: 1
@@ -65,14 +86,25 @@ const getBasicUtils = (context, {
       message
     });
   };
+
+  /**
+   * @param {import('comment-parser').Spec} tag
+   * @returns {string[]}
+   */
   utils.parseClosureTemplateTag = tag => {
     return _jsdocUtils.default.parseClosureTemplateTag(tag);
   };
   utils.pathDoesNotBeginWith = _jsdocUtils.default.pathDoesNotBeginWith;
+
+  /**
+   * @param {{
+   *   tagName: string
+   * }} cfg
+   */
   utils.getPreferredTagNameObject = ({
     tagName
   }) => {
-    const ret = _jsdocUtils.default.getPreferredTagName(context, mode, tagName, tagNamePreference);
+    const ret = _jsdocUtils.default.getPreferredTagName(context, /** @type {import('./jsdocUtils.js').ParserMode} */mode, tagName, tagNamePreference);
     const isObject = ret && typeof ret === 'object';
     if (ret === false || isObject && !ret.replacement) {
       return {
@@ -84,6 +116,19 @@ const getBasicUtils = (context, {
   };
   return utils;
 };
+
+/**
+ * @param {} node
+ * @param {import('comment-parser').Block} jsdoc
+ * @param {import('@es-joy/jsdoccomment').Token} jsdocNode
+ * @param {Settings} settings
+ * @param {} report
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {boolean} iteratingAll
+ * @param {} ruleConfig
+ * @param {string} indent
+ * @returns {}
+ */
 const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAll, ruleConfig, indent) => {
   const ancestors = context.getAncestors();
   const sourceCode = context.getSourceCode();
@@ -98,21 +143,48 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     minLines,
     mode
   } = settings;
+
+  /**
+   * @returns {boolean}
+   */
   utils.isIteratingFunction = () => {
     return !iteratingAll || ['MethodDefinition', 'ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'].includes(node && node.type);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.isVirtualFunction = () => {
     return iteratingAll && utils.hasATag(['callback', 'function', 'func', 'method']);
   };
+
+  /**
+   * @param {import('comment-parser').Block} tagBlock
+   * @param {boolean} [specRewire]
+   * @returns {string}
+   */
   utils.stringify = (tagBlock, specRewire) => {
     let block;
     if (specRewire) {
       block = rewireSpecs(tagBlock);
     }
-    return (0, _commentParser.stringify)(specRewire ? block : tagBlock);
+    return (0, _commentParser.stringify)( /** @type {import('comment-parser').Block} */
+    specRewire ? block : tagBlock);
   };
+
+  /* eslint-disable jsdoc/valid-types -- Old version */
+  /**
+   * @param {string} msg
+   * @param {import('comment-parser').Spec} tag
+   * @param {() => void} handler
+   * @param {boolean} [specRewire]
+   * @param {{
+   *   [key: string]: undefined|string
+   * }} [data]
+   */
   utils.reportJSDoc = (msg, tag, handler, specRewire, data) => {
-    report(msg, handler ? fixer => {
+    /* eslint-enable jsdoc/valid-types -- Old version */
+    report(msg, handler ? /** @type {import('eslint').Rule.ReportFixer} */fixer => {
       handler();
       const replacement = utils.stringify(jsdoc, specRewire);
       if (!replacement) {
@@ -126,10 +198,25 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       return fixer.replaceText(jsdocNode, replacement);
     } : null, tag, data);
   };
+
+  /**
+   * @param {string} str
+   * @param {string} requiredFlags
+   * @returns {RegExp}
+   */
   utils.getRegexFromString = (str, requiredFlags) => {
     return _jsdocUtils.default.getRegexFromString(str, requiredFlags);
   };
+
+  /**
+   * @param {import('comment-parser').Spec} tg
+   * @param {boolean} returnArray
+   * @returns {string[]|string}
+   */
   utils.getTagDescription = (tg, returnArray) => {
+    /**
+     * @type {string[]}
+     */
     const descriptions = [];
     tg.source.some(({
       tokens: {
@@ -158,6 +245,13 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     });
     return returnArray ? descriptions : descriptions.join('\n');
   };
+
+  /**
+   * @param {import('comment-parser').Spec} tg
+   * @param {RegExp} matcher
+   * @param {(description: string) => string} setter
+   * @returns {Integer}
+   */
   utils.setTagDescription = (tg, matcher, setter) => {
     let finalIdx = 0;
     tg.source.some(({
@@ -174,7 +268,16 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     });
     return finalIdx;
   };
+
+  /**
+   * @returns {{
+   *   description: string,
+   *   descriptions: string[],
+   *   lastDescriptionLine: Integer
+   * }}
+   */
   utils.getDescription = () => {
+    /** @type {string[]} */
     const descriptions = [];
     let lastDescriptionLine = 0;
     let tagsBegun = false;
@@ -206,9 +309,33 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       lastDescriptionLine
     };
   };
+
+  /* eslint-disable jsdoc/no-undefined-types -- Bug */
+  /**
+   * @param {(
+   *   info: undefined|{
+   *     delimiter: string,
+   *     postDelimiter: string,
+   *     start: string
+   *   },
+   *   seedTokens: (
+   *     tokens?: Partial<import('comment-parser').Tokens> | undefined
+   *   ) => import('comment-parser').Tokens,
+   *   descLines: string[]
+   * ) => import('comment-parser').Tokens[]} setter
+   * @returns {void}
+   */
   utils.setBlockDescription = setter => {
+    /* eslint-enable jsdoc/no-undefined-types -- Bug */
+    /** @type {string[]} */
     const descLines = [];
+    /**
+     * @type {undefined|Integer}
+     */
     let startIdx;
+    /**
+     * @type {undefined|Integer}
+     */
     let endIdx;
     let info;
     jsdoc.source.some(({
@@ -242,9 +369,15 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
 
     /* istanbul ignore else -- Won't be called if missing */
     if (descLines.length) {
-      jsdoc.source.splice(startIdx, endIdx - startIdx, ...setter(info, seedTokens, descLines));
+      jsdoc.source.splice( /** @type {Integer} */startIdx, /** @type {Integer} */endIdx - /** @type {Integer} */startIdx, ...setter(info, seedTokens, descLines));
     }
   };
+
+  /**
+   * @param {RegExp} matcher
+   * @param {(description: string) => string} setter
+   * @returns {Integer}
+   */
   utils.setDescriptionLines = (matcher, setter) => {
     let finalIdx = 0;
     jsdoc.source.some(({
@@ -267,6 +400,12 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     });
     return finalIdx;
   };
+
+  /**
+   * @param {import('comment-parser').Spec} tag
+   * @param {import('comment-parser').Tokens[]} tokens
+   * @returns {void}
+   */
   utils.changeTag = (tag, ...tokens) => {
     for (const [idx, src] of tag.source.entries()) {
       src.tokens = {
@@ -275,10 +414,21 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       };
     }
   };
+
+  /* eslint-disable jsdoc/no-undefined-types -- TS */
+  /**
+   * @param {import('comment-parser').Spec & {
+   *   line: Integer
+   * }} tag
+   * @param {Partial<import('comment-parser').Tokens>} tokens
+   * @returns {void}
+   */
   utils.setTag = (tag, tokens) => {
+    /* eslint-enable jsdoc/no-undefined-types -- TS */
     tag.source = [{
-      // Or tag.source[0].number?
       number: tag.line,
+      // Or tag.source[0].number?
+      source: '',
       tokens: seedTokens({
         delimiter: '*',
         postDelimiter: ' ',
@@ -288,6 +438,15 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       })
     }];
   };
+
+  /**
+   * @param {Integer} tagIndex
+   * @param {{
+   *   removeEmptyBlock?: boolean,
+   *   tagSourceOffset?: Integer
+   * }} cfg
+   * @returns {void}
+   */
   utils.removeTag = (tagIndex, {
     removeEmptyBlock = false,
     tagSourceOffset = 0
@@ -295,6 +454,7 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     const {
       source: tagSource
     } = jsdoc.tags[tagIndex];
+    /** @type {Integer|undefined} */
     let lastIndex;
     const firstNumber = jsdoc.source[0].number;
     tagSource.some(({
@@ -332,7 +492,12 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
             tokens
           } = jsdoc.source[spliceIdx];
           for (const item of ['postDelimiter', 'tag', 'postTag', 'type', 'postType', 'name', 'postName', 'description']) {
-            tokens[item] = '';
+            tokens[
+            /**
+             * @type {"postDelimiter"|"tag"|"type"|"postType"|
+             *   "postTag"|"name"|"postName"|"description"}
+             */
+            item] = '';
           }
         } else {
           jsdoc.source.splice(spliceIdx, spliceCount - tagSourceOffset + (spliceIdx ? 0 : jsdoc.source.length));
@@ -346,14 +511,21 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       return false;
     });
     for (const [idx, src] of jsdoc.source.slice(lastIndex).entries()) {
-      src.number = firstNumber + lastIndex + idx;
+      src.number = firstNumber + /** @type {Integer} */lastIndex + idx;
     }
 
-    // Todo: Once rewiring of tags may be fixed in comment-parser to reflect missing tags,
-    //         this step should be added here (so that, e.g., if accessing `jsdoc.tags`,
-    //         such as to add a new tag, the correct information will be available)
+    // Todo: Once rewiring of tags may be fixed in comment-parser to reflect
+    //         missing tags, this step should be added here (so that, e.g.,
+    //         if accessing `jsdoc.tags`, such as to add a new tag, the
+    //         correct information will be available)
   };
 
+  /**
+   * @param {string} targetTagName
+   * @param {Integer} number
+   * @param {import('comment-parser').Tokens|{}} tokens
+   * @returns {void}
+   */
   utils.addTag = (targetTagName, number = ((() => {
     var _jsdoc$tags, _jsdoc$tags$source$;
     return (_jsdoc$tags = jsdoc.tags[jsdoc.tags.length - 1]) === null || _jsdoc$tags === void 0 ? void 0 : (_jsdoc$tags$source$ = _jsdoc$tags.source[0]) === null || _jsdoc$tags$source$ === void 0 ? void 0 : _jsdoc$tags$source$.number;
@@ -379,6 +551,10 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       src.number++;
     }
   };
+
+  /**
+   * @returns {Integer|undefined}
+   */
   utils.getFirstLine = () => {
     let firstLine;
     for (const {
@@ -395,11 +571,29 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     return firstLine;
   };
   utils.seedTokens = seedTokens;
+
+  /**
+   * Sets tokens to empty string.
+   *
+   * @param {import('comment-parser').Tokens} tokens
+   * @returns {void}
+   */
   utils.emptyTokens = tokens => {
     for (const prop of ['start', 'postDelimiter', 'tag', 'type', 'postType', 'postTag', 'name', 'postName', 'description', 'end', 'lineEnd']) {
-      tokens[prop] = '';
+      tokens[
+      /**
+       * @type {"start"|"postDelimiter"|"tag"|"type"|"postType"|
+       *   "postTag"|"name"|"postName"|"description"|"end"|"lineEnd"}
+       */
+      prop] = '';
     }
   };
+
+  /**
+   * @param {Integer} sourceIndex
+   * @param {import('comment-parser').Tokens} tokens
+   * @returns {void}
+   */
   utils.addLine = (sourceIndex, tokens) => {
     var _jsdoc$source;
     const number = (((_jsdoc$source = jsdoc.source[sourceIndex - 1]) === null || _jsdoc$source === void 0 ? void 0 : _jsdoc$source.number) || 0) + 1;
@@ -415,10 +609,17 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     // rewireSource(jsdoc);
   };
 
+  /**
+   * @param {Integer} tagIndex
+   * @param {Integer} tagSourceOffset
+   * @param {Integer} numLines
+   * @returns {void}
+   */
   utils.addLines = (tagIndex, tagSourceOffset, numLines) => {
     const {
       source: tagSource
     } = jsdoc.tags[tagIndex];
+    /** @type {Integer|undefined} */
     let lastIndex;
     const firstNumber = jsdoc.source[0].number;
     tagSource.some(({
@@ -464,6 +665,10 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       src.number = firstNumber + lastIndex + idx;
     }
   };
+
+  /**
+   * @returns {void}
+   */
   utils.makeMultiline = () => {
     const {
       source: [{
@@ -517,21 +722,52 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       start: indent + ' '
     });
   };
+
+  /**
+   * @param {} params
+   * @returns {}
+   */
   utils.flattenRoots = params => {
     return _jsdocUtils.default.flattenRoots(params);
   };
+
+  /**
+   * @param {boolean} useDefaultObjectProperties
+   * @returns {}
+   */
   utils.getFunctionParameterNames = useDefaultObjectProperties => {
     return _jsdocUtils.default.getFunctionParameterNames(node, useDefaultObjectProperties);
   };
+
+  /**
+   * @returns {Integer}
+   */
   utils.hasParams = () => {
     return _jsdocUtils.default.hasParams(node);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.isGenerator = () => {
     return node && (node.generator || node.type === 'MethodDefinition' && node.value.generator || ['ExportNamedDeclaration', 'ExportDefaultDeclaration'].includes(node.type) && node.declaration.generator);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.isConstructor = () => {
     return _jsdocUtils.default.isConstructor(node);
   };
+
+  /**
+   * @param {string} tagName
+   * @returns {false|{
+   *   idx: Integer,
+   *   name: string,
+   *   type: string
+   * }[]}
+   */
   utils.getJsdocTagsDeep = tagName => {
     const name = utils.getPreferredTagName({
       tagName
@@ -541,6 +777,15 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     }
     return _jsdocUtils.default.getJsdocTagsDeep(jsdoc, name);
   };
+
+  /**
+   * @param {{
+   *   tagName: string,
+   *   skipReportingBlockedTag?: boolean,
+   *   allowObjectReturn?: boolean,
+   *   defaultMessage?: string
+   * }} cfg
+   */
   utils.getPreferredTagName = ({
     tagName,
     skipReportingBlockedTag = false,
@@ -562,21 +807,51 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     }
     return isObject && !allowObjectReturn ? ret.replacement : ret;
   };
+
+  /**
+   * @param {string} name
+   * @param {string[]} definedTags
+   * @returns {boolean}
+   */
   utils.isValidTag = (name, definedTags) => {
     return _jsdocUtils.default.isValidTag(context, mode, name, definedTags);
   };
+
+  /**
+   * @param {string[]} names
+   * @returns {boolean}
+   */
   utils.hasATag = names => {
     return _jsdocUtils.default.hasATag(jsdoc, names);
   };
+
+  /**
+   * @param {string} name
+   * @returns {boolean}
+   */
   utils.hasTag = name => {
     return _jsdocUtils.default.hasTag(jsdoc, name);
   };
+
+  /**
+   * @param {string} name
+   * @returns {}
+   */
   utils.comparePaths = name => {
     return _jsdocUtils.default.comparePaths(name);
   };
+
+  /**
+   * @param {string} name
+   * @returns {}
+   */
   utils.dropPathSegmentQuotes = name => {
     return _jsdocUtils.default.dropPathSegmentQuotes(name);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.avoidDocs = () => {
     var _context$options$;
     if (ignoreReplacesDocs !== false && (utils.hasTag('ignore') || utils.classHasTag('ignore')) || overrideReplacesDocs !== false && (utils.hasTag('override') || utils.classHasTag('override')) || implementsReplacesDocs !== false && (utils.hasTag('implements') || utils.classHasTag('implements')) || augmentsExtendsReplacesDocs && (utils.hasATag(['augments', 'extends']) || utils.classHasTag('augments') || utils.classHasTag('extends'))) {
@@ -592,8 +867,16 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     return false;
   };
   for (const method of ['tagMightHaveNamePosition', 'tagMightHaveTypePosition']) {
-    utils[method] = (tagName, otherModeMaps) => {
-      const result = _jsdocUtils.default[method](tagName);
+    /**
+     * @param {string} tagName
+     * @param {import('./getDefaultTagStructureForMode.js').
+     *   TagStructure[]} [otherModeMaps]
+     * @returns {boolean|{otherMode: true}}
+     */
+    utils[/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
+    method] = (tagName, otherModeMaps) => {
+      const result = _jsdocUtils.default[/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
+      method](tagName);
       if (result) {
         return true;
       }
@@ -601,7 +884,8 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
         return false;
       }
       const otherResult = otherModeMaps.some(otherModeMap => {
-        return _jsdocUtils.default[method](tagName, otherModeMap);
+        return _jsdocUtils.default[/** @type {"tagMightHaveNamePosition"|"tagMightHaveTypePosition"} */
+        method](tagName, otherModeMap);
       });
       return otherResult ? {
         otherMode: true
@@ -609,8 +893,16 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     };
   }
   for (const method of ['tagMustHaveNamePosition', 'tagMustHaveTypePosition', 'tagMissingRequiredTypeOrNamepath']) {
-    utils[method] = (tagName, otherModeMaps) => {
-      const result = _jsdocUtils.default[method](tagName);
+    /**
+     * @param {string} tagName
+     * @param {import('./getDefaultTagStructureForMode.js').
+     *   TagStructure[]} otherModeMaps
+     * @returns {}
+     */
+    utils[/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"|"tagMissingRequiredTypeOrNamepath"} */
+    method] = (tagName, otherModeMaps) => {
+      const result = _jsdocUtils.default[/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"|"tagMissingRequiredTypeOrNamepath"} */
+      method](tagName);
       if (!result) {
         return false;
       }
@@ -618,7 +910,8 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
       // if (!otherModeMaps) { return true; }
 
       const otherResult = otherModeMaps.every(otherModeMap => {
-        return _jsdocUtils.default[method](tagName, otherModeMap);
+        return _jsdocUtils.default[/** @type {"tagMustHaveNamePosition"|"tagMustHaveTypePosition"|"tagMissingRequiredTypeOrNamepath"} */
+        method](tagName, otherModeMap);
       });
       return otherResult ? true : {
         otherMode: false
@@ -626,31 +919,61 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     };
   }
   for (const method of ['isNamepathDefiningTag', 'isNamepathReferencingTag', 'isNamepathOrUrlReferencingTag', 'tagMightHaveNamepath']) {
+    /**
+     * @param {string} tagName
+     * @returns {}
+     */
     utils[method] = tagName => {
       return _jsdocUtils.default[method](tagName);
     };
   }
+
+  /**
+   * @param {import('./jsdocUtils.js').ParserMode} mde
+   * @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
+   */
   utils.getTagStructureForMode = mde => {
     return _jsdocUtils.default.getTagStructureForMode(mde, settings.structuredTags);
   };
+
+  /**
+   * @param {} tag
+   * @returns {}
+   */
   utils.mayBeUndefinedTypeTag = tag => {
     return _jsdocUtils.default.mayBeUndefinedTypeTag(tag, settings.mode);
   };
   utils.hasValueOrExecutorHasNonEmptyResolveValue = (anyPromiseAsReturn, allBranches) => {
     return _jsdocUtils.default.hasValueOrExecutorHasNonEmptyResolveValue(node, anyPromiseAsReturn, allBranches);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.hasYieldValue = () => {
     if (['ExportNamedDeclaration', 'ExportDefaultDeclaration'].includes(node.type)) {
       return _jsdocUtils.default.hasYieldValue(node.declaration);
     }
     return _jsdocUtils.default.hasYieldValue(node);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.hasYieldReturnValue = () => {
     return _jsdocUtils.default.hasYieldValue(node, true);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.hasThrowValue = () => {
     return _jsdocUtils.default.hasThrowValue(node);
   };
+
+  /**
+   * @returns {boolean}
+   */
   utils.isAsync = () => {
     return node.async;
   };
@@ -668,9 +991,19 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
     const tags = _jsdocUtils.default.getAllTags(jsdoc, includeInlineTags);
     return _jsdocUtils.default.filterTags(tags, filter);
   };
+
+  /**
+   * @param {import('comment-parser').Spec[]} tags
+   * @returns {}
+   */
   utils.getTagsByType = tags => {
     return _jsdocUtils.default.getTagsByType(context, mode, tags, tagNamePreference);
   };
+
+  /**
+   * @param {string} tagName
+   * @returns {boolean}
+   */
   utils.hasOptionTag = tagName => {
     const {
       tags
@@ -719,6 +1052,21 @@ const getUtils = (node, jsdoc, jsdocNode, settings, report, context, iteratingAl
   };
   return utils;
 };
+
+/* eslint-disable jsdoc/valid-types -- Old version */
+/**
+ * Settings from ESLint types.
+ *
+ * @typedef {{
+ *   [name: string]: any
+ * }} Settings
+ */
+/* eslint-enable jsdoc/valid-types -- Old version */
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @returns {Settings}
+ */
 const getSettings = context => {
   var _context$settings$jsd, _context$settings$jsd2, _context$settings$jsd3, _context$settings$jsd4, _context$settings$jsd5, _context$settings$jsd6, _context$settings$jsd7, _context$settings$jsd8, _context$settings$jsd9, _context$settings$jsd10, _context$settings$jsd11, _context$settings$jsd12, _context$settings$jsd13, _context$settings$jsd14;
   /* eslint-disable canonical/sort-keys */
@@ -770,12 +1118,23 @@ const getSettings = context => {
 /**
  * Create the report function
  *
- * @param {object} context
+ * @param {import('eslint').Rule.RuleContext} context
  * @param {object} commentNode
  */
 exports.getSettings = getSettings;
 const makeReport = (context, commentNode) => {
-  const report = (message, fix = null, jsdocLoc = null, data = null) => {
+  /* eslint-disable jsdoc/valid-types -- Old version */
+  /**
+   * @param {string} message
+   * @param {import('eslint').Rule.ReportFixer|null} fix
+   * @param {} jsdocLoc
+   * @param {undefined|{
+   *   [key: string]: string
+   * }} data
+   * @returns {void}
+   */
+  const report = (message, fix = null, jsdocLoc = null, data = undefined) => {
+    /* eslint-enable jsdoc/valid-types -- Old version */
     let loc;
     if (jsdocLoc) {
       if (!('line' in jsdocLoc)) {
@@ -815,11 +1174,10 @@ const makeReport = (context, commentNode) => {
 /* eslint-disable jsdoc/no-undefined-types -- canonical still using an older version where not defined */
 /**
  * @typedef {ReturnType<typeof getUtils>} Utils
- * @typedef {ReturnType<typeof getSettings>} Settings
  * @typedef {(
  *   arg: {
- *     context: object,
- *     sourceCode: object,
+ *     context: import('eslint').Rule.RuleContext,
+ *     sourceCode: import('eslint').SourceCode,
  *     indent: string,
  *     jsdoc: object,
  *     jsdocNode: object,
@@ -832,6 +1190,21 @@ const makeReport = (context, commentNode) => {
  */
 /* eslint-enable jsdoc/no-undefined-types -- canonical still using an older version where not defined */
 
+/**
+ * @param {} info
+ * @param {} indent
+ * @param {import('comment-parser').Block} jsdoc
+ * @param {} ruleConfig
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {} lines
+ * @param {import('@es-joy/jsdoccomment').Token} jsdocNode
+ * @param {} node
+ * @param {Settings} settings
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {} iterator
+ * @param {} state
+ * @param {boolean} iteratingAll
+ */
 const iterate = (info, indent, jsdoc, ruleConfig, context, lines, jsdocNode, node, settings, sourceCode, iterator, state, iteratingAll) => {
   const report = makeReport(context, jsdocNode);
   const utils = getUtils(node, jsdoc, jsdocNode, settings, report, context, iteratingAll, ruleConfig, indent);
@@ -865,6 +1238,14 @@ const iterate = (info, indent, jsdoc, ruleConfig, context, lines, jsdocNode, nod
     utils
   });
 };
+
+/**
+ * @param {} lines
+ * @param {import('@es-joy/jsdoccomment').Token} jsdocNode
+ * @returns {[indent: string, jsdoc: import('comment-parser').Block & {
+ *   inlineTags: import('@es-joy/jsdoccomment').JsdocInlineTagNoType[]
+ * }]}
+ */
 const getIndentAndJSDoc = function (lines, jsdocNode) {
   const sourceLine = lines[jsdocNode.loc.start.line - 1];
   const indnt = sourceLine.charAt(0).repeat(jsdocNode.loc.start.column);
@@ -877,13 +1258,6 @@ const getIndentAndJSDoc = function (lines, jsdocNode) {
  * @typedef {{node: Node, state: StateObject}} NonCommentArgs
  */
 
-/**
- * Our internal dynamic set of utilities.
- *
- * @todo Document
- * @typedef {any} Utils
- */
-
 /**
  * @typedef {object} RuleConfig
  * @property {EslintRuleMeta} meta ESLint rule meta
@@ -907,6 +1281,7 @@ const getIndentAndJSDoc = function (lines, jsdocNode) {
  * @param {boolean} additiveCommentContexts If true, will have a separate
  *   iteration for each matching comment context. Otherwise, will iterate
  *   once if there is a single matching comment context.
+ * @returns {import('eslint').Rule.RuleModule}
  */
 const iterateAllJsdocs = (iterator, ruleConfig, contexts, additiveCommentContexts) => {
   const trackedJsdocs = new Set();
@@ -1016,6 +1391,7 @@ const iterateAllJsdocs = (iterator, ruleConfig, contexts, additiveCommentContext
  *
  * @param {JsdocVisitor} iterator
  * @param {RuleConfig} ruleConfig
+ * @returns {import('eslint').Rule.RuleModule}
  */
 const checkFile = (iterator, ruleConfig) => {
   return {
@@ -1050,6 +1426,7 @@ const checkFile = (iterator, ruleConfig) => {
 /**
  * @param {JsdocVisitor} iterator
  * @param {RuleConfig} ruleConfig
+ * @returns {import('eslint').Rule.RuleModule}
  */
 function iterateJsdoc(iterator, ruleConfig) {
   var _ruleConfig$meta;
@@ -1066,14 +1443,16 @@ function iterateJsdoc(iterator, ruleConfig) {
   if (ruleConfig.iterateAllJsdocs) {
     return iterateAllJsdocs(iterator, ruleConfig);
   }
+
+  /** @type {import('eslint').Rule.RuleModule} */
   return {
     /**
      * The entrypoint for the JSDoc rule.
      *
-     * @param {*} context
+     * @param {import('eslint').Rule.RuleContext} context
      *   a reference to the context which hold all important information
      *   like settings and the sourcecode to check.
-     * @returns {object}
+     * @returns {import('eslint').Rule.RuleListener}
      *   a list with parser callback function.
      */
     create(context) {