xo 0.52.4 → 0.53.0

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

@@ -6,82 +6,29 @@ description: 'Require a specific member delimiter style for interfaces and type
 >
 > See **https://typescript-eslint.io/rules/member-delimiter-style** for documentation.
 
-Enforces a consistent member delimiter style in interfaces and type literals. There are three member delimiter styles primarily used in TypeScript:
-
-- Semicolon style (default, preferred in TypeScript).
+TypeScript allows three delimiters between members in interfaces and type aliases:
 
 <!-- prettier-ignore -->
 ```ts
 interface Foo {
+    // Semicolons (default, preferred in TypeScript):
     name: string;
-    greet(): void;
-}
-
-type Bar = {
-    name: string;
-    greet(): void;
-}
-```
-
-- Comma style (JSON style).
 
-<!-- prettier-ignore -->
-```ts
-interface Foo {
-    name: string,
-    greet(): void,
-}
-
-type Bar = {
+    // Commas (JSON-like):
     name: string,
-    greet(): void,
-}
-```
 
-- Line break (none) style.
-
-<!-- prettier-ignore -->
-```ts
-interface Foo {
+    // Line breaks (none):
     name: string
-    greet(): void
-}
-
-type Bar = {
-    name: string
-    greet(): void
 }
 ```
 
-The rule also enforces the presence (or absence) of the delimiter in the last member of the interface and/or type literal.
-Finally, this rule can enforce separate delimiter syntax for single line declarations.
+For code readability, it's generally best to use the same style consistently in your codebase.
 
-## Rule Details
-
-This rule aims to standardize the way interface and type literal members are delimited.
+This rule enforces keeping to one configurable code style.
+It can also standardize the presence (or absence) of a delimiter in the last member of a construct, as well as a separate delimiter syntax for single line declarations.
 
 ## Options
 
-```ts
-interface BaseConfig {
-  multiline?: {
-    delimiter?: 'none' | 'semi' | 'comma';
-    requireLast?: boolean;
-  };
-  singleline?: {
-    delimiter?: 'semi' | 'comma';
-    requireLast?: boolean;
-  };
-}
-type Config = BaseConfig & {
-  overrides?: {
-    interface?: BaseConfig;
-    typeLiteral?: BaseConfig;
-  };
-  multilineDetection?: 'brackets' | 'last-member';
-};
-```
-
 Default config:
 
 ```json

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

@@ -6,11 +6,8 @@ description: 'Require a consistent member declaration order.'
 >
 > See **https://typescript-eslint.io/rules/member-ordering** for documentation.
 
-A consistent ordering of fields, methods and constructors can make interfaces, type literals, classes and class expressions easier to read, navigate, and edit.
-
-## Rule Details
-
-This rule aims to standardize the way class declarations, class expressions, interfaces and type literals are structured and ordered.
+This rule aims to standardize the way classes, interfaces, and type literals are structured and ordered.
+A consistent ordering of fields, methods and constructors can make code easier to read, navigate, and edit.
 
 ## Options
 
@@ -27,7 +24,12 @@ type OrderConfig = MemberType[] | SortedOrderConfig | 'never';
 
 interface SortedOrderConfig {
   memberTypes?: MemberType[] | 'never';
-  order: 'alphabetically' | 'alphabetically-case-insensitive' | 'as-written';
+  order:
+    | 'alphabetically'
+    | 'alphabetically-case-insensitive'
+    | 'as-written'
+    | 'natural'
+    | 'natural-case-insensitive';
 }
 
 // See below for the more specific MemberType strings
@@ -59,6 +61,17 @@ The supported member attributes are, in order:
 Member attributes may be joined with a `'-'` to combine into more specific groups.
 For example, `'public-field'` would come before `'private-field'`.
 
+### Orders
+
+The `order` value specifies what order members should be within a group.
+It defaults to `as-written`, meaning any order is fine.
+Other allowed values are:
+
+- `alphabetically`: Sorted in a-z alphabetical order, directly using string `<` comparison (so `B` comes before `a`)
+- `alphabetically-case-insensitive`: Sorted in a-z alphabetical order, ignoring case (so `a` comes before `B`)
+- `natural`: Same as `alphabetically`, but using [`natural-compare-lite`](https://github.com/litejs/natural-compare-lite) for more friendly sorting of numbers
+- `natural-case-insensitive`: Same as `alphabetically-case-insensitive`, but using [`natural-compare-lite`](https://github.com/litejs/natural-compare-lite) for more friendly sorting of numbers
+
 ### Default configuration
 
 The default configuration looks as follows:

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/method-signature-style.md

@@ -6,20 +6,20 @@ description: 'Enforce using a particular method signature syntax.'
 >
 > See **https://typescript-eslint.io/rules/method-signature-style** for documentation.
 
-There are two ways to define an object/interface function property.
+TypeScript provides two ways to define an object/interface function property:
 
 ```ts
