@w5s/eslint-config 3.5.6 → 3.7.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { ESLintIgnoreOptions } from "@w5s/eslint-config-ignore";
 import { Linter } from "eslint";
 import { StylisticCustomizeOptions } from "@stylistic/eslint-plugin";
 
@@ -44,19 +45,169 @@ interface PluginOptionsBase<Rules> {
    * Plugin rules
    */
   rules?: Rules;
+  /**
+   * Include recommended settings
+   */
+  recommended?: boolean;
   /**
    * Stylistic options
    */
   stylistic?: boolean | StylisticParameters;
 }
 //#endregion
+//#region src/typegen/e18e.d.ts
+declare module 'eslint' {
+  namespace Linter {
+    interface RulesRecord extends RuleOptions$11 {}
+  }
+}
+interface RuleOptions$11 {
+  /**
+   * Disallow dependencies in favor of more performant or secure alternatives
+   */
+  'e18e/ban-dependencies'?: Linter.RuleEntry<E18EBanDependencies>;
+  /**
+   * Disallow `delete` on properties — V8 deoptimizes the object to dictionary mode
+   */
+  'e18e/no-delete-property'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer optimized alternatives to `indexOf()` equality checks
+   */
+  'e18e/no-indexof-equality'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallow spreading the accumulator inside a `reduce` callback (O(N²) growth)
+   */
+  'e18e/no-spread-in-reduce'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.prototype.at() over length-based indexing
+   */
+  'e18e/prefer-array-at'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.prototype.fill() over Array.from or map with constant values
+   */
+  'e18e/prefer-array-fill'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.from(iterable, mapper) over [...iterable].map(mapper) to avoid intermediate array allocation
+   */
+  'e18e/prefer-array-from-map'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.some() over Array.find() and Array.filter().length checks when checking for element existence
+   */
+  'e18e/prefer-array-some'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.prototype.toReversed() over copying and reversing arrays
+   */
+  'e18e/prefer-array-to-reversed'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.prototype.toSorted() over copying and sorting arrays
+   */
+  'e18e/prefer-array-to-sorted'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Array.prototype.toSpliced() over copying and splicing arrays
+   */
+  'e18e/prefer-array-to-spliced'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Date.now() over new Date().getTime() and +new Date()
+   */
+  'e18e/prefer-date-now'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer the exponentiation operator ** over Math.pow()
+   */
+  'e18e/prefer-exponentiation-operator'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer .includes() over indexOf() comparisons for arrays and strings
+   */
+  'e18e/prefer-includes'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer String.prototype.{includes,startsWith,endsWith} over equivalent regex.test() calls
+   */
+  'e18e/prefer-includes-over-regex-test'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer inline equality checks over temporary object creation for simple comparisons
+   */
+  'e18e/prefer-inline-equality'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer nullish coalescing operator (?? and ??=) over verbose null checks
+   */
+  'e18e/prefer-nullish-coalescing'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() and obj.hasOwnProperty()
+   */
+  'e18e/prefer-object-has-own'?: Linter.RuleEntry<[]>;
+  /**
+   * prefer `RegExp.test()` over `String.match()` and `RegExp.exec()` when only checking for match existence
+   */
+  'e18e/prefer-regex-test'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer spread syntax over Array.concat(), Array.from(), Object.assign({}, ...), and Function.apply()
+   */
+  'e18e/prefer-spread-syntax'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer hoisting an `Intl.Collator` instance over calling localeCompare in a sort callback
+   */
+  'e18e/prefer-static-collator'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer defining regular expressions at module scope to avoid re-compilation on every function call
+   */
+  'e18e/prefer-static-regex'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer String.fromCharCode() over String.fromCodePoint() for code points below 0x10000
+   */
+  'e18e/prefer-string-fromcharcode'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer passing function and arguments directly to setTimeout/setInterval instead of wrapping in an arrow function or using bind
+   */
+  'e18e/prefer-timer-args'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer URL.canParse() over try-catch blocks for URL validation
+   */
+  'e18e/prefer-url-canparse'?: Linter.RuleEntry<[]>;
+}
+/* ======= Declarations ======= */
+// ----- e18e/ban-dependencies -----
+type E18EBanDependencies = [] | [{
+  presets?: string[];
+  modules?: string[];
+  allowed?: string[];
+}];
+//#endregion
+//#region src/config/e18e.d.ts
+/**
+ * @see https://e18e.dev
+ * @param options
+ */
+declare function e18e(options?: e18e.Options): Promise<[Config, Config]>;
+declare namespace e18e {
+  type Rules = RuleOptions$11;
+  interface Options extends PluginOptionsBase<Rules> {
+    /**
+     * Include modernization default configuration
+     *
+     * @default true
+     */
+    modernization?: boolean;
+    /**
+     * Include moduleReplacements default configuration
+     *
+     * @default false
+     */
+    moduleReplacements?: boolean;
+    /**
+     * Include performanceImprovements default configuration
+     *
+     * @default true
+     */
+    performanceImprovements?: boolean;
+  }
+}
+//#endregion
 //#region src/typegen/jsonc.d.ts
 declare module 'eslint' {
   namespace Linter {
-    interface RulesRecord extends RuleOptions$9 {}
+    interface RulesRecord extends RuleOptions$10 {}
   }
 }
