source: trip-planner-front/node_modules/@types/eslint/rules/best-practices.d.ts@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 23.1 KB
Line 
1import { Linter } from "../index";
2
3export 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}
Note: See TracBrowser for help on using the repository browser.