eslint 9.9.0 → 9.10.0

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