@kazupon/eslint-config 0.7.0 → 0.9.0

package/dist/types/gens/jsdoc.d.ts

@@ -0,0 +1,744 @@
+import type { Linter } from 'eslint';
+export interface JsdocRules {
+    /**
+     * Checks that `@access` tags have a valid value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-access.md#repos-sticky-header
+     */
+    'jsdoc/check-access'?: Linter.RuleEntry<[]>;
+    /**
+     * Reports invalid alignment of JSDoc block asterisks.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-alignment.md#repos-sticky-header
+     */
+    'jsdoc/check-alignment'?: Linter.RuleEntry<[]>;
+    /**
+     * Ensures that (JavaScript) examples within JSDoc adhere to ESLint rules.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-examples.md#repos-sticky-header
+     */
+    'jsdoc/check-examples'?: Linter.RuleEntry<JsdocCheckExamples>;
+    /**
+     * Reports invalid padding inside JSDoc blocks.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-indentation.md#repos-sticky-header
+     */
+    'jsdoc/check-indentation'?: Linter.RuleEntry<JsdocCheckIndentation>;
+    /**
+     * Reports invalid alignment of JSDoc block lines.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-line-alignment.md#repos-sticky-header
+     */
+    'jsdoc/check-line-alignment'?: Linter.RuleEntry<JsdocCheckLineAlignment>;
+    /**
+     * Ensures that parameter names in JSDoc match those in the function declaration.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-param-names.md#repos-sticky-header
+     */
+    'jsdoc/check-param-names'?: Linter.RuleEntry<JsdocCheckParamNames>;
+    /**
+     * Ensures that property names in JSDoc are not duplicated on the same block and that nested properties have defined roots.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-property-names.md#repos-sticky-header
+     */
+    'jsdoc/check-property-names'?: Linter.RuleEntry<JsdocCheckPropertyNames>;
+    /**
+     * Reports against syntax not valid for the mode (e.g., Google Closure Compiler in non-Closure mode).
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-syntax.md#repos-sticky-header
+     */
+    'jsdoc/check-syntax'?: Linter.RuleEntry<[]>;
+    /**
+     * Reports invalid block tag names.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-tag-names.md#repos-sticky-header
+     */
+    'jsdoc/check-tag-names'?: Linter.RuleEntry<JsdocCheckTagNames>;
+    /**
+     * Reports invalid types.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-types.md#repos-sticky-header
+     */
+    'jsdoc/check-types'?: Linter.RuleEntry<JsdocCheckTypes>;
+    /**
+     * This rule checks the values for a handful of tags: `@version`, `@since`, `@license` and `@author`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-values.md#repos-sticky-header
+     */
+    'jsdoc/check-values'?: Linter.RuleEntry<JsdocCheckValues>;
+    /**
+     * Expects specific tags to be empty of any content.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/empty-tags.md#repos-sticky-header
+     */
+    'jsdoc/empty-tags'?: Linter.RuleEntry<JsdocEmptyTags>;
+    /**
+     * Reports an issue with any non-constructor function using `@implements`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/implements-on-classes.md#repos-sticky-header
+     */
+    'jsdoc/implements-on-classes'?: Linter.RuleEntry<JsdocImplementsOnClasses>;
+    /**
+     * Reports if JSDoc `import()` statements point to a package which is not listed in `dependencies` or `devDependencies`
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/imports-as-dependencies.md#repos-sticky-header
+     */
+    'jsdoc/imports-as-dependencies'?: Linter.RuleEntry<[]>;
+    /**
+     * This rule reports doc comments that only restate their attached name.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/informative-docs.md#repos-sticky-header
+     */
+    'jsdoc/informative-docs'?: Linter.RuleEntry<JsdocInformativeDocs>;
+    /**
+     * Enforces a regular expression pattern on descriptions.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/match-description.md#repos-sticky-header
+     */
+    'jsdoc/match-description'?: Linter.RuleEntry<JsdocMatchDescription>;
+    /**
+     * Reports the name portion of a JSDoc tag if matching or not matching a given regular expression.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/match-name.md#repos-sticky-header
+     */
+    'jsdoc/match-name'?: Linter.RuleEntry<JsdocMatchName>;
+    /**
+     * Controls how and whether jsdoc blocks can be expressed as single or multiple line blocks.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/multiline-blocks.md#repos-sticky-header
+     */
+    'jsdoc/multiline-blocks'?: Linter.RuleEntry<JsdocMultilineBlocks>;
+    /**
+     * This rule checks for multi-line-style comments which fail to meet the criteria of a jsdoc block.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-bad-blocks.md#repos-sticky-header
+     */
+    'jsdoc/no-bad-blocks'?: Linter.RuleEntry<JsdocNoBadBlocks>;
+    /**
+     * Detects and removes extra lines of a blank block description
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-blank-block-descriptions.md#repos-sticky-header
+     */
+    'jsdoc/no-blank-block-descriptions'?: Linter.RuleEntry<[]>;
+    /**
+     * Removes empty blocks with nothing but possibly line breaks
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-blank-blocks.md#repos-sticky-header
+     */
+    'jsdoc/no-blank-blocks'?: Linter.RuleEntry<JsdocNoBlankBlocks>;
+    /**
+     * This rule reports defaults being used on the relevant portion of `@param` or `@default`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-defaults.md#repos-sticky-header
+     */
+    'jsdoc/no-defaults'?: Linter.RuleEntry<JsdocNoDefaults>;
+    /**
+     * Reports when certain comment structures are always expected.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-missing-syntax.md#repos-sticky-header
+     */
+    'jsdoc/no-missing-syntax'?: Linter.RuleEntry<JsdocNoMissingSyntax>;
+    /**
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-multi-asterisks.md#repos-sticky-header
+     */
+    'jsdoc/no-multi-asterisks'?: Linter.RuleEntry<JsdocNoMultiAsterisks>;
+    /**
+     * Reports when certain comment structures are present.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-restricted-syntax.md#repos-sticky-header
+     */
+    'jsdoc/no-restricted-syntax'?: Linter.RuleEntry<JsdocNoRestrictedSyntax>;
+    /**
+     * This rule reports types being used on `@param` or `@returns`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-types.md#repos-sticky-header
+     */
+    'jsdoc/no-types'?: Linter.RuleEntry<JsdocNoTypes>;
+    /**
+     * Checks that types in jsdoc comments are defined.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-undefined-types.md#repos-sticky-header
+     */
+    'jsdoc/no-undefined-types'?: Linter.RuleEntry<JsdocNoUndefinedTypes>;
+    /**
+     * Requires that each JSDoc line starts with an `*`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-asterisk-prefix.md#repos-sticky-header
+     */
+    'jsdoc/require-asterisk-prefix'?: Linter.RuleEntry<JsdocRequireAsteriskPrefix>;
+    /**
+     * Requires that all functions have a description.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-description.md#repos-sticky-header
+     */
+    'jsdoc/require-description'?: Linter.RuleEntry<JsdocRequireDescription>;
+    /**
+     * Requires that block description, explicit `@description`, and `@param`/`@returns` tag descriptions are written in complete sentences.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-description-complete-sentence.md#repos-sticky-header
+     */
+    'jsdoc/require-description-complete-sentence'?: Linter.RuleEntry<JsdocRequireDescriptionCompleteSentence>;
+    /**
+     * Requires that all functions have examples.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-example.md#repos-sticky-header
+     */
+    'jsdoc/require-example'?: Linter.RuleEntry<JsdocRequireExample>;
+    /**
+     * Checks that all files have one `@file`, `@fileoverview`, or `@overview` tag at the beginning of the file.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-file-overview.md#repos-sticky-header
+     */
+    'jsdoc/require-file-overview'?: Linter.RuleEntry<JsdocRequireFileOverview>;
+    /**
+     * Requires a hyphen before the `@param` description.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-hyphen-before-param-description.md#repos-sticky-header
+     */
+    'jsdoc/require-hyphen-before-param-description'?: Linter.RuleEntry<JsdocRequireHyphenBeforeParamDescription>;
+    /**
+     * Require JSDoc comments
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-jsdoc.md#repos-sticky-header
+     */
+    'jsdoc/require-jsdoc'?: Linter.RuleEntry<JsdocRequireJsdoc>;
+    /**
+     * Requires that all function parameters are documented.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-param.md#repos-sticky-header
+     */
+    'jsdoc/require-param'?: Linter.RuleEntry<JsdocRequireParam>;
+    /**
+     * Requires that each `@param` tag has a `description` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-param-description.md#repos-sticky-header
+     */
+    'jsdoc/require-param-description'?: Linter.RuleEntry<JsdocRequireParamDescription>;
+    /**
+     * Requires that all function parameters have names.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-param-name.md#repos-sticky-header
+     */
+    'jsdoc/require-param-name'?: Linter.RuleEntry<JsdocRequireParamName>;
+    /**
+     * Requires that each `@param` tag has a `type` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-param-type.md#repos-sticky-header
+     */
+    'jsdoc/require-param-type'?: Linter.RuleEntry<JsdocRequireParamType>;
+    /**
+     * Requires that all `@typedef` and `@namespace` tags have `@property` when their type is a plain `object`, `Object`, or `PlainObject`.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-property.md#repos-sticky-header
+     */
+    'jsdoc/require-property'?: Linter.RuleEntry<[]>;
+    /**
+     * Requires that each `@property` tag has a `description` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-property-description.md#repos-sticky-header
+     */
+    'jsdoc/require-property-description'?: Linter.RuleEntry<[]>;
+    /**
+     * Requires that all function `@property` tags have names.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-property-name.md#repos-sticky-header
+     */
+    'jsdoc/require-property-name'?: Linter.RuleEntry<[]>;
+    /**
+     * Requires that each `@property` tag has a `type` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-property-type.md#repos-sticky-header
+     */
+    'jsdoc/require-property-type'?: Linter.RuleEntry<[]>;
+    /**
+     * Requires that returns are documented.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns.md#repos-sticky-header
+     */
+    'jsdoc/require-returns'?: Linter.RuleEntry<JsdocRequireReturns>;
+    /**
+     * Requires a return statement in function body if a `@returns` tag is specified in jsdoc comment.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-check.md#repos-sticky-header
+     */
+    'jsdoc/require-returns-check'?: Linter.RuleEntry<JsdocRequireReturnsCheck>;
+    /**
+     * Requires that the `@returns` tag has a `description` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-description.md#repos-sticky-header
+     */
+    'jsdoc/require-returns-description'?: Linter.RuleEntry<JsdocRequireReturnsDescription>;
+    /**
+     * Requires that `@returns` tag has `type` value.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-type.md#repos-sticky-header
+     */
+    'jsdoc/require-returns-type'?: Linter.RuleEntry<JsdocRequireReturnsType>;
+    /**
+     * Requires that throw statements are documented.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-throws.md#repos-sticky-header
+     */
+    'jsdoc/require-throws'?: Linter.RuleEntry<JsdocRequireThrows>;
+    /**
+     * Requires yields are documented.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-yields.md#repos-sticky-header
+     */
+    'jsdoc/require-yields'?: Linter.RuleEntry<JsdocRequireYields>;
+    /**
+     * Requires a yield statement in function body if a `@yields` tag is specified in jsdoc comment.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-yields-check.md#repos-sticky-header
+     */
+    'jsdoc/require-yields-check'?: Linter.RuleEntry<JsdocRequireYieldsCheck>;
+    /**
+     * Sorts tags by a specified sequence according to tag name.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/sort-tags.md#repos-sticky-header
+     */
+    'jsdoc/sort-tags'?: Linter.RuleEntry<JsdocSortTags>;
+    /**
+     * Enforces lines (or no lines) between tags.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/tag-lines.md#repos-sticky-header
+     */
+    'jsdoc/tag-lines'?: Linter.RuleEntry<JsdocTagLines>;
+    /**
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/text-escaping.md#repos-sticky-header
+     */
+    'jsdoc/text-escaping'?: Linter.RuleEntry<JsdocTextEscaping>;
+    /**
+     * Requires all types to be valid JSDoc or Closure compiler types without syntax errors.
+     * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/valid-types.md#repos-sticky-header
+     */
+    'jsdoc/valid-types'?: Linter.RuleEntry<JsdocValidTypes>;
+}
+type JsdocCheckExamples = [] | [
+    {
+        allowInlineConfig?: boolean;
+        baseConfig?: {
+            [k: string]: unknown | undefined;
+        };
+        captionRequired?: boolean;
+        checkDefaults?: boolean;
+        checkEslintrc?: boolean;
+        checkParams?: boolean;
+        checkProperties?: boolean;
+        configFile?: string;
+        exampleCodeRegex?: string;
+        matchingFileName?: string;
+        matchingFileNameDefaults?: string;
+        matchingFileNameParams?: string;
+        matchingFileNameProperties?: string;
+        noDefaultExampleRules?: boolean;
+        paddedIndent?: number;
+        rejectExampleCodeRegex?: string;
+        reportUnusedDisableDirectives?: boolean;
+    }
+];
+type JsdocCheckIndentation = [] | [
+    {
+        excludeTags?: string[];
+    }
+];
+type JsdocCheckLineAlignment = [] | [("always" | "never" | "any")] | [
+    ("always" | "never" | "any"),
+    {
+        customSpacings?: {
+            postDelimiter?: number;
+            postHyphen?: number;
+            postName?: number;
+            postTag?: number;
+            postType?: number;
+        };
+        preserveMainDescriptionPostDelimiter?: boolean;
+        tags?: string[];
+        wrapIndent?: string;
+        disableWrapIndent?: boolean;
+    }
+];
+type JsdocCheckParamNames = [] | [
+    {
+        allowExtraTrailingParamDocs?: boolean;
+        checkDestructured?: boolean;
+        checkRestProperty?: boolean;
+        checkTypesPattern?: string;
+        disableExtraPropertyReporting?: boolean;
+        disableMissingParamChecks?: boolean;
+        enableFixer?: boolean;
+        useDefaultObjectProperties?: boolean;
+    }
+];
+type JsdocCheckPropertyNames = [] | [
+    {
+        enableFixer?: boolean;
+    }
+];
+type JsdocCheckTagNames = [] | [
+    {
+        definedTags?: string[];
+        enableFixer?: boolean;
+        jsxTags?: boolean;
+        typed?: boolean;
+    }
+];
+type JsdocCheckTypes = [] | [
+    {
+        exemptTagContexts?: {
+            tag?: string;
+            types?: (boolean | string[]);
+        }[];
+        noDefaults?: boolean;
+        unifyParentAndChildTypeChecks?: boolean;
+    }
+];
+type JsdocCheckValues = [] | [
+    {
+        allowedAuthors?: string[];
+        allowedLicenses?: (string[] | boolean);
+        licensePattern?: string;
+        numericOnlyVariation?: boolean;
+    }
+];
+type JsdocEmptyTags = [] | [
+    {
+        tags?: string[];
+    }
+];
+type JsdocImplementsOnClasses = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+    }
+];
+type JsdocInformativeDocs = [] | [
+    {
+        aliases?: {
+            [k: string]: string[];
+        };
+        excludedTags?: string[];
+        uselessWords?: string[];
+    }
+];
+type JsdocMatchDescription = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        mainDescription?: (string | boolean | {
+            match?: (string | boolean);
+            message?: string;
+        });
+        matchDescription?: string;
+        message?: string;
+        nonemptyTags?: boolean;
+        tags?: {
+            [k: string]: (string | true | {
+                match?: (string | true);
+                message?: string;
+            });
+        };
+    }
+];
+type JsdocMatchName = [] | [
+    {
+        match: {
+            allowName?: string;
+            comment?: string;
+            context?: string;
+            disallowName?: string;
+            message?: string;
+            tags?: string[];
+            [k: string]: unknown | undefined;
+        }[];
+    }
+];
+type JsdocMultilineBlocks = [] | [
+    {
+        allowMultipleTags?: boolean;
+        minimumLengthForMultiline?: number;
+        multilineTags?: ("*" | string[]);
+        noFinalLineText?: boolean;
+        noMultilineBlocks?: boolean;
+        noSingleLineBlocks?: boolean;
+        noZeroLineText?: boolean;
+        singleLineTags?: string[];
+    }
+];
+type JsdocNoBadBlocks = [] | [
+    {
+        ignore?: string[];
+        preventAllMultiAsteriskBlocks?: boolean;
+    }
+];
+type JsdocNoBlankBlocks = [] | [
+    {
+        enableFixer?: boolean;
+    }
+];
+type JsdocNoDefaults = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        noOptionalParamNames?: boolean;
+    }
+];
+type JsdocNoMissingSyntax = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+            message?: string;
+            minimum?: number;
+        })[];
+    }
+];
+type JsdocNoMultiAsterisks = [] | [
+    {
+        allowWhitespace?: boolean;
+        preventAtEnd?: boolean;
+        preventAtMiddleLines?: boolean;
+    }
+];
+type JsdocNoRestrictedSyntax = [] | [
+    {
+        contexts: (string | {
+            comment?: string;
+            context?: string;
+            message?: string;
+        })[];
+    }
+];
+type JsdocNoTypes = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+    }
+];
+type JsdocNoUndefinedTypes = [] | [
+    {
+        definedTypes?: string[];
+        disableReporting?: boolean;
+        markVariablesAsUsed?: boolean;
+    }
+];
+type JsdocRequireAsteriskPrefix = [] | [("always" | "never" | "any")] | [
+    ("always" | "never" | "any"),
+    {
+        tags?: {
+            always?: string[];
+            any?: string[];
+            never?: string[];
+            [k: string]: unknown | undefined;
+        };
+    }
+];
+type JsdocRequireDescription = [] | [
+    {
+        checkConstructors?: boolean;
+        checkGetters?: boolean;
+        checkSetters?: boolean;
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        descriptionStyle?: ("body" | "tag" | "any");
+        exemptedBy?: string[];
+    }
+];
+type JsdocRequireDescriptionCompleteSentence = [] | [
+    {
+        abbreviations?: string[];
+        newlineBeforeCapsAssumesBadSentenceEnd?: boolean;
+        tags?: string[];
+    }
+];
+type JsdocRequireExample = [] | [
+    {
+        checkConstructors?: boolean;
+        checkGetters?: boolean;
+        checkSetters?: boolean;
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        enableFixer?: boolean;
+        exemptedBy?: string[];
+        exemptNoArguments?: boolean;
+    }
+];
+type JsdocRequireFileOverview = [] | [
+    {
+        tags?: {
+            [k: string]: {
+                initialCommentsOnly?: boolean;
+                mustExist?: boolean;
+                preventDuplicates?: boolean;
+            };
+        };
+    }
+];
+type JsdocRequireHyphenBeforeParamDescription = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        tags?: ({
+            [k: string]: ("always" | "never");
+        } | "any");
+    }
+];
+type JsdocRequireJsdoc = [] | [
+    {
+        checkConstructors?: boolean;
+        checkGetters?: (boolean | "no-setter");
+        checkSetters?: (boolean | "no-getter");
+        contexts?: (string | {
+            context?: string;
+            inlineCommentBlock?: boolean;
+            minLineCount?: number;
+        })[];
+        enableFixer?: boolean;
+        exemptEmptyConstructors?: boolean;
+        exemptEmptyFunctions?: boolean;
+        fixerMessage?: string;
+        minLineCount?: number;
+        publicOnly?: (boolean | {
+            ancestorsOnly?: boolean;
+            cjs?: boolean;
+            esm?: boolean;
+            window?: boolean;
+        });
+        require?: {
+            ArrowFunctionExpression?: boolean;
+            ClassDeclaration?: boolean;
+            ClassExpression?: boolean;
+            FunctionDeclaration?: boolean;
+            FunctionExpression?: boolean;
+            MethodDefinition?: boolean;
+        };
+    }
+];
+type JsdocRequireParam = [] | [
+    {
+        autoIncrementBase?: number;
+        checkConstructors?: boolean;
+        checkDestructured?: boolean;
+        checkDestructuredRoots?: boolean;
+        checkGetters?: boolean;
+        checkRestProperty?: boolean;
+        checkSetters?: boolean;
+        checkTypesPattern?: string;
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        enableFixer?: boolean;
+        enableRestElementFixer?: boolean;
+        enableRootFixer?: boolean;
+        exemptedBy?: string[];
+        unnamedRootBase?: string[];
+        useDefaultObjectProperties?: boolean;
+    }
+];
+type JsdocRequireParamDescription = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        defaultDestructuredRootDescription?: string;
+        setDefaultDestructuredRootDescription?: boolean;
+    }
+];
+type JsdocRequireParamName = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+    }
+];
+type JsdocRequireParamType = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        defaultDestructuredRootType?: string;
+        setDefaultDestructuredRootType?: boolean;
+    }
+];
+type JsdocRequireReturns = [] | [
+    {
+        checkConstructors?: boolean;
+        checkGetters?: boolean;
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+            forceRequireReturn?: boolean;
+        })[];
+        enableFixer?: boolean;
+        exemptedBy?: string[];
+        forceRequireReturn?: boolean;
+        forceReturnsWithAsync?: boolean;
+        publicOnly?: (boolean | {
+            ancestorsOnly?: boolean;
+            cjs?: boolean;
+            esm?: boolean;
+            window?: boolean;
+        });
+    }
+];
+type JsdocRequireReturnsCheck = [] | [
+    {
+        exemptAsync?: boolean;
+        exemptGenerators?: boolean;
+        reportMissingReturnForUndefinedTypes?: boolean;
+    }
+];
+type JsdocRequireReturnsDescription = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+    }
+];
+type JsdocRequireReturnsType = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+    }
+];
+type JsdocRequireThrows = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        exemptedBy?: string[];
+    }
+];
+type JsdocRequireYields = [] | [
+    {
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        exemptedBy?: string[];
+        forceRequireNext?: boolean;
+        forceRequireYields?: boolean;
+        next?: boolean;
+        nextWithGeneratorTag?: boolean;
+        withGeneratorTag?: boolean;
+    }
+];
+type JsdocRequireYieldsCheck = [] | [
+    {
+        checkGeneratorsOnly?: boolean;
+        contexts?: (string | {
+            comment?: string;
+            context?: string;
+        })[];
+        exemptedBy?: string[];
+        next?: boolean;
+    }
+];
+type JsdocSortTags = [] | [
+    {
+        alphabetizeExtras?: boolean;
+        linesBetween?: number;
+        reportIntraTagGroupSpacing?: boolean;
+        reportTagGroupSpacing?: boolean;
+        tagSequence?: {
+            tags?: string[];
+            [k: string]: unknown | undefined;
+        }[];
+    }
+];
+type JsdocTagLines = [] | [("always" | "any" | "never")] | [
+    ("always" | "any" | "never"),
+    {
+        applyToEndTag?: boolean;
+        count?: number;
+        endLines?: (number | null);
+        startLines?: (number | null);
+        tags?: {
+            [k: string]: {
+                count?: number;
+                lines?: ("always" | "never" | "any");
+            };
+        };
+    }
+];
+type JsdocTextEscaping = [] | [
+    {
+        escapeHTML?: boolean;
+        escapeMarkdown?: boolean;
+    }
+];
+type JsdocValidTypes = [] | [
+    {
+        allowEmptyNamepaths?: boolean;
+    }
+];
+export {};