diff --git a/src/schemas/json/putout.json b/src/schemas/json/putout.json
index e1b37eb0af6..3ec4d0ede18 100644
--- a/src/schemas/json/putout.json
+++ b/src/schemas/json/putout.json
@@ -57,682 +57,1366 @@
       "description": "🐊Putout comes with a large number of rules. You can modify which rules your project uses.",
       "type": "object",
       "properties": {
+        "apply-arrow": {
+          "$ref": "#/definitions/rule"
+        },
         "apply-at": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring": {
+        "apply-dot-notation": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-flat-map": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-global-this": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-overrides": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-shorthand-properties": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-starts-with": {
+          "$ref": "#/definitions/rule"
+        },
+        "apply-template-literals": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/apply-json-parse": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/apply-rest": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/convert-expression-to-arguments": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/remove-duplicate": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/remove-empty": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/remove-unused": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/remove-useless": {
+          "$ref": "#/definitions/rule"
+        },
+        "arguments/remove-useless-form-method": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment/convert-to-arrow-function": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment/convert-to-comparison": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment/convert-to-declaration": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment/simplify": {
+          "$ref": "#/definitions/rule"
+        },
+        "assignment/split": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/add-return": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/apply-comparison-order": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/apply-consistent-blocks": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/apply-equal": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/apply-if": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/convert-arrow-to-condition": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/convert-comparison-to-boolean": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/convert-equal-to-strict-equal": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/evaluate": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/merge-if-statements": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/merge-if-with-else": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/remove-boolean": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/remove-same-values-condition": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/remove-useless-else": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/remove-useless-loop-condition": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/remove-zero": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/reverse-condition": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/simplify": {
+          "$ref": "#/definitions/rule"
+        },
+        "conditions/wrap-with-block": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-concat-to-flat": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-index-of-to-includes": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-object-entries-to-array-entries": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-object-entries-to-object-keys": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-object-keys-to-object-entries": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-template-to-string": {
+          "$ref": "#/definitions/rule"
+        },
+        "convert-to-arrow-function": {
+          "$ref": "#/definitions/rule"
+        },
+        "declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "declare-before-reference": {
           "$ref": "#/definitions/rule"
         },
         "destructuring/apply-array": {
           "$ref": "#/definitions/rule"
         },
+        "destructuring": {
+          "$ref": "#/definitions/rule"
+        },
         "destructuring/apply-object": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/split-nested": {
+        "destructuring/convert-object-to-array": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/extract-properties-equal-deep": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/extract-properties-not-equal-deep": {
           "$ref": "#/definitions/rule"
         },
         "destructuring/merge-properties": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/extract-properties": {
