xo 0.46.4 → 0.47.0

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/README.md

@@ -0,0 +1,159 @@
+---
+title: Overview
+sidebar_label: Overview
+pagination_next: null
+pagination_prev: null
+slug: /
+---
+
+`@typescript-eslint/eslint-plugin` comes with two rulesets you can extend from to pull in the recommended starting rules:
+
+- `'plugin:@typescript-eslint/recommended'`: recommended rules for code correctness that you can drop in without additional configuration.
+  See [Linting](/docs/linting/linting) for more details.
+- `'plugin:@typescript-eslint/recommended-requiring-type-checking'` additional recommended rules that require type information.
+  See [Linting](/docs/linting/type-linting) for more details.
+
+## Supported Rules
+
+<!-- begin base rule list -->
+
+**Key**: :white_check_mark: = recommended, :wrench: = fixable, :thought_balloon: = requires type information
+
+| Name                                                                                                         | Description                                                                                                             | :white_check_mark: | :wrench: | :thought_balloon: |
+| ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- | ------------------ | -------- | ----------------- |
+| [`@typescript-eslint/adjacent-overload-signatures`](./adjacent-overload-signatures.md)                       | Require that member overloads be consecutive                                                                            | :white_check_mark: |          |                   |
+| [`@typescript-eslint/array-type`](./array-type.md)                                                           | Requires using either `T[]` or `Array<T>` for arrays                                                                    |                    | :wrench: |                   |
+| [`@typescript-eslint/await-thenable`](./await-thenable.md)                                                   | Disallows awaiting a value that is not a Thenable                                                                       | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/ban-ts-comment`](./ban-ts-comment.md)                                                   | Bans `@ts-<directive>` comments from being used or requires descriptions after directive                                | :white_check_mark: |          |                   |
+| [`@typescript-eslint/ban-tslint-comment`](./ban-tslint-comment.md)                                           | Bans `// tslint:<rule-flag>` comments from being used                                                                   |                    | :wrench: |                   |
+| [`@typescript-eslint/ban-types`](./ban-types.md)                                                             | Bans specific types from being used                                                                                     | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/class-literal-property-style`](./class-literal-property-style.md)                       | Ensures that literals on classes are exposed in a consistent style                                                      |                    | :wrench: |                   |
+| [`@typescript-eslint/consistent-indexed-object-style`](./consistent-indexed-object-style.md)                 | Enforce or disallow the use of the record type                                                                          |                    | :wrench: |                   |
+| [`@typescript-eslint/consistent-type-assertions`](./consistent-type-assertions.md)                           | Enforces consistent usage of type assertions                                                                            |                    |          |                   |
+| [`@typescript-eslint/consistent-type-definitions`](./consistent-type-definitions.md)                         | Consistent with type definition either `interface` or `type`                                                            |                    | :wrench: |                   |
+| [`@typescript-eslint/consistent-type-exports`](./consistent-type-exports.md)                                 | Enforces consistent usage of type exports                                                                               |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/consistent-type-imports`](./consistent-type-imports.md)                                 | Enforces consistent usage of type imports                                                                               |                    | :wrench: |                   |
+| [`@typescript-eslint/explicit-function-return-type`](./explicit-function-return-type.md)                     | Require explicit return types on functions and class methods                                                            |                    |          |                   |
+| [`@typescript-eslint/explicit-member-accessibility`](./explicit-member-accessibility.md)                     | Require explicit accessibility modifiers on class properties and methods                                                |                    | :wrench: |                   |
+| [`@typescript-eslint/explicit-module-boundary-types`](./explicit-module-boundary-types.md)                   | Require explicit return and argument types on exported functions' and classes' public class methods                     |                    |          |                   |
+| [`@typescript-eslint/member-delimiter-style`](./member-delimiter-style.md)                                   | Require a specific member delimiter style for interfaces and type literals                                              |                    | :wrench: |                   |
+| [`@typescript-eslint/member-ordering`](./member-ordering.md)                                                 | Require a consistent member declaration order                                                                           |                    |          |                   |
+| [`@typescript-eslint/method-signature-style`](./method-signature-style.md)                                   | Enforces using a particular method signature syntax.                                                                    |                    | :wrench: |                   |
+| [`@typescript-eslint/naming-convention`](./naming-convention.md)                                             | Enforces naming conventions for everything across a codebase                                                            |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-base-to-string`](./no-base-to-string.md)                                             | Requires that `.toString()` is only called on objects which provide useful information when stringified                 |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-confusing-non-null-assertion`](./no-confusing-non-null-assertion.md)                 | Disallow non-null assertion in locations that may be confusing                                                          |                    | :wrench: |                   |
+| [`@typescript-eslint/no-confusing-void-expression`](./no-confusing-void-expression.md)                       | Requires expressions of type void to appear in statement position                                                       |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-dynamic-delete`](./no-dynamic-delete.md)                                             | Disallow the delete operator with computed key expressions                                                              |                    | :wrench: |                   |
+| [`@typescript-eslint/no-empty-interface`](./no-empty-interface.md)                                           | Disallow the declaration of empty interfaces                                                                            | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-explicit-any`](./no-explicit-any.md)                                                 | Disallow usage of the `any` type                                                                                        | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-extra-non-null-assertion`](./no-extra-non-null-assertion.md)                         | Disallow extra non-null assertion                                                                                       | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-extraneous-class`](./no-extraneous-class.md)                                         | Forbids the use of classes as namespaces                                                                                |                    |          |                   |
+| [`@typescript-eslint/no-floating-promises`](./no-floating-promises.md)                                       | Requires Promise-like values to be handled appropriately                                                                | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-for-in-array`](./no-for-in-array.md)                                                 | Disallow iterating over an array with a for-in loop                                                                     | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-inferrable-types`](./no-inferrable-types.md)                                         | Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean            | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-invalid-void-type`](./no-invalid-void-type.md)                                       | Disallows usage of `void` type outside of generic or return types                                                       |                    |          |                   |
+| [`@typescript-eslint/no-meaningless-void-operator`](./no-meaningless-void-operator.md)                       | Disallow the `void` operator except when used to discard a value                                                        |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-misused-new`](./no-misused-new.md)                                                   | Enforce valid definition of `new` and `constructor`                                                                     | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-misused-promises`](./no-misused-promises.md)                                         | Avoid using promises in places not designed to handle them                                                              | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-namespace`](./no-namespace.md)                                                       | Disallow the use of custom TypeScript modules and namespaces                                                            | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-non-null-asserted-nullish-coalescing`](./no-non-null-asserted-nullish-coalescing.md) | Disallows using a non-null assertion in the left operand of the nullish coalescing operator                             |                    |          |                   |
+| [`@typescript-eslint/no-non-null-asserted-optional-chain`](./no-non-null-asserted-optional-chain.md)         | Disallows using a non-null assertion after an optional chain expression                                                 | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-non-null-assertion`](./no-non-null-assertion.md)                                     | Disallows non-null assertions using the `!` postfix operator                                                            | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-parameter-properties`](./no-parameter-properties.md)                                 | Disallow the use of parameter properties in class constructors                                                          |                    |          |                   |
+| [`@typescript-eslint/no-require-imports`](./no-require-imports.md)                                           | Disallows invocation of `require()`                                                                                     |                    |          |                   |
+| [`@typescript-eslint/no-this-alias`](./no-this-alias.md)                                                     | Disallow aliasing `this`                                                                                                | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-type-alias`](./no-type-alias.md)                                                     | Disallow the use of type aliases                                                                                        |                    |          |                   |
+| [`@typescript-eslint/no-unnecessary-boolean-literal-compare`](./no-unnecessary-boolean-literal-compare.md)   | Flags unnecessary equality comparisons against boolean literals                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-condition`](./no-unnecessary-condition.md)                               | Prevents conditionals where the type is always truthy or always falsy                                                   |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-qualifier`](./no-unnecessary-qualifier.md)                               | Warns when a namespace qualifier is unnecessary                                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-type-arguments`](./no-unnecessary-type-arguments.md)                     | Enforces that type arguments will not be used if not required                                                           |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-type-assertion`](./no-unnecessary-type-assertion.md)                     | Warns if a type assertion does not change the type of an expression                                                     | :white_check_mark: | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/no-unnecessary-type-constraint`](./no-unnecessary-type-constraint.md)                   | Disallows unnecessary constraints on generic types                                                                      | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-unsafe-argument`](./no-unsafe-argument.md)                                           | Disallows calling a function with an any type value                                                                     | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-assignment`](./no-unsafe-assignment.md)                                       | Disallows assigning any to variables and properties                                                                     | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-call`](./no-unsafe-call.md)                                                   | Disallows calling an any type value                                                                                     | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-member-access`](./no-unsafe-member-access.md)                                 | Disallows member access on any typed variables                                                                          | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-unsafe-return`](./no-unsafe-return.md)                                               | Disallows returning any from a function                                                                                 | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-var-requires`](./no-var-requires.md)                                                 | Disallows the use of require statements except in import statements                                                     | :white_check_mark: |          |                   |
+| [`@typescript-eslint/non-nullable-type-assertion-style`](./non-nullable-type-assertion-style.md)             | Prefers a non-null assertion over explicit type cast when possible                                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-as-const`](./prefer-as-const.md)                                                 | Prefer usage of `as const` over literal type                                                                            | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/prefer-enum-initializers`](./prefer-enum-initializers.md)                               | Prefer initializing each enums member value                                                                             |                    |          |                   |
+| [`@typescript-eslint/prefer-for-of`](./prefer-for-of.md)                                                     | Prefer a ‘for-of’ loop over a standard ‘for’ loop if the index is only used to access the array being iterated          |                    |          |                   |
+| [`@typescript-eslint/prefer-function-type`](./prefer-function-type.md)                                       | Use function types instead of interfaces with call signatures                                                           |                    | :wrench: |                   |
+| [`@typescript-eslint/prefer-includes`](./prefer-includes.md)                                                 | Enforce `includes` method over `indexOf` method                                                                         |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-literal-enum-member`](./prefer-literal-enum-member.md)                           | Require that all enum members be literal values to prevent unintended enum member name shadow issues                    |                    |          |                   |
+| [`@typescript-eslint/prefer-namespace-keyword`](./prefer-namespace-keyword.md)                               | Require the use of the `namespace` keyword instead of the `module` keyword to declare custom TypeScript modules         | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/prefer-nullish-coalescing`](./prefer-nullish-coalescing.md)                             | Enforce the usage of the nullish coalescing operator instead of logical chaining                                        |                    |          | :thought_balloon: |
+| [`@typescript-eslint/prefer-optional-chain`](./prefer-optional-chain.md)                                     | Prefer using concise optional chain expressions instead of chained logical ands                                         |                    |          |                   |
+| [`@typescript-eslint/prefer-readonly`](./prefer-readonly.md)                                                 | Requires that private members are marked as `readonly` if they're never modified outside of the constructor             |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-readonly-parameter-types`](./prefer-readonly-parameter-types.md)                 | Requires that function parameters are typed as readonly to prevent accidental mutation of inputs                        |                    |          | :thought_balloon: |
+| [`@typescript-eslint/prefer-reduce-type-parameter`](./prefer-reduce-type-parameter.md)                       | Prefer using type parameter when calling `Array#reduce` instead of casting                                              |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-regexp-exec`](./prefer-regexp-exec.md)                                           | Enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided                              |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-return-this-type`](./prefer-return-this-type.md)                                 | Enforce that `this` is used when only `this` type is returned                                                           |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-string-starts-ends-with`](./prefer-string-starts-ends-with.md)                   | Enforce the use of `String#startsWith` and `String#endsWith` instead of other equivalent methods of checking substrings |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/prefer-ts-expect-error`](./prefer-ts-expect-error.md)                                   | Recommends using `@ts-expect-error` over `@ts-ignore`                                                                   |                    | :wrench: |                   |
+| [`@typescript-eslint/promise-function-async`](./promise-function-async.md)                                   | Requires any function or method that returns a Promise to be marked async                                               |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/require-array-sort-compare`](./require-array-sort-compare.md)                           | Requires `Array#sort` calls to always provide a `compareFunction`                                                       |                    |          | :thought_balloon: |
+| [`@typescript-eslint/restrict-plus-operands`](./restrict-plus-operands.md)                                   | When adding two variables, operands must both be of type number or of type string                                       | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/restrict-template-expressions`](./restrict-template-expressions.md)                     | Enforce template literal expressions to be of string type                                                               | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/sort-type-union-intersection-members`](./sort-type-union-intersection-members.md)       | Enforces that members of a type union/intersection are sorted alphabetically                                            |                    | :wrench: |                   |
+| [`@typescript-eslint/strict-boolean-expressions`](./strict-boolean-expressions.md)                           | Restricts the types allowed in boolean expressions                                                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/switch-exhaustiveness-check`](./switch-exhaustiveness-check.md)                         | Exhaustiveness checking in switch with union type                                                                       |                    |          | :thought_balloon: |
+| [`@typescript-eslint/triple-slash-reference`](./triple-slash-reference.md)                                   | Sets preference level for triple slash directives versus ES6-style import declarations                                  | :white_check_mark: |          |                   |
+| [`@typescript-eslint/type-annotation-spacing`](./type-annotation-spacing.md)                                 | Require consistent spacing around type annotations                                                                      |                    | :wrench: |                   |
+| [`@typescript-eslint/typedef`](./typedef.md)                                                                 | Requires type annotations to exist                                                                                      |                    |          |                   |
+| [`@typescript-eslint/unbound-method`](./unbound-method.md)                                                   | Enforces unbound methods are called with their expected scope                                                           | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/unified-signatures`](./unified-signatures.md)                                           | Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter               |                    |          |                   |
+
+<!-- end base rule list -->
+
+### Extension Rules
+
+In some cases, ESLint provides a rule itself, but it doesn't support TypeScript syntax; either it crashes, or it ignores the syntax, or it falsely reports against it.
+In these cases, we create what we call an extension rule; a rule within our plugin that has the same functionality, but also supports TypeScript.
+
+<!-- begin extension rule list -->
+
+**Key**: :white_check_mark: = recommended, :wrench: = fixable, :thought_balloon: = requires type information
+
+| Name                                                                                         | Description                                                                          | :white_check_mark: | :wrench: | :thought_balloon: |
+| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | ------------------ | -------- | ----------------- |
+| [`@typescript-eslint/brace-style`](./brace-style.md)                                         | Enforce consistent brace style for blocks                                            |                    | :wrench: |                   |
+| [`@typescript-eslint/comma-dangle`](./comma-dangle.md)                                       | Require or disallow trailing comma                                                   |                    | :wrench: |                   |
+| [`@typescript-eslint/comma-spacing`](./comma-spacing.md)                                     | Enforces consistent spacing before and after commas                                  |                    | :wrench: |                   |
+| [`@typescript-eslint/default-param-last`](./default-param-last.md)                           | Enforce default parameters to be last                                                |                    |          |                   |
+| [`@typescript-eslint/dot-notation`](./dot-notation.md)                                       | enforce dot notation whenever possible                                               |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/func-call-spacing`](./func-call-spacing.md)                             | Require or disallow spacing between function identifiers and their invocations       |                    | :wrench: |                   |
+| [`@typescript-eslint/indent`](./indent.md)                                                   | Enforce consistent indentation                                                       |                    | :wrench: |                   |
+| [`@typescript-eslint/init-declarations`](./init-declarations.md)                             | require or disallow initialization in variable declarations                          |                    |          |                   |
+| [`@typescript-eslint/keyword-spacing`](./keyword-spacing.md)                                 | Enforce consistent spacing before and after keywords                                 |                    | :wrench: |                   |
+| [`@typescript-eslint/lines-between-class-members`](./lines-between-class-members.md)         | Require or disallow an empty line between class members                              |                    | :wrench: |                   |
+| [`@typescript-eslint/no-array-constructor`](./no-array-constructor.md)                       | Disallow generic `Array` constructors                                                | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-dupe-class-members`](./no-dupe-class-members.md)                     | Disallow duplicate class members                                                     |                    |          |                   |
+| [`@typescript-eslint/no-duplicate-imports`](./no-duplicate-imports.md)                       | Disallow duplicate imports                                                           |                    |          |                   |
+| [`@typescript-eslint/no-empty-function`](./no-empty-function.md)                             | Disallow empty functions                                                             | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-extra-parens`](./no-extra-parens.md)                                 | Disallow unnecessary parentheses                                                     |                    | :wrench: |                   |
+| [`@typescript-eslint/no-extra-semi`](./no-extra-semi.md)                                     | Disallow unnecessary semicolons                                                      | :white_check_mark: | :wrench: |                   |
+| [`@typescript-eslint/no-implied-eval`](./no-implied-eval.md)                                 | Disallow the use of `eval()`-like methods                                            | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/no-invalid-this`](./no-invalid-this.md)                                 | Disallow `this` keywords outside of classes or class-like objects                    |                    |          |                   |
+| [`@typescript-eslint/no-loop-func`](./no-loop-func.md)                                       | Disallow function declarations that contain unsafe references inside loop statements |                    |          |                   |
+| [`@typescript-eslint/no-loss-of-precision`](./no-loss-of-precision.md)                       | Disallow literal numbers that lose precision                                         | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-magic-numbers`](./no-magic-numbers.md)                               | Disallow magic numbers                                                               |                    |          |                   |
+| [`@typescript-eslint/no-redeclare`](./no-redeclare.md)                                       | Disallow variable redeclaration                                                      |                    |          |                   |
+| [`@typescript-eslint/no-restricted-imports`](./no-restricted-imports.md)                     | Disallow specified modules when loaded by `import`                                   |                    |          |                   |
+| [`@typescript-eslint/no-shadow`](./no-shadow.md)                                             | Disallow variable declarations from shadowing variables declared in the outer scope  |                    |          |                   |
+| [`@typescript-eslint/no-throw-literal`](./no-throw-literal.md)                               | Disallow throwing literals as exceptions                                             |                    |          | :thought_balloon: |
+| [`@typescript-eslint/no-unused-expressions`](./no-unused-expressions.md)                     | Disallow unused expressions                                                          |                    |          |                   |
+| [`@typescript-eslint/no-unused-vars`](./no-unused-vars.md)                                   | Disallow unused variables                                                            | :white_check_mark: |          |                   |
+| [`@typescript-eslint/no-use-before-define`](./no-use-before-define.md)                       | Disallow the use of variables before they are defined                                |                    |          |                   |
+| [`@typescript-eslint/no-useless-constructor`](./no-useless-constructor.md)                   | Disallow unnecessary constructors                                                    |                    |          |                   |
+| [`@typescript-eslint/object-curly-spacing`](./object-curly-spacing.md)                       | Enforce consistent spacing inside braces                                             |                    | :wrench: |                   |
+| [`@typescript-eslint/padding-line-between-statements`](./padding-line-between-statements.md) | require or disallow padding lines between statements                                 |                    | :wrench: |                   |
+| [`@typescript-eslint/quotes`](./quotes.md)                                                   | Enforce the consistent use of either backticks, double, or single quotes             |                    | :wrench: |                   |
+| [`@typescript-eslint/require-await`](./require-await.md)                                     | Disallow async functions which have no `await` expression                            | :white_check_mark: |          | :thought_balloon: |
+| [`@typescript-eslint/return-await`](./return-await.md)                                       | Enforces consistent returning of awaited values                                      |                    | :wrench: | :thought_balloon: |
+| [`@typescript-eslint/semi`](./semi.md)                                                       | Require or disallow semicolons instead of ASI                                        |                    | :wrench: |                   |
+| [`@typescript-eslint/space-before-function-paren`](./space-before-function-paren.md)         | Enforces consistent spacing before function parenthesis                              |                    | :wrench: |                   |
+| [`@typescript-eslint/space-infix-ops`](./space-infix-ops.md)                                 | This rule is aimed at ensuring there are spaces around infix operators.              |                    | :wrench: |                   |
+
+<!-- end extension rule list -->

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/comma-dangle.md

@@ -9,7 +9,7 @@ See the [ESLint documentation](https://eslint.org/docs/rules/comma-dangle) for m
 
 ## Rule Changes
 
-```cjson
+```jsonc
 {
   // note you must disable the base rule as it can report incorrect errors
   "comma-dangle": "off",

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/consistent-indexed-object-style.md

@@ -20,9 +20,12 @@ type Foo = Record<string, unknown>;
 
 For example:
 
-```CJSON
+```json
 {
-    "@typescript-eslint/consistent-indexed-object-style": ["error", "index-signature"]
+  "@typescript-eslint/consistent-indexed-object-style": [
+    "error",
+    "index-signature"
+  ]
 }
 ```
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/explicit-module-boundary-types.md

