oxlint 1.64.0 → 1.66.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.
Files changed (6) hide show
  1. package/configuration_schema.json +2407 -2
  2. package/dist/bindings.js +26 -26
  3. package/dist/index.d.ts +802 -1
  4. package/dist/js_config.js +46 -22
  5. package/dist/lint.js +5 -5
  6. package/package.json +20 -20
package/configuration_schema.json CHANGED
@@ -240,6 +240,2411 @@
240
240
  "DummyRuleMap": {
241
241
  "description": "See [Oxlint Rules](https://oxc.rs/docs/guide/usage/linter/rules.html)",
242
242
  "type": "object",
243
+ "properties": {
244
+ "accessor-pairs": {
245
+ "$ref": "#/definitions/DummyRule"
246
+ },
247
+ "array-callback-return": {
248
+ "$ref": "#/definitions/DummyRule"
249
+ },
250
+ "arrow-body-style": {
251
+ "$ref": "#/definitions/DummyRule"
252
+ },
253
+ "block-scoped-var": {
254
+ "$ref": "#/definitions/DummyRule"
255
+ },
256
+ "capitalized-comments": {
257
+ "$ref": "#/definitions/DummyRule"
258
+ },
259
+ "class-methods-use-this": {
260
+ "$ref": "#/definitions/DummyRule"
261
+ },
262
+ "complexity": {
263
+ "$ref": "#/definitions/DummyRule"
264
+ },
265
+ "constructor-super": {
266
+ "$ref": "#/definitions/DummyRule"
267
+ },
268
+ "curly": {
269
+ "$ref": "#/definitions/DummyRule"
270
+ },
271
+ "default-case": {
272
+ "$ref": "#/definitions/DummyRule"
273
+ },
274
+ "default-case-last": {
275
+ "$ref": "#/definitions/DummyRule"
276
+ },
277
+ "default-param-last": {
278
+ "$ref": "#/definitions/DummyRule"
279
+ },
280
+ "eqeqeq": {
281
+ "$ref": "#/definitions/DummyRule"
282
+ },
283
+ "for-direction": {
284
+ "$ref": "#/definitions/DummyRule"
285
+ },
286
+ "func-name-matching": {
287
+ "$ref": "#/definitions/DummyRule"
288
+ },
289
+ "func-names": {
290
+ "$ref": "#/definitions/DummyRule"
291
+ },
292
+ "func-style": {
293
+ "$ref": "#/definitions/DummyRule"
294
+ },
295
+ "getter-return": {
296
+ "$ref": "#/definitions/DummyRule"
297
+ },
298
+ "grouped-accessor-pairs": {
299
+ "$ref": "#/definitions/DummyRule"
300
+ },
301
+ "guard-for-in": {
302
+ "$ref": "#/definitions/DummyRule"
303
+ },
304
+ "id-length": {
305
+ "$ref": "#/definitions/DummyRule"
306
+ },
307
+ "id-match": {
308
+ "$ref": "#/definitions/DummyRule"
309
+ },
310
+ "import/consistent-type-specifier-style": {
311
+ "$ref": "#/definitions/DummyRule"
312
+ },
313
+ "import/default": {
314
+ "$ref": "#/definitions/DummyRule"
315
+ },
316
+ "import/export": {
317
+ "$ref": "#/definitions/DummyRule"
318
+ },
319
+ "import/exports-last": {
320
+ "$ref": "#/definitions/DummyRule"
321
+ },
322
+ "import/extensions": {
323
+ "$ref": "#/definitions/DummyRule"
324
+ },
325
+ "import/first": {
326
+ "$ref": "#/definitions/DummyRule"
327
+ },
328
+ "import/group-exports": {
329
+ "$ref": "#/definitions/DummyRule"
330
+ },
331
+ "import/max-dependencies": {
332
+ "$ref": "#/definitions/DummyRule"
333
+ },
334
+ "import/named": {
335
+ "$ref": "#/definitions/DummyRule"
336
+ },
337
+ "import/namespace": {
338
+ "$ref": "#/definitions/DummyRule"
339
+ },
340
+ "import/newline-after-import": {
341
+ "$ref": "#/definitions/DummyRule"
342
+ },
343
+ "import/no-absolute-path": {
344
+ "$ref": "#/definitions/DummyRule"
345
+ },
346
+ "import/no-amd": {
347
+ "$ref": "#/definitions/DummyRule"
348
+ },
349
+ "import/no-anonymous-default-export": {
350
+ "$ref": "#/definitions/DummyRule"
351
+ },
352
+ "import/no-commonjs": {
353
+ "$ref": "#/definitions/DummyRule"
354
+ },
355
+ "import/no-cycle": {
356
+ "$ref": "#/definitions/DummyRule"
357
+ },
358
+ "import/no-default-export": {
359
+ "$ref": "#/definitions/DummyRule"
360
+ },
361
+ "import/no-duplicates": {
362
+ "$ref": "#/definitions/DummyRule"
363
+ },
364
+ "import/no-dynamic-require": {
365
+ "$ref": "#/definitions/DummyRule"
366
+ },
367
+ "import/no-empty-named-blocks": {
368
+ "$ref": "#/definitions/DummyRule"
369
+ },
370
+ "import/no-mutable-exports": {
371
+ "$ref": "#/definitions/DummyRule"
372
+ },
373
+ "import/no-named-as-default": {
374
+ "$ref": "#/definitions/DummyRule"
375
+ },
376
+ "import/no-named-as-default-member": {
377
+ "$ref": "#/definitions/DummyRule"
378
+ },
379
+ "import/no-named-default": {
380
+ "$ref": "#/definitions/DummyRule"
381
+ },
382
+ "import/no-named-export": {
383
+ "$ref": "#/definitions/DummyRule"
384
+ },
385
+ "import/no-namespace": {
386
+ "$ref": "#/definitions/DummyRule"
387
+ },
388
+ "import/no-nodejs-modules": {
389
+ "$ref": "#/definitions/DummyRule"
390
+ },
391
+ "import/no-relative-parent-imports": {
392
+ "$ref": "#/definitions/DummyRule"
393
+ },
394
+ "import/no-self-import": {
395
+ "$ref": "#/definitions/DummyRule"
396
+ },
397
+ "import/no-unassigned-import": {
398
+ "$ref": "#/definitions/DummyRule"
399
+ },
400
+ "import/no-webpack-loader-syntax": {
401
+ "$ref": "#/definitions/DummyRule"
402
+ },
403
+ "import/prefer-default-export": {
404
+ "$ref": "#/definitions/DummyRule"
405
+ },
406
+ "import/unambiguous": {
407
+ "$ref": "#/definitions/DummyRule"
408
+ },
409
+ "init-declarations": {
410
+ "$ref": "#/definitions/DummyRule"
411
+ },
412
+ "jest/consistent-test-it": {
413
+ "$ref": "#/definitions/DummyRule"
414
+ },
415
+ "jest/expect-expect": {
416
+ "$ref": "#/definitions/DummyRule"
417
+ },
418
+ "jest/max-expects": {
419
+ "$ref": "#/definitions/DummyRule"
420
+ },
421
+ "jest/max-nested-describe": {
422
+ "$ref": "#/definitions/DummyRule"
423
+ },
424
+ "jest/no-alias-methods": {
425
+ "$ref": "#/definitions/DummyRule"
426
+ },
427
+ "jest/no-commented-out-tests": {
428
+ "$ref": "#/definitions/DummyRule"
429
+ },
430
+ "jest/no-conditional-expect": {
431
+ "$ref": "#/definitions/DummyRule"
432
+ },
433
+ "jest/no-conditional-in-test": {
434
+ "$ref": "#/definitions/DummyRule"
435
+ },
436
+ "jest/no-confusing-set-timeout": {
437
+ "$ref": "#/definitions/DummyRule"
438
+ },
439
+ "jest/no-deprecated-functions": {
440
+ "$ref": "#/definitions/DummyRule"
441
+ },
442
+ "jest/no-disabled-tests": {
443
+ "$ref": "#/definitions/DummyRule"
444
+ },
445
+ "jest/no-done-callback": {
446
+ "$ref": "#/definitions/DummyRule"
447
+ },
448
+ "jest/no-duplicate-hooks": {
449
+ "$ref": "#/definitions/DummyRule"
450
+ },
451
+ "jest/no-export": {
452
+ "$ref": "#/definitions/DummyRule"
453
+ },
454
+ "jest/no-focused-tests": {
455
+ "$ref": "#/definitions/DummyRule"
456
+ },
457
+ "jest/no-hooks": {
458
+ "$ref": "#/definitions/DummyRule"
459
+ },
460
+ "jest/no-identical-title": {
461
+ "$ref": "#/definitions/DummyRule"
462
+ },
463
+ "jest/no-interpolation-in-snapshots": {
464
+ "$ref": "#/definitions/DummyRule"
465
+ },
466
+ "jest/no-jasmine-globals": {
467
+ "$ref": "#/definitions/DummyRule"
468
+ },
469
+ "jest/no-large-snapshots": {
470
+ "$ref": "#/definitions/DummyRule"
471
+ },
472
+ "jest/no-mocks-import": {
473
+ "$ref": "#/definitions/DummyRule"
474
+ },
475
+ "jest/no-restricted-jest-methods": {
476
+ "$ref": "#/definitions/DummyRule"
477
+ },
478
+ "jest/no-restricted-matchers": {
479
+ "$ref": "#/definitions/DummyRule"
480
+ },
481
+ "jest/no-standalone-expect": {
482
+ "$ref": "#/definitions/DummyRule"
483
+ },
484
+ "jest/no-test-prefixes": {
485
+ "$ref": "#/definitions/DummyRule"
486
+ },
487
+ "jest/no-test-return-statement": {
488
+ "$ref": "#/definitions/DummyRule"
489
+ },
490
+ "jest/no-unneeded-async-expect-function": {
491
+ "$ref": "#/definitions/DummyRule"
492
+ },
493
+ "jest/no-untyped-mock-factory": {
494
+ "$ref": "#/definitions/DummyRule"
495
+ },
496
+ "jest/padding-around-after-all-blocks": {
497
+ "$ref": "#/definitions/DummyRule"
498
+ },
499
+ "jest/padding-around-test-blocks": {
500
+ "$ref": "#/definitions/DummyRule"
501
+ },
502
+ "jest/prefer-called-with": {
503
+ "$ref": "#/definitions/DummyRule"
504
+ },
505
+ "jest/prefer-comparison-matcher": {
506
+ "$ref": "#/definitions/DummyRule"
507
+ },
508
+ "jest/prefer-each": {
509
+ "$ref": "#/definitions/DummyRule"
510
+ },
511
+ "jest/prefer-ending-with-an-expect": {
512
+ "$ref": "#/definitions/DummyRule"
513
+ },
514
+ "jest/prefer-equality-matcher": {
515
+ "$ref": "#/definitions/DummyRule"
516
+ },
517
+ "jest/prefer-expect-assertions": {
518
+ "$ref": "#/definitions/DummyRule"
519
+ },
520
+ "jest/prefer-expect-resolves": {
521
+ "$ref": "#/definitions/DummyRule"
522
+ },
523
+ "jest/prefer-hooks-in-order": {
524
+ "$ref": "#/definitions/DummyRule"
525
+ },
526
+ "jest/prefer-hooks-on-top": {
527
+ "$ref": "#/definitions/DummyRule"
528
+ },
529
+ "jest/prefer-importing-jest-globals": {
530
+ "$ref": "#/definitions/DummyRule"
531
+ },
532
+ "jest/prefer-jest-mocked": {
533
+ "$ref": "#/definitions/DummyRule"
534
+ },
535
+ "jest/prefer-lowercase-title": {
536
+ "$ref": "#/definitions/DummyRule"
537
+ },
538
+ "jest/prefer-mock-promise-shorthand": {
539
+ "$ref": "#/definitions/DummyRule"
540
+ },
541
+ "jest/prefer-mock-return-shorthand": {
542
+ "$ref": "#/definitions/DummyRule"
543
+ },
544
+ "jest/prefer-snapshot-hint": {
545
+ "$ref": "#/definitions/DummyRule"
546
+ },
547
+ "jest/prefer-spy-on": {
548
+ "$ref": "#/definitions/DummyRule"
549
+ },
550
+ "jest/prefer-strict-equal": {
551
+ "$ref": "#/definitions/DummyRule"
552
+ },
553
+ "jest/prefer-to-be": {
554
+ "$ref": "#/definitions/DummyRule"
555
+ },
556
+ "jest/prefer-to-contain": {
557
+ "$ref": "#/definitions/DummyRule"
558
+ },
559
+ "jest/prefer-to-have-been-called": {
560
+ "$ref": "#/definitions/DummyRule"
561
+ },
562
+ "jest/prefer-to-have-been-called-times": {
563
+ "$ref": "#/definitions/DummyRule"
564
+ },
565
+ "jest/prefer-to-have-length": {
566
+ "$ref": "#/definitions/DummyRule"
567
+ },
568
+ "jest/prefer-todo": {
569
+ "$ref": "#/definitions/DummyRule"
570
+ },
571
+ "jest/require-hook": {
572
+ "$ref": "#/definitions/DummyRule"
573
+ },
574
+ "jest/require-to-throw-message": {
575
+ "$ref": "#/definitions/DummyRule"
576
+ },
577
+ "jest/require-top-level-describe": {
578
+ "$ref": "#/definitions/DummyRule"
579
+ },
580
+ "jest/valid-describe-callback": {
581
+ "$ref": "#/definitions/DummyRule"
582
+ },
583
+ "jest/valid-expect": {
584
+ "$ref": "#/definitions/DummyRule"
585
+ },
586
+ "jest/valid-expect-in-promise": {
587
+ "$ref": "#/definitions/DummyRule"
588
+ },
589
+ "jest/valid-title": {
590
+ "$ref": "#/definitions/DummyRule"
591
+ },
592
+ "jsdoc/check-access": {
593
+ "$ref": "#/definitions/DummyRule"
594
+ },
595
+ "jsdoc/check-property-names": {
596
+ "$ref": "#/definitions/DummyRule"
597
+ },
598
+ "jsdoc/check-tag-names": {
599
+ "$ref": "#/definitions/DummyRule"
600
+ },
601
+ "jsdoc/empty-tags": {
602
+ "$ref": "#/definitions/DummyRule"
603
+ },
604
+ "jsdoc/implements-on-classes": {
605
+ "$ref": "#/definitions/DummyRule"
606
+ },
607
+ "jsdoc/no-defaults": {
608
+ "$ref": "#/definitions/DummyRule"
609
+ },
610
+ "jsdoc/require-param": {
611
+ "$ref": "#/definitions/DummyRule"
612
+ },
613
+ "jsdoc/require-param-description": {
614
+ "$ref": "#/definitions/DummyRule"
615
+ },
616
+ "jsdoc/require-param-name": {
617
+ "$ref": "#/definitions/DummyRule"
618
+ },
619
+ "jsdoc/require-param-type": {
620
+ "$ref": "#/definitions/DummyRule"
621
+ },
622
+ "jsdoc/require-property": {
623
+ "$ref": "#/definitions/DummyRule"
624
+ },
625
+ "jsdoc/require-property-description": {
626
+ "$ref": "#/definitions/DummyRule"
627
+ },
628
+ "jsdoc/require-property-name": {
629
+ "$ref": "#/definitions/DummyRule"
630
+ },
631
+ "jsdoc/require-property-type": {
632
+ "$ref": "#/definitions/DummyRule"
633
+ },
634
+ "jsdoc/require-returns": {
635
+ "$ref": "#/definitions/DummyRule"
636
+ },
637
+ "jsdoc/require-returns-description": {
638
+ "$ref": "#/definitions/DummyRule"
639
+ },
640
+ "jsdoc/require-returns-type": {
641
+ "$ref": "#/definitions/DummyRule"
642
+ },
643
+ "jsdoc/require-throws-description": {
644
+ "$ref": "#/definitions/DummyRule"
645
+ },
646
+ "jsdoc/require-throws-type": {
647
+ "$ref": "#/definitions/DummyRule"
648
+ },
649
+ "jsdoc/require-yields": {
650
+ "$ref": "#/definitions/DummyRule"
651
+ },
652
+ "jsdoc/require-yields-type": {
653
+ "$ref": "#/definitions/DummyRule"
654
+ },
655
+ "jsx-a11y/alt-text": {
656
+ "$ref": "#/definitions/DummyRule"
657
+ },
658
+ "jsx-a11y/anchor-ambiguous-text": {
659
+ "$ref": "#/definitions/DummyRule"
660
+ },
661
+ "jsx-a11y/anchor-has-content": {
662
+ "$ref": "#/definitions/DummyRule"
663
+ },
664
+ "jsx-a11y/anchor-is-valid": {
665
+ "$ref": "#/definitions/DummyRule"
666
+ },
667
+ "jsx-a11y/aria-activedescendant-has-tabindex": {
668
+ "$ref": "#/definitions/DummyRule"
669
+ },
670
+ "jsx-a11y/aria-props": {
671
+ "$ref": "#/definitions/DummyRule"
672
+ },
673
+ "jsx-a11y/aria-proptypes": {
674
+ "$ref": "#/definitions/DummyRule"
675
+ },
676
+ "jsx-a11y/aria-role": {
677
+ "$ref": "#/definitions/DummyRule"
678
+ },
679
+ "jsx-a11y/aria-unsupported-elements": {
680
+ "$ref": "#/definitions/DummyRule"
681
+ },
682
+ "jsx-a11y/autocomplete-valid": {
683
+ "$ref": "#/definitions/DummyRule"
684
+ },
685
+ "jsx-a11y/click-events-have-key-events": {
686
+ "$ref": "#/definitions/DummyRule"
687
+ },
688
+ "jsx-a11y/control-has-associated-label": {
689
+ "$ref": "#/definitions/DummyRule"
690
+ },
691
+ "jsx-a11y/heading-has-content": {
692
+ "$ref": "#/definitions/DummyRule"
693
+ },
694
+ "jsx-a11y/html-has-lang": {
695
+ "$ref": "#/definitions/DummyRule"
696
+ },
697
+ "jsx-a11y/iframe-has-title": {
698
+ "$ref": "#/definitions/DummyRule"
699
+ },
700
+ "jsx-a11y/img-redundant-alt": {
701
+ "$ref": "#/definitions/DummyRule"
702
+ },
703
+ "jsx-a11y/interactive-supports-focus": {
704
+ "$ref": "#/definitions/DummyRule"
705
+ },
706
+ "jsx-a11y/label-has-associated-control": {
707
+ "$ref": "#/definitions/DummyRule"
708
+ },
709
+ "jsx-a11y/lang": {
710
+ "$ref": "#/definitions/DummyRule"
711
+ },
712
+ "jsx-a11y/media-has-caption": {
713
+ "$ref": "#/definitions/DummyRule"
714
+ },
715
+ "jsx-a11y/mouse-events-have-key-events": {
716
+ "$ref": "#/definitions/DummyRule"
717
+ },
718
+ "jsx-a11y/no-access-key": {
719
+ "$ref": "#/definitions/DummyRule"
720
+ },
721
+ "jsx-a11y/no-aria-hidden-on-focusable": {
722
+ "$ref": "#/definitions/DummyRule"
723
+ },
724
+ "jsx-a11y/no-autofocus": {
725
+ "$ref": "#/definitions/DummyRule"
726
+ },
727
+ "jsx-a11y/no-distracting-elements": {
728
+ "$ref": "#/definitions/DummyRule"
729
+ },
730
+ "jsx-a11y/no-interactive-element-to-noninteractive-role": {
731
+ "$ref": "#/definitions/DummyRule"
732
+ },
733
+ "jsx-a11y/no-noninteractive-element-interactions": {
734
+ "$ref": "#/definitions/DummyRule"
735
+ },
736
+ "jsx-a11y/no-noninteractive-element-to-interactive-role": {
737
+ "$ref": "#/definitions/DummyRule"
738
+ },
739
+ "jsx-a11y/no-noninteractive-tabindex": {
740
+ "$ref": "#/definitions/DummyRule"
741
+ },
742
+ "jsx-a11y/no-redundant-roles": {
743
+ "$ref": "#/definitions/DummyRule"
744
+ },
745
+ "jsx-a11y/no-static-element-interactions": {
746
+ "$ref": "#/definitions/DummyRule"
747
+ },
748
+ "jsx-a11y/prefer-tag-over-role": {
749
+ "$ref": "#/definitions/DummyRule"
750
+ },
751
+ "jsx-a11y/role-has-required-aria-props": {
752
+ "$ref": "#/definitions/DummyRule"
753
+ },
754
+ "jsx-a11y/role-supports-aria-props": {
755
+ "$ref": "#/definitions/DummyRule"
756
+ },
757
+ "jsx-a11y/scope": {
758
+ "$ref": "#/definitions/DummyRule"
759
+ },
760
+ "jsx-a11y/tabindex-no-positive": {
761
+ "$ref": "#/definitions/DummyRule"
762
+ },
763
+ "logical-assignment-operators": {
764
+ "$ref": "#/definitions/DummyRule"
765
+ },
766
+ "max-classes-per-file": {
767
+ "$ref": "#/definitions/DummyRule"
768
+ },
769
+ "max-depth": {
770
+ "$ref": "#/definitions/DummyRule"
771
+ },
772
+ "max-lines": {
773
+ "$ref": "#/definitions/DummyRule"
774
+ },
775
+ "max-lines-per-function": {
776
+ "$ref": "#/definitions/DummyRule"
777
+ },
778
+ "max-nested-callbacks": {
779
+ "$ref": "#/definitions/DummyRule"
780
+ },
781
+ "max-params": {
782
+ "$ref": "#/definitions/DummyRule"
783
+ },
784
+ "max-statements": {
785
+ "$ref": "#/definitions/DummyRule"
786
+ },
787
+ "new-cap": {
788
+ "$ref": "#/definitions/DummyRule"
789
+ },
790
+ "nextjs/google-font-display": {
791
+ "$ref": "#/definitions/DummyRule"
792
+ },
793
+ "nextjs/google-font-preconnect": {
794
+ "$ref": "#/definitions/DummyRule"
795
+ },
796
+ "nextjs/inline-script-id": {
797
+ "$ref": "#/definitions/DummyRule"
798
+ },
799
+ "nextjs/next-script-for-ga": {
800
+ "$ref": "#/definitions/DummyRule"
801
+ },
802
+ "nextjs/no-assign-module-variable": {
803
+ "$ref": "#/definitions/DummyRule"
804
+ },
805
+ "nextjs/no-async-client-component": {
806
+ "$ref": "#/definitions/DummyRule"
807
+ },
808
+ "nextjs/no-before-interactive-script-outside-document": {
809
+ "$ref": "#/definitions/DummyRule"
810
+ },
811
+ "nextjs/no-css-tags": {
812
+ "$ref": "#/definitions/DummyRule"
813
+ },
814
+ "nextjs/no-document-import-in-page": {
815
+ "$ref": "#/definitions/DummyRule"
816
+ },
817
+ "nextjs/no-duplicate-head": {
818
+ "$ref": "#/definitions/DummyRule"
819
+ },
820
+ "nextjs/no-head-element": {
821
+ "$ref": "#/definitions/DummyRule"
822
+ },
823
+ "nextjs/no-head-import-in-document": {
824
+ "$ref": "#/definitions/DummyRule"
825
+ },
826
+ "nextjs/no-html-link-for-pages": {
827
+ "$ref": "#/definitions/DummyRule"
828
+ },
829
+ "nextjs/no-img-element": {
830
+ "$ref": "#/definitions/DummyRule"
831
+ },
832
+ "nextjs/no-page-custom-font": {
833
+ "$ref": "#/definitions/DummyRule"
834
+ },
835
+ "nextjs/no-script-component-in-head": {
836
+ "$ref": "#/definitions/DummyRule"
837
+ },
838
+ "nextjs/no-styled-jsx-in-document": {
839
+ "$ref": "#/definitions/DummyRule"
840
+ },
841
+ "nextjs/no-sync-scripts": {
842
+ "$ref": "#/definitions/DummyRule"
843
+ },
844
+ "nextjs/no-title-in-document-head": {
845
+ "$ref": "#/definitions/DummyRule"
846
+ },
847
+ "nextjs/no-typos": {
848
+ "$ref": "#/definitions/DummyRule"
849
+ },
850
+ "nextjs/no-unwanted-polyfillio": {
851
+ "$ref": "#/definitions/DummyRule"
852
+ },
853
+ "no-alert": {
854
+ "$ref": "#/definitions/DummyRule"
855
+ },
856
+ "no-array-constructor": {
857
+ "$ref": "#/definitions/DummyRule"
858
+ },
859
+ "no-async-promise-executor": {
860
+ "$ref": "#/definitions/DummyRule"
861
+ },
862
+ "no-await-in-loop": {
863
+ "$ref": "#/definitions/DummyRule"
864
+ },
865
+ "no-bitwise": {
866
+ "$ref": "#/definitions/DummyRule"
867
+ },
868
+ "no-caller": {
869
+ "$ref": "#/definitions/DummyRule"
870
+ },
871
+ "no-case-declarations": {
872
+ "$ref": "#/definitions/DummyRule"
873
+ },
874
+ "no-class-assign": {
875
+ "$ref": "#/definitions/DummyRule"
876
+ },
877
+ "no-compare-neg-zero": {
878
+ "$ref": "#/definitions/DummyRule"
879
+ },
880
+ "no-cond-assign": {
881
+ "$ref": "#/definitions/DummyRule"
882
+ },
883
+ "no-console": {
884
+ "$ref": "#/definitions/DummyRule"
885
+ },
886
+ "no-const-assign": {
887
+ "$ref": "#/definitions/DummyRule"
888
+ },
889
+ "no-constant-binary-expression": {
890
+ "$ref": "#/definitions/DummyRule"
891
+ },
892
+ "no-constant-condition": {
893
+ "$ref": "#/definitions/DummyRule"
894
+ },
895
+ "no-constructor-return": {
896
+ "$ref": "#/definitions/DummyRule"
897
+ },
898
+ "no-continue": {
899
+ "$ref": "#/definitions/DummyRule"
900
+ },
901
+ "no-control-regex": {
902
+ "$ref": "#/definitions/DummyRule"
903
+ },
904
+ "no-debugger": {
905
+ "$ref": "#/definitions/DummyRule"
906
+ },
907
+ "no-delete-var": {
908
+ "$ref": "#/definitions/DummyRule"
909
+ },
910
+ "no-div-regex": {
911
+ "$ref": "#/definitions/DummyRule"
912
+ },
913
+ "no-dupe-class-members": {
914
+ "$ref": "#/definitions/DummyRule"
915
+ },
916
+ "no-dupe-else-if": {
917
+ "$ref": "#/definitions/DummyRule"
918
+ },
919
+ "no-dupe-keys": {
920
+ "$ref": "#/definitions/DummyRule"
921
+ },
922
+ "no-duplicate-case": {
923
+ "$ref": "#/definitions/DummyRule"
924
+ },
925
+ "no-duplicate-imports": {
926
+ "$ref": "#/definitions/DummyRule"
927
+ },
928
+ "no-else-return": {
929
+ "$ref": "#/definitions/DummyRule"
930
+ },
931
+ "no-empty": {
932
+ "$ref": "#/definitions/DummyRule"
933
+ },
934
+ "no-empty-character-class": {
935
+ "$ref": "#/definitions/DummyRule"
936
+ },
937
+ "no-empty-function": {
938
+ "$ref": "#/definitions/DummyRule"
939
+ },
940
+ "no-empty-pattern": {
941
+ "$ref": "#/definitions/DummyRule"
942
+ },
943
+ "no-empty-static-block": {
944
+ "$ref": "#/definitions/DummyRule"
945
+ },
946
+ "no-eq-null": {
947
+ "$ref": "#/definitions/DummyRule"
948
+ },
949
+ "no-eval": {
950
+ "$ref": "#/definitions/DummyRule"
951
+ },
952
+ "no-ex-assign": {
953
+ "$ref": "#/definitions/DummyRule"
954
+ },
955
+ "no-extend-native": {
956
+ "$ref": "#/definitions/DummyRule"
957
+ },
958
+ "no-extra-bind": {
959
+ "$ref": "#/definitions/DummyRule"
960
+ },
961
+ "no-extra-boolean-cast": {
962
+ "$ref": "#/definitions/DummyRule"
963
+ },
964
+ "no-extra-label": {
965
+ "$ref": "#/definitions/DummyRule"
966
+ },
967
+ "no-fallthrough": {
968
+ "$ref": "#/definitions/DummyRule"
969
+ },
970
+ "no-func-assign": {
971
+ "$ref": "#/definitions/DummyRule"
972
+ },
973
+ "no-global-assign": {
974
+ "$ref": "#/definitions/DummyRule"
975
+ },
976
+ "no-implicit-coercion": {
977
+ "$ref": "#/definitions/DummyRule"
978
+ },
979
+ "no-implicit-globals": {
980
+ "$ref": "#/definitions/DummyRule"
981
+ },
982
+ "no-implied-eval": {
983
+ "$ref": "#/definitions/DummyRule"
984
+ },
985
+ "no-import-assign": {
986
+ "$ref": "#/definitions/DummyRule"
987
+ },
988
+ "no-inline-comments": {
989
+ "$ref": "#/definitions/DummyRule"
990
+ },
991
+ "no-inner-declarations": {
992
+ "$ref": "#/definitions/DummyRule"
993
+ },
994
+ "no-invalid-regexp": {
995
+ "$ref": "#/definitions/DummyRule"
996
+ },
997
+ "no-irregular-whitespace": {
998
+ "$ref": "#/definitions/DummyRule"
999
+ },
1000
+ "no-iterator": {
1001
+ "$ref": "#/definitions/DummyRule"
1002
+ },
1003
+ "no-label-var": {
1004
+ "$ref": "#/definitions/DummyRule"
1005
+ },
1006
+ "no-labels": {
1007
+ "$ref": "#/definitions/DummyRule"
1008
+ },
1009
+ "no-lone-blocks": {
1010
+ "$ref": "#/definitions/DummyRule"
1011
+ },
1012
+ "no-lonely-if": {
1013
+ "$ref": "#/definitions/DummyRule"
1014
+ },
1015
+ "no-loop-func": {
1016
+ "$ref": "#/definitions/DummyRule"
1017
+ },
1018
+ "no-loss-of-precision": {
1019
+ "$ref": "#/definitions/DummyRule"
1020
+ },
1021
+ "no-magic-numbers": {
1022
+ "$ref": "#/definitions/DummyRule"
1023
+ },
1024
+ "no-misleading-character-class": {
1025
+ "$ref": "#/definitions/DummyRule"
1026
+ },
1027
+ "no-multi-assign": {
1028
+ "$ref": "#/definitions/DummyRule"
1029
+ },
1030
+ "no-multi-str": {
1031
+ "$ref": "#/definitions/DummyRule"
1032
+ },
1033
+ "no-negated-condition": {
1034
+ "$ref": "#/definitions/DummyRule"
1035
+ },
1036
+ "no-nested-ternary": {
1037
+ "$ref": "#/definitions/DummyRule"
1038
+ },
1039
+ "no-new": {
1040
+ "$ref": "#/definitions/DummyRule"
1041
+ },
1042
+ "no-new-func": {
1043
+ "$ref": "#/definitions/DummyRule"
1044
+ },
1045
+ "no-new-native-nonconstructor": {
1046
+ "$ref": "#/definitions/DummyRule"
1047
+ },
1048
+ "no-new-wrappers": {
1049
+ "$ref": "#/definitions/DummyRule"
1050
+ },
1051
+ "no-nonoctal-decimal-escape": {
1052
+ "$ref": "#/definitions/DummyRule"
1053
+ },
1054
+ "no-obj-calls": {
1055
+ "$ref": "#/definitions/DummyRule"
1056
+ },
1057
+ "no-object-constructor": {
1058
+ "$ref": "#/definitions/DummyRule"
1059
+ },
1060
+ "no-param-reassign": {
1061
+ "$ref": "#/definitions/DummyRule"
1062
+ },
1063
+ "no-plusplus": {
1064
+ "$ref": "#/definitions/DummyRule"
1065
+ },
1066
+ "no-promise-executor-return": {
1067
+ "$ref": "#/definitions/DummyRule"
1068
+ },
1069
+ "no-proto": {
1070
+ "$ref": "#/definitions/DummyRule"
1071
+ },
1072
+ "no-prototype-builtins": {
1073
+ "$ref": "#/definitions/DummyRule"
1074
+ },
1075
+ "no-redeclare": {
1076
+ "$ref": "#/definitions/DummyRule"
1077
+ },
1078
+ "no-regex-spaces": {
1079
+ "$ref": "#/definitions/DummyRule"
1080
+ },
1081
+ "no-restricted-exports": {
1082
+ "$ref": "#/definitions/DummyRule"
1083
+ },
1084
+ "no-restricted-globals": {
1085
+ "$ref": "#/definitions/DummyRule"
1086
+ },
1087
+ "no-restricted-imports": {
1088
+ "$ref": "#/definitions/DummyRule"
1089
+ },
1090
+ "no-restricted-properties": {
1091
+ "$ref": "#/definitions/DummyRule"
1092
+ },
1093
+ "no-return-assign": {
1094
+ "$ref": "#/definitions/DummyRule"
1095
+ },
1096
+ "no-script-url": {
1097
+ "$ref": "#/definitions/DummyRule"
1098
+ },
1099
+ "no-self-assign": {
1100
+ "$ref": "#/definitions/DummyRule"
1101
+ },
1102
+ "no-self-compare": {
1103
+ "$ref": "#/definitions/DummyRule"
1104
+ },
1105
+ "no-sequences": {
1106
+ "$ref": "#/definitions/DummyRule"
1107
+ },
1108
+ "no-setter-return": {
1109
+ "$ref": "#/definitions/DummyRule"
1110
+ },
1111
+ "no-shadow": {
1112
+ "$ref": "#/definitions/DummyRule"
1113
+ },
1114
+ "no-shadow-restricted-names": {
1115
+ "$ref": "#/definitions/DummyRule"
1116
+ },
1117
+ "no-sparse-arrays": {
1118
+ "$ref": "#/definitions/DummyRule"
1119
+ },
1120
+ "no-template-curly-in-string": {
1121
+ "$ref": "#/definitions/DummyRule"
1122
+ },
1123
+ "no-ternary": {
1124
+ "$ref": "#/definitions/DummyRule"
1125
+ },
1126
+ "no-this-before-super": {
1127
+ "$ref": "#/definitions/DummyRule"
1128
+ },
1129
+ "no-throw-literal": {
1130
+ "$ref": "#/definitions/DummyRule"
1131
+ },
1132
+ "no-unassigned-vars": {
1133
+ "$ref": "#/definitions/DummyRule"
1134
+ },
1135
+ "no-undef": {
1136
+ "$ref": "#/definitions/DummyRule"
1137
+ },
1138
+ "no-undefined": {
1139
+ "$ref": "#/definitions/DummyRule"
1140
+ },
1141
+ "no-underscore-dangle": {
1142
+ "$ref": "#/definitions/DummyRule"
1143
+ },
1144
+ "no-unexpected-multiline": {
1145
+ "$ref": "#/definitions/DummyRule"
1146
+ },
1147
+ "no-unmodified-loop-condition": {
1148
+ "$ref": "#/definitions/DummyRule"
1149
+ },
1150
+ "no-unneeded-ternary": {
1151
+ "$ref": "#/definitions/DummyRule"
1152
+ },
1153
+ "no-unreachable": {
1154
+ "$ref": "#/definitions/DummyRule"
1155
+ },
1156
+ "no-unsafe-finally": {
1157
+ "$ref": "#/definitions/DummyRule"
1158
+ },
1159
+ "no-unsafe-negation": {
1160
+ "$ref": "#/definitions/DummyRule"
1161
+ },
1162
+ "no-unsafe-optional-chaining": {
1163
+ "$ref": "#/definitions/DummyRule"
1164
+ },
1165
+ "no-unused-expressions": {
1166
+ "$ref": "#/definitions/DummyRule"
1167
+ },
1168
+ "no-unused-labels": {
1169
+ "$ref": "#/definitions/DummyRule"
1170
+ },
1171
+ "no-unused-private-class-members": {
1172
+ "$ref": "#/definitions/DummyRule"
1173
+ },
1174
+ "no-unused-vars": {
1175
+ "$ref": "#/definitions/DummyRule"
1176
+ },
1177
+ "no-use-before-define": {
1178
+ "$ref": "#/definitions/DummyRule"
1179
+ },
1180
+ "no-useless-assignment": {
1181
+ "$ref": "#/definitions/DummyRule"
1182
+ },
1183
+ "no-useless-backreference": {
1184
+ "$ref": "#/definitions/DummyRule"
1185
+ },
1186
+ "no-useless-call": {
1187
+ "$ref": "#/definitions/DummyRule"
1188
+ },
1189
+ "no-useless-catch": {
1190
+ "$ref": "#/definitions/DummyRule"
1191
+ },
1192
+ "no-useless-computed-key": {
1193
+ "$ref": "#/definitions/DummyRule"
1194
+ },
1195
+ "no-useless-concat": {
1196
+ "$ref": "#/definitions/DummyRule"
1197
+ },
1198
+ "no-useless-constructor": {
1199
+ "$ref": "#/definitions/DummyRule"
1200
+ },
1201
+ "no-useless-escape": {
1202
+ "$ref": "#/definitions/DummyRule"
1203
+ },
1204
+ "no-useless-rename": {
1205
+ "$ref": "#/definitions/DummyRule"
1206
+ },
1207
+ "no-useless-return": {
1208
+ "$ref": "#/definitions/DummyRule"
1209
+ },
1210
+ "no-var": {
1211
+ "$ref": "#/definitions/DummyRule"
1212
+ },
1213
+ "no-void": {
1214
+ "$ref": "#/definitions/DummyRule"
1215
+ },
1216
+ "no-warning-comments": {
1217
+ "$ref": "#/definitions/DummyRule"
1218
+ },
1219
+ "no-with": {
1220
+ "$ref": "#/definitions/DummyRule"
1221
+ },
1222
+ "node/global-require": {
1223
+ "$ref": "#/definitions/DummyRule"
1224
+ },
1225
+ "node/handle-callback-err": {
1226
+ "$ref": "#/definitions/DummyRule"
1227
+ },
1228
+ "node/no-exports-assign": {
1229
+ "$ref": "#/definitions/DummyRule"
1230
+ },
1231
+ "node/no-new-require": {
1232
+ "$ref": "#/definitions/DummyRule"
1233
+ },
1234
+ "node/no-path-concat": {
1235
+ "$ref": "#/definitions/DummyRule"
1236
+ },
1237
+ "node/no-process-env": {
1238
+ "$ref": "#/definitions/DummyRule"
1239
+ },
1240
+ "object-shorthand": {
1241
+ "$ref": "#/definitions/DummyRule"
1242
+ },
1243
+ "operator-assignment": {
1244
+ "$ref": "#/definitions/DummyRule"
1245
+ },
1246
+ "oxc/approx-constant": {
1247
+ "$ref": "#/definitions/DummyRule"
1248
+ },
1249
+ "oxc/bad-array-method-on-arguments": {
1250
+ "$ref": "#/definitions/DummyRule"
1251
+ },
1252
+ "oxc/bad-bitwise-operator": {
1253
+ "$ref": "#/definitions/DummyRule"
1254
+ },
1255
+ "oxc/bad-char-at-comparison": {
1256
+ "$ref": "#/definitions/DummyRule"
1257
+ },
1258
+ "oxc/bad-comparison-sequence": {
1259
+ "$ref": "#/definitions/DummyRule"
1260
+ },
1261
+ "oxc/bad-min-max-func": {
1262
+ "$ref": "#/definitions/DummyRule"
1263
+ },
1264
+ "oxc/bad-object-literal-comparison": {
1265
+ "$ref": "#/definitions/DummyRule"
1266
+ },
1267
+ "oxc/bad-replace-all-arg": {
1268
+ "$ref": "#/definitions/DummyRule"
1269
+ },
1270
+ "oxc/branches-sharing-code": {
1271
+ "$ref": "#/definitions/DummyRule"
1272
+ },
1273
+ "oxc/const-comparisons": {
1274
+ "$ref": "#/definitions/DummyRule"
1275
+ },
1276
+ "oxc/double-comparisons": {
1277
+ "$ref": "#/definitions/DummyRule"
1278
+ },
1279
+ "oxc/erasing-op": {
1280
+ "$ref": "#/definitions/DummyRule"
1281
+ },
1282
+ "oxc/misrefactored-assign-op": {
1283
+ "$ref": "#/definitions/DummyRule"
1284
+ },
1285
+ "oxc/missing-throw": {
1286
+ "$ref": "#/definitions/DummyRule"
1287
+ },
1288
+ "oxc/no-accumulating-spread": {
1289
+ "$ref": "#/definitions/DummyRule"
1290
+ },
1291
+ "oxc/no-async-await": {
1292
+ "$ref": "#/definitions/DummyRule"
1293
+ },
1294
+ "oxc/no-async-endpoint-handlers": {
1295
+ "$ref": "#/definitions/DummyRule"
1296
+ },
1297
+ "oxc/no-barrel-file": {
1298
+ "$ref": "#/definitions/DummyRule"
1299
+ },
1300
+ "oxc/no-const-enum": {
1301
+ "$ref": "#/definitions/DummyRule"
1302
+ },
1303
+ "oxc/no-map-spread": {
1304
+ "$ref": "#/definitions/DummyRule"
1305
+ },
1306
+ "oxc/no-optional-chaining": {
1307
+ "$ref": "#/definitions/DummyRule"
1308
+ },
1309
+ "oxc/no-rest-spread-properties": {
1310
+ "$ref": "#/definitions/DummyRule"
1311
+ },
1312
+ "oxc/no-this-in-exported-function": {
1313
+ "$ref": "#/definitions/DummyRule"
1314
+ },
1315
+ "oxc/number-arg-out-of-range": {
1316
+ "$ref": "#/definitions/DummyRule"
1317
+ },
1318
+ "oxc/only-used-in-recursion": {
1319
+ "$ref": "#/definitions/DummyRule"
1320
+ },
1321
+ "oxc/uninvoked-array-callback": {
1322
+ "$ref": "#/definitions/DummyRule"
1323
+ },
1324
+ "prefer-arrow-callback": {
1325
+ "$ref": "#/definitions/DummyRule"
1326
+ },
1327
+ "prefer-const": {
1328
+ "$ref": "#/definitions/DummyRule"
1329
+ },
1330
+ "prefer-destructuring": {
1331
+ "$ref": "#/definitions/DummyRule"
1332
+ },
1333
+ "prefer-exponentiation-operator": {
1334
+ "$ref": "#/definitions/DummyRule"
1335
+ },
1336
+ "prefer-numeric-literals": {
1337
+ "$ref": "#/definitions/DummyRule"
1338
+ },
1339
+ "prefer-object-has-own": {
1340
+ "$ref": "#/definitions/DummyRule"
1341
+ },
1342
+ "prefer-object-spread": {
1343
+ "$ref": "#/definitions/DummyRule"
1344
+ },
1345
+ "prefer-promise-reject-errors": {
1346
+ "$ref": "#/definitions/DummyRule"
1347
+ },
1348
+ "prefer-regex-literals": {
1349
+ "$ref": "#/definitions/DummyRule"
1350
+ },
1351
+ "prefer-rest-params": {
1352
+ "$ref": "#/definitions/DummyRule"
1353
+ },
1354
+ "prefer-spread": {
1355
+ "$ref": "#/definitions/DummyRule"
1356
+ },
1357
+ "prefer-template": {
1358
+ "$ref": "#/definitions/DummyRule"
1359
+ },
1360
+ "preserve-caught-error": {
1361
+ "$ref": "#/definitions/DummyRule"
1362
+ },
1363
+ "promise/always-return": {
1364
+ "$ref": "#/definitions/DummyRule"
1365
+ },
1366
+ "promise/avoid-new": {
1367
+ "$ref": "#/definitions/DummyRule"
1368
+ },
1369
+ "promise/catch-or-return": {
1370
+ "$ref": "#/definitions/DummyRule"
1371
+ },
1372
+ "promise/no-callback-in-promise": {
1373
+ "$ref": "#/definitions/DummyRule"
1374
+ },
1375
+ "promise/no-multiple-resolved": {
1376
+ "$ref": "#/definitions/DummyRule"
1377
+ },
1378
+ "promise/no-nesting": {
1379
+ "$ref": "#/definitions/DummyRule"
1380
+ },
1381
+ "promise/no-new-statics": {
1382
+ "$ref": "#/definitions/DummyRule"
1383
+ },
1384
+ "promise/no-promise-in-callback": {
1385
+ "$ref": "#/definitions/DummyRule"
1386
+ },
1387
+ "promise/no-return-in-finally": {
1388
+ "$ref": "#/definitions/DummyRule"
1389
+ },
1390
+ "promise/no-return-wrap": {
1391
+ "$ref": "#/definitions/DummyRule"
1392
+ },
1393
+ "promise/param-names": {
1394
+ "$ref": "#/definitions/DummyRule"
1395
+ },
1396
+ "promise/prefer-await-to-callbacks": {
1397
+ "$ref": "#/definitions/DummyRule"
1398
+ },
1399
+ "promise/prefer-await-to-then": {
1400
+ "$ref": "#/definitions/DummyRule"
1401
+ },
1402
+ "promise/prefer-catch": {
1403
+ "$ref": "#/definitions/DummyRule"
1404
+ },
1405
+ "promise/spec-only": {
1406
+ "$ref": "#/definitions/DummyRule"
1407
+ },
1408
+ "promise/valid-params": {
1409
+ "$ref": "#/definitions/DummyRule"
1410
+ },
1411
+ "radix": {
1412
+ "$ref": "#/definitions/DummyRule"
1413
+ },
1414
+ "react-perf/jsx-no-jsx-as-prop": {
1415
+ "$ref": "#/definitions/DummyRule"
1416
+ },
1417
+ "react-perf/jsx-no-new-array-as-prop": {
1418
+ "$ref": "#/definitions/DummyRule"
1419
+ },
1420
+ "react-perf/jsx-no-new-function-as-prop": {
1421
+ "$ref": "#/definitions/DummyRule"
1422
+ },
1423
+ "react-perf/jsx-no-new-object-as-prop": {
1424
+ "$ref": "#/definitions/DummyRule"
1425
+ },
1426
+ "react/button-has-type": {
1427
+ "$ref": "#/definitions/DummyRule"
1428
+ },
1429
+ "react/checked-requires-onchange-or-readonly": {
1430
+ "$ref": "#/definitions/DummyRule"
1431
+ },
1432
+ "react/display-name": {
1433
+ "$ref": "#/definitions/DummyRule"
1434
+ },
1435
+ "react/exhaustive-deps": {
1436
+ "$ref": "#/definitions/DummyRule"
1437
+ },
1438
+ "react/forbid-component-props": {
1439
+ "$ref": "#/definitions/DummyRule"
1440
+ },
1441
+ "react/forbid-dom-props": {
1442
+ "$ref": "#/definitions/DummyRule"
1443
+ },
1444
+ "react/forbid-elements": {
1445
+ "$ref": "#/definitions/DummyRule"
1446
+ },
1447
+ "react/forward-ref-uses-ref": {
1448
+ "$ref": "#/definitions/DummyRule"
1449
+ },
1450
+ "react/hook-use-state": {
1451
+ "$ref": "#/definitions/DummyRule"
1452
+ },
1453
+ "react/iframe-missing-sandbox": {
1454
+ "$ref": "#/definitions/DummyRule"
1455
+ },
1456
+ "react/jsx-boolean-value": {
1457
+ "$ref": "#/definitions/DummyRule"
1458
+ },
1459
+ "react/jsx-curly-brace-presence": {
1460
+ "$ref": "#/definitions/DummyRule"
1461
+ },
1462
+ "react/jsx-filename-extension": {
1463
+ "$ref": "#/definitions/DummyRule"
1464
+ },
1465
+ "react/jsx-fragments": {
1466
+ "$ref": "#/definitions/DummyRule"
1467
+ },
1468
+ "react/jsx-handler-names": {
1469
+ "$ref": "#/definitions/DummyRule"
1470
+ },
1471
+ "react/jsx-key": {
1472
+ "$ref": "#/definitions/DummyRule"
1473
+ },
1474
+ "react/jsx-max-depth": {
1475
+ "$ref": "#/definitions/DummyRule"
1476
+ },
1477
+ "react/jsx-no-comment-textnodes": {
1478
+ "$ref": "#/definitions/DummyRule"
1479
+ },
1480
+ "react/jsx-no-constructed-context-values": {
1481
+ "$ref": "#/definitions/DummyRule"
1482
+ },
1483
+ "react/jsx-no-duplicate-props": {
1484
+ "$ref": "#/definitions/DummyRule"
1485
+ },
1486
+ "react/jsx-no-script-url": {
1487
+ "$ref": "#/definitions/DummyRule"
1488
+ },
1489
+ "react/jsx-no-target-blank": {
1490
+ "$ref": "#/definitions/DummyRule"
1491
+ },
1492
+ "react/jsx-no-undef": {
1493
+ "$ref": "#/definitions/DummyRule"
1494
+ },
1495
+ "react/jsx-no-useless-fragment": {
1496
+ "$ref": "#/definitions/DummyRule"
1497
+ },
1498
+ "react/jsx-pascal-case": {
1499
+ "$ref": "#/definitions/DummyRule"
1500
+ },
1501
+ "react/jsx-props-no-spread-multi": {
1502
+ "$ref": "#/definitions/DummyRule"
1503
+ },
1504
+ "react/jsx-props-no-spreading": {
1505
+ "$ref": "#/definitions/DummyRule"
1506
+ },
1507
+ "react/no-array-index-key": {
1508
+ "$ref": "#/definitions/DummyRule"
1509
+ },
1510
+ "react/no-children-prop": {
1511
+ "$ref": "#/definitions/DummyRule"
1512
+ },
1513
+ "react/no-clone-element": {
1514
+ "$ref": "#/definitions/DummyRule"
1515
+ },
1516
+ "react/no-danger": {
1517
+ "$ref": "#/definitions/DummyRule"
1518
+ },
1519
+ "react/no-danger-with-children": {
1520
+ "$ref": "#/definitions/DummyRule"
1521
+ },
1522
+ "react/no-did-mount-set-state": {
1523
+ "$ref": "#/definitions/DummyRule"
1524
+ },
1525
+ "react/no-did-update-set-state": {
1526
+ "$ref": "#/definitions/DummyRule"
1527
+ },
1528
+ "react/no-direct-mutation-state": {
1529
+ "$ref": "#/definitions/DummyRule"
1530
+ },
1531
+ "react/no-find-dom-node": {
1532
+ "$ref": "#/definitions/DummyRule"
1533
+ },
1534
+ "react/no-is-mounted": {
1535
+ "$ref": "#/definitions/DummyRule"
1536
+ },
1537
+ "react/no-multi-comp": {
1538
+ "$ref": "#/definitions/DummyRule"
1539
+ },
1540
+ "react/no-namespace": {
1541
+ "$ref": "#/definitions/DummyRule"
1542
+ },
1543
+ "react/no-object-type-as-default-prop": {
1544
+ "$ref": "#/definitions/DummyRule"
1545
+ },
1546
+ "react/no-react-children": {
1547
+ "$ref": "#/definitions/DummyRule"
1548
+ },
1549
+ "react/no-redundant-should-component-update": {
1550
+ "$ref": "#/definitions/DummyRule"
1551
+ },
1552
+ "react/no-render-return-value": {
1553
+ "$ref": "#/definitions/DummyRule"
1554
+ },
1555
+ "react/no-set-state": {
1556
+ "$ref": "#/definitions/DummyRule"
1557
+ },
1558
+ "react/no-string-refs": {
1559
+ "$ref": "#/definitions/DummyRule"
1560
+ },
1561
+ "react/no-this-in-sfc": {
1562
+ "$ref": "#/definitions/DummyRule"
1563
+ },
1564
+ "react/no-unescaped-entities": {
1565
+ "$ref": "#/definitions/DummyRule"
1566
+ },
1567
+ "react/no-unknown-property": {
1568
+ "$ref": "#/definitions/DummyRule"
1569
+ },
1570
+ "react/no-unsafe": {
1571
+ "$ref": "#/definitions/DummyRule"
1572
+ },
1573
+ "react/no-unstable-nested-components": {
1574
+ "$ref": "#/definitions/DummyRule"
1575
+ },
1576
+ "react/no-will-update-set-state": {
1577
+ "$ref": "#/definitions/DummyRule"
1578
+ },
1579
+ "react/only-export-components": {
1580
+ "$ref": "#/definitions/DummyRule"
1581
+ },
1582
+ "react/prefer-es6-class": {
1583
+ "$ref": "#/definitions/DummyRule"
1584
+ },
1585
+ "react/prefer-function-component": {
1586
+ "$ref": "#/definitions/DummyRule"
1587
+ },
1588
+ "react/react-in-jsx-scope": {
1589
+ "$ref": "#/definitions/DummyRule"
1590
+ },
1591
+ "react/require-render-return": {
1592
+ "$ref": "#/definitions/DummyRule"
1593
+ },
1594
+ "react/rules-of-hooks": {
1595
+ "$ref": "#/definitions/DummyRule"
1596
+ },
1597
+ "react/self-closing-comp": {
1598
+ "$ref": "#/definitions/DummyRule"
1599
+ },
1600
+ "react/state-in-constructor": {
1601
+ "$ref": "#/definitions/DummyRule"
1602
+ },
1603
+ "react/style-prop-object": {
1604
+ "$ref": "#/definitions/DummyRule"
1605
+ },
1606
+ "react/void-dom-elements-no-children": {
1607
+ "$ref": "#/definitions/DummyRule"
1608
+ },
1609
+ "require-await": {
1610
+ "$ref": "#/definitions/DummyRule"
1611
+ },
1612
+ "require-unicode-regexp": {
1613
+ "$ref": "#/definitions/DummyRule"
1614
+ },
1615
+ "require-yield": {
1616
+ "$ref": "#/definitions/DummyRule"
1617
+ },
1618
+ "sort-imports": {
1619
+ "$ref": "#/definitions/DummyRule"
1620
+ },
1621
+ "sort-keys": {
1622
+ "$ref": "#/definitions/DummyRule"
1623
+ },
1624
+ "sort-vars": {
1625
+ "$ref": "#/definitions/DummyRule"
1626
+ },
1627
+ "symbol-description": {
1628
+ "$ref": "#/definitions/DummyRule"
1629
+ },
1630
+ "typescript/adjacent-overload-signatures": {
1631
+ "$ref": "#/definitions/DummyRule"
1632
+ },
1633
+ "typescript/array-type": {
1634
+ "$ref": "#/definitions/DummyRule"
1635
+ },
1636
+ "typescript/await-thenable": {
1637
+ "$ref": "#/definitions/DummyRule"
1638
+ },
1639
+ "typescript/ban-ts-comment": {
1640
+ "$ref": "#/definitions/DummyRule"
1641
+ },
1642
+ "typescript/ban-tslint-comment": {
1643
+ "$ref": "#/definitions/DummyRule"
1644
+ },
1645
+ "typescript/ban-types": {
1646
+ "$ref": "#/definitions/DummyRule"
1647
+ },
1648
+ "typescript/class-literal-property-style": {
1649
+ "$ref": "#/definitions/DummyRule"
1650
+ },
1651
+ "typescript/consistent-generic-constructors": {
1652
+ "$ref": "#/definitions/DummyRule"
1653
+ },
1654
+ "typescript/consistent-indexed-object-style": {
1655
+ "$ref": "#/definitions/DummyRule"
1656
+ },
1657
+ "typescript/consistent-return": {
1658
+ "$ref": "#/definitions/DummyRule"
1659
+ },
1660
+ "typescript/consistent-type-assertions": {
1661
+ "$ref": "#/definitions/DummyRule"
1662
+ },
1663
+ "typescript/consistent-type-definitions": {
1664
+ "$ref": "#/definitions/DummyRule"
1665
+ },
1666
+ "typescript/consistent-type-exports": {
1667
+ "$ref": "#/definitions/DummyRule"
1668
+ },
1669
+ "typescript/consistent-type-imports": {
1670
+ "$ref": "#/definitions/DummyRule"
1671
+ },
1672
+ "typescript/dot-notation": {
1673
+ "$ref": "#/definitions/DummyRule"
1674
+ },
1675
+ "typescript/explicit-function-return-type": {
1676
+ "$ref": "#/definitions/DummyRule"
1677
+ },
1678
+ "typescript/explicit-member-accessibility": {
1679
+ "$ref": "#/definitions/DummyRule"
1680
+ },
1681
+ "typescript/explicit-module-boundary-types": {
1682
+ "$ref": "#/definitions/DummyRule"
1683
+ },
1684
+ "typescript/no-array-delete": {
1685
+ "$ref": "#/definitions/DummyRule"
1686
+ },
1687
+ "typescript/no-base-to-string": {
1688
+ "$ref": "#/definitions/DummyRule"
1689
+ },
1690
+ "typescript/no-confusing-non-null-assertion": {
1691
+ "$ref": "#/definitions/DummyRule"
1692
+ },
1693
+ "typescript/no-confusing-void-expression": {
1694
+ "$ref": "#/definitions/DummyRule"
1695
+ },
1696
+ "typescript/no-deprecated": {
1697
+ "$ref": "#/definitions/DummyRule"
1698
+ },
1699
+ "typescript/no-duplicate-enum-values": {
1700
+ "$ref": "#/definitions/DummyRule"
1701
+ },
1702
+ "typescript/no-duplicate-type-constituents": {
1703
+ "$ref": "#/definitions/DummyRule"
1704
+ },
1705
+ "typescript/no-dynamic-delete": {
1706
+ "$ref": "#/definitions/DummyRule"
1707
+ },
1708
+ "typescript/no-empty-interface": {
1709
+ "$ref": "#/definitions/DummyRule"
1710
+ },
1711
+ "typescript/no-empty-object-type": {
1712
+ "$ref": "#/definitions/DummyRule"
1713
+ },
1714
+ "typescript/no-explicit-any": {
1715
+ "$ref": "#/definitions/DummyRule"
1716
+ },
1717
+ "typescript/no-extra-non-null-assertion": {
1718
+ "$ref": "#/definitions/DummyRule"
1719
+ },
1720
+ "typescript/no-extraneous-class": {
1721
+ "$ref": "#/definitions/DummyRule"
1722
+ },
1723
+ "typescript/no-floating-promises": {
1724
+ "$ref": "#/definitions/DummyRule"
1725
+ },
1726
+ "typescript/no-for-in-array": {
1727
+ "$ref": "#/definitions/DummyRule"
1728
+ },
1729
+ "typescript/no-implied-eval": {
1730
+ "$ref": "#/definitions/DummyRule"
1731
+ },
1732
+ "typescript/no-import-type-side-effects": {
1733
+ "$ref": "#/definitions/DummyRule"
1734
+ },
1735
+ "typescript/no-inferrable-types": {
1736
+ "$ref": "#/definitions/DummyRule"
1737
+ },
1738
+ "typescript/no-invalid-void-type": {
1739
+ "$ref": "#/definitions/DummyRule"
1740
+ },
1741
+ "typescript/no-meaningless-void-operator": {
1742
+ "$ref": "#/definitions/DummyRule"
1743
+ },
1744
+ "typescript/no-misused-new": {
1745
+ "$ref": "#/definitions/DummyRule"
1746
+ },
1747
+ "typescript/no-misused-promises": {
1748
+ "$ref": "#/definitions/DummyRule"
1749
+ },
1750
+ "typescript/no-misused-spread": {
1751
+ "$ref": "#/definitions/DummyRule"
1752
+ },
1753
+ "typescript/no-mixed-enums": {
1754
+ "$ref": "#/definitions/DummyRule"
1755
+ },
1756
+ "typescript/no-namespace": {
1757
+ "$ref": "#/definitions/DummyRule"
1758
+ },
1759
+ "typescript/no-non-null-asserted-nullish-coalescing": {
1760
+ "$ref": "#/definitions/DummyRule"
1761
+ },
1762
+ "typescript/no-non-null-asserted-optional-chain": {
1763
+ "$ref": "#/definitions/DummyRule"
1764
+ },
1765
+ "typescript/no-non-null-assertion": {
1766
+ "$ref": "#/definitions/DummyRule"
1767
+ },
1768
+ "typescript/no-redundant-type-constituents": {
1769
+ "$ref": "#/definitions/DummyRule"
1770
+ },
1771
+ "typescript/no-require-imports": {
1772
+ "$ref": "#/definitions/DummyRule"
1773
+ },
1774
+ "typescript/no-restricted-types": {
1775
+ "$ref": "#/definitions/DummyRule"
1776
+ },
1777
+ "typescript/no-this-alias": {
1778
+ "$ref": "#/definitions/DummyRule"
1779
+ },
1780
+ "typescript/no-unnecessary-boolean-literal-compare": {
1781
+ "$ref": "#/definitions/DummyRule"
1782
+ },
1783
+ "typescript/no-unnecessary-condition": {
1784
+ "$ref": "#/definitions/DummyRule"
1785
+ },
1786
+ "typescript/no-unnecessary-parameter-property-assignment": {
1787
+ "$ref": "#/definitions/DummyRule"
1788
+ },
1789
+ "typescript/no-unnecessary-qualifier": {
1790
+ "$ref": "#/definitions/DummyRule"
1791
+ },
1792
+ "typescript/no-unnecessary-template-expression": {
1793
+ "$ref": "#/definitions/DummyRule"
1794
+ },
1795
+ "typescript/no-unnecessary-type-arguments": {
1796
+ "$ref": "#/definitions/DummyRule"
1797
+ },
1798
+ "typescript/no-unnecessary-type-assertion": {
1799
+ "$ref": "#/definitions/DummyRule"
1800
+ },
1801
+ "typescript/no-unnecessary-type-constraint": {
1802
+ "$ref": "#/definitions/DummyRule"
1803
+ },
1804
+ "typescript/no-unnecessary-type-conversion": {
1805
+ "$ref": "#/definitions/DummyRule"
1806
+ },
1807
+ "typescript/no-unnecessary-type-parameters": {
1808
+ "$ref": "#/definitions/DummyRule"
1809
+ },
1810
+ "typescript/no-unsafe-argument": {
1811
+ "$ref": "#/definitions/DummyRule"
1812
+ },
1813
+ "typescript/no-unsafe-assignment": {
1814
+ "$ref": "#/definitions/DummyRule"
1815
+ },
1816
+ "typescript/no-unsafe-call": {
1817
+ "$ref": "#/definitions/DummyRule"
1818
+ },
1819
+ "typescript/no-unsafe-declaration-merging": {
1820
+ "$ref": "#/definitions/DummyRule"
1821
+ },
1822
+ "typescript/no-unsafe-enum-comparison": {
1823
+ "$ref": "#/definitions/DummyRule"
1824
+ },
1825
+ "typescript/no-unsafe-function-type": {
1826
+ "$ref": "#/definitions/DummyRule"
1827
+ },
1828
+ "typescript/no-unsafe-member-access": {
1829
+ "$ref": "#/definitions/DummyRule"
1830
+ },
1831
+ "typescript/no-unsafe-return": {
1832
+ "$ref": "#/definitions/DummyRule"
1833
+ },
1834
+ "typescript/no-unsafe-type-assertion": {
1835
+ "$ref": "#/definitions/DummyRule"
1836
+ },
1837
+ "typescript/no-unsafe-unary-minus": {
1838
+ "$ref": "#/definitions/DummyRule"
1839
+ },
1840
+ "typescript/no-useless-default-assignment": {
1841
+ "$ref": "#/definitions/DummyRule"
1842
+ },
1843
+ "typescript/no-useless-empty-export": {
1844
+ "$ref": "#/definitions/DummyRule"
1845
+ },
1846
+ "typescript/no-var-requires": {
1847
+ "$ref": "#/definitions/DummyRule"
1848
+ },
1849
+ "typescript/no-wrapper-object-types": {
1850
+ "$ref": "#/definitions/DummyRule"
1851
+ },
1852
+ "typescript/non-nullable-type-assertion-style": {
1853
+ "$ref": "#/definitions/DummyRule"
1854
+ },
1855
+ "typescript/only-throw-error": {
1856
+ "$ref": "#/definitions/DummyRule"
1857
+ },
1858
+ "typescript/parameter-properties": {
1859
+ "$ref": "#/definitions/DummyRule"
1860
+ },
1861
+ "typescript/prefer-as-const": {
1862
+ "$ref": "#/definitions/DummyRule"
1863
+ },
1864
+ "typescript/prefer-enum-initializers": {
1865
+ "$ref": "#/definitions/DummyRule"
1866
+ },
1867
+ "typescript/prefer-find": {
1868
+ "$ref": "#/definitions/DummyRule"
1869
+ },
1870
+ "typescript/prefer-for-of": {
1871
+ "$ref": "#/definitions/DummyRule"
1872
+ },
1873
+ "typescript/prefer-function-type": {
1874
+ "$ref": "#/definitions/DummyRule"
1875
+ },
1876
+ "typescript/prefer-includes": {
1877
+ "$ref": "#/definitions/DummyRule"
1878
+ },
1879
+ "typescript/prefer-literal-enum-member": {
1880
+ "$ref": "#/definitions/DummyRule"
1881
+ },
1882
+ "typescript/prefer-namespace-keyword": {
1883
+ "$ref": "#/definitions/DummyRule"
1884
+ },
1885
+ "typescript/prefer-nullish-coalescing": {
1886
+ "$ref": "#/definitions/DummyRule"
1887
+ },
1888
+ "typescript/prefer-optional-chain": {
1889
+ "$ref": "#/definitions/DummyRule"
1890
+ },
1891
+ "typescript/prefer-promise-reject-errors": {
1892
+ "$ref": "#/definitions/DummyRule"
1893
+ },
1894
+ "typescript/prefer-readonly": {
1895
+ "$ref": "#/definitions/DummyRule"
1896
+ },
1897
+ "typescript/prefer-readonly-parameter-types": {
1898
+ "$ref": "#/definitions/DummyRule"
1899
+ },
1900
+ "typescript/prefer-reduce-type-parameter": {
1901
+ "$ref": "#/definitions/DummyRule"
1902
+ },
1903
+ "typescript/prefer-regexp-exec": {
1904
+ "$ref": "#/definitions/DummyRule"
1905
+ },
1906
+ "typescript/prefer-return-this-type": {
1907
+ "$ref": "#/definitions/DummyRule"
1908
+ },
1909
+ "typescript/prefer-string-starts-ends-with": {
1910
+ "$ref": "#/definitions/DummyRule"
1911
+ },
1912
+ "typescript/prefer-ts-expect-error": {
1913
+ "$ref": "#/definitions/DummyRule"
1914
+ },
1915
+ "typescript/promise-function-async": {
1916
+ "$ref": "#/definitions/DummyRule"
1917
+ },
1918
+ "typescript/related-getter-setter-pairs": {
1919
+ "$ref": "#/definitions/DummyRule"
1920
+ },
1921
+ "typescript/require-array-sort-compare": {
1922
+ "$ref": "#/definitions/DummyRule"
1923
+ },
1924
+ "typescript/require-await": {
1925
+ "$ref": "#/definitions/DummyRule"
1926
+ },
1927
+ "typescript/restrict-plus-operands": {
1928
+ "$ref": "#/definitions/DummyRule"
1929
+ },
1930
+ "typescript/restrict-template-expressions": {
1931
+ "$ref": "#/definitions/DummyRule"
1932
+ },
1933
+ "typescript/return-await": {
1934
+ "$ref": "#/definitions/DummyRule"
1935
+ },
1936
+ "typescript/strict-boolean-expressions": {
1937
+ "$ref": "#/definitions/DummyRule"
1938
+ },
1939
+ "typescript/strict-void-return": {
1940
+ "$ref": "#/definitions/DummyRule"
1941
+ },
1942
+ "typescript/switch-exhaustiveness-check": {
1943
+ "$ref": "#/definitions/DummyRule"
1944
+ },
1945
+ "typescript/triple-slash-reference": {
1946
+ "$ref": "#/definitions/DummyRule"
1947
+ },
1948
+ "typescript/unbound-method": {
1949
+ "$ref": "#/definitions/DummyRule"
1950
+ },
1951
+ "typescript/unified-signatures": {
1952
+ "$ref": "#/definitions/DummyRule"
1953
+ },
1954
+ "typescript/use-unknown-in-catch-callback-variable": {
1955
+ "$ref": "#/definitions/DummyRule"
1956
+ },
1957
+ "unicode-bom": {
1958
+ "$ref": "#/definitions/DummyRule"
1959
+ },
1960
+ "unicorn/catch-error-name": {
1961
+ "$ref": "#/definitions/DummyRule"
1962
+ },
1963
+ "unicorn/consistent-assert": {
1964
+ "$ref": "#/definitions/DummyRule"
1965
+ },
1966
+ "unicorn/consistent-date-clone": {
1967
+ "$ref": "#/definitions/DummyRule"
1968
+ },
1969
+ "unicorn/consistent-empty-array-spread": {
1970
+ "$ref": "#/definitions/DummyRule"
1971
+ },
1972
+ "unicorn/consistent-existence-index-check": {
1973
+ "$ref": "#/definitions/DummyRule"
1974
+ },
1975
+ "unicorn/consistent-function-scoping": {
1976
+ "$ref": "#/definitions/DummyRule"
1977
+ },
1978
+ "unicorn/consistent-template-literal-escape": {
1979
+ "$ref": "#/definitions/DummyRule"
1980
+ },
1981
+ "unicorn/custom-error-definition": {
1982
+ "$ref": "#/definitions/DummyRule"
1983
+ },
1984
+ "unicorn/empty-brace-spaces": {
1985
+ "$ref": "#/definitions/DummyRule"
1986
+ },
1987
+ "unicorn/error-message": {
1988
+ "$ref": "#/definitions/DummyRule"
1989
+ },
1990
+ "unicorn/escape-case": {
1991
+ "$ref": "#/definitions/DummyRule"
1992
+ },
1993
+ "unicorn/explicit-length-check": {
1994
+ "$ref": "#/definitions/DummyRule"
1995
+ },
1996
+ "unicorn/filename-case": {
1997
+ "$ref": "#/definitions/DummyRule"
1998
+ },
1999
+ "unicorn/new-for-builtins": {
2000
+ "$ref": "#/definitions/DummyRule"
2001
+ },
2002
+ "unicorn/no-abusive-eslint-disable": {
2003
+ "$ref": "#/definitions/DummyRule"
2004
+ },
2005
+ "unicorn/no-accessor-recursion": {
2006
+ "$ref": "#/definitions/DummyRule"
2007
+ },
2008
+ "unicorn/no-anonymous-default-export": {
2009
+ "$ref": "#/definitions/DummyRule"
2010
+ },
2011
+ "unicorn/no-array-callback-reference": {
2012
+ "$ref": "#/definitions/DummyRule"
2013
+ },
2014
+ "unicorn/no-array-for-each": {
2015
+ "$ref": "#/definitions/DummyRule"
2016
+ },
2017
+ "unicorn/no-array-method-this-argument": {
2018
+ "$ref": "#/definitions/DummyRule"
2019
+ },
2020
+ "unicorn/no-array-reduce": {
2021
+ "$ref": "#/definitions/DummyRule"
2022
+ },
2023
+ "unicorn/no-array-reverse": {
2024
+ "$ref": "#/definitions/DummyRule"
2025
+ },
2026
+ "unicorn/no-array-sort": {
2027
+ "$ref": "#/definitions/DummyRule"
2028
+ },
2029
+ "unicorn/no-await-expression-member": {
2030
+ "$ref": "#/definitions/DummyRule"
2031
+ },
2032
+ "unicorn/no-await-in-promise-methods": {
2033
+ "$ref": "#/definitions/DummyRule"
2034
+ },
2035
+ "unicorn/no-console-spaces": {
2036
+ "$ref": "#/definitions/DummyRule"
2037
+ },
2038
+ "unicorn/no-document-cookie": {
2039
+ "$ref": "#/definitions/DummyRule"
2040
+ },
2041
+ "unicorn/no-empty-file": {
2042
+ "$ref": "#/definitions/DummyRule"
2043
+ },
2044
+ "unicorn/no-hex-escape": {
2045
+ "$ref": "#/definitions/DummyRule"
2046
+ },
2047
+ "unicorn/no-immediate-mutation": {
2048
+ "$ref": "#/definitions/DummyRule"
2049
+ },
2050
+ "unicorn/no-instanceof-array": {
2051
+ "$ref": "#/definitions/DummyRule"
2052
+ },
2053
+ "unicorn/no-instanceof-builtins": {
2054
+ "$ref": "#/definitions/DummyRule"
2055
+ },
2056
+ "unicorn/no-invalid-fetch-options": {
2057
+ "$ref": "#/definitions/DummyRule"
2058
+ },
2059
+ "unicorn/no-invalid-remove-event-listener": {
2060
+ "$ref": "#/definitions/DummyRule"
2061
+ },
2062
+ "unicorn/no-length-as-slice-end": {
2063
+ "$ref": "#/definitions/DummyRule"
2064
+ },
2065
+ "unicorn/no-lonely-if": {
2066
+ "$ref": "#/definitions/DummyRule"
2067
+ },
2068
+ "unicorn/no-magic-array-flat-depth": {
2069
+ "$ref": "#/definitions/DummyRule"
2070
+ },
2071
+ "unicorn/no-negated-condition": {
2072
+ "$ref": "#/definitions/DummyRule"
2073
+ },
2074
+ "unicorn/no-negation-in-equality-check": {
2075
+ "$ref": "#/definitions/DummyRule"
2076
+ },
2077
+ "unicorn/no-nested-ternary": {
2078
+ "$ref": "#/definitions/DummyRule"
2079
+ },
2080
+ "unicorn/no-new-array": {
2081
+ "$ref": "#/definitions/DummyRule"
2082
+ },
2083
+ "unicorn/no-new-buffer": {
2084
+ "$ref": "#/definitions/DummyRule"
2085
+ },
2086
+ "unicorn/no-null": {
2087
+ "$ref": "#/definitions/DummyRule"
2088
+ },
2089
+ "unicorn/no-object-as-default-parameter": {
2090
+ "$ref": "#/definitions/DummyRule"
2091
+ },
2092
+ "unicorn/no-process-exit": {
2093
+ "$ref": "#/definitions/DummyRule"
2094
+ },
2095
+ "unicorn/no-single-promise-in-promise-methods": {
2096
+ "$ref": "#/definitions/DummyRule"
2097
+ },
2098
+ "unicorn/no-static-only-class": {
2099
+ "$ref": "#/definitions/DummyRule"
2100
+ },
2101
+ "unicorn/no-thenable": {
2102
+ "$ref": "#/definitions/DummyRule"
2103
+ },
2104
+ "unicorn/no-this-assignment": {
2105
+ "$ref": "#/definitions/DummyRule"
2106
+ },
2107
+ "unicorn/no-typeof-undefined": {
2108
+ "$ref": "#/definitions/DummyRule"
2109
+ },
2110
+ "unicorn/no-unnecessary-array-flat-depth": {
2111
+ "$ref": "#/definitions/DummyRule"
2112
+ },
2113
+ "unicorn/no-unnecessary-array-splice-count": {
2114
+ "$ref": "#/definitions/DummyRule"
2115
+ },
2116
+ "unicorn/no-unnecessary-await": {
2117
+ "$ref": "#/definitions/DummyRule"
2118
+ },
2119
+ "unicorn/no-unnecessary-slice-end": {
2120
+ "$ref": "#/definitions/DummyRule"
2121
+ },
2122
+ "unicorn/no-unreadable-array-destructuring": {
2123
+ "$ref": "#/definitions/DummyRule"
2124
+ },
2125
+ "unicorn/no-unreadable-iife": {
2126
+ "$ref": "#/definitions/DummyRule"
2127
+ },
2128
+ "unicorn/no-useless-collection-argument": {
2129
+ "$ref": "#/definitions/DummyRule"
2130
+ },
2131
+ "unicorn/no-useless-error-capture-stack-trace": {
2132
+ "$ref": "#/definitions/DummyRule"
2133
+ },
2134
+ "unicorn/no-useless-fallback-in-spread": {
2135
+ "$ref": "#/definitions/DummyRule"
2136
+ },
2137
+ "unicorn/no-useless-iterator-to-array": {
2138
+ "$ref": "#/definitions/DummyRule"
2139
+ },
2140
+ "unicorn/no-useless-length-check": {
2141
+ "$ref": "#/definitions/DummyRule"
2142
+ },
2143
+ "unicorn/no-useless-promise-resolve-reject": {
2144
+ "$ref": "#/definitions/DummyRule"
2145
+ },
2146
+ "unicorn/no-useless-spread": {
2147
+ "$ref": "#/definitions/DummyRule"
2148
+ },
2149
+ "unicorn/no-useless-switch-case": {
2150
+ "$ref": "#/definitions/DummyRule"
2151
+ },
2152
+ "unicorn/no-useless-undefined": {
2153
+ "$ref": "#/definitions/DummyRule"
2154
+ },
2155
+ "unicorn/no-zero-fractions": {
2156
+ "$ref": "#/definitions/DummyRule"
2157
+ },
2158
+ "unicorn/number-literal-case": {
2159
+ "$ref": "#/definitions/DummyRule"
2160
+ },
2161
+ "unicorn/numeric-separators-style": {
2162
+ "$ref": "#/definitions/DummyRule"
2163
+ },
2164
+ "unicorn/prefer-add-event-listener": {
2165
+ "$ref": "#/definitions/DummyRule"
2166
+ },
2167
+ "unicorn/prefer-array-find": {
2168
+ "$ref": "#/definitions/DummyRule"
2169
+ },
2170
+ "unicorn/prefer-array-flat": {
2171
+ "$ref": "#/definitions/DummyRule"
2172
+ },
2173
+ "unicorn/prefer-array-flat-map": {
2174
+ "$ref": "#/definitions/DummyRule"
2175
+ },
2176
+ "unicorn/prefer-array-index-of": {
2177
+ "$ref": "#/definitions/DummyRule"
2178
+ },
2179
+ "unicorn/prefer-array-some": {
2180
+ "$ref": "#/definitions/DummyRule"
2181
+ },
2182
+ "unicorn/prefer-at": {
2183
+ "$ref": "#/definitions/DummyRule"
2184
+ },
2185
+ "unicorn/prefer-bigint-literals": {
2186
+ "$ref": "#/definitions/DummyRule"
2187
+ },
2188
+ "unicorn/prefer-blob-reading-methods": {
2189
+ "$ref": "#/definitions/DummyRule"
2190
+ },
2191
+ "unicorn/prefer-class-fields": {
2192
+ "$ref": "#/definitions/DummyRule"
2193
+ },
2194
+ "unicorn/prefer-classlist-toggle": {
2195
+ "$ref": "#/definitions/DummyRule"
2196
+ },
2197
+ "unicorn/prefer-code-point": {
2198
+ "$ref": "#/definitions/DummyRule"
2199
+ },
2200
+ "unicorn/prefer-date-now": {
2201
+ "$ref": "#/definitions/DummyRule"
2202
+ },
2203
+ "unicorn/prefer-default-parameters": {
2204
+ "$ref": "#/definitions/DummyRule"
2205
+ },
2206
+ "unicorn/prefer-dom-node-append": {
2207
+ "$ref": "#/definitions/DummyRule"
2208
+ },
2209
+ "unicorn/prefer-dom-node-dataset": {
2210
+ "$ref": "#/definitions/DummyRule"
2211
+ },
2212
+ "unicorn/prefer-dom-node-remove": {
2213
+ "$ref": "#/definitions/DummyRule"
2214
+ },
2215
+ "unicorn/prefer-dom-node-text-content": {
2216
+ "$ref": "#/definitions/DummyRule"
2217
+ },
2218
+ "unicorn/prefer-event-target": {
2219
+ "$ref": "#/definitions/DummyRule"
2220
+ },
2221
+ "unicorn/prefer-global-this": {
2222
+ "$ref": "#/definitions/DummyRule"
2223
+ },
2224
+ "unicorn/prefer-import-meta-properties": {
2225
+ "$ref": "#/definitions/DummyRule"
2226
+ },
2227
+ "unicorn/prefer-includes": {
2228
+ "$ref": "#/definitions/DummyRule"
2229
+ },
2230
+ "unicorn/prefer-keyboard-event-key": {
2231
+ "$ref": "#/definitions/DummyRule"
2232
+ },
2233
+ "unicorn/prefer-logical-operator-over-ternary": {
2234
+ "$ref": "#/definitions/DummyRule"
2235
+ },
2236
+ "unicorn/prefer-math-min-max": {
2237
+ "$ref": "#/definitions/DummyRule"
2238
+ },
2239
+ "unicorn/prefer-math-trunc": {
2240
+ "$ref": "#/definitions/DummyRule"
2241
+ },
2242
+ "unicorn/prefer-modern-dom-apis": {
2243
+ "$ref": "#/definitions/DummyRule"
2244
+ },
2245
+ "unicorn/prefer-modern-math-apis": {
2246
+ "$ref": "#/definitions/DummyRule"
2247
+ },
2248
+ "unicorn/prefer-module": {
2249
+ "$ref": "#/definitions/DummyRule"
2250
+ },
2251
+ "unicorn/prefer-native-coercion-functions": {
2252
+ "$ref": "#/definitions/DummyRule"
2253
+ },
2254
+ "unicorn/prefer-negative-index": {
2255
+ "$ref": "#/definitions/DummyRule"
2256
+ },
2257
+ "unicorn/prefer-node-protocol": {
2258
+ "$ref": "#/definitions/DummyRule"
2259
+ },
2260
+ "unicorn/prefer-number-properties": {
2261
+ "$ref": "#/definitions/DummyRule"
2262
+ },
2263
+ "unicorn/prefer-object-from-entries": {
2264
+ "$ref": "#/definitions/DummyRule"
2265
+ },
2266
+ "unicorn/prefer-optional-catch-binding": {
2267
+ "$ref": "#/definitions/DummyRule"
2268
+ },
2269
+ "unicorn/prefer-prototype-methods": {
2270
+ "$ref": "#/definitions/DummyRule"
2271
+ },
2272
+ "unicorn/prefer-query-selector": {
2273
+ "$ref": "#/definitions/DummyRule"
2274
+ },
2275
+ "unicorn/prefer-reflect-apply": {
2276
+ "$ref": "#/definitions/DummyRule"
2277
+ },
2278
+ "unicorn/prefer-regexp-test": {
2279
+ "$ref": "#/definitions/DummyRule"
2280
+ },
2281
+ "unicorn/prefer-response-static-json": {
2282
+ "$ref": "#/definitions/DummyRule"
2283
+ },
2284
+ "unicorn/prefer-set-has": {
2285
+ "$ref": "#/definitions/DummyRule"
2286
+ },
2287
+ "unicorn/prefer-set-size": {
2288
+ "$ref": "#/definitions/DummyRule"
2289
+ },
2290
+ "unicorn/prefer-spread": {
2291
+ "$ref": "#/definitions/DummyRule"
2292
+ },
2293
+ "unicorn/prefer-string-raw": {
2294
+ "$ref": "#/definitions/DummyRule"
2295
+ },
2296
+ "unicorn/prefer-string-replace-all": {
2297
+ "$ref": "#/definitions/DummyRule"
2298
+ },
2299
+ "unicorn/prefer-string-slice": {
2300
+ "$ref": "#/definitions/DummyRule"
2301
+ },
2302
+ "unicorn/prefer-string-starts-ends-with": {
2303
+ "$ref": "#/definitions/DummyRule"
2304
+ },
2305
+ "unicorn/prefer-string-trim-start-end": {
2306
+ "$ref": "#/definitions/DummyRule"
2307
+ },
2308
+ "unicorn/prefer-structured-clone": {
2309
+ "$ref": "#/definitions/DummyRule"
2310
+ },
2311
+ "unicorn/prefer-ternary": {
2312
+ "$ref": "#/definitions/DummyRule"
2313
+ },
2314
+ "unicorn/prefer-top-level-await": {
2315
+ "$ref": "#/definitions/DummyRule"
2316
+ },
2317
+ "unicorn/prefer-type-error": {
2318
+ "$ref": "#/definitions/DummyRule"
2319
+ },
2320
+ "unicorn/relative-url-style": {
2321
+ "$ref": "#/definitions/DummyRule"
2322
+ },
2323
+ "unicorn/require-array-join-separator": {
2324
+ "$ref": "#/definitions/DummyRule"
2325
+ },
2326
+ "unicorn/require-module-attributes": {
2327
+ "$ref": "#/definitions/DummyRule"
2328
+ },
2329
+ "unicorn/require-module-specifiers": {
2330
+ "$ref": "#/definitions/DummyRule"
2331
+ },
2332
+ "unicorn/require-number-to-fixed-digits-argument": {
2333
+ "$ref": "#/definitions/DummyRule"
2334
+ },
2335
+ "unicorn/require-post-message-target-origin": {
2336
+ "$ref": "#/definitions/DummyRule"
2337
+ },
2338
+ "unicorn/switch-case-braces": {
2339
+ "$ref": "#/definitions/DummyRule"
2340
+ },
2341
+ "unicorn/switch-case-break-position": {
2342
+ "$ref": "#/definitions/DummyRule"
2343
+ },
2344
+ "unicorn/text-encoding-identifier-case": {
2345
+ "$ref": "#/definitions/DummyRule"
2346
+ },
2347
+ "unicorn/throw-new-error": {
2348
+ "$ref": "#/definitions/DummyRule"
2349
+ },
2350
+ "use-isnan": {
2351
+ "$ref": "#/definitions/DummyRule"
2352
+ },
2353
+ "valid-typeof": {
2354
+ "$ref": "#/definitions/DummyRule"
2355
+ },
2356
+ "vars-on-top": {
2357
+ "$ref": "#/definitions/DummyRule"
2358
+ },
2359
+ "vitest/consistent-each-for": {
2360
+ "$ref": "#/definitions/DummyRule"
2361
+ },
2362
+ "vitest/consistent-test-filename": {
2363
+ "$ref": "#/definitions/DummyRule"
2364
+ },
2365
+ "vitest/consistent-test-it": {
2366
+ "$ref": "#/definitions/DummyRule"
2367
+ },
2368
+ "vitest/consistent-vitest-vi": {
2369
+ "$ref": "#/definitions/DummyRule"
2370
+ },
2371
+ "vitest/expect-expect": {
2372
+ "$ref": "#/definitions/DummyRule"
2373
+ },
2374
+ "vitest/hoisted-apis-on-top": {
2375
+ "$ref": "#/definitions/DummyRule"
2376
+ },
2377
+ "vitest/max-expects": {
2378
+ "$ref": "#/definitions/DummyRule"
2379
+ },
2380
+ "vitest/max-nested-describe": {
2381
+ "$ref": "#/definitions/DummyRule"
2382
+ },
2383
+ "vitest/no-alias-methods": {
2384
+ "$ref": "#/definitions/DummyRule"
2385
+ },
2386
+ "vitest/no-commented-out-tests": {
2387
+ "$ref": "#/definitions/DummyRule"
2388
+ },
2389
+ "vitest/no-conditional-expect": {
2390
+ "$ref": "#/definitions/DummyRule"
2391
+ },
2392
+ "vitest/no-conditional-in-test": {
2393
+ "$ref": "#/definitions/DummyRule"
2394
+ },
2395
+ "vitest/no-conditional-tests": {
2396
+ "$ref": "#/definitions/DummyRule"
2397
+ },
2398
+ "vitest/no-disabled-tests": {
2399
+ "$ref": "#/definitions/DummyRule"
2400
+ },
2401
+ "vitest/no-duplicate-hooks": {
2402
+ "$ref": "#/definitions/DummyRule"
2403
+ },
2404
+ "vitest/no-focused-tests": {
2405
+ "$ref": "#/definitions/DummyRule"
2406
+ },
2407
+ "vitest/no-hooks": {
2408
+ "$ref": "#/definitions/DummyRule"
2409
+ },
2410
+ "vitest/no-identical-title": {
2411
+ "$ref": "#/definitions/DummyRule"
2412
+ },
2413
+ "vitest/no-import-node-test": {
2414
+ "$ref": "#/definitions/DummyRule"
2415
+ },
2416
+ "vitest/no-importing-vitest-globals": {
2417
+ "$ref": "#/definitions/DummyRule"
2418
+ },
2419
+ "vitest/no-interpolation-in-snapshots": {
2420
+ "$ref": "#/definitions/DummyRule"
2421
+ },
2422
+ "vitest/no-large-snapshots": {
2423
+ "$ref": "#/definitions/DummyRule"
2424
+ },
2425
+ "vitest/no-mocks-import": {
2426
+ "$ref": "#/definitions/DummyRule"
2427
+ },
2428
+ "vitest/no-restricted-matchers": {
2429
+ "$ref": "#/definitions/DummyRule"
2430
+ },
2431
+ "vitest/no-restricted-vi-methods": {
2432
+ "$ref": "#/definitions/DummyRule"
2433
+ },
2434
+ "vitest/no-standalone-expect": {
2435
+ "$ref": "#/definitions/DummyRule"
2436
+ },
2437
+ "vitest/no-test-prefixes": {
2438
+ "$ref": "#/definitions/DummyRule"
2439
+ },
2440
+ "vitest/no-test-return-statement": {
2441
+ "$ref": "#/definitions/DummyRule"
2442
+ },
2443
+ "vitest/no-unneeded-async-expect-function": {
2444
+ "$ref": "#/definitions/DummyRule"
2445
+ },
2446
+ "vitest/padding-around-after-all-blocks": {
2447
+ "$ref": "#/definitions/DummyRule"
2448
+ },
2449
+ "vitest/prefer-called-exactly-once-with": {
2450
+ "$ref": "#/definitions/DummyRule"
2451
+ },
2452
+ "vitest/prefer-called-once": {
2453
+ "$ref": "#/definitions/DummyRule"
2454
+ },
2455
+ "vitest/prefer-called-times": {
2456
+ "$ref": "#/definitions/DummyRule"
2457
+ },
2458
+ "vitest/prefer-called-with": {
2459
+ "$ref": "#/definitions/DummyRule"
2460
+ },
2461
+ "vitest/prefer-comparison-matcher": {
2462
+ "$ref": "#/definitions/DummyRule"
2463
+ },
2464
+ "vitest/prefer-describe-function-title": {
2465
+ "$ref": "#/definitions/DummyRule"
2466
+ },
2467
+ "vitest/prefer-each": {
2468
+ "$ref": "#/definitions/DummyRule"
2469
+ },
2470
+ "vitest/prefer-equality-matcher": {
2471
+ "$ref": "#/definitions/DummyRule"
2472
+ },
2473
+ "vitest/prefer-expect-assertions": {
2474
+ "$ref": "#/definitions/DummyRule"
2475
+ },
2476
+ "vitest/prefer-expect-resolves": {
2477
+ "$ref": "#/definitions/DummyRule"
2478
+ },
2479
+ "vitest/prefer-expect-type-of": {
2480
+ "$ref": "#/definitions/DummyRule"
2481
+ },
2482
+ "vitest/prefer-hooks-in-order": {
2483
+ "$ref": "#/definitions/DummyRule"
2484
+ },
2485
+ "vitest/prefer-hooks-on-top": {
2486
+ "$ref": "#/definitions/DummyRule"
2487
+ },
2488
+ "vitest/prefer-import-in-mock": {
2489
+ "$ref": "#/definitions/DummyRule"
2490
+ },
2491
+ "vitest/prefer-importing-vitest-globals": {
2492
+ "$ref": "#/definitions/DummyRule"
2493
+ },
2494
+ "vitest/prefer-lowercase-title": {
2495
+ "$ref": "#/definitions/DummyRule"
2496
+ },
2497
+ "vitest/prefer-mock-promise-shorthand": {
2498
+ "$ref": "#/definitions/DummyRule"
2499
+ },
2500
+ "vitest/prefer-mock-return-shorthand": {
2501
+ "$ref": "#/definitions/DummyRule"
2502
+ },
2503
+ "vitest/prefer-snapshot-hint": {
2504
+ "$ref": "#/definitions/DummyRule"
2505
+ },
2506
+ "vitest/prefer-spy-on": {
2507
+ "$ref": "#/definitions/DummyRule"
2508
+ },
2509
+ "vitest/prefer-strict-boolean-matchers": {
2510
+ "$ref": "#/definitions/DummyRule"
2511
+ },
2512
+ "vitest/prefer-strict-equal": {
2513
+ "$ref": "#/definitions/DummyRule"
2514
+ },
2515
+ "vitest/prefer-to-be": {
2516
+ "$ref": "#/definitions/DummyRule"
2517
+ },
2518
+ "vitest/prefer-to-be-falsy": {
2519
+ "$ref": "#/definitions/DummyRule"
2520
+ },
2521
+ "vitest/prefer-to-be-object": {
2522
+ "$ref": "#/definitions/DummyRule"
2523
+ },
2524
+ "vitest/prefer-to-be-truthy": {
2525
+ "$ref": "#/definitions/DummyRule"
2526
+ },
2527
+ "vitest/prefer-to-contain": {
2528
+ "$ref": "#/definitions/DummyRule"
2529
+ },
2530
+ "vitest/prefer-to-have-been-called-times": {
2531
+ "$ref": "#/definitions/DummyRule"
2532
+ },
2533
+ "vitest/prefer-to-have-length": {
2534
+ "$ref": "#/definitions/DummyRule"
2535
+ },
2536
+ "vitest/prefer-todo": {
2537
+ "$ref": "#/definitions/DummyRule"
2538
+ },
2539
+ "vitest/require-awaited-expect-poll": {
2540
+ "$ref": "#/definitions/DummyRule"
2541
+ },
2542
+ "vitest/require-hook": {
2543
+ "$ref": "#/definitions/DummyRule"
2544
+ },
2545
+ "vitest/require-local-test-context-for-concurrent-snapshots": {
2546
+ "$ref": "#/definitions/DummyRule"
2547
+ },
2548
+ "vitest/require-mock-type-parameters": {
2549
+ "$ref": "#/definitions/DummyRule"
2550
+ },
2551
+ "vitest/require-test-timeout": {
2552
+ "$ref": "#/definitions/DummyRule"
2553
+ },
2554
+ "vitest/require-to-throw-message": {
2555
+ "$ref": "#/definitions/DummyRule"
2556
+ },
2557
+ "vitest/require-top-level-describe": {
2558
+ "$ref": "#/definitions/DummyRule"
2559
+ },
2560
+ "vitest/valid-describe-callback": {
2561
+ "$ref": "#/definitions/DummyRule"
2562
+ },
2563
+ "vitest/valid-expect": {
2564
+ "$ref": "#/definitions/DummyRule"
2565
+ },
2566
+ "vitest/valid-expect-in-promise": {
2567
+ "$ref": "#/definitions/DummyRule"
2568
+ },
2569
+ "vitest/valid-title": {
2570
+ "$ref": "#/definitions/DummyRule"
2571
+ },
2572
+ "vitest/warn-todo": {
2573
+ "$ref": "#/definitions/DummyRule"
2574
+ },
2575
+ "vue/define-emits-declaration": {
2576
+ "$ref": "#/definitions/DummyRule"
2577
+ },
2578
+ "vue/define-props-declaration": {
2579
+ "$ref": "#/definitions/DummyRule"
2580
+ },
2581
+ "vue/define-props-destructuring": {
2582
+ "$ref": "#/definitions/DummyRule"
2583
+ },
2584
+ "vue/max-props": {
2585
+ "$ref": "#/definitions/DummyRule"
2586
+ },
2587
+ "vue/no-arrow-functions-in-watch": {
2588
+ "$ref": "#/definitions/DummyRule"
2589
+ },
2590
+ "vue/no-deprecated-data-object-declaration": {
2591
+ "$ref": "#/definitions/DummyRule"
2592
+ },
2593
+ "vue/no-deprecated-delete-set": {
2594
+ "$ref": "#/definitions/DummyRule"
2595
+ },
2596
+ "vue/no-deprecated-destroyed-lifecycle": {
2597
+ "$ref": "#/definitions/DummyRule"
2598
+ },
2599
+ "vue/no-deprecated-events-api": {
2600
+ "$ref": "#/definitions/DummyRule"
2601
+ },
2602
+ "vue/no-deprecated-model-definition": {
2603
+ "$ref": "#/definitions/DummyRule"
2604
+ },
2605
+ "vue/no-deprecated-vue-config-keycodes": {
2606
+ "$ref": "#/definitions/DummyRule"
2607
+ },
2608
+ "vue/no-export-in-script-setup": {
2609
+ "$ref": "#/definitions/DummyRule"
2610
+ },
2611
+ "vue/no-import-compiler-macros": {
2612
+ "$ref": "#/definitions/DummyRule"
2613
+ },
2614
+ "vue/no-lifecycle-after-await": {
2615
+ "$ref": "#/definitions/DummyRule"
2616
+ },
2617
+ "vue/no-multiple-slot-args": {
2618
+ "$ref": "#/definitions/DummyRule"
2619
+ },
2620
+ "vue/no-required-prop-with-default": {
2621
+ "$ref": "#/definitions/DummyRule"
2622
+ },
2623
+ "vue/no-this-in-before-route-enter": {
2624
+ "$ref": "#/definitions/DummyRule"
2625
+ },
2626
+ "vue/prefer-import-from-vue": {
2627
+ "$ref": "#/definitions/DummyRule"
2628
+ },
2629
+ "vue/require-default-export": {
2630
+ "$ref": "#/definitions/DummyRule"
2631
+ },
2632
+ "vue/require-typed-ref": {
2633
+ "$ref": "#/definitions/DummyRule"
2634
+ },
2635
+ "vue/return-in-computed-property": {
2636
+ "$ref": "#/definitions/DummyRule"
2637
+ },
2638
+ "vue/valid-define-emits": {
2639
+ "$ref": "#/definitions/DummyRule"
2640
+ },
2641
+ "vue/valid-define-props": {
2642
+ "$ref": "#/definitions/DummyRule"
2643
+ },
2644
+ "yoda": {
2645
+ "$ref": "#/definitions/DummyRule"
2646
+ }
2647
+ },
243
2648
  "additionalProperties": {
244
2649
  "$ref": "#/definitions/DummyRule"
245
2650
  },
@@ -261,9 +2666,9 @@
261
2666
  ],
