{
  "$id": "https://json.schemastore.org/putout.json",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "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": {
        "add-return-await": {
          "$ref": "#/definitions/rule"
        },
        "apply-at": {
          "$ref": "#/definitions/rule"
        },
        "apply-await-import": {
          "$ref": "#/definitions/rule"
        },
        "apply-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "apply-early-return": {
          "$ref": "#/definitions/rule"
        },
        "apply-montag": {
          "$ref": "#/definitions/rule"
        },
        "apply-nullish-coalescing": {
          "$ref": "#/definitions/rule"
        },
        "apply-numeric-separators": {
          "$ref": "#/definitions/rule"
        },
        "apply-optional-chaining": {
          "$ref": "#/definitions/rule"
        },
        "apply-shorthand-properties": {
          "$ref": "#/definitions/rule"
        },
        "apply-try-catch": {
          "$ref": "#/definitions/rule"
        },
        "apply-utility-types": {
          "$ref": "#/definitions/rule"
        },
        "browserlist": {
          "$ref": "#/definitions/rule"
        },
        "cloudcmd": {
          "$ref": "#/definitions/rule"
        },
        "conditions": {
          "$ref": "#/definitions/rule"
        },
        "conditions/apply-comparison-order": {
          "$ref": "#/definitions/rule"
        },
        "conditions/apply-if": {
          "$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/simplify": {
          "$ref": "#/definitions/rule"
        },
        "conditions/remove-constant": {
          "$ref": "#/definitions/rule"
        },
        "conditions/remove-boolean": {
          "$ref": "#/definitions/rule"
        },
        "conditions/remove-useless-else": {
          "$ref": "#/definitions/rule"
        },
        "convert-apply-to-spread": {
          "$ref": "#/definitions/rule"
        },
        "convert-arguments-to-rest": {
          "$ref": "#/definitions/rule"
        },
        "convert-array-copy-to-slice": {
          "$ref": "#/definitions/rule"
        },
        "convert-assignment-to-arrow-function": {
          "$ref": "#/definitions/rule"
        },
        "convert-assignment-to-comparison": {
          "$ref": "#/definitions/rule"
        },
        "convert-bitwise-to-logical": {
          "$ref": "#/definitions/rule"
        },
        "convert-commonjs-to-esm": {
          "$ref": "#/definitions/rule"
        },
        "convert-concat-to-flat": {
          "$ref": "#/definitions/rule"
        },
        "convert-esm-to-commonjs": {
          "$ref": "#/definitions/rule"
        },
        "convert-index-of-to-includes": {
          "$ref": "#/definitions/rule"
        },
        "convert-is-nan-to-number-is-nan": {
          "$ref": "#/definitions/rule"
        },
        "convert-math-pow": {
          "$ref": "#/definitions/rule"
        },
        "convert-mock-require-to-mock-import": {
          "$ref": "#/definitions/rule"
        },
        "convert-object-assign-to-merge-spread": {
          "$ref": "#/definitions/rule"
        },
        "convert-quotes-to-backticks": {
          "$ref": "#/definitions/rule"
        },
        "convert-spread-to-array-from": {
          "$ref": "#/definitions/rule"
        },
        "convert-template-to-string": {
          "$ref": "#/definitions/rule"
        },
        "convert-throw": {
          "$ref": "#/definitions/rule"
        },
        "convert-to-arrow-function": {
          "$ref": "#/definitions/rule"
        },
        "declare": {
          "$ref": "#/definitions/rule"
        },
        "eslint": {
          "$ref": "#/definitions/rule"
        },
        "extract-object-properties": {
          "$ref": "#/definitions/rule"
        },
        "extract-sequence-expressions": {
          "$ref": "#/definitions/rule"
        },
        "for-of/for": {
          "$ref": "#/definitions/rule"
        },
        "for-of/for-each": {
          "$ref": "#/definitions/rule"
        },
        "for-of/for-in": {
          "$ref": "#/definitions/rule"
        },
        "for-of/map": {
          "$ref": "#/definitions/rule"
        },
        "for-of/remove-useless": {
          "$ref": "#/definitions/rule"
        },
        "for-of/remove-unused-variables": {
          "$ref": "#/definitions/rule"
        },
        "for-of/remove-useless-array-from": {
          "$ref": "#/definitions/rule"
        },
        "github": {
          "$ref": "#/definitions/rule"
        },
        "gitignore": {
          "$ref": "#/definitions/rule"
        },
        "jest": {
          "$ref": "#/definitions/rule"
        },
        "madrun": {
          "$ref": "#/definitions/rule"
        },
        "maybe": {
          "$ref": "#/definitions/rule"
        },
        "merge-destructuring-properties": {
          "$ref": "#/definitions/rule"
        },
        "merge-duplicate-imports": {
          "$ref": "#/definitions/rule"
        },
        "nodejs": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-dirname-to-url": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-fs-promises": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-promisify-to-fs-promises": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/convert-top-level-return": {
          "$ref": "#/definitions/rule"
        },
        "nodejs/remove-process-exit": {
          "$ref": "#/definitions/rule"
        },
        "npmignore": {
          "$ref": "#/definitions/rule"
        },
        "package-json": {
          "$ref": "#/definitions/rule"
        },
        "postcss": {
          "$ref": "#/definitions/rule"
        },
        "promises": {
          "$ref": "#/definitions/rule"
        },
        "promises/add-missing-await": {
          "$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/remove-useless-async": {
          "$ref": "#/definitions/rule"
        },
        "promises/remove-useless-await": {
          "$ref": "#/definitions/rule"
        },
        "promises/remove-useless-resolve": {
          "$ref": "#/definitions/rule"
        },
        "putout": {
          "$ref": "#/definitions/rule"
        },
        "putout/add-args": {
          "$ref": "#/definitions/rule"
        },
        "putout/add-index-to-import": {
          "$ref": "#/definitions/rule"
        },
        "putout/add-push": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-async-formatter": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-create-test": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-declare": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-insert-after": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-insert-before": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-namaspace-specifier": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-processors-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "putout/apply-remove": {
          "$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-rule-to-require": {
          "$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-process-to-find": {
          "$ref": "#/definitions/rule"
        },
        "putout/convert-putout-test-to-create-test": {
          "$ref": "#/definitions/rule"
        },
        "putout/convert-replace-to-function": {
          "$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-url-to-dirname": {
          "$ref": "#/definitions/rule"
        },
        "putout/create-test": {
          "$ref": "#/definitions/rule"
        },
        "putout/declare": {
          "$ref": "#/definitions/rule"
        },
        "putout/includer": {
          "$ref": "#/definitions/rule"
        },
        "putout/insert-rust": {
          "$ref": "#/definitions/rule"
        },
        "putout/move-require-on-top-level": {
          "$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-config": {
          "$ref": "#/definitions/rule"
        },
        "react-hooks": {
          "$ref": "#/definitions/rule"
        },
        "regexp": {
          "$ref": "#/definitions/rule"
        },
        "remove-boolean-from-assertions": {
          "$ref": "#/definitions/rule"
        },
        "remove-boolean-from-logical-expressions": {
          "$ref": "#/definitions/rule"
        },
        "remove-console": {
          "$ref": "#/definitions/rule"
        },
        "remove-debugger": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicate-case": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicate-interface-keys": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicate-keys": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicates-from-logical-expressions": {
          "$ref": "#/definitions/rule"
        },
        "remove-duplicates-from-union": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/argument": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/block": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/export": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/import": {
          "$ref": "#/definitions/rule"
        },
        "remove-empty/pattern": {
          "$ref": "#/definitions/rule"
        },
        "remove-iife": {
          "$ref": "#/definitions/rule"
        },
        "remove-nested-blocks": {
          "$ref": "#/definitions/rule"
        },
        "remove-unreachable-code": {
          "$ref": "#/definitions/rule"
        },
        "remove-unreferenced-variables": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-expressions": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-private-fields": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-types": {
          "$ref": "#/definitions/rule"
        },
        "remove-unused-variables": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-arguments": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-array-constructor": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-array-entries": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-constructor": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-continue": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-escape": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-functions": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-map": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-new": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-operand": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-return": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-spread": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-template-expressions": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-templates": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-type-conversion": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-types-from-constants": {
          "$ref": "#/definitions/rule"
        },
        "remove-useless-variables": {
          "$ref": "#/definitions/rule"
        },
        "reuse-duplicate-init": {
          "$ref": "#/definitions/rule"
        },
        "simplify-assignment": {
          "$ref": "#/definitions/rule"
        },
        "simplify-logical-expressions": {
          "$ref": "#/definitions/rule"
        },
        "simplify-ternary": {
          "$ref": "#/definitions/rule"
        },
        "split-nested-destructuring": {
          "$ref": "#/definitions/rule"
        },
        "split-variable-declarations": {
          "$ref": "#/definitions/rule"
        },
        "strict-mode": {
          "$ref": "#/definitions/rule"
        },
        "tape": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-only": {
          "$ref": "#/definitions/rule"
        },
        "tape/remove-skip": {
          "$ref": "#/definitions/rule"
        },
        "travis": {
          "$ref": "#/definitions/rule"
        },
        "types": {
          "$ref": "#/definitions/rule"
        },
        "types/convert-typeof-to-is-type": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-useless-conversion": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-double-negations": {
          "$ref": "#/definitions/rule"
        },
        "types/remove-useless-typeof": {
          "$ref": "#/definitions/rule"
        },
        "types/apply-is-array": {
          "$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"
        },
        "webpack": {
          "$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"
}
