{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://json.schemastore.org/putout.json",
  "additionalProperties": false,
  "definitions": {
    "rule": {
      "oneOf": [
        {
          "description": "🐊Putout rule\n\n\"off\" means rule is off\n\"on\" means it is a on\n",
          "enum": ["on", "off"]
        },
        {
          "type": "array",
          "items": [
            {
              "enum": ["on", "off"]
            },
            {
              "type": "object"
            }
          ],
          "minItems": 2,
          "additionalItems": false
        },
        {
          "type": "array",
          "items": [
            {
              "enum": ["on", "off"]
            },
            {
              "type": "string"
            },
            {
              "type": "object"
            }
          ],
          "minItems": 3,
          "additionalItems": false
        },
        {
          "type": "array",
          "items": [
            {
              "enum": ["on", "off"]
            },
            {
              "type": "string"
            }
          ],
          "minItems": 2,
          "additionalItems": false
        }
      ]
    },
    "rules": {
      "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"
        },
        "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/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/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"
        },
        "putout/declare-path-variable": {
          "$ref": "#/definitions/rule"
        },
        "putout/declare-template-variables": {
          "$ref": "#/definitions/rule"
        },
        "putout/includer": {
          "$ref": "#/definitions/rule"
        },
        "putout/move-require-on-top-level": {
          "$ref": "#/definitions/rule"
        },
        "putout/remove-empty-array-from-process": {
          "$ref": "#/definitions/rule"
        },
        "putout/remove-empty-object-from-transform": {
          "$ref": "#/definitions/rule"
        },
        "putout/remove-message-from-no-report-after-transform": {
          "$ref": "#/definitions/rule"
        },
        "putout/remove-unused-get-properties-argument": {
          "$ref": "#/definitions/rule"
        },
        "putout/remove-useless-printer-option": {
          "$ref": "#/definitions/rule"
        },
        "putout/rename-operate-to-operator": {
          "$ref": "#/definitions/rule"
        },
        "putout/replace-operate-with-operator": {
          "$ref": "#/definitions/rule"
        },
        "putout/replace-test-message": {
          "$ref": "#/definitions/rule"
        },
        "putout/shorten-imports": {
          "$ref": "#/definitions/rule"
        },
        "putout/simplify-replace-template": {
          "$ref": "#/definitions/rule"
        },
        "regexp/apply-character-class": {
          "$ref": "#/definitions/rule"
        },
        "regexp": {
          "$ref": "#/definitions/rule"
        },
        "regexp/apply-ends-with": {
          "$ref": "#/definitions/rule"
        },
        "regexp/apply-global-regexp-to-replace-all": {
          "$ref": "#/definitions/rule"
        },
        "regexp/apply-literal-notation": {
          "$ref": "#/definitions/rule"
        },
        "regexp/apply-starts-with": {
          "$ref": "#/definitions/rule"
        },
        "regexp/convert-replace-to-replace-all": {
          "$ref": "#/definitions/rule"
        },
        "regexp/convert-to-string": {
          "$ref": "#/definitions/rule"
        },
        "regexp/optimize": {
          "$ref": "#/definitions/rule"
        },
        "regexp/remove-duplicates-from-character-class": {
          "$ref": "#/definitions/rule"
        },
        "regexp/remove-useless-escape": {
          "$ref": "#/definitions/rule"
        },
        "regexp/remove-useless-group": {
          "$ref": "#/definitions/rule"
        },
        "regexp/remove-useless-regexp": {
          "$ref": "#/definitions/rule"
        },
        "remove-console": {
          "$ref": "#/definitions/rule"
        },
        "remove-debugger": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicate-case": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicate-keys": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/argument": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/block": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/nested-pattern": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/pattern": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/static-block": {
          "$ref": "#/definitions/rule"
        },
        "remove-iife": {
          "$ref": "#/definitions/rule"
        },
        "remove-nested-blocks": {
          "$ref": "#/definitions/rule"
        },
        "remove-unreachable-code": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-expressions": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-private-fields": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-array": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-array-constructor": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-array-entries": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-assign": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-constructor": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-continue": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-delete": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-escape": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-functions": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-map": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-object-from-entries": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-operand": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-push": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-replace": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-template-expressions": {
          "$ref": "#/definitions/rule"
        },
        "return/apply-early": {
          "$ref": "#/definitions/rule"
        },
        "return": {
          "$ref": "#/definitions/rule"
        },
        "return/convert-from-break": {
          "$ref": "#/definitions/rule"
        },
        "return/convert-from-continue": {
          "$ref": "#/definitions/rule"
        },
        "return/merge-with-next-sibling": {
          "$ref": "#/definitions/rule"
        },
        "return/remove-useless": {
          "$ref": "#/definitions/rule"
        },
        "return/simplify-boolean": {
          "$ref": "#/definitions/rule"
        },
        "simplify-ternary/spread": {
          "$ref": "#/definitions/rule"
        },
        "simplify-ternary": {
          "$ref": "#/definitions/rule"
        },
        "simplify-ternary/value": {
          "$ref": "#/definitions/rule"
        },
        "spread/convert-apply-to-spread": {
          "$ref": "#/definitions/rule"
        },
        "spread": {
          "$ref": "#/definitions/rule"
        },
        "spread/convert-object-assign-to-merge-spread": {
          "$ref": "#/definitions/rule"
        },
        "spread/remove-useless-array": {
          "$ref": "#/definitions/rule"
        },
        "spread/simplify-nested": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/apply-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "try-catch": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/args": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/async": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/await": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/declare": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/expand-args": {
          "$ref": "#/definitions/rule"
        },
        "try-catch/sync": {
          "$ref": "#/definitions/rule"
        },
        "types/apply-is-array": {
          "$ref": "#/definitions/rule"
        },
        "types": {
          "$ref": "#/definitions/rule"
        },
        "types/convert-typeof-to-is-type": {
          "$ref": "#/definitions/rule"
        },
        "types/declare": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-double-negations": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-useless-constructor": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-useless-conversion": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-useless-typeof": {
          "$ref": "#/definitions/rule"
        },
        "variables/apply-declarations-order": {
          "$ref": "#/definitions/rule"
        },
        "variables": {
          "$ref": "#/definitions/rule"
        },
        "variables/convert-const-to-let": {
          "$ref": "#/definitions/rule"
        },
        "variables/extract-keywords": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-unreferenced": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-unused": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-useless": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-useless-assignment": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-useless-declarations": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-useless-duplicates": {
          "$ref": "#/definitions/rule"
        },
        "variables/remove-useless-rename": {
          "$ref": "#/definitions/rule"
        },
        "variables/reuse-duplicate-init": {
          "$ref": "#/definitions/rule"
        },
        "variables/split-declarations": {
          "$ref": "#/definitions/rule"
        },
        "convert-quotes-to-backticks": {
          "$ref": "#/definitions/rule"
        },
        "madrun/add-cut-env": {
          "$ref": "#/definitions/rule"
        },
        "madrun": {
          "$ref": "#/definitions/rule"
        },
        "madrun/add-fix-lint": {
          "$ref": "#/definitions/rule"
        },
        "madrun/add-function": {
          "$ref": "#/definitions/rule"
        },
        "madrun/add-missing-quotes-to-watcher": {
          "$ref": "#/definitions/rule"
        },
        "madrun/add-run": {
          "$ref": "#/definitions/rule"
        },
        "madrun/call-run": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-args-to-scripts": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-cut-env-to-run": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-lint-lib": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-nyc-to-c8": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-run-argument": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-run-to-cut-env": {
          "$ref": "#/definitions/rule"
        },
        "madrun/convert-to-async": {
          "$ref": "#/definitions/rule"
        },
        "madrun/declare": {
          "$ref": "#/definitions/rule"
        },
        "madrun/remove-check-duplicates-from-test": {
          "$ref": "#/definitions/rule"
        },
        "madrun/remove-putout": {
          "$ref": "#/definitions/rule"
        },
        "madrun/remove-useless-array-in-run": {
          "$ref": "#/definitions/rule"
        },
        "madrun/remove-useless-string-conversion": {
          "$ref": "#/definitions/rule"
        },
        "madrun/rename-eslint-to-putout": {
          "$ref": "#/definitions/rule"
        },
        "madrun/rename-series-to-run": {
          "$ref": "#/definitions/rule"
        },
        "madrun/set-lint-dot": {
          "$ref": "#/definitions/rule"
        },
        "madrun/set-report-lcov": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-commonjs-to-esm/common": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-commonjs-to-esm/exports": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-commonjs-to-esm/require": {
          "$ref": "#/definitions/rule"
        },
        "npmignore/add": {
          "$ref": "#/definitions/rule"
        },
        "npmignore": {
          "$ref": "#/definitions/rule"
        },
        "npmignore/sort": {
          "$ref": "#/definitions/rule"
        },
        "coverage/add-to-exclude": {
          "$ref": "#/definitions/rule"
        },
        "coverage": {
          "$ref": "#/definitions/rule"
        },
        "coverage/sort-ignore": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-arguments": {
          "$ref": "#/definitions/rule"
        },
        "putout-config": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-assignment": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-conditions": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-coverage": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-esm": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-for-of": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-labels": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-math": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-nodejs": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-optional-chaining": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-parens": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-promises": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-return": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-spread": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-tape": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-types": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/apply-variables": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/convert-boolean-to-string": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/move-formatter-up": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/remove-empty": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/rename-rules": {
          "$ref": "#/definitions/rule"
        },
        "putout-config/sort-ignore": {
          "$ref": "#/definitions/rule"
        },
        "eslint/add-putout": {
          "$ref": "#/definitions/rule"
        },
        "eslint": {
          "$ref": "#/definitions/rule"
        },
        "eslint/apply-create-eslint-config": {
          "$ref": "#/definitions/rule"
        },
        "eslint/apply-define-config": {
          "$ref": "#/definitions/rule"
        },
        "eslint/apply-dir-to-flat": {
          "$ref": "#/definitions/rule"
        },
        "eslint/apply-match-to-flat": {
          "$ref": "#/definitions/rule"
        },
        "eslint/apply-safe-align": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-export-match-to-declaration": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-files-to-array": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-ide-to-safe": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-node-to-n": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-plugins-array-to-object": {
          "$ref": "#/definitions/rule"
        },
        "eslint/convert-require-to-import": {
          "$ref": "#/definitions/rule"
        },
        "eslint/declare": {
          "$ref": "#/definitions/rule"
        },
        "eslint/move-putout-to-end-of-extends": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-create-eslint-config-with-one-argument": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-no-missing": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-no-unpublished-require": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-no-unsupported-features": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-overrides-with-empty-rules": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-parser-options": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-spread-from-create-eslint-config": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-suffix-config": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-useless-define-config": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-useless-match-to-flat": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-useless-properties": {
          "$ref": "#/definitions/rule"
        },
        "eslint/remove-useless-slice": {
          "$ref": "#/definitions/rule"
        },
        "package-json/add-type": {
          "$ref": "#/definitions/rule"
        },
        "package-json": {
          "$ref": "#/definitions/rule"
        },
        "package-json/apply-https-to-repository-url": {
          "$ref": "#/definitions/rule"
        },
        "package-json/apply-js-extension": {
          "$ref": "#/definitions/rule"
        },
        "package-json/remove-commit-type": {
          "$ref": "#/definitions/rule"
        },
        "package-json/remove-duplicate-keywords": {
          "$ref": "#/definitions/rule"
        },
        "package-json/remove-imports-nesting": {
          "$ref": "#/definitions/rule"
        },
        "package-json/remove-nyc": {
          "$ref": "#/definitions/rule"
        },
        "tape/add-args": {
          "$ref": "#/definitions/rule"
        },
        "tape": {
          "$ref": "#/definitions/rule"
        },
        "tape/add-stop-all": {
          "$ref": "#/definitions/rule"
        },
        "tape/add-t-end": {
          "$ref": "#/definitions/rule"
        },
        "tape/apply-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "tape/apply-stub": {
          "$ref": "#/definitions/rule"
        },
        "tape/apply-with-name": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-called-with-args": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-called-with-no-args-to-called-with": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-called-with-to-called-with-no-args": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-deep-equal-to-equal": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-does-not-throw-to-try-catch": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-emitter-to-promise": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-equal-to-called-once": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-equal-to-deep-equal": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-equal-to-not-ok": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-equal-to-ok": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-equals-to-equal": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-match-regexp-to-string": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-ok-to-called-with": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-ok-to-match": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-tape-to-supertape": {
          "$ref": "#/definitions/rule"
        },
        "tape/convert-throws-to-try-catch": {
          "$ref": "#/definitions/rule"
        },
        "tape/declare": {
          "$ref": "#/definitions/rule"
        },
        "tape/jest": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-default-messages": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-only": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-skip": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-useless-not-called-args": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-useless-t-end": {
          "$ref": "#/definitions/rule"
        },
        "tape/switch-expected-with-result": {
          "$ref": "#/definitions/rule"
        },
        "tape/sync-with-name": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/add-missing-strict-mode": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/remove-useless-strict-mode": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-esm-to-commonjs": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-commonjs-to-esm": {
          "$ref": "#/definitions/rule"
        },
        "typescript": {
          "$ref": "#/definitions/rule"
        },
        "typescript/apply-as-type-assertion": {
          "$ref": "#/definitions/rule"
        },
        "typescript/apply-utility-types": {
          "$ref": "#/definitions/rule"
        },
        "typescript/convert-generic-to-shorthand": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-duplicate-interface-keys": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-duplicates-from-union": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-unused-types": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-useless-mapped-types": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-useless-mapping-modifiers": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-useless-types": {
          "$ref": "#/definitions/rule"
        },
        "typescript/remove-useless-types-from-constants": {
          "$ref": "#/definitions/rule"
        }
      }
    }
  },
  "properties": {
    "printer": {
      "description": "Tell 🐊Putout which printer to use",
      "oneOf": [
        {
          "type": "string"
        },
        {
          "type": "array",
          "minItems": 2,
          "maxItems": 2,
          "items": [
            {
              "type": "string"
            },
            {
              "type": "object"
            }
          ]
        }
      ]
    },
    "parser": {
      "description": "Tell 🐊Putout which parser to use",
      "type": "string"
    },
    "formatter": {
      "description": "Choose the way to show information about errors found",
      "type": ["string", "array"]
    },
    "processors": {
      "description": "Tell 🐊Putout which processors to use to support file types other then JavaScript",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "type": "string"
      }
    },
    "ignore": {
      "description": "Tell 🐊Putout to ignore specific files and directories.",
      "type": "array",
      "uniqueItems": true,
      "items": {
        "type": "string"
      }
    },
    "match": {
      "description": "Allows to match rules for files and folders, specified by glob patterns.",
      "type": "object",
      "patternProperties": {
        "^.*$": {
          "$ref": "#/definitions/rules"
        },
        "additionalProperties": false
      }
    },
    "plugins": {
      "description": "Tell 🐊Putout which plugins to load",
      "type": "array",
      "uniqueItems": true
    },
    "rules": {
      "$ref": "#/definitions/rules"
    }
  },
  "type": "object"
}