262
2667
  "properties": {
263
2668
  "name": {
264
- "description": "Custom name/alias for the plugin.\n\nNote: The following plugin names are reserved because they are implemented natively in Rust within oxlint and cannot be used for JS plugins:\n- react (includes react-hooks)\n- unicorn\n- typescript (includes @typescript-eslint)\n- oxc\n- import (includes import-x)\n- jsdoc\n- jest\n- vitest\n- jsx-a11y\n- nextjs\n- react-perf\n- promise\n- node\n- vue\n- eslint\n\nIf you need to use the JavaScript version of any of these plugins, provide a custom alias to avoid conflicts.",
2669
+ "description": "Custom name/alias for the plugin.\n\nNote: The following plugin names are reserved because they are implemented natively in Rust within oxlint and cannot be used for JS plugins:\n- react (includes react-hooks)\n- unicorn\n- typescript (includes @typescript-eslint)\n- oxc\n- import (includes import-x)\n- jsdoc\n- jest\n- vitest\n- jsx-a11y (includes jsx-a11y-x)\n- nextjs\n- react-perf\n- promise\n- node\n- vue\n- eslint\n\nIf you need to use the JavaScript version of any of these plugins, provide a custom alias to avoid conflicts.",
265
2670
  "type": "string",
266
- "markdownDescription": "Custom name/alias for the plugin.\n\nNote: The following plugin names are reserved because they are implemented natively in Rust within oxlint and cannot be used for JS plugins:\n- react (includes react-hooks)\n- unicorn\n- typescript (includes @typescript-eslint)\n- oxc\n- import (includes import-x)\n- jsdoc\n- jest\n- vitest\n- jsx-a11y\n- nextjs\n- react-perf\n- promise\n- node\n- vue\n- eslint\n\nIf you need to use the JavaScript version of any of these plugins, provide a custom alias to avoid conflicts."
2671
+ "markdownDescription": "Custom name/alias for the plugin.\n\nNote: The following plugin names are reserved because they are implemented natively in Rust within oxlint and cannot be used for JS plugins:\n- react (includes react-hooks)\n- unicorn\n- typescript (includes @typescript-eslint)\n- oxc\n- import (includes import-x)\n- jsdoc\n- jest\n- vitest\n- jsx-a11y (includes jsx-a11y-x)\n- nextjs\n- react-perf\n- promise\n- node\n- vue\n- eslint\n\nIf you need to use the JavaScript version of any of these plugins, provide a custom alias to avoid conflicts."
267
2672
  },
268
2673
  "specifier": {
269
2674
  "description": "Path or package name of the plugin",