VSCodeSetting/globalStorage/vscode.json-language-features/json-schema-cache/50ab969b57b661ead929ae5ada1eae12.schema.json

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "title": "JSON schema for the TSLint configuration files.",
  "type": "object",
  "definitions": {
    "rule": {
      "type": [
        "boolean",
        "object",
        "array"
      ],
      "minItems": 1,
      "properties": {
        "severity": {
          "description": "Severity level. Level \"error\" will cause exit code 2.",
          "type": "string",
          "enum": [
            "default",
            "error",
            "warning",
            "warn",
            "off",
            "none"
          ],
          "default": "default"
        }
      }
    },
    "rules": {
      "properties": {
        "align": {
          "description": "Enforces vertical alignment.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "arguments",
                  "elements",
                  "members",
                  "parameters",
                  "statements"
                ]
              },
              "minItems": 1,
              "maxItems": 5,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/align/definitions/options/items"
              },
              "maxItems": 6,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/align/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/align/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "arrow-parens": {
          "description": "Requires parentheses around the parameters of arrow function definitions.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ban-single-arg-parens"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/arrow-parens/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/arrow-parens/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/arrow-parens/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "arrow-return-shorthand": {
          "description": "Suggests to convert `() => { return x; }` to `() => x`.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "multiline"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/arrow-return-shorthand/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/arrow-return-shorthand/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/arrow-return-shorthand/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "ban": {
          "description": "Bans the use of specific functions or global methods.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minItems": 1,
                    "maxItems": 3
                  },
                  {
                    "type": "object",
                    "properties": {
                      "name": {
                        "anyOf": [
                          {
                            "type": "string"
                          },
                          {
                            "type": "array",
                            "items": {
                              "type": "string"
                            },
                            "minItems": 1,
                            "maxItems": 3
                          }
                        ]
                      },
                      "message": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "name"
                    ],
                    "additionalProperties": false
                  }
                ]
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/ban/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/ban/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/ban/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "ban-comma-operator": {
          "description": "Bans the comma operator.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "binary-expression-operand-order": {
          "description": "In a binary expression, a literal should always be on the right-hand side if possible.\nFor example, prefer 'x + 1' over '1 + x'.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "class-name": {
          "description": "Enforces PascalCased class and interface names.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "comment-format": {
          "description": "Enforces formatting rules for single-line comments.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "anyOf": [
                  {
                    "type": "string",
                    "enum": [
                      "check-space",
                      "check-lowercase",
                      "check-uppercase"
                    ],
                    "minItems": 1,
                    "maxItems": 3,
                    "uniqueItems": true
                  },
                  {
                    "type": "object",
                    "properties": {
                      "ignore-words": {
                        "type": "array",
                        "items": {
                          "type": "string"
                        },
                        "uniqueItems": true
                      },
                      "ignore-pattern": {
                        "type": "string"
                      }
                    },
                    "minProperties": 1,
                    "maxProperties": 1
                  }
                ]
              },
              "minItems": 1,
              "maxItems": 4,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/comment-format/definitions/options/items"
              },
              "maxItems": 5,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/comment-format/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/comment-format/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "completed-docs": {
          "description": "Enforces documentation for important items be filled out.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "oneOf": [
                  {
                    "type": "string",
                    "enum": [
                      "classes",
                      "enums",
                      "enum-members",
                      "functions",
                      "interfaces",
                      "methods",
                      "namespaces",
                      "properties",
                      "types",
                      "variables"
                    ]
                  },
                  {
                    "type": "object",
                    "properties": {
                      "classes": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "enums": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "enum-members": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "functions": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "interfaces": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "methods": {
                        "type": "object",
                        "properties": {
                          "locations": {
                            "type": "string",
                            "enum": [
                              "all",
                              "instance",
                              "static"
                            ]
                          },
                          "privacies": {
                            "type": "string",
                            "enum": [
                              "all",
                              "private",
                              "protected",
                              "public"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "namespaces": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "properties": {
                        "type": "object",
                        "properties": {
                          "locations": {
                            "type": "string",
                            "enum": [
                              "all",
                              "instance",
                              "static"
                            ]
                          },
                          "privacies": {
                            "type": "string",
                            "enum": [
                              "all",
                              "private",
                              "protected",
                              "public"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "types": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      },
                      "variables": {
                        "type": "object",
                        "properties": {
                          "visibilities": {
                            "type": "string",
                            "enum": [
                              "all",
                              "exported",
                              "internal"
                            ]
                          }
                        },
                        "additionalProperties": false
                      }
                    }
                  }
                ]
              },
              "minItems": 1,
              "maxItems": 10,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/completed-docs/definitions/options/items"
              },
              "maxItems": 11,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/completed-docs/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/completed-docs/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "curly": {
          "description": "Enforces braces for `if`/`for`/`do`/`while` statements.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "as-needed",
                  "ignore-same-line"
                ],
                "minItems": 1,
                "maxItems": 2,
                "uniqueItems": true
              }
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/curly/definitions/options/items"
              },
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/curly/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/curly/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "cyclomatic-complexity": {
          "description": "Enforces a threshold of cyclomatic complexity.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "number",
                "minimum": 2
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/cyclomatic-complexity/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/cyclomatic-complexity/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/cyclomatic-complexity/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "deprecation": {
          "description": "Warns when deprecated APIs are used.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "encoding": {
          "description": "Enforces UTF-8 file encoding.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "eofline": {
          "description": "Ensures the file ends with a newline.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "file-header": {
          "description": "Enforces a certain header comment for all files, matched by a regular expression.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "maxItems": 2
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/file-header/definitions/options/items"
              },
              "maxItems": 3,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/file-header/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/file-header/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "file-name-casing": {
          "description": "Enforces a consistent file naming convention.",
          "definitions": {
            "file-name-cases": {
              "type": "string",
              "enum": [
                "camel-case",
                "pascal-case",
                "kebab-case",
                "snake-case"
              ]
            }
          },
          "type": "array",
          "minItems": 2,
          "items": [
            {
              "type": "boolean"
            },
            {
              "oneOf": [
                {
                  "$ref": "#/definitions/rules/properties/file-name-casing/definitions/file-name-cases"
                },
                {
                  "type": "object",
                  "additionalProperties": {
                    "$ref": "#/definitions/rules/properties/file-name-casing/definitions/file-name-cases"
                  },
                  "minProperties": 1
                }
              ]
            }
          ]
        },
        "forin": {
          "description": "Requires a `for ... in` statement to be filtered with an `if` statement.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "import-blacklist": {
          "description": "Disallows importing the specified modules directly via `import` and `require`.\nInstead only sub modules may be imported from that module.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "oneOf": [
                  {
                    "type": "string",
                    "minLength": 1
                  },
                  {
                    "type": "object",
                    "additionalProperties": {
                      "type": "array",
                      "minItems": 1,
                      "items": {
                        "type": "string",
                        "minLength": 1
                      }
                    }
                  },
                  {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minLength": 1
                  }
                ]
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/import-blacklist/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/import-blacklist/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/import-blacklist/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "import-spacing": {
          "description": "Ensures proper spacing between import statement keywords",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "indent": {
          "description": "Enforces indentation with tabs or spaces.",
          "definitions": {
            "options": {
              "type": "array",
              "items": [
                {
                  "type": "string",
                  "enum": [
                    "tabs",
                    "spaces"
                  ]
                },
                {
                  "type": "number",
                  "enum": [
                    2,
                    4
                  ]
                }
              ],
              "minItems": 1,
              "maxItems": 2
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "$ref": "#/definitions/rules/properties/indent/definitions/options/items/0"
                },
                {
                  "$ref": "#/definitions/rules/properties/indent/definitions/options/items/1"
                }
              ],
              "maxItems": 3,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/indent/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/indent/definitions/options/items/0"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "jsdoc-format": {
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-multiline-start"
                ]
              },
              "minItems": 0,
              "maxItems": 1,
              "uniqueItems": true
            }
          },
          "description": "Enforces basic format rules for JSDoc comments.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/jsdoc-format/definitions/options/items"
              },
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/jsdoc-format/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/jsdoc-format/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "label-position": {
          "description": "Only allows labels in sensible locations.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "linebreak-style": {
          "description": "Enforces a consistent linebreak style.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "LF",
                  "CRLF"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/linebreak-style/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/linebreak-style/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/linebreak-style/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "max-classes-per-file": {
          "description": "A file may not contain more than the specified number of classes",
          "definitions": {
            "options": {
              "type": "array",
              "items": [
                {
                  "type": "number",
                  "minimum": 1
                },
                {
                  "type": "string",
                  "enum": [
                    "exclude-class-expressions"
                  ]
                }
              ],
              "minItems": 1,
              "maxItems": 2
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "$ref": "#/definitions/rules/properties/max-classes-per-file/definitions/options/items/0"
                },
                {
                  "$ref": "#/definitions/rules/properties/max-classes-per-file/definitions/options/items/1"
                }
              ],
              "additionalItems": false,
              "minItems": 2,
              "maxItems": 3,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/max-classes-per-file/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/max-classes-per-file/definitions/options/items/0"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "max-file-line-count": {
          "description": "Requires files to remain under a certain number of lines",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "number",
                "minimum": 1
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/max-file-line-count/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/max-file-line-count/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/max-file-line-count/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "max-line-length": {
          "description": "Requires lines to be under a certain max length.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "oneOf": [
                  {
                    "type": "number"
                  },
                  {
                    "type": "object",
                    "properties": {
                      "limit": {
                        "type": "number"
                      },
                      "ignore-pattern": {
                        "type": "string"
                      },
                      "check-strings": {
                        "type": "boolean"
                      },
                      "check-regex": {
                        "type": "boolean"
                      }
                    },
                    "additionalProperties": false
                  }
                ]
              },
              "minLength": 1,
              "maxLength": 2
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/max-line-length/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/max-line-length/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/max-line-length/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "member-ordering": {
          "description": "Enforces member ordering.",
          "definitions": {
            "kinds": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "static-field",
                  "instance-field",
                  "static-method",
                  "instance-method",
                  "constructor",
                  "public-static-field",
                  "public-static-method",
                  "protected-static-field",
                  "protected-static-method",
                  "private-static-field",
                  "private-static-method",
                  "public-instance-field",
                  "protected-instance-field",
                  "private-instance-field",
                  "public-constructor",
                  "protected-constructor",
                  "private-constructor",
                  "public-instance-method",
                  "protected-instance-method",
                  "private-instance-method",
                  "public-static-accessor",
                  "protected-static-accessor",
                  "private-static-accessor",
                  "public-instance-accessor",
                  "protected-instance-accessor",
                  "private-instance-accessor"
                ]
              },
              "minItems": 1,
              "maxItems": 15,
              "uniqueItems": true
            },
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "order": {
                    "oneOf": [
                      {
                        "type": "string",
                        "enum": [
                          "fields-first",
                          "instance-sandwich",
                          "statics-first"
                        ]
                      },
                      {
                        "type": "array",
                        "items": {
                          "anyOf": [
                            {
                              "$ref": "#/definitions/rules/properties/member-ordering/definitions/kinds/items"
                            },
                            {
                              "type": "object",
                              "properties": {
                                "name": {
                                  "type": "string"
                                },
                                "kinds": {
                                  "$ref": "#/definitions/rules/properties/member-ordering/definitions/kinds"
                                }
                              },
                              "additionalProperties": false
                            }
                          ]
                        },
                        "minItems": 1,
                        "maxItems": 15,
                        "uniqueItems": true
                      }
                    ]
                  },
                  "alphabetize": {
                    "type": "boolean"
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/member-ordering/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/member-ordering/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/member-ordering/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "newline-before-return": {
          "description": "Enforces blank line before return when not the only line in the block.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "newline-per-chained-call": {
          "description": "Requires that chained method calls be broken apart onto separate lines.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "new-parens": {
          "description": "Requires parentheses when invoking a constructor via the `new` keyword.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-arg": {
          "description": "Disallows use of `arguments.callee`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-bitwise": {
          "description": "Disallows bitwise operators.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-conditional-assignment": {
          "description": "Disallows any type of assignment in conditionals.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-consecutive-blank-lines": {
          "description": "Disallows one or more blank lines in a row.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "number",
                "minimum": 1
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-consecutive-blank-lines/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-consecutive-blank-lines/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-consecutive-blank-lines/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-console": {
          "description": "Bans the use of specified `console` methods.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-console/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-console/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-console/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-construct": {
          "description": "Disallows access to the constructors of `String`, `Number`, and `Boolean`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-debugger": {
          "description": "Disallows `debugger` statements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-default-export": {
          "description": "Disallows default exports in ES6-style modules.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-duplicate-imports": {
          "description": "Disallows multiple import statements from the same module.",
          "definitions": {
            "options": {
              "type": "object",
              "properties": {
                "allow-namespace-imports": {
                  "type": "boolean"
                }
              },
              "additionalProperties": false
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "$ref": "#/definitions/rules/properties/no-duplicate-imports/definitions/options"
                }
              ],
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-duplicate-imports/definitions/options"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-duplicate-super": {
          "description": "Warns if 'super()' appears twice in a constructor.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-duplicate-switch-case": {
          "description": "Prevents duplicate cases in switch statements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-duplicate-variable": {
          "description": "Disallows duplicate variable declarations in the same block scope.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-parameters"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-duplicate-variable/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-duplicate-variable/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-duplicate-variable/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-dynamic-delete": {
          "description": "Bans usage of the delete operator with computed key expressions.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-empty": {
          "description": "Disallows empty blocks.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-empty-catch",
                  "allow-empty-functions"
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-empty/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-empty/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-empty/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-eval": {
          "description": "Disallows `eval` function invocations.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-for-in-array": {
          "description": "Disallows iterating over an array with a for-in loop.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-implicit-dependencies": {
          "description": "Disallows importing modules that are not listed as dependency in the project’s package.json.",
          "definitions": {
            "options": {
              "type": "array",
              "items": [
                {
                  "type": "string",
                  "enum": [
                    "dev",
                    "optional"
                  ]
                },
                {
                  "type": "array"
                }
              ],
              "minItems": 0,
              "maxItems": 3
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "maxItems": 3,
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-implicit-dependencies/definitions/options/items"
              },
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-implicit-dependencies/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-implicit-dependencies/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-import-side-effect": {
          "description": "Avoid import statements with side-effect.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "ignore-module": {
                    "type": "string"
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-import-side-effect/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-import-side-effect/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-import-side-effect/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-invalid-template-strings": {
          "description": "Warns on use of `${` in non-template strings.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-invalid-this": {
          "description": "Disallows using the `this` keyword outside of classes.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-function-in-method"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-invalid-this/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-invalid-this/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-invalid-this/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-irregular-whitespace": {
          "description": "Disallow irregular whitespace outside of strings and comments",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-magic-numbers": {
          "description": "Disallows the use constant number values outside of variable assignments.\nWhen no list of allowed values is specified, -1, 0 and 1 are allowed by default.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "number"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-magic-numbers/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-magic-numbers/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-magic-numbers/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-null-keyword": {
          "description": "Disallows use of the `null` keyword literal.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-parameter-reassignment": {
          "description": "Disallows reassigning parameters.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-reference": {
          "description": "Disallows `/// <reference path=>` imports (use ES6-style imports instead).",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-return-await": {
          "description": "Disallows unnecessary `return await`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-require-imports": {
          "description": "Disallows invocation of `require()`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-shadowed-variable": {
          "description": "Disallows shadowing variable declarations.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "class": {
                    "type": "boolean"
                  },
                  "enum": {
                    "type": "boolean"
                  },
                  "function": {
                    "type": "boolean"
                  },
                  "import": {
                    "type": "boolean"
                  },
                  "interface": {
                    "type": "boolean"
                  },
                  "namespace": {
                    "type": "boolean"
                  },
                  "typeAlias": {
                    "type": "boolean"
                  },
                  "typeParameter": {
                    "type": "boolean"
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-shadowed-variable/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-shadowed-variable/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-shadowed-variable/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-sparse-arrays": {
          "description": "Forbids array literals to contain missing elements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-string-literal": {
          "description": "Forbids unnecessary string literal property access.\nAllows `obj[\"prop-erty\"]` (can't be a regular property access).\nDisallows `obj[\"property\"]` (should be `obj.property`).",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-string-throw": {
          "description": "Flags throwing plain strings or concatenations of strings because only Errors produce proper stack traces.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-submodule-imports": {
          "description": "Disallows importing any submodule.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-submodule-imports/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-submodule-imports/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-submodule-imports/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-switch-case-fall-through": {
          "description": "Disallows falling through case statements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-this-assignment": {
          "description": "Disallows unnecessary references to `this`.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "allow-destructuring": {
                    "type": "boolean"
                  },
                  "allowed-names": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minItems": 1,
                    "uniqueItems": true
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-this-assignment/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-this-assignment/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-this-assignment/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-trailing-whitespace": {
          "description": "Disallows trailing whitespace at the end of a line.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-comments",
                  "ignore-jsdoc",
                  "ignore-template-strings",
                  "ignore-blank-lines"
                ]
              },
              "minItems": 1,
              "maxItems": 4,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-trailing-whitespace/definitions/options/items"
              },
              "maxItems": 5,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-trailing-whitespace/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-trailing-whitespace/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unnecessary-callback-wrapper": {
          "description": "Replaces `x => f(x)` with just `f`.\nTo catch more cases, enable `only-arrow-functions` and `arrow-return-shorthand` too.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unnecessary-class": {
          "description": "Disallows classes that are not strictly necessary.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-constructor-only",
                  "allow-empty-class",
                  "allow-static-only"
                ]
              },
              "minLength": 0,
              "maxLength": 3
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-unnecessary-class/definitions/options/items"
              },
              "maxItems": 4,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-unnecessary-class/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-unnecessary-class/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unnecessary-initializer": {
          "description": "Forbids a 'var'/'let' statement or destructuring initializer to be initialized to 'undefined'.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unsafe-finally": {
          "description": "Disallows control flow statements, such as `return`, `continue` `break` and `throws` in finally blocks.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unused-expression": {
          "description": "Disallows unused expression statements.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-fast-null-checks",
                  "allow-new",
                  "allow-tagged-template"
                ]
              },
              "minItems": 1,
              "maxItems": 3,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-unused-expression/definitions/options/items"
              },
              "maxItems": 4,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-unused-expression/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-unused-expression/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-use-before-declare": {
          "description": "Disallows usage of variables before their declaration.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-var-keyword": {
          "description": "Disallows usage of the `var` keyword.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-void-expression": {
          "description": "Requires expressions of type `void` to appear in statement position.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-arrow-function-shorthand"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/no-void-expression/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/no-void-expression/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/no-void-expression/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "number-literal-format": {
          "description": "Checks that decimal literals should begin with '0.' instead of just '.', and should not end with a trailing '0'.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "object-literal-key-quotes": {
          "description": "Enforces consistent object literal property quote style.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "always",
                  "as-needed",
                  "consistent",
                  "consistent-as-needed"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/object-literal-key-quotes/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-key-quotes/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-key-quotes/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "object-literal-shorthand": {
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "always",
                  "never"
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "description": "Enforces use of ES6 object literal shorthand when possible.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/object-literal-shorthand/definitions/options/items"
              },
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-shorthand/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-shorthand/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "object-literal-sort-keys": {
          "description": "Checks ordering of keys in object literals.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-case",
                  "locale-compare",
                  "match-declaration-order",
                  "shorthand-first"
                ]
              },
              "minItems": 1,
              "maxItems": 4,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/object-literal-sort-keys/definitions/options/items"
              },
              "maxItems": 5,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-sort-keys/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/object-literal-sort-keys/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "one-line": {
          "description": "Requires the specified tokens to be on the same line as the expression preceding them.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-catch",
                  "check-finally",
                  "check-else",
                  "check-open-brace",
                  "check-whitespace"
                ]
              },
              "minItems": 1,
              "maxItems": 5,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/one-line/definitions/options/items"
              },
              "maxItems": 6,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/one-line/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/one-line/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "one-variable-per-declaration": {
          "description": "Disallows multiple variable definitions in the same declaration statement.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-for-loop"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/one-variable-per-declaration/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/one-variable-per-declaration/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/one-variable-per-declaration/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "only-arrow-functions": {
          "description": "Disallows traditional (non-arrow) function expressions.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-declarations",
                  "allow-named-functions"
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/only-arrow-functions/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/only-arrow-functions/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/only-arrow-functions/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "ordered-imports": {
          "description": "Requires that import statements be alphabetized.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "grouped-imports": {
                    "type": "boolean"
                  },
                  "groups": {
                    "type": "array",
                    "items": {
                      "oneOf": [
                        {
                          "type": "string"
                        },
                        {
                          "type": "object",
                          "properties": {
                            "name": {
                              "type": "string"
                            },
                            "match": {
                              "type": "string"
                            },
                            "order": {
                              "type": "number"
                            }
                          },
                          "required": [
                            "match",
                            "order"
                          ]
                        }
                      ]
                    }
                  },
                  "import-sources-order": {
                    "type": "string",
                    "enum": [
                      "case-insensitive",
                      "case-insensitive-legacy",
                      "lowercase-first",
                      "lowercase-last",
                      "any"
                    ]
                  },
                  "named-imports-order": {
                    "type": "string",
                    "enum": [
                      "case-insensitive",
                      "case-insensitive-legacy",
                      "lowercase-first",
                      "lowercase-last",
                      "any"
                    ]
                  },
                  "module-source-path": {
                    "type": "string",
                    "enum": [
                      "full",
                      "basename"
                    ]
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/ordered-imports/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/ordered-imports/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/ordered-imports/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-conditional-expression": {
          "description": "Recommends to use a conditional expression instead of assigning to the same thing in each branch of an if statement.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-else-if"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/prefer-conditional-expression/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/prefer-conditional-expression/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/prefer-conditional-expression/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-const": {
          "description": "Requires that variable declarations use `const` instead of `let` and `var` if possible.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "destructuring": {
                    "type": "string",
                    "enum": [
                      "all",
                      "any"
                    ]
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/prefer-const/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/prefer-const/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/prefer-const/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-for-of": {
          "description": "Recommends a 'for-of' loop over a standard 'for' loop if the index is only used to access the array being iterated.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-function-over-method": {
          "description": "Warns for class methods that do not use 'this'.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-public",
                  "allow-protected"
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/prefer-function-over-method/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/prefer-function-over-method/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/prefer-function-over-method/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-method-signature": {
          "description": "Prefer `foo(): void` over `foo: () => void` in interfaces and types.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-object-spread": {
          "description": "Enforces the use of the ES2015 object spread operator over `Object.assign()` where appropriate.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-switch": {
          "description": "Prefer a `switch` statement to an `if` statement with simple `===` comparisons.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "min-cases": {
                    "type": "number",
                    "minimum": 0
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/prefer-switch/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/prefer-switch/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/prefer-switch/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-template": {
          "description": "Prefer a template expression over string literal concatenation.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-single-concat"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/prefer-template/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/prefer-template/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/prefer-template/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-while": {
          "description": "Prefer while loops instead of for loops without an initializer and incrementor.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "additionalProperties": false
            }
          ]
        },
        "promise-function-async": {
          "description": "Requires any function or method that returns a promise to be marked async.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "quotemark": {
          "description": "Requires single or double quotes for string literals.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "single",
                  "double",
                  "jsx-single",
                  "jsx-double",
                  "avoid-escape",
                  "avoid-template"
                ]
              },
              "minItems": 1,
              "maxItems": 4,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/quotemark/definitions/options/items"
              },
              "maxItems": 5,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/quotemark/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/quotemark/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "radix": {
          "description": "Requires the radix parameter to be specified when calling `parseInt`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "restrict-plus-operands": {
          "description": "When adding two variables, operands must both be of type number or of type string.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "return-undefined": {
          "description": "Prefer `return;` in void functions and `return undefined;` in value-returning functions.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "semicolon": {
          "description": "Enforces consistent semicolon usage at the end of every statement.",
          "definitions": {
            "options": {
              "type": "array",
              "items": [
                {
                  "type": "string",
                  "enum": [
                    "always",
                    "never"
                  ]
                },
                {
                  "type": "string",
                  "enum": [
                    "ignore-interfaces",
                    "ignore-bound-class-methods",
                    "strict-bound-class-methods"
                  ]
                }
              ],
              "minItems": 1,
              "maxItems": 3
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "$ref": "#/definitions/rules/properties/semicolon/definitions/options/items/0"
                },
                {
                  "$ref": "#/definitions/rules/properties/semicolon/definitions/options/items/1"
                }
              ],
              "maxItems": 3,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/semicolon/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/semicolon/definitions/options/items/0"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "space-before-function-paren": {
          "description": "Require or disallow a space before function parenthesis",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "anonymous": {
                    "type": "string",
                    "enum": [
                      "always",
                      "never"
                    ]
                  },
                  "asyncArrow": {
                    "type": "string",
                    "enum": [
                      "always",
                      "never"
                    ]
                  },
                  "constructor": {
                    "type": "string",
                    "enum": [
                      "always",
                      "never"
                    ]
                  },
                  "method": {
                    "type": "string",
                    "enum": [
                      "always",
                      "never"
                    ]
                  },
                  "named": {
                    "type": "string",
                    "enum": [
                      "always",
                      "never"
                    ]
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/space-before-function-paren/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/space-before-function-paren/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/space-before-function-paren/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "space-within-parens": {
          "description": "Enforces spaces within parentheses or disallow them.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "number",
                "min": 0
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/space-within-parens/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/space-within-parens/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/space-within-parens/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "switch-default": {
          "description": "Require a `default` case in all `switch` statements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "switch-final-break": {
          "description": "Checks whether the final clause of a switch statement ends in `break;`.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "always"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/switch-final-break/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/switch-final-break/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/switch-final-break/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "trailing-comma": {
          "description": "Requires or disallows trailing commas in array and object literals, destructuring assignments, function typings, named imports and exports and function parameters.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "multiline": {
                    "anyOf": [
                      {
                        "type": "string",
                        "enum": [
                          "always",
                          "never"
                        ]
                      },
                      {
                        "type": "object",
                        "properties": {
                          "arrays": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "exports": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "functions": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "imports": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "objects": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "typeLiterals": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          }
                        },
                        "additionalProperties": false
                      }
                    ]
                  },
                  "singleline": {
                    "anyOf": [
                      {
                        "type": "string",
                        "enum": [
                          "always",
                          "never"
                        ]
                      },
                      {
                        "type": "object",
                        "properties": {
                          "arrays": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "exports": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "functions": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "imports": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "objects": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          },
                          "typeLiterals": {
                            "type": "string",
                            "enum": [
                              "always",
                              "never",
                              "ignore"
                            ]
                          }
                        },
                        "additionalProperties": false
                      }
                    ]
                  },
                  "esSpecCompliant": {
                    "description": "Option to forbid trailing comma after rest",
                    "type": "boolean"
                  }
                },
                "additionalProperties": false
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/trailing-comma/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/trailing-comma/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/trailing-comma/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "triple-equals": {
          "description": "Requires `===` and `!==` in place of `==` and `!=`.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-null-check",
                  "allow-undefined-check"
                ]
              },
              "minItems": 1,
              "maxItems": 3,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/triple-equals/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/triple-equals/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/triple-equals/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "typeof-compare": {
          "description": "Makes sure result of `typeof` is compared to correct string values",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "use-isnan": {
          "description": "Enforces use of the `isNaN()` function to check for NaN references instead of a comparison to the `NaN` constant.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "variable-name": {
          "description": "Checks variable names for various errors.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-format",
                  "require-const-for-all-caps",
                  "allow-leading-underscore",
                  "allow-trailing-underscore",
                  "allow-pascal-case",
                  "allow-snake-case",
                  "ban-keywords"
                ]
              },
              "minItems": 1,
              "maxItems": 7,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/variable-name/definitions/options/items"
              },
              "maxItems": 7,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/variable-name/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/variable-name/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "whitespace": {
          "description": "Enforces whitespace style conventions.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "check-branch",
                  "check-decl",
                  "check-operator",
                  "check-module",
                  "check-separator",
                  "check-rest-spread",
                  "check-type",
                  "check-typecast",
                  "check-type-operator",
                  "check-preblock",
                  "check-postbrace"
                ],
                "minItems": 1,
                "maxItems": 10,
                "uniqueItems": true
              }
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/rules/properties/whitespace/definitions/options/items"
              },
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/rules/properties/whitespace/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/rules/properties/whitespace/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        }
      }
    },
    "tsRules": {
      "properties": {
        "adjacent-overload-signatures": {
          "description": "Enforces function overloads to be consecutive.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "array-type": {
          "description": "Requires using either 'T[]' or 'Array<T>' for arrays.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "array",
                  "generic",
                  "array-simple"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/array-type/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/array-type/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/array-type/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "await-promise": {
          "description": "Warns for an awaited value that is not a Promise.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/await-promise/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/await-promise/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/await-promise/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "ban-types": {
          "description": "Bans specific types from being used. Does not ban the corresponding runtime objects from being used.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "minItems": 1,
                "maxItems": 2
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/ban-types/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/ban-types/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/ban-types/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "callable-types": {
          "description": "An interface or literal type with just a call signature can be written as a function type.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "interface-name": {
          "description": "Requires interface names to begin with a capital 'I'",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "always-prefix",
                  "never-prefix"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/interface-name/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/interface-name/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/interface-name/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "interface-over-type-literal": {
          "description": "Prefer an interface declaration over a type literal (`type T = { ... }`)",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "match-default-export-name": {
          "description": "Requires that a default import have the same name as the declaration it imports.\nDoes nothing for anonymous default exports.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "member-access": {
          "description": "Requires explicit visibility declarations for class members.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "no-public",
                  "check-accessor",
                  "check-constructor",
                  "check-parameter-property"
                ]
              },
              "minItems": 1,
              "maxItems": 4,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/member-access/definitions/options/items"
              },
              "maxItems": 4,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/member-access/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/member-access/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-angle-bracket-type-assertion": {
          "description": "Requires the use of `as Type` for type assertions instead of `<Type>`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-any": {
          "description": "Disallows usages of `any` as a type declaration.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "type": "object",
                  "properties": {
                    "ignore-rest-args": {
                      "type": "boolean"
                    }
                  }
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-boolean-literal-compare": {
          "description": "Warns on comparison to a boolean literal, as in `x === true`.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-empty-interface": {
          "description": "Forbids empty interfaces.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-floating-promises": {
          "description": "Promises returned by functions must be handled appropriately.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-floating-promises/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-floating-promises/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-floating-promises/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-inferrable-types": {
          "description": "Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-params",
                  "ignore-properties"
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-inferrable-types/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-inferrable-types/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-inferrable-types/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-inferred-empty-object-type": {
          "description": "Disallow type inference of {} (empty object type) at function and constructor call sites",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-internal-module": {
          "description": "Disallows internal `module`",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-mergeable-namespace": {
          "description": "Disallows mergeable namespaces in the same file.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-misused-new": {
          "description": "Warns on apparent attempts to define constructors for interfaces or `new` for classes.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-namespace": {
          "description": "Disallows use of internal `module`s and `namespace`s.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-declarations"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-namespace/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-namespace/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-namespace/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-non-null-assertion": {
          "description": "Disallows non-null assertions.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-object-literal-type-assertion": {
          "description": "Forbids an object literal to appear in a type assertion expression.\nCasting to `any` is still allowed.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-parameter-properties": {
          "description": "Disallows parameter properties in class constructors.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-redundant-jsdoc": {
          "description": "Forbids JSDoc which duplicates TypeScript functionality.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-reference-import": {
          "description": "Don't `<reference types=\"foo\" />` if you import `foo` anyway.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unbound-method": {
          "description": "Warns when a method is used as outside of a method call.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "ignore-static"
                ]
              },
              "minItems": 1,
              "maxItems": 1
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-unbound-method/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unbound-method/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unbound-method/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unnecessary-qualifier": {
          "description": "Warns when a namespace qualifier (`A.x`) is unnecessary.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unnecessary-type-assertion": {
          "description": "Warns if a type assertion does not change the type of an expression.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minItems": 1,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-unnecessary-type-assertion/definitions/options/items"
              },
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unnecessary-type-assertion/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unnecessary-type-assertion/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unsafe-any": {
          "description": "Warns when using an expression of type 'any' in a dynamic way.\nUses are only allowed if they would work for `{} | null | undefined`.\nType casts and tests are allowed.\nExpressions that work on all values (such as `\"\" + x`) are allowed.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-unused-variable": {
          "description": "Disallows unused imports, variables, functions and private class members. Similar to tsc's --noUnusedParameters and --noUnusedLocals options, but does not interrupt code compilation.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "oneOf": [
                  {
                    "type": "string",
                    "enum": [
                      "check-parameters"
                    ]
                  },
                  {
                    "type": "object",
                    "properties": {
                      "ignore-pattern": {
                        "type": "string"
                      }
                    },
                    "additionalProperties": false
                  }
                ]
              },
              "minItems": 1,
              "maxItems": 2,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/no-unused-variable/definitions/options/items"
              },
              "maxItems": 3,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unused-variable/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/no-unused-variable/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "no-var-requires": {
          "description": "Disallows the use of require statements except in import statements.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "prefer-readonly": {
          "description": "Requires that private variables are marked as `readonly` if they’re never modified outside of the constructor.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "enum": [
                  "only-inline-lambdas"
                ],
                "type": "string"
              }
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/prefer-readonly/definitions/options/items"
              },
              "maxItems": 2,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/prefer-readonly/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/prefer-readonly/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "strict-boolean-expressions": {
          "description": "Restricts the types allowed in boolean expressions. By default only booleans are allowed.\n\nThe following nodes are checked:\n* Arguments to the `!`, `&&`, and `||` operators\n* The condition in a conditional expression (`cond ? x : y`)\n* Conditions for `if`, `for`, `while`, and `do-while` statements.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "allow-null-union",
                  "allow-undefined-union",
                  "allow-string",
                  "allow-enum",
                  "allow-number",
                  "allow-mix",
                  "allow-boolean-or-undefined",
                  "ignore-rhs"
                ]
              },
              "minItems": 1,
              "maxItems": 8,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/strict-boolean-expressions/definitions/options/items"
              },
              "maxItems": 6,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/strict-boolean-expressions/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/strict-boolean-expressions/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "strict-type-predicates": {
          "description": "Warns for type predicates that are always true or always false.\nWorks for 'typeof' comparisons to constants (e.g. 'typeof foo === \"string\"'), and equality comparison to 'null'/'undefined'.\n(TypeScript won't let you compare '1 === 2', but it has an exception for '1 === undefined'.)\nDoes not yet work for 'instanceof'.\nDoes *not* warn for 'if (x.y)' where 'x.y' is always truthy. For that, see strict-boolean-expressions.\n\nThis rule requires `strictNullChecks` to work properly.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "typedef": {
          "description": "Requires type definitions to exist.",
          "definitions": {
            "options": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "call-signature",
                  "arrow-call-signature",
                  "parameter",
                  "arrow-parameter",
                  "property-declaration",
                  "variable-declaration",
                  "member-variable-declaration",
                  "object-destructuring",
                  "array-destructuring"
                ]
              },
              "minItems": 1,
              "maxItems": 9,
              "uniqueItems": true
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": {
                "$ref": "#/definitions/tsRules/properties/typedef/definitions/options/items"
              },
              "maxItems": 10,
              "uniqueItems": true,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/typedef/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/typedef/definitions/options/items"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "typedef-whitespace": {
          "description": "Requires or disallows whitespace for type definitions.",
          "definitions": {
            "options": {
              "type": "array",
              "items": [
                {
                  "type": "object",
                  "properties": {
                    "call-signature": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "index-signature": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "parameter": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "property-declaration": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "variable-declaration": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    }
                  },
                  "additionalProperties": false
                },
                {
                  "type": "object",
                  "properties": {
                    "call-signature": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "index-signature": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "parameter": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "property-declaration": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    },
                    "variable-declaration": {
                      "type": "string",
                      "enum": [
                        "nospace",
                        "onespace",
                        "space"
                      ]
                    }
                  },
                  "additionalProperties": false
                }
              ],
              "minItems": 1,
              "maxItems": 2
            }
          },
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "$ref": "#/definitions/tsRules/properties/typedef-whitespace/definitions/options/items/0"
                },
                {
                  "$ref": "#/definitions/tsRules/properties/typedef-whitespace/definitions/options/items/1"
                }
              ],
              "maxItems": 3,
              "properties": {
                "options": {
                  "description": "An option value or an array of multiple option values.",
                  "oneOf": [
                    {
                      "$ref": "#/definitions/tsRules/properties/typedef-whitespace/definitions/options"
                    },
                    {
                      "$ref": "#/definitions/tsRules/properties/typedef-whitespace/definitions/options/items/0"
                    }
                  ]
                },
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "type-literal-delimiter": {
          "description": "Checks that type literal members are separated by semicolons.\nEnforces a trailing semicolon for multiline type literals.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                },
                {
                  "type": "object",
                  "properties": {
                    "singleLine": {
                      "type": "string",
                      "enum": [
                        "always",
                        "never"
                      ]
                    }
                  }
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "unified-signatures": {
          "description": "Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        },
        "use-default-type-parameter": {
          "description": "Warns if an explicitly specified type argument is the default for that type parameter.",
          "allOf": [
            {
              "$ref": "#/definitions/rule"
            },
            {
              "items": [
                {
                  "type": "boolean"
                }
              ],
              "additionalItems": false,
              "properties": {
                "severity": {}
              },
              "additionalProperties": false
            }
          ]
        }
      }
    }
  },
  "properties": {
    "extends": {
      "description": "The name of a built-in configuration preset, or a path or array of paths to other configuration files which are extended by this configuration. These values are handled using node module resolution semantics.",
      "type": [
        "string",
        "array"
      ],
      "items": {
        "type": "string"
      }
    },
    "rulesDirectory": {
      "description": "A path to a directory or an array of paths to directories of custom rules. These values are handled using node module resolution semantics, if an `index.js` is placed in your rules directory.",
      "type": [
        "string",
        "array"
      ],
      "items": {
        "type": "string"
      }
    },
    "rules": {
      "description": "A map of rules that will be used to lint TypeScript files. These rules apply to `.ts` and `.tsx` files.",
      "allOf": [
        {
          "$ref": "#/definitions/tsRules"
        },
        {
          "$ref": "#/definitions/rules"
        }
      ]
    },
    "jsRules": {
      "description": "A map of rules that will be used to lint JavaScript files. These rules apply to `.js` and `.jsx` files.",
      "$ref": "#/definitions/rules"
    },
    "defaultSeverity": {
      "description": "The severity level used when a rule specifies \"default\" as its severity level. If undefined, \"error\" is used.",
      "type": "string",
      "enum": [
        "error",
        "warning",
        "warn",
        "off",
        "none"
      ],
      "default": "error"
    },
    "linterOptions": {
      "description": "Additional linter options.",
      "type": "object",
      "properties": {
        "exclude": {
          "description": "An array of globs. Any file matching these globs will not be linted. All exclude patterns are relative to the configuration file they were specified in.",
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      }
    }
  }
}