-// method shorthand syntax
-interface T1 {
+interface Example {
+  // method shorthand syntax
   func(arg: string): number;
-}
 
-// regular property with function type
-interface T2 {
+  // regular property with function type
   func: (arg: string) => number;
 }
 ```
 
+The two are very similar; most of the time it doesn't matter which one you use.
+
 A good practice is to use the TypeScript's `strict` option (which implies `strictFunctionTypes`) which enables correct typechecking for function properties only (method signatures get old behavior).
 
 TypeScript FAQ:

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

@@ -9,9 +9,7 @@ description: 'Enforce naming conventions for everything across a codebase.'
 Enforcing naming conventions helps keep the codebase consistent, and reduces overhead when thinking about how to name a variable.
 Additionally, a well-designed style guide can help communicate intent, such as by enforcing all private properties begin with an `_`, and all global-level constants are written in `UPPER_CASE`.
 
-There are many different rules that have existed over time, but they have had the problem of not having enough granularity, meaning it was hard to have a well defined style guide, and most of the time you needed 3 or more rules at once to enforce different conventions, hoping they didn't conflict.
-
-## Rule Details
+## Examples
 
 This rule allows you to enforce conventions for any identifier, using granular selectors to create a fine-grained style guide.
 
@@ -151,7 +149,7 @@ The `leadingUnderscore` / `trailingUnderscore` options control whether leading/t
 
 The `prefix` / `suffix` options control which prefix/suffix strings must exist for the identifier. Accepts an array of strings.
 
-If these are provided, the identifier must start with one of the provided values. For example, if you provide `{ prefix: ['IFace', 'Class', 'Type'] }`, then the following names are valid: `IFaceFoo`, `ClassBar`, `TypeBaz`, but the name `Bang` is not valid, as it contains none of the prefixes.
+If these are provided, the identifier must start with one of the provided values. For example, if you provide `{ prefix: ['Class', 'IFace', 'Type'] }`, then the following names are valid: `ClassBar`, `IFaceFoo`, `TypeBaz`, but the name `Bang` is not valid, as it contains none of the prefixes.
 
 **Note:** As [documented above](#format-options), the prefix is trimmed before format is validated, therefore PascalCase must be used to allow variables such as `isEnabled` using the prefix `is`.
 
@@ -159,11 +157,11 @@ If these are provided, the identifier must start with one of the provided values
 
 - `selector` allows you to specify what types of identifiers to target.
   - Accepts one or array of selectors to define an option block that applies to one or multiple selectors.
-  - For example, if you provide `{ selector: ['variable', 'function'] }`, then it will apply the same option to variable and function nodes.
+  - For example, if you provide `{ selector: ['function', 'variable'] }`, then it will apply the same option to variable and function nodes.
   - See [Allowed Selectors, Modifiers and Types](#allowed-selectors-modifiers-and-types) below for the complete list of allowed selectors.
-- `modifiers` allows you to specify which modifiers to granularly apply to, such as the accessibility (`private`/`public`/`protected`), or if the thing is `static`, etc.
+- `modifiers` allows you to specify which modifiers to granularly apply to, such as the accessibility (`private`/`protected`/`public`), or if the thing is `static`, etc.
   - The name must match _all_ of the modifiers.
-  - For example, if you provide `{ modifiers: ['private', 'static', 'readonly'] }`, then it will only match something that is `private static readonly`, and something that is just `private` will not match.
+  - For example, if you provide `{ modifiers: ['private','readonly','static'] }`, then it will only match something that is `private static readonly`, and something that is just `private` will not match.
   - The following `modifiers` are allowed:
     - `const` - matches a variable declared as being `const` (`const x = 1`).
     - `destructured` - matches a variable declared via an object destructuring pattern (`const {x, z = 2}`).
@@ -173,8 +171,9 @@ If these are provided, the identifier must start with one of the provided values
     - `unused` - matches anything that is not used.
     - `requiresQuotes` - matches any name that requires quotes as it is not a valid identifier (i.e. has a space, a dash, etc in it).
     - `public` - matches any member that is either explicitly declared as `public`, or has no visibility modifier (i.e. implicitly public).
-    - `readonly`, `static`, `abstract`, `protected`, `private` - matches any member explicitly declared with the given modifier.
-- `types` allows you to specify which types to match. This option supports simple, primitive types only (`boolean`, `string`, `number`, `array`, `function`).
+    - `abstract`,`override`,`private`,`protected`,`readonly`,`static` - matches any member explicitly declared with the given modifier.
+    - `async` - matches any method, function, or function variable which is async via the `async` keyword (e.g. does not match functions that return promises without using `async` keyword)
+- `types` allows you to specify which types to match. This option supports simple, primitive types only (`array`,`boolean`,`function`,`number`,`string`).
   - The name must match _one_ of the types.
   - **_NOTE - Using this option will require that you lint with type information._**
   - For example, this lets you do things like enforce that `boolean` variables are prefixed with a verb.
@@ -195,39 +194,39 @@ There are two types of selectors, individual selectors, and grouped selectors.
 
 Individual Selectors match specific, well-defined sets. There is no overlap between each of the individual selectors.
 
-- `variable` - matches any `var` / `let` / `const` variable name.
-  - Allowed `modifiers`: `const`, `destructured`, `global`, `exported`, `unused`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+- `variable` - matches any `let` / `const` / `var` variable name.
+  - Allowed `modifiers`: `async`, `const`, `destructured`, `exported`, `global`, `unused`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `function` - matches any named function declaration or named function expression.
-  - Allowed `modifiers`: `global`, `exported`, `unused`.
+  - Allowed `modifiers`: `async`, `exported`, `global`, `unused`.
   - Allowed `types`: none.
 - `parameter` - matches any function parameter. Does not match parameter properties.
   - Allowed `modifiers`: `destructured`, `unused`.
   - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
 - `classProperty` - matches any class property. Does not match properties that have direct function expression or arrow function expression values.
-  - Allowed `modifiers`: `abstract`, `private`, `protected`, `public`, `readonly`, `requiresQuotes`, `static`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `modifiers`: `abstract`, `override`, `private`, `protected`, `public`, `readonly`, `requiresQuotes`, `static`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `objectLiteralProperty` - matches any object literal property. Does not match properties that have direct function expression or arrow function expression values.
   - Allowed `modifiers`: `public`, `requiresQuotes`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `typeProperty` - matches any object type property. Does not match properties that have direct function expression or arrow function expression values.
   - Allowed `modifiers`: `public`, `readonly`, `requiresQuotes`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `parameterProperty` - matches any parameter property.
   - Allowed `modifiers`: `private`, `protected`, `public`, `readonly`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `classMethod` - matches any class method. Also matches properties that have direct function expression or arrow function expression values. Does not match accessors.
-  - Allowed `modifiers`: `abstract`, `private`, `protected`, `public`, `requiresQuotes`, `static`.
+  - Allowed `modifiers`: `abstract`, `async`, `override`, `private`, `protected`, `public`, `requiresQuotes`, `static`.
   - Allowed `types`: none.
 - `objectLiteralMethod` - matches any object literal method. Also matches properties that have direct function expression or arrow function expression values. Does not match accessors.
-  - Allowed `modifiers`: `public`, `requiresQuotes`.
+  - Allowed `modifiers`: `async`, `public`, `requiresQuotes`.
   - Allowed `types`: none.
 - `typeMethod` - matches any object type method. Also matches properties that have direct function expression or arrow function expression values. Does not match accessors.
   - Allowed `modifiers`: `public`, `requiresQuotes`.
   - Allowed `types`: none.
 - `accessor` - matches any accessor.
-  - Allowed `modifiers`: `abstract`, `private`, `protected`, `public`, `requiresQuotes`, `static`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `modifiers`: `abstract`, `override`, `private`, `protected`, `public`, `requiresQuotes`, `static`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `enumMember` - matches any enum member.
   - Allowed `modifiers`: `requiresQuotes`.
   - Allowed `types`: none.
@@ -254,20 +253,20 @@ Group Selectors are provided for convenience, and essentially bundle up sets of
 - `default` - matches everything.
   - Allowed `modifiers`: all modifiers.
   - Allowed `types`: none.
-- `variableLike` - matches the same as `variable`, `function` and `parameter`.
-  - Allowed `modifiers`: `unused`.
+- `variableLike` - matches the same as `function`, `parameter` and `variable`.
+  - Allowed `modifiers`: `async`, `unused`.
   - Allowed `types`: none.
-- `memberLike` - matches the same as `property`, `parameterProperty`, `method`, `accessor`, `enumMember`.
-  - Allowed `modifiers`: `private`, `protected`, `public`, `static`, `readonly`, `abstract`, `requiresQuotes`.
+- `memberLike` - matches the same as `accessor`, `enumMember`, `method`, `parameterProperty`, `property`.
+  - Allowed `modifiers`: `abstract`, `async`, `override`, `private`, `protected`, `public`, `readonly`, `requiresQuotes`, `static`.
   - Allowed `types`: none.
-- `typeLike` - matches the same as `class`, `interface`, `typeAlias`, `enum`, `typeParameter`.
+- `typeLike` - matches the same as `class`, `enum`, `interface`, `typeAlias`, `typeParameter`.
   - Allowed `modifiers`: `abstract`, `unused`.
   - Allowed `types`: none.
 - `property` - matches the same as `classProperty`, `objectLiteralProperty`, `typeProperty`.
-  - Allowed `modifiers`: `private`, `protected`, `public`, `static`, `readonly`, `abstract`, `requiresQuotes`.
-  - Allowed `types`: `boolean`, `string`, `number`, `function`, `array`.
+  - Allowed `modifiers`: `abstract`, `async`, `override`, `private`, `protected`, `public`, `readonly`, `requiresQuotes`, `static`.
+  - Allowed `types`: `array`, `boolean`, `function`, `number`, `string`.
 - `method` - matches the same as `classMethod`, `objectLiteralMethod`, `typeMethod`.
-  - Allowed `modifiers`: `private`, `protected`, `public`, `static`, `readonly`, `abstract`, `requiresQuotes`.
+  - Allowed `modifiers`: `abstract`, `async`, `override`, `private`, `protected`, `public`, `readonly`, `requiresQuotes`, `static`.
   - Allowed `types`: none.
 
 ## FAQ

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-array-constructor.md

@@ -6,7 +6,7 @@ description: 'Disallow generic `Array` constructors.'
 >
 > See **https://typescript-eslint.io/rules/no-array-constructor** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-array-constructor`](https://eslint.org/docs/rules/no-array-constructor) rule.
 It adds support for the generically typed `Array` constructor (`new Array<Foo>()`).

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-base-to-string.md

@@ -6,20 +6,14 @@ description: 'Require `.toString()` to only be called on objects which provide u
 >
 > See **https://typescript-eslint.io/rules/no-base-to-string** for documentation.
 
-Requires `.toString()` to only be called on objects which provide useful information when stringified.
-
 JavaScript will call `toString()` on an object when it is converted to a string, such as when `+` adding to a string or in `${}` template literals.
+The default Object `.toString()` returns `"[object Object]"`, which is often not what was intended.
+This rule reports on stringified values that aren't primitives and don't define a more useful `.toString()` method.
 
-The default Object `.toString()` returns `"[object Object]"`, so this rule requires stringified objects define a more useful `.toString()` method.
-
-Note that `Function` provides its own `.toString()` that returns the function's code.
-Functions are not flagged by this rule.
-
-This rule has some overlap with [`restrict-plus-operands`](./restrict-plus-operands.md) and [`restrict-template-expressions`](./restrict-template-expressions.md).
-
-## Rule Details
+> Note that `Function` provides its own `.toString()` that returns the function's code.
+> Functions are not flagged by this rule.
 
-This rule prevents accidentally defaulting to the base Object `.toString()` method.
+## Examples
 
 <!--tabs-->
 
@@ -84,4 +78,11 @@ let text = `${value}`;
 
 If you don't mind `"[object Object]"` in your strings, then you will not need this rule.
 
+## Related To
+
+- [`restrict-plus-operands`](./restrict-plus-operands.md)
+- [`restrict-template-expressions`](./restrict-template-expressions.md)
+
+## Further Reading
+
 - [`Object.prototype.toString()` MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-confusing-non-null-assertion.md

@@ -6,8 +6,6 @@ description: 'Disallow non-null assertion in locations that may be confusing.'
 >
 > See **https://typescript-eslint.io/rules/no-confusing-non-null-assertion** for documentation.
 
-## Rule Details
-
 Using a non-null assertion (`!`) next to an assign or equals check (`=` or `==` or `===`) creates code that is confusing as it looks similar to a not equals check (`!=` `!==`).
 
 ```typescript
@@ -16,6 +14,10 @@ a !== b; // not equals test(`!==`)
 a! === b; // a non-null assertions(`!`) and an triple equals test(`===`)
 ```
 
+This rule flags confusing `!` assertions and suggests either removing them or wrapping the asserted expression in `()` parenthesis.
+
+## Examples
+
 <!--tabs-->
 
 ### ❌ Incorrect

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-confusing-void-expression.md

@@ -6,12 +6,11 @@ description: 'Require expressions of type void to appear in statement position.'
 >
 > See **https://typescript-eslint.io/rules/no-confusing-void-expression** for documentation.
 
-Returning the results of an expression whose type is void can be misleading.
-Attempting to do so is likely a symptom of expecting a different return type from a function.
-Even if used correctly, it can be misleading for other developers,
-who don't know what a particular function does and if its result matters.
+`void` in TypeScript refers to a function return that is meant to be ignored.
+Attempting to use a `void`-typed value, such as storing the result of a called function in a variable, is often a sign of a programmer error.
+`void` can also be misleading for other developers even if used correctly.
 
-This rule provides automatic fixes for most common cases.
+This rule prevents `void` type expressions from being used in misleading locations such as being assigned to a variable, provided as a function argument, or returned from a function.
 
 ## Examples
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-dupe-class-members.md

@@ -6,7 +6,7 @@ description: 'Disallow duplicate class members.'
 >
 > See **https://typescript-eslint.io/rules/no-dupe-class-members** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-dupe-class-members`](https://eslint.org/docs/rules/no-dupe-class-members) rule.
 It adds support for TypeScript's method overload definitions.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-duplicate-enum-values.md

@@ -8,9 +8,12 @@ description: 'Disallow duplicate enum member values.'
 
 Although TypeScript supports duplicate enum member values, people usually expect members to have unique values within the same enum. Duplicate values can lead to bugs that are hard to track down.
 
-## Rule Details
+## Examples
 
-This rule disallows defining an enum with multiple members initialized to the same value. Now it only enforces on enum members initialized with String or Number literals. Members without initializer or initialized with an expression are not checked by this rule.
+This rule disallows defining an enum with multiple members initialized to the same value.
+
+> This rule only enforces on enum members initialized with string or number literals.
+> Members without an initializer or initialized with an expression are not checked by this rule.
 
 <!--tabs-->
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-dynamic-delete.md

@@ -7,12 +7,12 @@ description: 'Disallow using the `delete` operator on computed key expressions.'
 > See **https://typescript-eslint.io/rules/no-dynamic-delete** for documentation.
 
 Deleting dynamically computed keys can be dangerous and in some cases not well optimized.
-
-## Rule Details
-
 Using the `delete` operator on keys that aren't runtime constants could be a sign that you're using the wrong data structures.
 Using `Object`s with added and removed keys can cause occasional edge case bugs, such as if a key is named `"hasOwnProperty"`.
-Consider using a `Map` or `Set` if you’re storing collections of objects.
+
+> Consider using a `Map` or `Set` if you’re storing collections of objects.
+
+## Examples
 
 <!--tabs-->
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-empty-function.md

@@ -6,7 +6,7 @@ description: 'Disallow empty functions.'
 >
 > See **https://typescript-eslint.io/rules/no-empty-function** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-empty-function`](https://eslint.org/docs/rules/no-empty-function) rule.
 It adds support for handling TypeScript specific code that would otherwise trigger the rule.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-empty-interface.md

@@ -6,13 +6,13 @@ description: 'Disallow the declaration of empty interfaces.'
 >
 > See **https://typescript-eslint.io/rules/no-empty-interface** for documentation.
 
-An empty interface is equivalent to its supertype. If the interface does not implement a supertype, then
-the interface is equivalent to an empty object (`{}`). In both cases it can be omitted.
-
-## Rule Details
+An empty interface in TypeScript does very little: any non-nullable value is assignable to `{}`.
+Using an empty interface is often a sign of programmer error, such as misunderstanding the concept of `{}` or forgetting to fill in fields.
 
 This rule aims to ensure that only meaningful interfaces are declared in the code.
 
+## Examples
+
 <!--tabs-->
 
 ### ❌ Incorrect
@@ -48,7 +48,7 @@ interface Baz extends Foo, Bar {}
 
 <!--/tabs-->
 
-### Options
+## Options
 
 This rule accepts a single object option with the following default configuration:
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-explicit-any.md

@@ -6,16 +6,13 @@ description: 'Disallow the `any` type.'
 >
 > See **https://typescript-eslint.io/rules/no-explicit-any** for documentation.
 
-Using the `any` type defeats the purpose of using TypeScript.
-When `any` is used, all compiler type checks around that value are ignored.
+The `any` type in TypeScript is a dangerous "escape hatch" from the type system.
+Using `any` disables many type checking rules and is generally best used only as a last resort or when prototyping code.
+This rule reports on explicit uses of the `any` keyword as a type annotation.
 
-## Rule Details
+> TypeScript's `--noImplicitAny` compiler option prevents an implied `any`, but doesn't prevent `any` from being explicitly used the way this rule does.
 
-This rule doesn't allow `any` types to be defined.
-It aims to keep TypeScript maximally useful.
-TypeScript has a compiler flag for `--noImplicitAny` that will prevent
-an `any` type from being implied by the compiler, but doesn't prevent
-`any` from being explicitly used.
+## Examples
 
 <!--tabs-->
 
@@ -164,6 +161,14 @@ interface Garply {
 If an unknown type or a library without typings is used
 and you want to be able to specify `any`.
 
+## Related To
+
+- [`no-unsafe-argument`](./no-unsafe-argument.md)
+- [`no-unsafe-assignment`](./no-unsafe-assignment.md)
+- [`no-unsafe-call`](./no-unsafe-call.md)
+- [`no-unsafe-member-access`](./no-unsafe-member-access.md)
+- [`no-unsafe-return`](./no-unsafe-return.md)
+
 ## Further Reading
 
 - TypeScript [any type](https://www.typescriptlang.org/docs/handbook/basic-types.html#any)

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-non-null-assertion.md

@@ -1,14 +1,15 @@
 ---
-description: 'Disallow extra non-null assertion.'
+description: 'Disallow extra non-null assertions.'
 ---
 
 > 🛑 This file is source code, not the primary documentation location! 🛑
 >
 > See **https://typescript-eslint.io/rules/no-extra-non-null-assertion** for documentation.
 
-## Rule Details
+The `!` non-null assertion operator in TypeScript is used to assert that a value's type does not include `null` or `undefined`.
+Using the operator any more than once on a single value does nothing.
 
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-parens.md

@@ -6,7 +6,7 @@ description: 'Disallow unnecessary parentheses.'
 >
 > See **https://typescript-eslint.io/rules/no-extra-parens** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-extra-parens`](https://eslint.org/docs/rules/no-extra-parens) rule.
 It adds support for TypeScript type assertions.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extra-semi.md

@@ -6,7 +6,7 @@ description: 'Disallow unnecessary semicolons.'
 >
 > See **https://typescript-eslint.io/rules/no-extra-semi** for documentation.
 
-## Rule Details
+## Examples
 
 This rule extends the base [`eslint/no-extra-semi`](https://eslint.org/docs/rules/no-extra-semi) rule.
 It adds support for class properties.

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-extraneous-class.md

@@ -6,23 +6,21 @@ description: 'Disallow classes used as namespaces.'
 >
 > See **https://typescript-eslint.io/rules/no-extraneous-class** for documentation.
 
-This rule warns when a class has no non-static members, such as for a class used exclusively as a static namespace.
-
-## Rule Details
+This rule reports when a class has no non-static members, such as for a class used exclusively as a static namespace.
 
 Users who come from a [OOP](https://en.wikipedia.org/wiki/Object-oriented_programming) paradigm may wrap their utility functions in an extra class, instead of putting them at the top level of an ECMAScript module.
 Doing so is generally unnecessary in JavaScript and TypeScript projects.
 
 - Wrapper classes add extra cognitive complexity to code without adding any structural improvements
   - Whatever would be put on them, such as utility functions, are already organized by virtue of being in a module.
-  - As an alternative, you can always `import * as ...` the module to get all of them in a single object.
+  - As an alternative, you can `import * as ...` the module to get all of them in a single object.
 - IDEs can't provide as good suggestions for static class or namespace imported properties when you start typing property names
 - It's more difficult to statically analyze code for unused variables, etc. when they're all on the class (see: [Finding dead code (and dead types) in TypeScript](https://effectivetypescript.com/2020/10/20/tsprune)).
 
-This rule also flags classes that have only a constructor and no fields.
+This rule also reports classes that have only a constructor and no fields.
 Those classes can generally be replaced with a standalone function.
 
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->
 

package/node_modules/@typescript-eslint/eslint-plugin/docs/rules/no-floating-promises.md

@@ -7,9 +7,9 @@ description: 'Require Promise-like statements to be handled appropriately.'
 > See **https://typescript-eslint.io/rules/no-floating-promises** for documentation.
 
 A "floating" Promise is one that is created without any code set up to handle any errors it might throw.
-
 Floating Promises can cause several issues, such as improperly sequenced operations, ignored Promise rejections, and more.
 
+This rule reports when a Promise is created and not properly handled.
 Valid ways of handling a Promise-valued statement include:
 
 - `await`ing it
@@ -22,9 +22,7 @@ Valid ways of handling a Promise-valued statement include:
 See [`no-misused-promises`](./no-misused-promises.md) for detecting code that provides Promises to _logical_ locations such as if statements.
 :::
 
-## Rule Details
-
-Examples of code for this rule:
+## Examples
 
 <!--tabs-->