+        "destructuring/remove-useless-arguments": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/remove-useless-object": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/remove-useless-variables": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/split-call": {
+          "$ref": "#/definitions/rule"
+        },
+        "destructuring/split-nested": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/apply-default-import": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/apply-export-from": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/apply-import-attributes": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/convert-assert-to-with": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/declare-imports-first": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/group-imports-by-source": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/merge-declaration-with-export": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/merge-duplicate-imports/join": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/merge-duplicate-imports/rename": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/merge-export-declarations": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/remove-empty-export": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/remove-empty-import": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/remove-quotes-from-import-assertions": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/remove-useless-export-specifiers": {
+          "$ref": "#/definitions/rule"
+        },
+        "esm/sort-imports-by-specifiers": {
+          "$ref": "#/definitions/rule"
+        },
+        "extract-sequence-expressions": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/add-missing-declaration": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-each": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-entries": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-entries-n": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-in-negative": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-in-positive": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-length": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/for-n": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/map": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/reduce": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/remove-unused-variables": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/remove-useless": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/remove-useless-array-from": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/remove-useless-variables": {
+          "$ref": "#/definitions/rule"
+        },
+        "for-of/to-for-n": {
+          "$ref": "#/definitions/rule"
+        },
+        "generators/add-missing-star": {
+          "$ref": "#/definitions/rule"
+        },
+        "generators": {
+          "$ref": "#/definitions/rule"
+        },
+        "generators/convert-multiply-to-generator": {
+          "$ref": "#/definitions/rule"
+        },
+        "gitignore/add": {
+          "$ref": "#/definitions/rule"
+        },
+        "gitignore": {
+          "$ref": "#/definitions/rule"
+        },
+        "gitignore/sort": {
+          "$ref": "#/definitions/rule"
+        },
+        "labels/convert-to-object": {
+          "$ref": "#/definitions/rule"
+        },
+        "labels": {
+          "$ref": "#/definitions/rule"
+        },
+        "labels/remove-unused": {
+          "$ref": "#/definitions/rule"
+        },
+        "logical-expressions/convert-bitwise-to-logical": {
+          "$ref": "#/definitions/rule"
+        },
+        "logical-expressions": {
+          "$ref": "#/definitions/rule"
+        },
+        "logical-expressions/remove-boolean": {
+          "$ref": "#/definitions/rule"
+        },
+        "logical-expressions/remove-duplicates": {
+          "$ref": "#/definitions/rule"
+        },
+        "logical-expressions/simplify": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/apply-exponentiation": {
+          "$ref": "#/definitions/rule"
+        },
+        "math": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/apply-multiplication": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/apply-numeric-separators": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/convert-sqrt-to-hypot": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "math/remove-unchanged-zero-declarations": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe/array": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe/declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe/empty-array": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe/fn": {
+          "$ref": "#/definitions/rule"
+        },
+        "maybe/noop": {
+          "$ref": "#/definitions/rule"
+        },
+        "merge-duplicate-functions": {
+          "$ref": "#/definitions/rule"
+        },
+        "montag/apply": {
+          "$ref": "#/definitions/rule"
+        },
+        "montag": {
+          "$ref": "#/definitions/rule"
+        },
+        "montag/declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "new/add-missing": {
+          "$ref": "#/definitions/rule"
+        },
+        "new": {
+          "$ref": "#/definitions/rule"
+        },
+        "new/remove-useless": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/add-node-prefix": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-buffer-to-buffer-alloc": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-dirname-to-url": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-exports-to-module-exports": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-fs-promises": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-promisify-to-fs-promises": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-url-to-dirname": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/declare-after-require": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/group-require-by-id": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/remove-illegal-strict-mode": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/remove-process-exit": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/remove-top-level-process-exit": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/remove-useless-promisify": {
+          "$ref": "#/definitions/rule"
+        },
+        "optional-chaining/convert-logical-to-optional": {
+          "$ref": "#/definitions/rule"
+        },
+        "optional-chaining": {
+          "$ref": "#/definitions/rule"
+        },
+        "optional-chaining/convert-optional-assign-to-logical": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens/add-missing-for-assign": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens/add-missing-for-awai": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens/add-missing-for-template": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens/remove-useless-for-await": {
+          "$ref": "#/definitions/rule"
+        },
+        "parens/remove-useless-for-params": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/add-missing-async": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/add-missing-await": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/apply-await-import": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/apply-top-level-await": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/convert-new-promise-to-async": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/convert-reject-to-throw": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/convert-resolve-to-async": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/remove-useless-async": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/remove-useless-await": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/remove-useless-resolve": {
+          "$ref": "#/definitions/rule"
+        },
+        "promises/remove-useless-variables": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-await-to-progress": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-crawl-file": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-path-arg-to-fix": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-path-arg-to-match": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-path-arg-to-visitors": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-places-to-compare-places": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-push-arg": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-test-args": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-track-file": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/add-traverse-args": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-async-formatter": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-create-nested-directory": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-create-test": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-desturcturing": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-engine-node-version": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-exports-to-add-args": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-exports-to-match-files": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-exports-to-rename-files": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-fixture-name-to-message": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-for-of-to-track-file": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-insert-after": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-insert-before": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-lowercase-to-node-builders": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-namespace-specifier": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-parens": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-processors-destructuring": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-remove": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-rename": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-report": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-short-processors": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-transform-with-options": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-traverser-to-ignore": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/apply-vars": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/check-declare": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/check-match": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/check-replace-code": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-add-argument-to-add-args": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-babel-types": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-destructuring-to-identifier": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-dirname-to-url": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-find-to-traverse": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-get-file-content-to-read-file-content": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-get-rule-to-require": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-include-to-traverse": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-match-to-function": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-method-to-property": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-node-to-path-in-get-template-values": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-number-to-numeric": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-plugins-element-to-tuple": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-process-to-find": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-progress-to-track-file": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-push-object-to-push-path": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-putout-test-to-create-test": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-replace-to-function": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-replace-to-traverse": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-replace-with": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-replace-with-multiple": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-report-to-function": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-to-no-transform-code": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-traverse-to-include": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-traverse-to-replace": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-traverse-to-scan": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/convert-url-to-dirname": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/create-test": {
+          "$ref": "#/definitions/rule"
+        },
+        "putout/declare": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/extract-properties-equal-deep": {
+        "putout/declare-path-variable": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/extract-properties-not-equal-deep": {
+        "putout/declare-template-variables": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/remove-useless-object": {
+        "putout/includer": {
           "$ref": "#/definitions/rule"
         },