-interface RuleOptions$9 {
+interface RuleOptions$10 {
   /**
    * enforce line breaks after opening and before closing array brackets
    * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-bracket-newline.html
@@ -532,28 +683,359 @@ type JsoncSpaceUnaryOps = [] | [{
 //#region src/config/es.d.ts
 declare function es(options: es.Options): Promise<[Config, Config]>;
 declare namespace es {
-  type Rules = RuleOptions$9;
+  var recommended: {
+    'class-methods-use-this': "off";
+    'default-case': "off";
+    'no-console': "error";
+    'no-nested-ternary': "off";
+    'no-param-reassign': ["error", {
+      props: boolean;
+    }];
+    'no-underscore-dangle': "off";
+    'no-unused-vars': ["error", {
+      argsIgnorePattern: string;
+    }];
+    'no-use-before-define': ["error", string];
+    'no-void': ["error", {
+      allowAsStatement: boolean;
+    }];
+    'unicode-bom': ["error", string];
+    'init-declarations': "off";
+    'no-catch-shadow': "off";
+    'no-delete-var': "error";
+    'no-label-var': "error";
+    'no-restricted-globals': ["error", {
+      name: string;
+      message: string;
+    }, {
+      name: string;
+      message: string;
+    }];
+    'no-shadow': "error";
+    'no-shadow-restricted-names': "error";
+    'no-undef': "error";
+    'no-undef-init': "error";
+    'no-undefined': "off";
+    strict: ["error", string];
+    'arrow-body-style': ["error", string, {
+      requireReturnForObjectLiteral: boolean;
+    }];
+    'arrow-parens': ["error", string];
+    'arrow-spacing': ["error", {
+      before: boolean;
+      after: boolean;
+    }];
+    'constructor-super': "error";
+    'generator-star-spacing': ["error", {
+      before: boolean;
+      after: boolean;
+    }];
+    'no-class-assign': "error";
+    'no-confusing-arrow': ["error", {
+      allowParens: boolean;
+    }];
+    'no-const-assign': "error";
+    'no-dupe-class-members': "error";
+    'no-duplicate-imports': "off";
+    'no-new-symbol': "error";
+    'no-restricted-exports': ["error", {
+      restrictedNamedExports: string[];
+    }];
+    'no-restricted-imports': ["off", {
+      paths: never[];
+      patterns: never[];
+    }];
+    'no-this-before-super': "error";
+    'no-useless-computed-key': "error";
+    'no-useless-constructor': "error";
+    'no-useless-rename': ["error", {
+      ignoreDestructuring: boolean;
+      ignoreImport: boolean;
+      ignoreExport: boolean;
+    }];
+    'no-var': "error";
+    'object-shorthand': ["error", string, {
+      ignoreConstructors: boolean;
+      avoidQuotes: boolean;
+    }];
+    'prefer-arrow-callback': ["error", {
+      allowNamedFunctions: boolean;
+      allowUnboundThis: boolean;
+    }];
+    'prefer-const': ["error", {
+      destructuring: string;
+      ignoreReadBeforeAssign: boolean;
+    }];
+    'prefer-destructuring': ["error", {
+      VariableDeclarator: {
+        array: boolean;
+        object: boolean;
+      };
+      AssignmentExpression: {
+        array: boolean;
+        object: boolean;
+      };
+    }, {
+      enforceForRenamedProperties: boolean;
+    }];
+    'prefer-numeric-literals': "error";
+    'prefer-reflect': "off";
+    'prefer-rest-params': "error";
+    'prefer-spread': "error";
+    'prefer-template': "error";
+    'require-yield': "error";
+    'rest-spread-spacing': ["error", string];
+    'sort-imports': ["off", {
+      ignoreCase: boolean;
+      ignoreDeclarationSort: boolean;
+      ignoreMemberSort: boolean;
+      memberSyntaxSortOrder: string[];
+    }];
+    'symbol-description': "error";
+    'template-curly-spacing': "error";
+    'yield-star-spacing': ["error", string];
+    'for-direction': "error";
+    'getter-return': ["error", {
+      allowImplicit: boolean;
+    }];
+    'no-async-promise-executor': "error";
+    'no-await-in-loop': "error";
+    'no-compare-neg-zero': "error";
+    'no-cond-assign': ["error", string];
+    'no-constant-binary-expression': "off";
+    'no-constant-condition': "warn";
+    'no-control-regex': "error";
+    'no-debugger': "error";
+    'no-dupe-args': "error";
+    'no-dupe-else-if': "error";
+    'no-dupe-keys': "error";
+    'no-duplicate-case': "error";
+    'no-empty': "error";
+    'no-empty-character-class': "error";
+    'no-ex-assign': "error";
+    'no-extra-boolean-cast': "error";
+    'no-extra-parens': ["off", string, {
+      conditionalAssign: boolean;
+      nestedBinaryExpressions: boolean;
+      returnAssign: boolean;
+      ignoreJSX: string;
+      enforceForArrowConditionals: boolean;
+    }];
+    'no-extra-semi': "error";
+    'no-func-assign': "error";
+    'no-import-assign': "error";
+    'no-inner-declarations': "error";
+    'no-invalid-regexp': "error";
+    'no-irregular-whitespace': "error";
+    'no-loss-of-precision': "error";
+    'no-misleading-character-class': "error";
+    'no-obj-calls': "error";
+    'no-new-native-nonconstructor': "off";
+    'no-promise-executor-return': "error";
+    'no-prototype-builtins': "error";
+    'no-regex-spaces': "error";
+    'no-setter-return': "error";
+    'no-sparse-arrays': "error";
+    'no-template-curly-in-string': "error";
+    'no-unexpected-multiline': "error";
+    'no-unreachable': "error";
+    'no-unreachable-loop': ["error", {
+      ignore: never[];
+    }];
+    'no-unsafe-finally': "error";
+    'no-unsafe-negation': "error";
+    'no-unsafe-optional-chaining': ["error", {
+      disallowArithmeticOperators: boolean;
+    }];
+    'no-unused-private-class-members': "off";
+    'no-useless-backreference': "error";
+    'no-negated-in-lhs': "off";
+    'require-atomic-updates': "off";
+    'use-isnan': "error";
+    'valid-jsdoc': "off";
+    'valid-typeof': ["error", {
+      requireStringLiterals: boolean;
+    }];
+    'accessor-pairs': "off";
+    'array-callback-return': ["error", {
+      allowImplicit: boolean;
+    }];
+    'block-scoped-var': "error";
+    complexity: ["off", number];
+    'consistent-return': "error";
+    curly: ["error", string];
+    'default-case-last': "error";
+    'default-param-last': "error";
+    'dot-notation': ["error", {
+      allowKeywords: boolean;
+    }];
+    'dot-location': ["error", string];
+    eqeqeq: ["error", string, {
+      null: string;
+    }];
+    'grouped-accessor-pairs': "error";
+    'guard-for-in': "error";
+    'max-classes-per-file': ["error", number];
+    'no-alert': "warn";
+    'no-caller': "error";
+    'no-case-declarations': "error";
+    'no-constructor-return': "error";
+    'no-div-regex': "off";
+    'no-else-return': ["error", {
+      allowElseIf: boolean;
+    }];
+    'no-empty-function': ["error", {
+      allow: string[];
+    }];
+    'no-empty-pattern': "error";
+    'no-empty-static-block': "off";
+    'no-eq-null': "off";
+    'no-eval': "error";
+    'no-extend-native': "error";
+    'no-extra-bind': "error";
+    'no-extra-label': "error";
+    'no-fallthrough': "error";
+    'no-floating-decimal': "error";
+    'no-global-assign': ["error", {
+      exceptions: never[];
+    }];
+    'no-native-reassign': "off";
+    'no-implicit-coercion': ["off", {
+      boolean: boolean;
+      number: boolean;
+      string: boolean;
+      allow: never[];
+    }];
+    'no-implicit-globals': "off";
+    'no-implied-eval': "error";
+    'no-invalid-this': "off";
+    'no-iterator': "error";
+    'no-labels': ["error", {
+      allowLoop: boolean;
+      allowSwitch: boolean;
+    }];
+    'no-lone-blocks': "error";
+    'no-loop-func': "error";
+    'no-magic-numbers': ["off", {
+      ignore: never[];
+      ignoreArrayIndexes: boolean;
+      enforceConst: boolean;
+      detectObjects: boolean;
+    }];
+    'no-multi-spaces': ["error", {
+      ignoreEOLComments: boolean;
+    }];
+    'no-multi-str': "error";
+    'no-new': "error";
+    'no-new-func': "error";
+    'no-new-wrappers': "error";
+    'no-nonoctal-decimal-escape': "error";
+    'no-object-constructor': "off";
+    'no-octal': "error";
+    'no-octal-escape': "error";
+    'no-proto': "error";
+    'no-redeclare': "error";
+    'no-restricted-properties': ["error", {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }, {
+      property: string;
+      message: string;
+    }, {
+      property: string;
+      message: string;
+    }, {
+      object: string;
+      property: string;
+      message: string;
+    }];
+    'no-return-assign': ["error", string];
+    'no-return-await': "error";
+    'no-script-url': "error";
+    'no-self-assign': ["error", {
+      props: boolean;
+    }];
+    'no-self-compare': "error";
+    'no-sequences': "error";
+    'no-throw-literal': "error";
+    'no-unmodified-loop-condition': "off";
+    'no-unused-expressions': ["error", {
+      allowShortCircuit: boolean;
+      allowTernary: boolean;
+      allowTaggedTemplates: boolean;
+    }];
+    'no-unused-labels': "error";
+    'no-useless-call': "off";
+    'no-useless-catch': "error";
+    'no-useless-concat': "error";
+    'no-useless-escape': "error";
+    'no-useless-return': "error";
+    'no-warning-comments': ["off", {
+      terms: string[];
+      location: string;
+    }];
+    'no-with': "error";
+    'prefer-promise-reject-errors': ["error", {
+      allowEmptyReject: boolean;
+    }];
+    'prefer-named-capture-group': "off";
+    'prefer-object-has-own': "off";
+    'prefer-regex-literals': ["error", {
+      disallowRedundantWrapping: boolean;
+    }];
+    radix: "error";
+    'require-await': "off";
+    'require-unicode-regexp': "off";
+    'vars-on-top': "error";
+    'wrap-iife': ["error", string, {
+      functionPrototypeMethods: boolean;
+    }];
+    yoda: "error";
+  };
+}
+declare namespace es {
+  type Rules = RuleOptions$10;
   interface Options extends PluginOptionsBase<Rules> {}
 }
 //#endregion
 //#region src/config/ignores.d.ts
-declare function ignores(options?: ignores.Options): Promise<[{
-  readonly ignores: Array<string>;
-  readonly name: "w5s/ignore";
-}]>;
+declare function ignores(options?: ignores.Options): Promise<import("@w5s/eslint-config-ignore").ESLintIgnoreConfig[]>;
 declare namespace ignores {
-  interface Options {
-    ignores?: string[];
-  }
+  type Options = ESLintIgnoreOptions;
 }
 //#endregion
 //#region src/typegen/jsdoc.d.ts
 declare module 'eslint' {
   namespace Linter {
-    interface RulesRecord extends RuleOptions$8 {}
+    interface RulesRecord extends RuleOptions$9 {}
   }
 }
-interface RuleOptions$8 {
+interface RuleOptions$9 {
   /**
    * 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
@@ -1430,24 +1912,24 @@ type JsdocValidTypes = [] | [{
 //#region src/config/jsdoc.d.ts
 declare function jsdoc(options?: jsdoc.Options): Promise<readonly Config[]>;
 declare namespace jsdoc {
-  type Rules = RuleOptions$8;
+  type Rules = RuleOptions$9;
   interface Options extends PluginOptionsBase<Rules> {}
 }
 //#endregion
 //#region src/config/jsonc.d.ts
 declare function jsonc(options?: jsonc.Options): Promise<readonly Config[]>;
 declare namespace jsonc {
-  type Rules = RuleOptions$9;
+  type Rules = RuleOptions$10;
   interface Options extends PluginOptionsBase<Rules> {}
 }
 //#endregion
 //#region src/typegen/import.d.ts
 declare module 'eslint' {
   namespace Linter {
-    interface RulesRecord extends RuleOptions$7 {}
+    interface RulesRecord extends RuleOptions$8 {}
   }
 }
-interface RuleOptions$7 {
+interface RuleOptions$8 {
   /**
    * Enforce or ban the use of inline type-only markers for named imports.
    * @see https://github.com/import-js/eslint-plugin-import/blob/v2.32.0/docs/rules/consistent-type-specifier-style.md
@@ -1893,17 +2375,30 @@ type ImportPreferDefaultExport = [] | [{
 //#region src/config/imports.d.ts
 declare function imports(options?: imports.Options): Promise<[Config]>;
 declare namespace imports {
-  type Rules = RuleOptions$7;
+  var recommended: {
+    'import/first': string;
+    'import/no-duplicates': string;
+    'import/no-mutable-exports': string;
+    'import/no-named-default': string;
+  };
+  var stylistic: {
+    'import/newline-after-import': (string | {
+      count: number;
+    })[];
+  };
+}
+declare namespace imports {
+  type Rules = RuleOptions$8;
   interface Options extends PluginOptionsBase<Rules> {}
 }
 //#endregion
 //#region src/typegen/markdown.d.ts
 declare module 'eslint' {
   namespace Linter {
-    interface RulesRecord extends RuleOptions$6 {}
+    interface RulesRecord extends RuleOptions$7 {}
   }
 }
-interface RuleOptions$6 {
+interface RuleOptions$7 {
   /**
    * Require languages for fenced code blocks
    * @see https://github.com/eslint/markdown/blob/main/docs/rules/fenced-code-language.md
@@ -2064,7 +2559,7 @@ type MarkdownTableColumnCount = [] | [{
 //#region src/config/markdown.d.ts
 declare function markdown(options?: markdown.Options): Promise<[Config, Config]>;
 declare namespace markdown {
-  type Rules = RuleOptions$6;
+  type Rules = RuleOptions$7;
   interface Options extends PluginOptionsBase<Rules> {
     /**
      * Default to 'markdown/gfm' (Github Flavored Markdown)
@@ -2073,6 +2568,129 @@ declare namespace markdown {
   }
 }
 //#endregion
+//#region src/typegen/next.d.ts
+declare module 'eslint' {
+  namespace Linter {
+    interface RulesRecord extends RuleOptions$6 {}
+  }
+}
+interface RuleOptions$6 {
+  /**
+   * Enforce font-display behavior with Google Fonts.
+   * @see https://nextjs.org/docs/messages/google-font-display
+   */
+  'next/google-font-display'?: Linter.RuleEntry<[]>;
+  /**
+   * Ensure `preconnect` is used with Google Fonts.
+   * @see https://nextjs.org/docs/messages/google-font-preconnect
+   */
+  'next/google-font-preconnect'?: Linter.RuleEntry<[]>;
+  /**
+   * Enforce `id` attribute on `next/script` components with inline content.
+   * @see https://nextjs.org/docs/messages/inline-script-id
+   */
+  'next/inline-script-id'?: Linter.RuleEntry<[]>;
+  /**
+   * Prefer `@next/third-parties/google` when using the inline script for Google Analytics and Tag Manager.
+   * @see https://nextjs.org/docs/messages/next-script-for-ga
+   */
+  'next/next-script-for-ga'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent assignment to the `module` variable.
+   * @see https://nextjs.org/docs/messages/no-assign-module-variable
+   */
+  'next/no-assign-module-variable'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent Client Components from being async functions.
+   * @see https://nextjs.org/docs/messages/no-async-client-component
+   */
+  'next/no-async-client-component'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `next/script`'s `beforeInteractive` strategy outside of `pages/_document.js`.
+   * @see https://nextjs.org/docs/messages/no-before-interactive-script-outside-document
+   */
+  'next/no-before-interactive-script-outside-document'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent manual stylesheet tags.
+   * @see https://nextjs.org/docs/messages/no-css-tags
+   */
+  'next/no-css-tags'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent importing `next/document` outside of `pages/_document.js`.
+   * @see https://nextjs.org/docs/messages/no-document-import-in-page
+   */
+  'next/no-document-import-in-page'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent duplicate usage of `<Head>` in `pages/_document.js`.
+   * @see https://nextjs.org/docs/messages/no-duplicate-head
+   */
+  'next/no-duplicate-head'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `<head>` element.
+   * @see https://nextjs.org/docs/messages/no-head-element
+   */
+  'next/no-head-element'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `next/head` in `pages/_document.js`.
+   * @see https://nextjs.org/docs/messages/no-head-import-in-document
+   */
+  'next/no-head-import-in-document'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `<a>` elements to navigate to internal Next.js pages.
+   * @see https://nextjs.org/docs/messages/no-html-link-for-pages
+   */
+  'next/no-html-link-for-pages'?: Linter.RuleEntry<NextNoHtmlLinkForPages>;
+  /**
+   * Prevent usage of `<img>` element due to slower LCP and higher bandwidth.
+   * @see https://nextjs.org/docs/messages/no-img-element
+   */
+  'next/no-img-element'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent page-only custom fonts.
+   * @see https://nextjs.org/docs/messages/no-page-custom-font
+   */
+  'next/no-page-custom-font'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `next/script` in `next/head` component.
+   * @see https://nextjs.org/docs/messages/no-script-component-in-head
+   */
+  'next/no-script-component-in-head'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `styled-jsx` in `pages/_document.js`.
+   * @see https://nextjs.org/docs/messages/no-styled-jsx-in-document
+   */
+  'next/no-styled-jsx-in-document'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent synchronous scripts.
+   * @see https://nextjs.org/docs/messages/no-sync-scripts
+   */
+  'next/no-sync-scripts'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent usage of `<title>` with `Head` component from `next/document`.
+   * @see https://nextjs.org/docs/messages/no-title-in-document-head
+   */
+  'next/no-title-in-document-head'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent common typos in Next.js data fetching functions.
+   */
+  'next/no-typos'?: Linter.RuleEntry<[]>;
+  /**
+   * Prevent duplicate polyfills from Polyfill.io.
+   * @see https://nextjs.org/docs/messages/no-unwanted-polyfillio
+   */
+  'next/no-unwanted-polyfillio'?: Linter.RuleEntry<[]>;
+}
+/* ======= Declarations ======= */
+// ----- next/no-html-link-for-pages -----
+type NextNoHtmlLinkForPages = [] | [(string | string[])];
+//#endregion
+//#region src/config/next.d.ts
+declare function next(options?: next.Options): Promise<[Config, Config]>;
+declare namespace next {
+  type Rules = RuleOptions$6;
+  interface Options extends Omit<PluginOptionsBase<Rules>, 'stylistic'> {}
+}
+//#endregion
 //#region src/typegen/node.d.ts
 declare module 'eslint' {
   namespace Linter {
@@ -7646,18 +8264,21 @@ declare namespace yml {
 //#endregion
 //#region src/defineConfig.d.ts
 interface DefineConfigOptions extends ignores.Options {
+  e18e?: boolean | e18e.Options;
   es?: boolean | es.Options;
   import?: boolean | imports.Options;
   markdown?: boolean | markdown.Options;
   jsdoc?: boolean | jsdoc.Options;
   jsonc?: boolean | jsonc.Options;
+  next?: boolean | next.Options;
   node?: boolean | node.Options;
   stylistic?: boolean | stylistic.Options;
+  test?: boolean | test.Options;
   ts?: boolean | ts.Options;
   unicorn?: boolean | unicorn.Options;
   yml?: boolean | yml.Options;
 }
-declare function defineConfig(options?: DefineConfigOptions): Promise<Config[]>;
+declare function defineConfig(options?: DefineConfigOptions): Promise<import("eslint").Linter.Config<import("eslint").Linter.RulesRecord>[]>;
 //#endregion
 //#region src/meta.d.ts
 declare const meta: Readonly<{
@@ -7666,5 +8287,5 @@ declare const meta: Readonly<{
   buildNumber: number;
 }>;
 //#endregion
-export { Config, DefineConfigOptions, PluginOptionsBase, StylisticConfig, StylisticParameters, defineConfig as default, defineConfig, es, ignores, imports, jsdoc, jsonc, markdown, meta, node, stylistic, test, ts, unicorn, yml };
+export { Config, DefineConfigOptions, PluginOptionsBase, StylisticConfig, StylisticParameters, defineConfig as default, defineConfig, e18e, es, ignores, imports, jsdoc, jsonc, markdown, meta, next, node, stylistic, test, ts, unicorn, yml };
 //# sourceMappingURL=index.d.ts.map