@@ -2,8 +2,6 @@
 
 Explicit types for function return values and arguments makes it clear to any calling code what is the module boundary's input and output.
 
-Consider using this rule in place of [`no-untyped-public-signature`](./no-untyped-public-signature.md) which has been deprecated.
-
 ## Rule Details
 
 This rule aims to ensure that the values returned from a module are of the expected type.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/member-delimiter-style.md

@@ -78,17 +78,17 @@ type Config = BaseConfig & {
 
 Default config:
 
-```JSON
+```json
 {
-    "multiline": {
-        "delimiter": "semi",
-        "requireLast": true
-    },
-    "singleline": {
-        "delimiter": "semi",
-        "requireLast": false
-    },
-    "multilineDetection": "brackets"
+  "multiline": {
+    "delimiter": "semi",
+    "requireLast": true
+  },
+  "singleline": {
+    "delimiter": "semi",
+    "requireLast": false
+  },
+  "multilineDetection": "brackets"
 }
 ```
 
@@ -108,7 +108,10 @@ Accepts three values (or two for `singleline`):
 - `comma` - each member should be delimited with a comma (`,`).
 - `semi` - each member should be delimited with a semicolon (`;`).
 - `none` - each member should be delimited with nothing.
-  - NOTE - this is not an option for `singleline` because having no delimiter between members on a single line is a syntax error in TS.
+
+:::note
+`none` is not an option for `singleline` because having no delimiter between members on a single line is a syntax error in TS.
+:::
 
 ### `requireLast`
 
@@ -123,24 +126,24 @@ Allows you to specify options specifically for either `interface`s or `type` def
 
 For example, to require commas for `type`s, and semicolons for multiline `interface`s:
 
-```JSON
+```json
 {
-    "multiline": {
-        "delimiter": "comma",
-        "requireLast": true
-    },
-    "singleline": {
-        "delimiter": "comma",
+  "multiline": {
+    "delimiter": "comma",
+    "requireLast": true
+  },
+  "singleline": {
+    "delimiter": "comma",
+    "requireLast": true
+  },
+  "overrides": {
+    "interface": {
+      "multiline": {
+        "delimiter": "semi",
         "requireLast": true
-    },
-    "overrides": {
-        "interface": {
-            "multiline": {
-                "delimiter": "semi",
-                "requireLast": true
-            }
-        }
+      }
     }
+  }
 }
 ```
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-inferrable-types.md

@@ -22,10 +22,10 @@ interface Options {
 
 The default options are:
 
-```JSON
+```json
 {
   "ignoreParameters": false,
-  "ignoreProperties": false,
+  "ignoreProperties": false
 }
 ```
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/object-curly-spacing.md

@@ -7,7 +7,7 @@ It adds support for TypeScript's object types.
 
 ## How to use
 
-```cjson
+```jsonc
 {
   // note you must disable the base rule as it can report incorrect errors
   "object-curly-spacing": "off",

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/padding-line-between-statements.md

@@ -43,7 +43,9 @@ This rule extends the base [`eslint/padding-line-between-statements`](https://es
 
 See [`eslint/padding-line-between-statements` options](https://eslint.org/docs/rules/padding-line-between-statements#options).
 
-**Note** - In addition to options provided by ESLint, we have also added options for `interface` and `type`.
+In addition to options provided by ESLint, `interface` and `type` can be used as statement types.
+
+**Note:** ESLint `cjs-export` and `cjs-import` statement types are renamed to `exports` and `require` respectively.
 
 <sup>Taken with ❤️ [from ESLint core](https://github.com/eslint/eslint/blob/master/docs/rules/padding-line-between-statements.md)</sup>
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/prefer-string-starts-ends-with.md

@@ -43,9 +43,9 @@ foo.endsWith('bar');
 
 There are no options.
 
-```JSON
+```json
 {
-    "@typescript-eslint/prefer-string-starts-ends-with": "error"
+  "@typescript-eslint/prefer-string-starts-ends-with": "error"
 }
 ```
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/require-array-sort-compare.md

@@ -13,7 +13,11 @@ When sorting numbers, this results in the classic "10 before 2" order:
 
 This also means that `Array#sort` does not always sort consistently, as elements may have custom `#toString` implementations that are not deterministic; this trap is noted in the language specification thusly:
 
-> NOTE 2: Method calls performed by the `ToString` abstract operations in steps 5 and 7 have the potential to cause `SortCompare` to not behave as a consistent comparison function.<br> > https://www.ecma-international.org/ecma-262/9.0/#sec-sortcompare
+:::note
+Method calls performed by the `ToString` abstract operations in steps 5 and 7 have the potential to cause `SortCompare` to not behave as a consistent comparison function.
+
+https://www.ecma-international.org/ecma-262/9.0/#sec-sortcompare
+:::
 
 ## Rule Details
 

package/node_modules/@typescript-eslint/eslint-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "5.3.0",
+  "version": "5.4.0",
   "description": "TypeScript plugin for ESLint",
   "keywords": [
     "eslint",
@@ -44,8 +44,8 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "5.3.0",
-    "@typescript-eslint/scope-manager": "5.3.0",
+    "@typescript-eslint/experimental-utils": "5.4.0",
+    "@typescript-eslint/scope-manager": "5.4.0",
     "debug": "^4.3.2",
     "functional-red-black-tree": "^1.0.1",
     "ignore": "^5.1.8",
@@ -75,5 +75,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/typescript-eslint"
   },
-  "gitHead": "c289d1358c62c41847ee2f32d135f13321dca177"
+  "gitHead": "0060a74413a3efb7872a3c8e2f4d45a733f3d149"
 }

package/node_modules/@typescript-eslint/experimental-utils/dist/ast-utils/predicates.d.ts

@@ -48,19 +48,19 @@ declare const isVariableDeclarator: (node: TSESTree.Node | null | undefined) =>
 };
 declare const isFunction: (node: TSESTree.Node | null | undefined) => node is (TSESTree.ArrowFunctionExpression & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression;
-}) | (TSESTree.FunctionExpression & {
-    type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression;
 }) | (TSESTree.FunctionDeclaration & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression;
+}) | (TSESTree.FunctionExpression & {
+    type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression;
 });
-declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is (TSESTree.TSEmptyBodyFunctionExpression & {
-    type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
-}) | (TSESTree.TSCallSignatureDeclaration & {
+declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node is (TSESTree.TSCallSignatureDeclaration & {
     type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSConstructorType & {
     type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSConstructSignatureDeclaration & {
     type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
+}) | (TSESTree.TSEmptyBodyFunctionExpression & {
+    type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSFunctionType & {
     type: AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSMethodSignatureComputedName & {
@@ -70,11 +70,9 @@ declare const isFunctionType: (node: TSESTree.Node | null | undefined) => node i
 });
 declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined) => node is (TSESTree.ArrowFunctionExpression & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
-}) | (TSESTree.FunctionExpression & {
-    type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.FunctionDeclaration & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
-}) | (TSESTree.TSEmptyBodyFunctionExpression & {
+}) | (TSESTree.FunctionExpression & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSCallSignatureDeclaration & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
@@ -82,6 +80,8 @@ declare const isFunctionOrFunctionType: (node: TSESTree.Node | null | undefined)
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSConstructSignatureDeclaration & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
+}) | (TSESTree.TSEmptyBodyFunctionExpression & {
+    type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSFunctionType & {
     type: AST_NODE_TYPES.ArrowFunctionExpression | AST_NODE_TYPES.FunctionDeclaration | AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructorType | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSFunctionType | AST_NODE_TYPES.TSMethodSignature;
 }) | (TSESTree.TSMethodSignatureComputedName & {
@@ -113,14 +113,14 @@ declare const isClassOrTypeElement: (node: TSESTree.Node | null | undefined) =>
     type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
 }) | (TSESTree.TSAbstractPropertyDefinitionNonComputedName & {
     type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
-}) | (TSESTree.TSIndexSignature & {
-    type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
-}) | (TSESTree.TSEmptyBodyFunctionExpression & {
-    type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
 }) | (TSESTree.TSCallSignatureDeclaration & {
     type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
 }) | (TSESTree.TSConstructSignatureDeclaration & {
     type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
+}) | (TSESTree.TSEmptyBodyFunctionExpression & {
+    type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
+}) | (TSESTree.TSIndexSignature & {
+    type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
 }) | (TSESTree.TSMethodSignatureComputedName & {
     type: AST_NODE_TYPES.FunctionExpression | AST_NODE_TYPES.MethodDefinition | AST_NODE_TYPES.PropertyDefinition | AST_NODE_TYPES.TSAbstractMethodDefinition | AST_NODE_TYPES.TSAbstractPropertyDefinition | AST_NODE_TYPES.TSCallSignatureDeclaration | AST_NODE_TYPES.TSConstructSignatureDeclaration | AST_NODE_TYPES.TSEmptyBodyFunctionExpression | AST_NODE_TYPES.TSIndexSignature | AST_NODE_TYPES.TSMethodSignature | AST_NODE_TYPES.TSPropertySignature;
 }) | (TSESTree.TSMethodSignatureNonComputedName & {

package/node_modules/@typescript-eslint/experimental-utils/dist/eslint-utils/RuleCreator.d.ts

@@ -1,13 +1,35 @@
 import { RuleMetaData, RuleMetaDataDocs, RuleListener, RuleContext, RuleModule } from '../ts-eslint/Rule';
-declare type CreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
-declare type CreateRuleMeta<TMessageIds extends string> = {
-    docs: CreateRuleMetaDocs;
+declare type NamedCreateRuleMetaDocs = Omit<RuleMetaDataDocs, 'url'>;
+declare type NamedCreateRuleMeta<TMessageIds extends string> = {
+    docs: NamedCreateRuleMetaDocs;
 } & Omit<RuleMetaData<TMessageIds>, 'docs'>;
-declare function RuleCreator(urlCreator: (ruleName: string) => string): <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener = RuleListener>({ name, meta, defaultOptions, create, }: Readonly<{
-    name: string;
-    meta: CreateRuleMeta<TMessageIds>;
-    defaultOptions: Readonly<TOptions>;
+interface CreateAndOptions<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> {
     create: (context: Readonly<RuleContext<TMessageIds, TOptions>>, optionsWithDefault: Readonly<TOptions>) => TRuleListener;
-}>) => RuleModule<TMessageIds, TOptions, TRuleListener>;
+    defaultOptions: Readonly<TOptions>;
+}
+interface RuleWithMeta<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> extends CreateAndOptions<TOptions, TMessageIds, TRuleListener> {
+    meta: RuleMetaData<TMessageIds>;
+}
+interface RuleWithMetaAndName<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener> extends CreateAndOptions<TOptions, TMessageIds, TRuleListener> {
+    meta: NamedCreateRuleMeta<TMessageIds>;
+    name: string;
+}
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
+declare function RuleCreator(urlCreator: (ruleName: string) => string): <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener = RuleListener>({ name, meta, ...rule }: Readonly<RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => RuleModule<TMessageIds, TOptions, TRuleListener>;
+declare namespace RuleCreator {
+    var withoutDocs: typeof createRule;
+}
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+declare function createRule<TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends RuleListener = RuleListener>({ create, defaultOptions, meta, }: Readonly<RuleWithMeta<TOptions, TMessageIds, TRuleListener>>): RuleModule<TMessageIds, TOptions, TRuleListener>;
 export { RuleCreator };
 //# sourceMappingURL=RuleCreator.d.ts.map

package/node_modules/@typescript-eslint/experimental-utils/dist/eslint-utils/RuleCreator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuleCreator.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B,aAAK,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AACxD,aAAK,cAAc,CAAC,WAAW,SAAS,MAAM,IAAI;IAChD,IAAI,EAAE,kBAAkB,CAAC;CAC1B,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;AAE5C,iBAAS,WAAW,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM;UAanD,MAAM;;;;wDA2Bf;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"RuleCreator.d.ts","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B,aAAK,uBAAuB,GAAG,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAC7D,aAAK,mBAAmB,CAAC,WAAW,SAAS,MAAM,IAAI;IACrD,IAAI,EAAE,uBAAuB,CAAC;CAC/B,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;AAE5C,UAAU,gBAAgB,CACxB,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,YAAY;IAElC,MAAM,EAAE,CACN,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,EACrD,kBAAkB,EAAE,QAAQ,CAAC,QAAQ,CAAC,KACnC,aAAa,CAAC;IACnB,cAAc,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;CACpC;AAED,UAAU,YAAY,CACpB,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,YAAY,CAClC,SAAQ,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,aAAa,CAAC;IAC9D,IAAI,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CACjC;AAED,UAAU,mBAAmB,CAC3B,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,YAAY,CAClC,SAAQ,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,aAAa,CAAC;IAC9D,IAAI,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,iBAAS,WAAW,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,0QAyB5D;kBAzBQ,WAAW;;;AA2BpB;;;;;GAKG;AACH,iBAAS,UAAU,CACjB,QAAQ,SAAS,SAAS,OAAO,EAAE,EACnC,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,YAAY,GAAG,YAAY,EACjD,EACA,MAAM,EACN,cAAc,EACd,IAAI,GACL,EAAE,QAAQ,CAAC,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,GAAG,UAAU,CAC1E,WAAW,EACX,QAAQ,EACR,aAAa,CACd,CAUA;AAID,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/node_modules/@typescript-eslint/experimental-utils/dist/eslint-utils/RuleCreator.js

@@ -1,19 +1,47 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuleCreator = void 0;
 const applyDefault_1 = require("./applyDefault");
+/**
+ * Creates reusable function to create rules with default options and docs URLs.
+ *
+ * @param urlCreator Creates a documentation URL for a given rule name.
+ * @returns Function to create a rule with the docs URL format.
+ */
 function RuleCreator(urlCreator) {
     // This function will get much easier to call when this is merged https://github.com/Microsoft/TypeScript/pull/26349
     // TODO - when the above PR lands; add type checking for the context.report `data` property
-    return function createRule({ name, meta, defaultOptions, create, }) {
-        return {
-            meta: Object.assign(Object.assign({}, meta), { docs: Object.assign(Object.assign({}, meta.docs), { url: urlCreator(name) }) }),
-            create(context) {
-                const optionsWithDefault = (0, applyDefault_1.applyDefault)(defaultOptions, context.options);
-                return create(context, optionsWithDefault);
-            },
-        };
+    return function createNamedRule(_a) {
+        var { name, meta } = _a, rule = __rest(_a, ["name", "meta"]);
+        return createRule(Object.assign({ meta: Object.assign(Object.assign({}, meta), { docs: Object.assign(Object.assign({}, meta.docs), { url: urlCreator(name) }) }) }, rule));
     };
 }
 exports.RuleCreator = RuleCreator;
+/**
+ * Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+ *
+ * @returns Well-typed TSESLint custom ESLint rule.
+ * @remarks It is generally better to provide a docs URL function to RuleCreator.
+ */
+function createRule({ create, defaultOptions, meta, }) {
+    return {
+        meta,
+        create(context) {
+            const optionsWithDefault = (0, applyDefault_1.applyDefault)(defaultOptions, context.options);
+            return create(context, optionsWithDefault);
+        },
+    };
+}
+RuleCreator.withoutDocs = createRule;
 //# sourceMappingURL=RuleCreator.js.map

package/node_modules/@typescript-eslint/experimental-utils/dist/eslint-utils/RuleCreator.js.map

@@ -1 +1 @@
-{"version":3,"file":"RuleCreator.js","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":";;;AAOA,iDAA8C;AAQ9C,SAAS,WAAW,CAAC,UAAwC;IAC3D,oHAAoH;IACpH,2FAA2F;IAC3F,OAAO,SAAS,UAAU,CAIxB,EACA,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,MAAM,GASN;QACA,OAAO;YACL,IAAI,kCACC,IAAI,KACP,IAAI,kCACC,IAAI,CAAC,IAAI,KACZ,GAAG,EAAE,UAAU,CAAC,IAAI,CAAC,MAExB;YACD,MAAM,CACJ,OAAqD;gBAErD,MAAM,kBAAkB,GAAG,IAAA,2BAAY,EACrC,cAAc,EACd,OAAO,CAAC,OAAO,CAChB,CAAC;gBACF,OAAO,MAAM,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;YAC7C,CAAC;SACF,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAEQ,kCAAW"}
+{"version":3,"file":"RuleCreator.js","sourceRoot":"","sources":["../../src/eslint-utils/RuleCreator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAOA,iDAA8C;AAqC9C;;;;;GAKG;AACH,SAAS,WAAW,CAAC,UAAwC;IAC3D,oHAAoH;IACpH,2FAA2F;IAC3F,OAAO,SAAS,eAAe,CAI7B,EAMD;YANC,EACA,IAAI,EACJ,IAAI,OAIL,EAHI,IAAI,cAHP,gBAID,CADQ;QAIP,OAAO,UAAU,iBACf,IAAI,kCACC,IAAI,KACP,IAAI,kCACC,IAAI,CAAC,IAAI,KACZ,GAAG,EAAE,UAAU,CAAC,IAAI,CAAC,UAGtB,IAAI,EACP,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAkCQ,kCAAW;AAhCpB;;;;;GAKG;AACH,SAAS,UAAU,CAIjB,EACA,MAAM,EACN,cAAc,EACd,IAAI,GACyD;IAK7D,OAAO;QACL,IAAI;QACJ,MAAM,CACJ,OAAqD;YAErD,MAAM,kBAAkB,GAAG,IAAA,2BAAY,EAAC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACzE,OAAO,MAAM,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC;AACJ,CAAC;AAED,WAAW,CAAC,WAAW,GAAG,UAAU,CAAC"}