1 | import { Linter } from "../index";
|
2 |
|
3 | export interface BestPractices extends Linter.RulesRecord {
|
4 | /**
|
5 | * Rule to enforce getter and setter pairs in objects.
|
6 | *
|
7 | * @since 0.22.0
|
8 | * @see https://eslint.org/docs/rules/accessor-pairs
|
9 | */
|
10 | "accessor-pairs": Linter.RuleEntry<
|
11 | [
|
12 | Partial<{
|
13 | /**
|
14 | * @default true
|
15 | */
|
16 | setWithoutGet: boolean;
|
17 | /**
|
18 | * @default false
|
19 | */
|
20 | getWithoutSet: boolean;
|
21 | }>,
|
22 | ]
|
23 | >;
|
24 |
|
25 | /**
|
26 | * Rule to enforce `return` statements in callbacks of array methods.
|
27 | *
|
28 | * @since 2.0.0-alpha-1
|
29 | * @see https://eslint.org/docs/rules/array-callback-return
|
30 | */
|
31 | "array-callback-return": Linter.RuleEntry<
|
32 | [
|
33 | Partial<{
|
34 | /**
|
35 | * @default false
|
36 | */
|
37 | allowImplicit: boolean;
|
38 | }>,
|
39 | ]
|
40 | >;
|
41 |
|
42 | /**
|
43 | * Rule to enforce the use of variables within the scope they are defined.
|
44 | *
|
45 | * @since 0.1.0
|
46 | * @see https://eslint.org/docs/rules/block-scoped-var
|
47 | */
|
48 | "block-scoped-var": Linter.RuleEntry<[]>;
|
49 |
|
50 | /**
|
51 | * Rule to enforce that class methods utilize `this`.
|
52 | *
|
53 | * @since 3.4.0
|
54 | * @see https://eslint.org/docs/rules/class-methods-use-this
|
55 | */
|
56 | "class-methods-use-this": Linter.RuleEntry<
|
57 | [
|
58 | Partial<{
|
59 | exceptMethods: string[];
|
60 | }>,
|
61 | ]
|
62 | >;
|
63 |
|
64 | /**
|
65 | * Rule to enforce a maximum cyclomatic complexity allowed in a program.
|
66 | *
|
67 | * @since 0.0.9
|
68 | * @see https://eslint.org/docs/rules/complexity
|
69 | */
|
70 | complexity: Linter.RuleEntry<
|
71 | [
|
72 | | Partial<{
|
73 | /**
|
74 | * @default 20
|
75 | */
|
76 | max: number;
|
77 | /**
|
78 | * @deprecated
|
79 | * @default 20
|
80 | */
|
81 | maximum: number;
|
82 | }>
|
83 | | number,
|
84 | ]
|
85 | >;
|
86 |
|
87 | /**
|
88 | * Rule to require `return` statements to either always or never specify values.
|
89 | *
|
90 | * @since 0.4.0
|
91 | * @see https://eslint.org/docs/rules/consistent-return
|
92 | */
|
93 | "consistent-return": Linter.RuleEntry<
|
94 | [
|
95 | Partial<{
|
96 | /**
|
97 | * @default false
|
98 | */
|
99 | treatUndefinedAsUnspecified: boolean;
|
100 | }>,
|
101 | ]
|
102 | >;
|
103 |
|
104 | /**
|
105 | * Rule to enforce consistent brace style for all control statements.
|
106 | *
|
107 | * @since 0.0.2
|
108 | * @see https://eslint.org/docs/rules/curly
|
109 | */
|
110 | curly: Linter.RuleEntry<["all" | "multi" | "multi-line" | "multi-or-nest" | "consistent"]>;
|
111 |
|
112 | /**
|
113 | * Rule to require `default` cases in `switch` statements.
|
114 | *
|
115 | * @since 0.6.0
|
116 | * @see https://eslint.org/docs/rules/default-case
|
117 | */
|
118 | "default-case": Linter.RuleEntry<
|
119 | [
|
120 | Partial<{
|
121 | /**
|
122 | * @default '^no default$'
|
123 | */
|
124 | commentPattern: string;
|
125 | }>,
|
126 | ]
|
127 | >;
|
128 |
|
129 | /**
|
130 | * Rule to enforce consistent newlines before and after dots.
|
131 | *
|
132 | * @since 0.21.0
|
133 | * @see https://eslint.org/docs/rules/dot-location
|
134 | */
|
135 | "dot-location": Linter.RuleEntry<["object" | "property"]>;
|
136 |
|
137 | /**
|
138 | * Rule to enforce dot notation whenever possible.
|
139 | *
|
140 | * @since 0.0.7
|
141 | * @see https://eslint.org/docs/rules/dot-notation
|
142 | */
|
143 | "dot-notation": Linter.RuleEntry<
|
144 | [
|
145 | Partial<{
|
146 | /**
|
147 | * @default true
|
148 | */
|
149 | allowKeywords: boolean;
|
150 | allowPattern: string;
|
151 | }>,
|
152 | ]
|
153 | >;
|
154 |
|
155 | /**
|
156 | * Rule to require the use of `===` and `!==`.
|
157 | *
|
158 | * @since 0.0.2
|
159 | * @see https://eslint.org/docs/rules/eqeqeq
|
160 | */
|
161 | eqeqeq:
|
162 | | Linter.RuleEntry<
|
163 | [
|
164 | "always",
|
165 | Partial<{
|
166 | /**
|
167 | * @default 'always'
|
168 | */
|
169 | null: "always" | "never" | "ignore";
|
170 | }>,
|
171 | ]
|
172 | >
|
173 | | Linter.RuleEntry<["smart" | "allow-null"]>;
|
174 |
|
175 | /**
|
176 | * Rule to require `for-in` loops to include an `if` statement.
|
177 | *
|
178 | * @since 0.0.6
|
179 | * @see https://eslint.org/docs/rules/guard-for-in
|
180 | */
|
181 | "guard-for-in": Linter.RuleEntry<[]>;
|
182 |
|
183 | /**
|
184 | * Rule to enforce a maximum number of classes per file.
|
185 | *
|
186 | * @since 5.0.0-alpha.3
|
187 | * @see https://eslint.org/docs/rules/max-classes-per-file
|
188 | */
|
189 | "max-classes-per-file": Linter.RuleEntry<[number]>;
|
190 |
|
191 | /**
|
192 | * Rule to disallow the use of `alert`, `confirm`, and `prompt`.
|
193 | *
|
194 | * @since 0.0.5
|
195 | * @see https://eslint.org/docs/rules/no-alert
|
196 | */
|
197 | "no-alert": Linter.RuleEntry<[]>;
|
198 |
|
199 | /**
|
200 | * Rule to disallow the use of `arguments.caller` or `arguments.callee`.
|
201 | *
|
202 | * @since 0.0.6
|
203 | * @see https://eslint.org/docs/rules/no-caller
|
204 | */
|
205 | "no-caller": Linter.RuleEntry<[]>;
|
206 |
|
207 | /**
|
208 | * Rule to disallow lexical declarations in case clauses.
|
209 | *
|
210 | * @remarks
|
211 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
212 | *
|
213 | * @since 1.9.0
|
214 | * @see https://eslint.org/docs/rules/no-case-declarations
|
215 | */
|
216 | "no-case-declarations": Linter.RuleEntry<[]>;
|
217 |
|
218 | /**
|
219 | * Rule to disallow division operators explicitly at the beginning of regular expressions.
|
220 | *
|
221 | * @since 0.1.0
|
222 | * @see https://eslint.org/docs/rules/no-div-regex
|
223 | */
|
224 | "no-div-regex": Linter.RuleEntry<[]>;
|
225 |
|
226 | /**
|
227 | * Rule to disallow `else` blocks after `return` statements in `if` statements.
|
228 | *
|
229 | * @since 0.0.9
|
230 | * @see https://eslint.org/docs/rules/no-else-return
|
231 | */
|
232 | "no-else-return": Linter.RuleEntry<
|
233 | [
|
234 | Partial<{
|
235 | /**
|
236 | * @default true
|
237 | */
|
238 | allowElseIf: boolean;
|
239 | }>,
|
240 | ]
|
241 | >;
|
242 |
|
243 | /**
|
244 | * Rule to disallow empty functions.
|
245 | *
|
246 | * @since 2.0.0
|
247 | * @see https://eslint.org/docs/rules/no-empty-function
|
248 | */
|
249 | "no-empty-function": Linter.RuleEntry<
|
250 | [
|
251 | Partial<{
|
252 | /**
|
253 | * @default []
|
254 | */
|
255 | allow: Array<
|
256 | | "functions"
|
257 | | "arrowFunctions"
|
258 | | "generatorFunctions"
|
259 | | "methods"
|
260 | | "generatorMethods"
|
261 | | "getters"
|
262 | | "setters"
|
263 | | "constructors"
|
264 | >;
|
265 | }>,
|
266 | ]
|
267 | >;
|
268 |
|
269 | /**
|
270 | * Rule to disallow empty destructuring patterns.
|
271 | *
|
272 | * @remarks
|
273 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
274 | *
|
275 | * @since 1.7.0
|
276 | * @see https://eslint.org/docs/rules/no-empty-pattern
|
277 | */
|
278 | "no-empty-pattern": Linter.RuleEntry<[]>;
|
279 |
|
280 | /**
|
281 | * Rule to disallow `null` comparisons without type-checking operators.
|
282 | *
|
283 | * @since 0.0.9
|
284 | * @see https://eslint.org/docs/rules/no-eq-null
|
285 | */
|
286 | "no-eq-null": Linter.RuleEntry<[]>;
|
287 |
|
288 | /**
|
289 | * Rule to disallow the use of `eval()`.
|
290 | *
|
291 | * @since 0.0.2
|
292 | * @see https://eslint.org/docs/rules/no-eval
|
293 | */
|
294 | "no-eval": Linter.RuleEntry<
|
295 | [
|
296 | Partial<{
|
297 | /**
|
298 | * @default false
|
299 | */
|
300 | allowIndirect: boolean;
|
301 | }>,
|
302 | ]
|
303 | >;
|
304 |
|
305 | /**
|
306 | * Rule to disallow extending native types.
|
307 | *
|
308 | * @since 0.1.4
|
309 | * @see https://eslint.org/docs/rules/no-extend-native
|
310 | */
|
311 | "no-extend-native": Linter.RuleEntry<
|
312 | [
|
313 | Partial<{
|
314 | exceptions: string[];
|
315 | }>,
|
316 | ]
|
317 | >;
|
318 |
|
319 | /**
|
320 | * Rule to disallow unnecessary calls to `.bind()`.
|
321 | *
|
322 | * @since 0.8.0
|
323 | * @see https://eslint.org/docs/rules/no-extra-bind
|
324 | */
|
325 | "no-extra-bind": Linter.RuleEntry<[]>;
|
326 |
|
327 | /**
|
328 | * Rule to disallow unnecessary labels.
|
329 | *
|
330 | * @since 2.0.0-rc.0
|
331 | * @see https://eslint.org/docs/rules/no-extra-label
|
332 | */
|
333 | "no-extra-label": Linter.RuleEntry<[]>;
|
334 |
|
335 | /**
|
336 | * Rule to disallow fallthrough of `case` statements.
|
337 | *
|
338 | * @remarks
|
339 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
340 | *
|
341 | * @since 0.0.7
|
342 | * @see https://eslint.org/docs/rules/no-fallthrough
|
343 | */
|
344 | "no-fallthrough": Linter.RuleEntry<
|
345 | [
|
346 | Partial<{
|
347 | /**
|
348 | * @default 'falls?\s?through'
|
349 | */
|
350 | commentPattern: string;
|
351 | }>,
|
352 | ]
|
353 | >;
|
354 |
|
355 | /**
|
356 | * Rule to disallow leading or trailing decimal points in numeric literals.
|
357 | *
|
358 | * @since 0.0.6
|
359 | * @see https://eslint.org/docs/rules/no-floating-decimal
|
360 | */
|
361 | "no-floating-decimal": Linter.RuleEntry<[]>;
|
362 |
|
363 | /**
|
364 | * Rule to disallow assignments to native objects or read-only global variables.
|
365 | *
|
366 | * @remarks
|
367 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
368 | *
|
369 | * @since 3.3.0
|
370 | * @see https://eslint.org/docs/rules/no-global-assign
|
371 | */
|
372 | "no-global-assign": Linter.RuleEntry<
|
373 | [
|
374 | Partial<{
|
375 | exceptions: string[];
|
376 | }>,
|
377 | ]
|
378 | >;
|
379 |
|
380 | /**
|
381 | * Rule to disallow shorthand type conversions.
|
382 | *
|
383 | * @since 1.0.0-rc-2
|
384 | * @see https://eslint.org/docs/rules/no-implicit-coercion
|
385 | */
|
386 | "no-implicit-coercion": Linter.RuleEntry<
|
387 | [
|
388 | Partial<{
|
389 | /**
|
390 | * @default true
|
391 | */
|
392 | boolean: boolean;
|
393 | /**
|
394 | * @default true
|
395 | */
|
396 | number: boolean;
|
397 | /**
|
398 | * @default true
|
399 | */
|
400 | string: boolean;
|
401 | /**
|
402 | * @default []
|
403 | */
|
404 | allow: Array<"~" | "!!" | "+" | "*">;
|
405 | }>,
|
406 | ]
|
407 | >;
|
408 |
|
409 | /**
|
410 | * Rule to disallow variable and `function` declarations in the global scope.
|
411 | *
|
412 | * @since 2.0.0-alpha-1
|
413 | * @see https://eslint.org/docs/rules/no-implicit-globals
|
414 | */
|
415 | "no-implicit-globals": Linter.RuleEntry<[]>;
|
416 |
|
417 | /**
|
418 | * Rule to disallow the use of `eval()`-like methods.
|
419 | *
|
420 | * @since 0.0.7
|
421 | * @see https://eslint.org/docs/rules/no-implied-eval
|
422 | */
|
423 | "no-implied-eval": Linter.RuleEntry<[]>;
|
424 |
|
425 | /**
|
426 | * Rule to disallow `this` keywords outside of classes or class-like objects.
|
427 | *
|
428 | * @since 1.0.0-rc-2
|
429 | * @see https://eslint.org/docs/rules/no-invalid-this
|
430 | */
|
431 | "no-invalid-this": Linter.RuleEntry<[]>;
|
432 |
|
433 | /**
|
434 | * Rule to disallow the use of the `__iterator__` property.
|
435 | *
|
436 | * @since 0.0.9
|
437 | * @see https://eslint.org/docs/rules/no-iterator
|
438 | */
|
439 | "no-iterator": Linter.RuleEntry<[]>;
|
440 |
|
441 | /**
|
442 | * Rule to disallow labeled statements.
|
443 | *
|
444 | * @since 0.4.0
|
445 | * @see https://eslint.org/docs/rules/no-labels
|
446 | */
|
447 | "no-labels": Linter.RuleEntry<
|
448 | [
|
449 | Partial<{
|
450 | /**
|
451 | * @default false
|
452 | */
|
453 | allowLoop: boolean;
|
454 | /**
|
455 | * @default false
|
456 | */
|
457 | allowSwitch: boolean;
|
458 | }>,
|
459 | ]
|
460 | >;
|
461 |
|
462 | /**
|
463 | * Rule to disallow unnecessary nested blocks.
|
464 | *
|
465 | * @since 0.4.0
|
466 | * @see https://eslint.org/docs/rules/no-lone-blocks
|
467 | */
|
468 | "no-lone-blocks": Linter.RuleEntry<[]>;
|
469 |
|
470 | /**
|
471 | * Rule to disallow function declarations that contain unsafe references inside loop statements.
|
472 | *
|
473 | * @since 0.0.9
|
474 | * @see https://eslint.org/docs/rules/no-loop-func
|
475 | */
|
476 | "no-loop-func": Linter.RuleEntry<[]>;
|
477 |
|
478 | /**
|
479 | * Rule to disallow magic numbers.
|
480 | *
|
481 | * @since 1.7.0
|
482 | * @see https://eslint.org/docs/rules/no-magic-numbers
|
483 | */
|
484 | "no-magic-numbers": Linter.RuleEntry<
|
485 | [
|
486 | Partial<{
|
487 | /**
|
488 | * @default []
|
489 | */
|
490 | ignore: number[];
|
491 | /**
|
492 | * @default false
|
493 | */
|
494 | ignoreArrayIndexes: boolean;
|
495 | /**
|
496 | * @default false
|
497 | */
|
498 | enforceConst: boolean;
|
499 | /**
|
500 | * @default false
|
501 | */
|
502 | detectObjects: boolean;
|
503 | }>,
|
504 | ]
|
505 | >;
|
506 |
|
507 | /**
|
508 | * Rule to disallow multiple spaces.
|
509 | *
|
510 | * @since 0.9.0
|
511 | * @see https://eslint.org/docs/rules/no-multi-spaces
|
512 | */
|
513 | "no-multi-spaces": Linter.RuleEntry<
|
514 | [
|
515 | Partial<{
|
516 | /**
|
517 | * @default false
|
518 | */
|
519 | ignoreEOLComments: boolean;
|
520 | /**
|
521 | * @default { Property: true }
|
522 | */
|
523 | exceptions: Record<string, boolean>;
|
524 | }>,
|
525 | ]
|
526 | >;
|
527 |
|
528 | /**
|
529 | * Rule to disallow multiline strings.
|
530 | *
|
531 | * @since 0.0.9
|
532 | * @see https://eslint.org/docs/rules/no-multi-str
|
533 | */
|
534 | "no-multi-str": Linter.RuleEntry<[]>;
|
535 |
|
536 | /**
|
537 | * Rule to disallow `new` operators outside of assignments or comparisons.
|
538 | *
|
539 | * @since 0.0.7
|
540 | * @see https://eslint.org/docs/rules/no-new
|
541 | */
|
542 | "no-new": Linter.RuleEntry<[]>;
|
543 |
|
544 | /**
|
545 | * Rule to disallow `new` operators with the `Function` object.
|
546 | *
|
547 | * @since 0.0.7
|
548 | * @see https://eslint.org/docs/rules/no-new-func
|
549 | */
|
550 | "no-new-func": Linter.RuleEntry<[]>;
|
551 |
|
552 | /**
|
553 | * Rule to disallow `new` operators with the `String`, `Number`, and `Boolean` objects.
|
554 | *
|
555 | * @since 0.0.6
|
556 | * @see https://eslint.org/docs/rules/no-new-wrappers
|
557 | */
|
558 | "no-new-wrappers": Linter.RuleEntry<[]>;
|
559 |
|
560 | /**
|
561 | * Rule to disallow octal literals.
|
562 | *
|
563 | * @remarks
|
564 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
565 | *
|
566 | * @since 0.0.6
|
567 | * @see https://eslint.org/docs/rules/no-octal
|
568 | */
|
569 | "no-octal": Linter.RuleEntry<[]>;
|
570 |
|
571 | /**
|
572 | * Rule to disallow octal escape sequences in string literals.
|
573 | *
|
574 | * @since 0.0.9
|
575 | * @see https://eslint.org/docs/rules/no-octal-escape
|
576 | */
|
577 | "no-octal-escape": Linter.RuleEntry<[]>;
|
578 |
|
579 | /**
|
580 | * Rule to disallow reassigning `function` parameters.
|
581 | *
|
582 | * @since 0.18.0
|
583 | * @see https://eslint.org/docs/rules/no-param-reassign
|
584 | */
|
585 | "no-param-reassign": Linter.RuleEntry<
|
586 | [
|
587 | Partial<{
|
588 | /**
|
589 | * @default false
|
590 | */
|
591 | props: boolean;
|
592 | /**
|
593 | * @default []
|
594 | */
|
595 | ignorePropertyModificationsFor: string[];
|
596 | }>,
|
597 | ]
|
598 | >;
|
599 |
|
600 | /**
|
601 | * Rule to disallow the use of the `__proto__` property.
|
602 | *
|
603 | * @since 0.0.9
|
604 | * @see https://eslint.org/docs/rules/no-proto
|
605 | */
|
606 | "no-proto": Linter.RuleEntry<[]>;
|
607 |
|
608 | /**
|
609 | * Rule to disallow variable redeclaration.
|
610 | *
|
611 | * @remarks
|
612 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
613 | *
|
614 | * @since 0.0.9
|
615 | * @see https://eslint.org/docs/rules/no-redeclare
|
616 | */
|
617 | "no-redeclare": Linter.RuleEntry<
|
618 | [
|
619 | Partial<{
|
620 | /**
|
621 | * @default true
|
622 | */
|
623 | builtinGlobals: boolean;
|
624 | }>,
|
625 | ]
|
626 | >;
|
627 |
|
628 | /**
|
629 | * Rule to disallow certain properties on certain objects.
|
630 | *
|
631 | * @since 3.5.0
|
632 | * @see https://eslint.org/docs/rules/no-restricted-properties
|
633 | */
|
634 | "no-restricted-properties": Linter.RuleEntry<
|
635 | [
|
636 | ...Array<
|
637 | | {
|
638 | object: string;
|
639 | property?: string | undefined;
|
640 | message?: string | undefined;
|
641 | }
|
642 | | {
|
643 | property: string;
|
644 | message?: string | undefined;
|
645 | }
|
646 | >
|
647 | ]
|
648 | >;
|
649 |
|
650 | /**
|
651 | * Rule to disallow assignment operators in `return` statements.
|
652 | *
|
653 | * @since 0.0.9
|
654 | * @see https://eslint.org/docs/rules/no-return-assign
|
655 | */
|
656 | "no-return-assign": Linter.RuleEntry<["except-parens" | "always"]>;
|
657 |
|
658 | /**
|
659 | * Rule to disallow unnecessary `return await`.
|
660 | *
|
661 | * @since 3.10.0
|
662 | * @see https://eslint.org/docs/rules/no-return-await
|
663 | */
|
664 | "no-return-await": Linter.RuleEntry<[]>;
|
665 |
|
666 | /**
|
667 | * Rule to disallow `javascript:` urls.
|
668 | *
|
669 | * @since 0.0.9
|
670 | * @see https://eslint.org/docs/rules/no-script-url
|
671 | */
|
672 | "no-script-url": Linter.RuleEntry<[]>;
|
673 |
|
674 | /**
|
675 | * Rule to disallow assignments where both sides are exactly the same.
|
676 | *
|
677 | * @remarks
|
678 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
679 | *
|
680 | * @since 2.0.0-rc.0
|
681 | * @see https://eslint.org/docs/rules/no-self-assign
|
682 | */
|
683 | "no-self-assign": Linter.RuleEntry<[]>;
|
684 |
|
685 | /**
|
686 | * Rule to disallow comparisons where both sides are exactly the same.
|
687 | *
|
688 | * @since 0.0.9
|
689 | * @see https://eslint.org/docs/rules/no-self-compare
|
690 | */
|
691 | "no-self-compare": Linter.RuleEntry<[]>;
|
692 |
|
693 | /**
|
694 | * Rule to disallow comma operators.
|
695 | *
|
696 | * @since 0.5.1
|
697 | * @see https://eslint.org/docs/rules/no-sequences
|
698 | */
|
699 | "no-sequences": Linter.RuleEntry<[]>;
|
700 |
|
701 | /**
|
702 | * Rule to disallow throwing literals as exceptions.
|
703 | *
|
704 | * @since 0.15.0
|
705 | * @see https://eslint.org/docs/rules/no-throw-literal
|
706 | */
|
707 | "no-throw-literal": Linter.RuleEntry<[]>;
|
708 |
|
709 | /**
|
710 | * Rule to disallow unmodified loop conditions.
|
711 | *
|
712 | * @since 2.0.0-alpha-2
|
713 | * @see https://eslint.org/docs/rules/no-unmodified-loop-condition
|
714 | */
|
715 | "no-unmodified-loop-condition": Linter.RuleEntry<[]>;
|
716 |
|
717 | /**
|
718 | * Rule to disallow unused expressions.
|
719 | *
|
720 | * @since 0.1.0
|
721 | * @see https://eslint.org/docs/rules/no-unused-expressions
|
722 | */
|
723 | "no-unused-expressions": Linter.RuleEntry<
|
724 | [
|
725 | Partial<{
|
726 | /**
|
727 | * @default false
|
728 | */
|
729 | allowShortCircuit: boolean;
|
730 | /**
|
731 | * @default false
|
732 | */
|
733 | allowTernary: boolean;
|
734 | /**
|
735 | * @default false
|
736 | */
|
737 | allowTaggedTemplates: boolean;
|
738 | }>,
|
739 | ]
|
740 | >;
|
741 |
|
742 | /**
|
743 | * Rule to disallow unused labels.
|
744 | *
|
745 | * @remarks
|
746 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
747 | *
|
748 | * @since 2.0.0-rc.0
|
749 | * @see https://eslint.org/docs/rules/no-unused-labels
|
750 | */
|
751 | "no-unused-labels": Linter.RuleEntry<[]>;
|
752 |
|
753 | /**
|
754 | * Rule to disallow unnecessary calls to `.call()` and `.apply()`.
|
755 | *
|
756 | * @since 1.0.0-rc-1
|
757 | * @see https://eslint.org/docs/rules/no-useless-call
|
758 | */
|
759 | "no-useless-call": Linter.RuleEntry<[]>;
|
760 |
|
761 | /**
|
762 | * Rule to disallow unnecessary `catch` clauses.
|
763 | *
|
764 | * @remarks
|
765 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
766 | *
|
767 | * @since 5.11.0
|
768 | * @see https://eslint.org/docs/rules/no-useless-catch
|
769 | */
|
770 | "no-useless-catch": Linter.RuleEntry<[]>;
|
771 |
|
772 | /**
|
773 | * Rule to disallow unnecessary concatenation of literals or template literals.
|
774 | *
|
775 | * @since 1.3.0
|
776 | * @see https://eslint.org/docs/rules/no-useless-concat
|
777 | */
|
778 | "no-useless-concat": Linter.RuleEntry<[]>;
|
779 |
|
780 | /**
|
781 | * Rule to disallow unnecessary escape characters.
|
782 | *
|
783 | * @remarks
|
784 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
785 | *
|
786 | * @since 2.5.0
|
787 | * @see https://eslint.org/docs/rules/no-useless-escape
|
788 | */
|
789 | "no-useless-escape": Linter.RuleEntry<[]>;
|
790 |
|
791 | /**
|
792 | * Rule to disallow redundant return statements.
|
793 | *
|
794 | * @since 3.9.0
|
795 | * @see https://eslint.org/docs/rules/no-useless-return
|
796 | */
|
797 | "no-useless-return": Linter.RuleEntry<[]>;
|
798 |
|
799 | /**
|
800 | * Rule to disallow `void` operators.
|
801 | *
|
802 | * @since 0.8.0
|
803 | * @see https://eslint.org/docs/rules/no-void
|
804 | */
|
805 | "no-void": Linter.RuleEntry<[]>;
|
806 |
|
807 | /**
|
808 | * Rule to disallow specified warning terms in comments.
|
809 | *
|
810 | * @since 0.4.4
|
811 | * @see https://eslint.org/docs/rules/no-warning-comments
|
812 | */
|
813 | "no-warning-comments": Linter.RuleEntry<
|
814 | [
|
815 | {
|
816 | /**
|
817 | * @default ["todo", "fixme", "xxx"]
|
818 | */
|
819 | terms: string[];
|
820 | /**
|
821 | * @default 'start'
|
822 | */
|
823 | location: "start" | "anywhere";
|
824 | },
|
825 | ]
|
826 | >;
|
827 |
|
828 | /**
|
829 | * Rule to disallow `with` statements.
|
830 | *
|
831 | * @remarks
|
832 | * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
|
833 | *
|
834 | * @since 0.0.2
|
835 | * @see https://eslint.org/docs/rules/no-with
|
836 | */
|
837 | "no-with": Linter.RuleEntry<[]>;
|
838 |
|
839 | /**
|
840 | * Rule to enforce using named capture group in regular expression.
|
841 | *
|
842 | * @since 5.15.0
|
843 | * @see https://eslint.org/docs/rules/prefer-named-capture-group
|
844 | */
|
845 | "prefer-named-capture-group": Linter.RuleEntry<[]>;
|
846 |
|
847 | /**
|
848 | * Rule to require using Error objects as Promise rejection reasons.
|
849 | *
|
850 | * @since 3.14.0
|
851 | * @see https://eslint.org/docs/rules/prefer-promise-reject-errors
|
852 | */
|
853 | "prefer-promise-reject-errors": Linter.RuleEntry<
|
854 | [
|
855 | Partial<{
|
856 | /**
|
857 | * @default false
|
858 | */
|
859 | allowEmptyReject: boolean;
|
860 | }>,
|
861 | ]
|
862 | >;
|
863 |
|
864 | /**
|
865 | * Rule to enforce the consistent use of the radix argument when using `parseInt()`.
|
866 | *
|
867 | * @since 0.0.7
|
868 | * @see https://eslint.org/docs/rules/radix
|
869 | */
|
870 | radix: Linter.RuleEntry<["always" | "as-needed"]>;
|
871 |
|
872 | /**
|
873 | * Rule to disallow async functions which have no `await` expression.
|
874 | *
|
875 | * @since 3.11.0
|
876 | * @see https://eslint.org/docs/rules/require-await
|
877 | */
|
878 | "require-await": Linter.RuleEntry<[]>;
|
879 |
|
880 | /**
|
881 | * Rule to enforce the use of `u` flag on RegExp.
|
882 | *
|
883 | * @since 5.3.0
|
884 | * @see https://eslint.org/docs/rules/require-unicode-regexp
|
885 | */
|
886 | "require-unicode-regexp": Linter.RuleEntry<[]>;
|
887 |
|
888 | /**
|
889 | * Rule to require `var` declarations be placed at the top of their containing scope.
|
890 | *
|
891 | * @since 0.8.0
|
892 | * @see https://eslint.org/docs/rules/vars-on-top
|
893 | */
|
894 | "vars-on-top": Linter.RuleEntry<[]>;
|
895 |
|
896 | /**
|
897 | * Rule to require parentheses around immediate `function` invocations.
|
898 | *
|
899 | * @since 0.0.9
|
900 | * @see https://eslint.org/docs/rules/wrap-iife
|
901 | */
|
902 | "wrap-iife": Linter.RuleEntry<
|
903 | [
|
904 | "outside" | "inside" | "any",
|
905 | Partial<{
|
906 | /**
|
907 | * @default false
|
908 | */
|
909 | functionPrototypeMethods: boolean;
|
910 | }>,
|
911 | ]
|
912 | >;
|
913 |
|
914 | /**
|
915 | * Rule to require or disallow “Yoda” conditions.
|
916 | *
|
917 | * @since 0.7.1
|
918 | * @see https://eslint.org/docs/rules/yoda
|
919 | */
|
920 | yoda:
|
921 | | Linter.RuleEntry<
|
922 | [
|
923 | "never",
|
924 | Partial<{
|
925 | exceptRange: boolean;
|
926 | onlyEquality: boolean;
|
927 | }>,
|
928 | ]
|
929 | >
|
930 | | Linter.RuleEntry<["always"]>;
|
931 | }
|