-        "destructuring/remove-useless-arguments": {
+        "putout/move-require-on-top-level": {
           "$ref": "#/definitions/rule"
         },
-        "return": {
+        "putout/remove-empty-array-from-process": {
           "$ref": "#/definitions/rule"
         },
-        "return/apply-early": {
+        "putout/remove-empty-object-from-transform": {
           "$ref": "#/definitions/rule"
         },
-        "return/simplify-boolean": {
+        "putout/remove-message-from-no-report-after-transform": {
           "$ref": "#/definitions/rule"
         },
-        "return/convert-from-break": {
+        "putout/remove-unused-get-properties-argument": {
           "$ref": "#/definitions/rule"
         },
-        "return/remove-useless": {
+        "putout/remove-useless-printer-option": {
           "$ref": "#/definitions/rule"
         },
-        "apply-montag": {
+        "putout/rename-operate-to-operator": {
           "$ref": "#/definitions/rule"
         },
-        "apply-nullish-coalescing": {
+        "putout/replace-operate-with-operator": {
           "$ref": "#/definitions/rule"
         },
-        "math": {
+        "putout/replace-test-message": {
           "$ref": "#/definitions/rule"
         },
-        "math/apply-numeric-separators": {
+        "putout/shorten-imports": {
           "$ref": "#/definitions/rule"
         },
-        "math/apply-exponentiation": {
+        "putout/simplify-replace-template": {
           "$ref": "#/definitions/rule"
         },
-        "math/apply-multiplication": {
+        "regexp/apply-character-class": {
           "$ref": "#/definitions/rule"
         },
-        "math/convert-sqrt-to-hypot": {
+        "regexp": {
           "$ref": "#/definitions/rule"
         },
-        "math/declare": {
+        "regexp/apply-ends-with": {
           "$ref": "#/definitions/rule"
         },
-        "math/remove-unchanged-zero-declarations": {
+        "regexp/apply-global-regexp-to-replace-all": {
           "$ref": "#/definitions/rule"
         },
-        "apply-shorthand-properties": {
+        "regexp/apply-literal-notation": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch": {
+        "regexp/apply-starts-with": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/await": {
+        "regexp/convert-replace-to-replace-all": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/async": {
+        "regexp/convert-to-string": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/sync": {
+        "regexp/optimize": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/declare": {
+        "regexp/remove-duplicates-from-character-class": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/args": {
+        "regexp/remove-useless-escape": {
           "$ref": "#/definitions/rule"
         },
-        "try-catch/expand-args": {
+        "regexp/remove-useless-group": {
           "$ref": "#/definitions/rule"
         },
-        "browserlist": {
+        "regexp/remove-useless-regexp": {
           "$ref": "#/definitions/rule"
         },
-        "cloudcmd": {
+        "remove-console": {
           "$ref": "#/definitions/rule"
         },
-        "conditions": {
+        "remove-debugger": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/apply-comparison-order": {
+        "remove-duplicate-case": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/apply-if": {
+        "remove-duplicate-keys": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/convert-comparison-to-boolean": {
+        "remove-empty/argument": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/convert-equal-to-strict-equal": {
+        "remove-empty": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/evaluate": {
+        "remove-empty/block": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/merge-if-statements": {
+        "remove-empty/nested-pattern": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/simplify": {
+        "remove-empty/pattern": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/remove-constant": {
+        "remove-empty/static-block": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/remove-useless-else": {
+        "remove-iife": {
           "$ref": "#/definitions/rule"
         },
-        "label": {
+        "remove-nested-blocks": {
           "$ref": "#/definitions/rule"
         },
-        "label/convert-to-object": {
+        "remove-unreachable-code": {
           "$ref": "#/definitions/rule"
         },
-        "label/remove-unused": {
+        "remove-unused-expressions": {
           "$ref": "#/definitions/rule"
         },
-        "convert-bitwise-to-logical": {
+        "remove-unused-private-fields": {
           "$ref": "#/definitions/rule"
         },
-        "convert-concat-to-flat": {
+        "remove-useless-array": {
           "$ref": "#/definitions/rule"
         },
-        "convert-index-of-to-includes": {
+        "remove-useless-array-constructor": {
           "$ref": "#/definitions/rule"
         },
-        "convert-is-nan-to-number-is-nan": {
+        "remove-useless-array-entries": {
           "$ref": "#/definitions/rule"
         },
-        "math/apply-exponential": {
+        "remove-useless-assign": {
           "$ref": "#/definitions/rule"
         },
-        "tape/convert-mock-require-to-mock-import": {
+        "remove-useless-constructor": {
           "$ref": "#/definitions/rule"
         },
-        "convert-quotes-to-backticks": {
+        "remove-useless-continue": {
           "$ref": "#/definitions/rule"
         },
-        "convert-template-to-string": {
+        "remove-useless-delete": {
           "$ref": "#/definitions/rule"
         },
-        "convert-throw": {
+        "remove-useless-escape": {
           "$ref": "#/definitions/rule"
         },
-        "convert-to-arrow-function": {
+        "remove-useless-functions": {
           "$ref": "#/definitions/rule"
         },
-        "declare": {
+        "remove-useless-map": {
           "$ref": "#/definitions/rule"
         },
-        "eslint": {
+        "remove-useless-object-from-entries": {
           "$ref": "#/definitions/rule"
         },
-        "extract-sequence-expressions": {
+        "remove-useless-operand": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/for": {
+        "remove-useless-push": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/for-each": {
+        "remove-useless-replace": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/for-in": {
+        "remove-useless-template-expressions": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/map": {
+        "return/apply-early": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/remove-useless": {
+        "return": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/remove-unused-variables": {
+        "return/convert-from-break": {
           "$ref": "#/definitions/rule"
         },
-        "for-of/remove-useless-array-from": {
+        "return/convert-from-continue": {
           "$ref": "#/definitions/rule"
         },
-        "github": {
+        "return/merge-with-next-sibling": {
           "$ref": "#/definitions/rule"
         },
-        "gitignore": {
+        "return/remove-useless": {
           "$ref": "#/definitions/rule"
         },
-        "jest": {
+        "return/simplify-boolean": {
           "$ref": "#/definitions/rule"
         },
-        "madrun": {
+        "simplify-ternary/spread": {
           "$ref": "#/definitions/rule"
         },
-        "maybe": {
+        "simplify-ternary": {
           "$ref": "#/definitions/rule"
         },
-        "parens": {
+        "simplify-ternary/value": {
           "$ref": "#/definitions/rule"
         },
-        "parens/add-missing": {
+        "spread/convert-apply-to-spread": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs": {
+        "spread": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-esm-to-commonjs": {
+        "spread/convert-object-assign-to-merge-spread": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-commonjs-to-esm": {
+        "spread/remove-useless-array": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-dirname-to-url": {
+        "spread/simplify-nested": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-fs-promises": {
+        "try-catch/apply-destructuring": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-promisify-to-fs-promises": {
+        "try-catch": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/convert-top-level-return": {
+        "try-catch/args": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/remove-process-exit": {
+        "try-catch/async": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/add-missing-strict-mode": {
+        "try-catch/await": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/remove-useless-strict-mode": {
+        "try-catch/declare": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/rename-file-mjs-to-js": {
+        "try-catch/expand-args": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/cjs-file": {
+        "try-catch/sync": {
           "$ref": "#/definitions/rule"
         },
-        "nodejs/mjs-file": {
+        "types/apply-is-array": {
           "$ref": "#/definitions/rule"
         },
-        "npmignore": {
+        "types": {
           "$ref": "#/definitions/rule"
         },
-        "package-json": {
+        "types/convert-typeof-to-is-type": {
           "$ref": "#/definitions/rule"
         },
-        "postcss": {
+        "types/declare": {
           "$ref": "#/definitions/rule"
         },
-        "promises": {
+        "types/remove-double-negations": {
           "$ref": "#/definitions/rule"
         },
-        "promises/add-missing-await": {
+        "types/remove-useless-constructor": {
           "$ref": "#/definitions/rule"
         },
-        "promises/apply-top-level-await": {
+        "types/remove-useless-conversion": {
           "$ref": "#/definitions/rule"
         },
-        "promises/apply-await-import": {
+        "types/remove-useless-typeof": {
           "$ref": "#/definitions/rule"
         },
-        "promises/convert-new-promise-to-async": {
+        "variables/apply-declarations-order": {
           "$ref": "#/definitions/rule"
         },
-        "promises/convert-reject-to-throw": {
+        "variables": {
           "$ref": "#/definitions/rule"
         },
-        "promises/remove-useless-async": {
+        "variables/convert-const-to-let": {
           "$ref": "#/definitions/rule"
         },
-        "promises/remove-useless-await": {
+        "variables/extract-keywords": {
           "$ref": "#/definitions/rule"
         },
-        "promises/remove-useless-resolve": {
+        "variables/remove-unreferenced": {
           "$ref": "#/definitions/rule"
         },
-        "putout": {
+        "variables/remove-unused": {
           "$ref": "#/definitions/rule"
         },
-        "putout/add-args": {
+        "variables/remove-useless": {
           "$ref": "#/definitions/rule"
         },
-        "putout/add-push": {
+        "variables/remove-useless-assignment": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-async-formatter": {
+        "variables/remove-useless-declarations": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-create-test": {
+        "variables/remove-useless-duplicates": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-declare": {
+        "variables/remove-useless-rename": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-insert-after": {
+        "variables/reuse-duplicate-init": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-insert-before": {
+        "variables/split-declarations": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-namaspace-specifier": {
+        "convert-quotes-to-backticks": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-processors-destructuring": {
+        "madrun/add-cut-env": {
           "$ref": "#/definitions/rule"
         },
-        "putout/apply-remove": {
+        "madrun": {
           "$ref": "#/definitions/rule"
         },
-        "putout/check-match": {
+        "madrun/add-fix-lint": {
           "$ref": "#/definitions/rule"
         },
-        "putout/check-replace-code": {
+        "madrun/add-function": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-add-argument-to-add-args": {
+        "madrun/add-missing-quotes-to-watcher": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-babel-types": {
+        "madrun/add-run": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-destructuring-to-identifier": {
+        "madrun/call-run": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-dirname-to-url": {
+        "madrun/convert-args-to-scripts": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-find-to-traverse": {
+        "madrun/convert-cut-env-to-run": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-get-rule-to-require": {
+        "madrun/convert-lint-lib": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-match-to-function": {
+        "madrun/convert-nyc-to-c8": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-method-to-property": {
+        "madrun/convert-run-argument": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-node-to-path-in-get-template-values": {
+        "madrun/convert-run-to-cut-env": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-number-to-numeric": {
+        "madrun/convert-to-async": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-process-to-find": {
+        "madrun/declare": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-putout-test-to-create-test": {
+        "madrun/remove-check-duplicates-from-test": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-replace-to-function": {
+        "madrun/remove-putout": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-replace-with": {
+        "madrun/remove-useless-array-in-run": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-replace-with-multiple": {
+        "madrun/remove-useless-string-conversion": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-report-to-function": {
+        "madrun/rename-eslint-to-putout": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-to-no-transform-code": {
+        "madrun/rename-series-to-run": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-traverse-to-include": {
+        "madrun/set-lint-dot": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-traverse-to-replace": {
+        "madrun/set-report-lcov": {
           "$ref": "#/definitions/rule"
         },
-        "putout/convert-url-to-dirname": {
+        "nodejs/convert-commonjs-to-esm/common": {
           "$ref": "#/definitions/rule"
         },
-        "putout/create-test": {
+        "nodejs/convert-commonjs-to-esm/exports": {
           "$ref": "#/definitions/rule"
         },
-        "putout/declare": {
+        "nodejs/convert-commonjs-to-esm/require": {
           "$ref": "#/definitions/rule"
         },
-        "putout/includer": {
+        "npmignore/add": {
           "$ref": "#/definitions/rule"
         },
-        "putout/insert-rust": {
+        "npmignore": {
           "$ref": "#/definitions/rule"
         },
-        "putout/move-require-on-top-level": {
+        "npmignore/sort": {
           "$ref": "#/definitions/rule"
         },
-        "putout/rename-operate-to-operator": {
+        "coverage/add-to-exclude": {
           "$ref": "#/definitions/rule"
         },
-        "putout/replace-operate-with-operator": {
+        "coverage": {
           "$ref": "#/definitions/rule"
         },
-        "putout/replace-test-message": {
+        "coverage/sort-ignore": {
           "$ref": "#/definitions/rule"
         },
-        "putout/shorten-imports": {
+        "putout-config/apply-arguments": {
           "$ref": "#/definitions/rule"
         },
         "putout-config": {
           "$ref": "#/definitions/rule"
         },
-        "react-hooks": {
+        "putout-config/apply-assignment": {
           "$ref": "#/definitions/rule"
         },
-        "regexp": {
+        "putout-config/apply-conditions": {
           "$ref": "#/definitions/rule"
         },
-        "conditions/remove-boolean": {
+        "putout-config/apply-coverage": {
           "$ref": "#/definitions/rule"
         },
-        "remove-boolean-from-logical-expressions": {
+        "putout-config/apply-destructuring": {
           "$ref": "#/definitions/rule"
         },
-        "remove-console": {
+        "putout-config/apply-esm": {
           "$ref": "#/definitions/rule"
         },
-        "remove-debugger": {
+        "putout-config/apply-for-of": {
           "$ref": "#/definitions/rule"
         },
-        "remove-duplicate-case": {
+        "putout-config/apply-labels": {
           "$ref": "#/definitions/rule"
         },
-        "remove-duplicate-interface-keys": {
+        "putout-config/apply-math": {
           "$ref": "#/definitions/rule"
         },
-        "remove-duplicate-keys": {
+        "putout-config/apply-nodejs": {
           "$ref": "#/definitions/rule"
         },
-        "remove-duplicates-from-logical-expressions": {
+        "putout-config/apply-optional-chaining": {
           "$ref": "#/definitions/rule"
         },
-        "remove-duplicates-from-union": {
+        "putout-config/apply-parens": {
           "$ref": "#/definitions/rule"
         },
-        "remove-empty": {
+        "putout-config/apply-promises": {
           "$ref": "#/definitions/rule"
         },
-        "remove-empty/argument": {
+        "putout-config/apply-return": {
           "$ref": "#/definitions/rule"
         },
-        "remove-empty/block": {
+        "putout-config/apply-spread": {
           "$ref": "#/definitions/rule"
         },
-        "remove-empty/pattern": {
+        "putout-config/apply-tape": {
           "$ref": "#/definitions/rule"
         },
-        "esm": {
+        "putout-config/apply-types": {
           "$ref": "#/definitions/rule"
         },
-        "esm/add-index-to-import": {
+        "putout-config/apply-variables": {
           "$ref": "#/definitions/rule"
         },
-        "esm/remove-empty-import": {
+        "putout-config/convert-boolean-to-string": {
           "$ref": "#/definitions/rule"
         },
-        "esm/remove-empty-export": {
+        "putout-config/move-formatter-up": {
           "$ref": "#/definitions/rule"
         },
-        "esm/convert-assert-to-with": {
+        "putout-config/remove-empty": {
           "$ref": "#/definitions/rule"
         },
-        "esm/group-imports-by-source": {
+        "putout-config/rename-rules": {
           "$ref": "#/definitions/rule"
         },
-        "esm/declare-imports-first": {
+        "putout-config/sort-ignore": {
           "$ref": "#/definitions/rule"
         },
-        "esm/remove-quotes-from-import-assertions": {
+        "eslint/add-putout": {
           "$ref": "#/definitions/rule"
         },
-        "esm/merge-duplicate-imports": {
+        "eslint": {
           "$ref": "#/definitions/rule"
         },
-        "esm/sort-imports-by-specifier": {
+        "eslint/apply-create-eslint-config": {
           "$ref": "#/definitions/rule"
         },
-        "optional-chaining": {
+        "eslint/apply-define-config": {
           "$ref": "#/definitions/rule"
         },
-        "optional-chaining/convert-optional-assign-to-logical": {
+        "eslint/apply-dir-to-flat": {
           "$ref": "#/definitions/rule"
         },
-        "optional-chaining/convert-optional-to-logical": {
+        "eslint/apply-match-to-flat": {
           "$ref": "#/definitions/rule"
         },
-        "optional-chaining/convert-logical-assign-to-optional": {
+        "eslint/apply-safe-align": {
           "$ref": "#/definitions/rule"
         },
-        "optional-chaining/convert-logical-to-optional": {
+        "eslint/convert-export-match-to-declaration": {
           "$ref": "#/definitions/rule"
         },
-        "remove-iife": {
+        "eslint/convert-files-to-array": {
           "$ref": "#/definitions/rule"
         },
-        "remove-nested-blocks": {
+        "eslint/convert-ide-to-safe": {
           "$ref": "#/definitions/rule"
         },
-        "remove-unreachable-code": {
+        "eslint/convert-node-to-n": {
           "$ref": "#/definitions/rule"
         },
-        "variables": {
+        "eslint/convert-plugins-array-to-object": {
           "$ref": "#/definitions/rule"
         },
-        "variables/convert-const-to-let": {
+        "eslint/convert-require-to-import": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-unused": {
+        "eslint/declare": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-useless": {
+        "eslint/move-putout-to-end-of-extends": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-useless-assignment": {
+        "eslint/remove-create-eslint-config-with-one-argument": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-useless-declarations": {
+        "eslint/remove-no-missing": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-useless-duplicates": {
+        "eslint/remove-no-unpublished-require": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-useless-rename": {
+        "eslint/remove-no-unsupported-features": {
           "$ref": "#/definitions/rule"
         },
-        "variables/remove-unreferenced": {
+        "eslint/remove-overrides-with-empty-rules": {
           "$ref": "#/definitions/rule"
         },
-        "variables/extract-keyword": {
+        "eslint/remove-parser-options": {
           "$ref": "#/definitions/rule"
         },
-        "variables/split-declarations": {
+        "eslint/remove-spread-from-create-eslint-config": {
           "$ref": "#/definitions/rule"
         },
-        "remove-unused-expressions": {
+        "eslint/remove-suffix-config": {
           "$ref": "#/definitions/rule"
         },
-        "remove-unused-private-fields": {
+        "eslint/remove-useless-define-config": {
           "$ref": "#/definitions/rule"
         },
-        "remove-unused-types": {
+        "eslint/remove-useless-match-to-flat": {
           "$ref": "#/definitions/rule"
         },
-        "arguments": {
+        "eslint/remove-useless-properties": {
           "$ref": "#/definitions/rule"
         },
-        "arguments/apply-json-parse": {
+        "eslint/remove-useless-slice": {
           "$ref": "#/definitions/rule"
         },
-        "arguments/apply-rest": {
+        "package-json/add-type": {
           "$ref": "#/definitions/rule"
         },
-        "arguments/remove-useless": {
+        "package-json": {
           "$ref": "#/definitions/rule"
         },
-        "arguments/remove-useless-from-method": {
+        "package-json/apply-https-to-repository-url": {
           "$ref": "#/definitions/rule"
         },
-        "arguments/remove-unused": {
+        "package-json/apply-js-extension": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-array": {
+        "package-json/remove-commit-type": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-array-constructor": {
+        "package-json/remove-duplicate-keywords": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-array-entries": {
+        "package-json/remove-imports-nesting": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-constructor": {
+        "package-json/remove-nyc": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-continue": {
+        "tape/add-args": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-escape": {
+        "tape": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-functions": {
+        "tape/add-stop-all": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-map": {
+        "tape/add-t-end": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-new": {
+        "tape/apply-destructuring": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-operand": {
+        "tape/apply-stub": {
           "$ref": "#/definitions/rule"
         },
-        "spread": {
+        "tape/apply-with-name": {
           "$ref": "#/definitions/rule"
         },
-        "spread/convert-object-assign-to-merge-spread": {
+        "tape/convert-called-with-args": {
           "$ref": "#/definitions/rule"
         },
-        "spread/simplify-nested": {
+        "tape/convert-called-with-no-args-to-called-with": {
           "$ref": "#/definitions/rule"
         },
-        "spread/convert-apply-to-spread": {
+        "tape/convert-called-with-to-called-with-no-args": {
           "$ref": "#/definitions/rule"
         },
-        "spread/remove-useless-array": {
+        "tape/convert-deep-equal-to-equal": {
           "$ref": "#/definitions/rule"
         },
-        "spread/remove-useless-object": {
+        "tape/convert-does-not-throw-to-try-catch": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-template-expressions": {
+        "tape/convert-emitter-to-promise": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-templates": {
+        "tape/convert-equal-to-called-once": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-type-conversion": {
+        "tape/convert-equal-to-deep-equal": {
           "$ref": "#/definitions/rule"
         },
-        "remove-useless-types-from-constants": {
+        "tape/convert-equal-to-not-ok": {
           "$ref": "#/definitions/rule"
         },
-        "reuse-duplicate-init": {
+        "tape/convert-equal-to-ok": {
           "$ref": "#/definitions/rule"
         },
-        "assignment": {
+        "tape/convert-equals-to-equal": {
           "$ref": "#/definitions/rule"
         },
-        "assignment/simplify": {
+        "tape/convert-match-regexp-to-string": {
           "$ref": "#/definitions/rule"
         },
-        "assignment/split": {
+        "tape/convert-ok-to-called-with": {
           "$ref": "#/definitions/rule"
         },
-        "assignment/convert-to-arrow-function": {
+        "tape/convert-ok-to-match": {
           "$ref": "#/definitions/rule"
         },
-        "assignment/convert-to-comparison": {
+        "tape/convert-tape-to-supertape": {
           "$ref": "#/definitions/rule"
         },
-        "assignment/convert-to-declaration": {
+        "tape/convert-throws-to-try-catch": {
           "$ref": "#/definitions/rule"
         },
-        "simplify-logical-expressions": {
+        "tape/declare": {
           "$ref": "#/definitions/rule"
         },
-        "simplify-ternary": {
+        "tape/jest": {
           "$ref": "#/definitions/rule"
         },
-        "tape": {
+        "tape/remove-default-messages": {
           "$ref": "#/definitions/rule"
         },
         "tape/remove-only": {
@@ -741,25 +1425,28 @@
         "tape/remove-skip": {
           "$ref": "#/definitions/rule"
         },
-        "travis": {
+        "tape/remove-useless-not-called-args": {
           "$ref": "#/definitions/rule"
         },
-        "types": {
+        "tape/remove-useless-t-end": {
           "$ref": "#/definitions/rule"
         },
-        "types/convert-typeof-to-is-type": {
+        "tape/switch-expected-with-result": {
           "$ref": "#/definitions/rule"
         },
-        "types/remove-useless-conversion": {
+        "tape/sync-with-name": {
           "$ref": "#/definitions/rule"
         },
-        "types/remove-double-negations": {
+        "nodejs/add-missing-strict-mode": {
           "$ref": "#/definitions/rule"
         },
-        "types/remove-useless-typeof": {
+        "nodejs/remove-useless-strict-mode": {
           "$ref": "#/definitions/rule"
         },
-        "types/apply-is-array": {
+        "nodejs/convert-esm-to-commonjs": {
+          "$ref": "#/definitions/rule"
+        },
+        "nodejs/convert-commonjs-to-esm": {
           "$ref": "#/definitions/rule"
         },
         "typescript": {
@@ -794,9 +1481,6 @@
         },
         "typescript/remove-useless-types-from-constants": {
           "$ref": "#/definitions/rule"
-        },
-        "webpack": {
-          "$ref": "#/definitions/rule"
         }
       }
     }