{
  "definitions": {
    "TrailingWhitespaceCheck": {
      "description": "Checks if there are any trailing white spaces.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks if there are any trailing white spaces.",
          "type": "string",
          "enum": [
            "TrailingWhitespace"
          ]
        },
        "props": {
          "description": "Checks if there are any trailing white spaces.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "DynamicCheck": {
      "description": "Checks for use of Dynamic type anywhere in the code.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for use of Dynamic type anywhere in the code.",
          "type": "string",
          "enum": [
            "Dynamic"
          ]
        },
        "props": {
          "description": "Checks for use of Dynamic type anywhere in the code.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "InterfaceCheck": {
      "description": "Checks and enforces interface style. Either to allow properties and methods or just methods. Has an option to `allowMarkerInterfaces`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks and enforces interface style. Either to allow properties and methods or just methods. Has an option to `allowMarkerInterfaces`.",
          "type": "string",
          "enum": [
            "Interface"
          ]
        },
        "props": {
          "description": "Checks and enforces interface style. Either to allow properties and methods or just methods. Has an option to `allowMarkerInterfaces`.",
          "additionalProperties": false,
          "properties": {
            "allowMarkerInterfaces": {
              "description": "allows empty marker interfaces, or forbid their use",
              "type": "boolean",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "allowProperties": {
              "description": "allow properties inside interface types",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TabForAligningCheck": {
      "description": "Checks if there are any tabs in the middle of a line.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks if there are any tabs in the middle of a line.",
          "type": "string",
          "enum": [
            "TabForAligning"
          ]
        },
        "props": {
          "description": "Checks if there are any tabs in the middle of a line.",
          "additionalProperties": false,
          "properties": {
            "ignorePattern": {
              "description": "ignore linex matching regex",
              "type": "string",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "IndentationCheck": {
      "description": "Checks correct indentation",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks correct indentation",
          "type": "string",
          "enum": [
            "Indentation"
          ]
        },
        "props": {
          "description": "Checks correct indentation",
          "additionalProperties": false,
          "properties": {
            "wrapPolicy": {
              "description": "indentation of wrapped statements (= continued on next line)\n\t\t- none = wrapped statements must have the same indentation as parent\n\t\t- exact = wrapped statemenmts must have a +1 indentation in relation to parent\n\t\t- larger = wrapped statements must have a +1 or larger indentation in relation to parent",
              "type": "string",
              "enum": [
                "none",
                "exact",
                "larger"
              ],
              "propertyOrder": 4
            },
            "character": {
              "description": "character sequence to use for indentation\n\t\t- \"tab\" for using tabs\n\t\t- a string containing as many spaces as one indentation level requires",
              "type": "string",
              "enum": [
                "tab",
                " ",
                "  ",
                "   ",
                "    ",
                "     ",
                "      ",
                "       ",
                "        "
              ],
              "propertyOrder": 0
            },
            "ignoreComments": {
              "description": "ignore indentation of comments",
              "type": "boolean",
              "propertyOrder": 3
            },
            "conditionalPolicy": {
              "description": "indentation of conditional statements\n\t\t- ignore = ignores conditioonals, same as \"ignoreConditionals\"\n\t\t- fixed_zero = contitionals have to start at the beginning of a line (only where conditional is the first statement)\n\t\t- aligned = align wih surrounding code\n\t\t- aligned_increase = align wih surrounding code and increase indentation of enclosed code by +1",
              "type": "string",
              "enum": [
                "ignore",
                "fixed_zero",
                "aligned",
                "aligned_increase"
              ],
              "propertyOrder": 2
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 5
            },
            "ignoreConditionals": {
              "description": "ignore indentation of conditionals (same as setting conditionalPolicy to ignore)",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ArrowFunctionCheck": {
      "description": "Checks for use of curlies, nested (non-arrow) functions or returns in arrow functions.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for use of curlies, nested (non-arrow) functions or returns in arrow functions.",
          "type": "string",
          "enum": [
            "ArrowFunction"
          ]
        },
        "props": {
          "description": "Checks for use of curlies, nested (non-arrow) functions or returns in arrow functions.",
          "additionalProperties": false,
          "properties": {
            "allowFunction": {
              "description": "allow using `function` inside arrow function bodies",
              "type": "boolean",
              "propertyOrder": 1
            },
            "allowReturn": {
              "description": "allow using `return` inside arrow function bodies",
              "type": "boolean",
              "propertyOrder": 0
            },
            "allowSingleArgParens": {
              "description": "allow using parenthesis around single argument arrow function (`(arg) -> arg * 2`)",
              "type": "boolean",
              "propertyOrder": 3
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 4
            },
            "allowCurlyBody": {
              "description": "allow using curly block as arrow function body (`{...}`)",
              "type": "boolean",
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "UnusedLocalVarCheck": {
      "description": "Checks for unused local variables.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for unused local variables.",
          "type": "string",
          "enum": [
            "UnusedLocalVar"
          ]
        },
        "props": {
          "description": "Checks for unused local variables.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ModifierOrderCheck": {
      "description": "Checks that the order of modifiers conforms to the standards.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that the order of modifiers conforms to the standards.",
          "type": "string",
          "enum": [
            "ModifierOrder"
          ]
        },
        "props": {
          "description": "Checks that the order of modifiers conforms to the standards.",
          "additionalProperties": false,
          "properties": {
            "modifiers": {
              "description": "order in which modifier should occur",
              "items": {
                "description": "list of modifiers\n\t- PUBLIC_PRIVATE = public / private modifier\n\t- INLINE = inline modifier\n\t- STATIC = static modifier\n\t- OVERRIDE = override modifier\n\t- MACRO = macro modifier\n\t- DYNAMIC = dynamic modifier\n\t- EXTERN = extern modifier\n\t- FINAL = final modifier",
                "type": "string",
                "enum": [
                  "PUBLIC_PRIVATE",
                  "INLINE",
                  "STATIC",
                  "OVERRIDE",
                  "MACRO",
                  "DYNAMIC",
                  "EXTERN",
                  "FINAL"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "StringLiteralCheck": {
      "description": "Checks for single or double quote string literals.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for single or double quote string literals.",
          "type": "string",
          "enum": [
            "StringLiteral"
          ]
        },
        "props": {
          "description": "Checks for single or double quote string literals.",
          "additionalProperties": false,
          "properties": {
            "policy": {
              "description": "policy for string literal use\n\t\t- onlySingle = enforce single quotes\n\t\t- onlyDouble = enforce double quotes, no interpolation allowed\n\t\t- doubleAndInterpolation = enforce double quotes, allow single quotes for interpolation",
              "type": "string",
              "enum": [
                "onlySingle",
                "onlyDouble",
                "doubleAndInterpolation"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "allowException": {
              "description": "\"allowException\" allows using single quotes in \"onlyDouble\" and \"doubleAndInterpolation\" mode, when string contains a double quote character.\n\t\tOr double quotes in \"onlySingle\" mode when string contains a single quote character, reducing the need to escape quotation marks.",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "DocCommentStyleCheck": {
      "description": "Checks code documentation style (/**...**/ vs /*...*/)",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks code documentation style (/**...**/ vs /*...*/)",
          "type": "string",
          "enum": [
            "DocCommentStyle"
          ]
        },
        "props": {
          "description": "Checks code documentation style (/**...**/ vs /*...*/)",
          "additionalProperties": false,
          "properties": {
            "lineStyle": {
              "description": "Defines how each doc comments line should start:\n\t\t- ignore = accepts any line prefix\n\t\t- none =\n\t\t- onestar = *\n\t\t- twostar = **",
              "type": "string",
              "enum": [
                "ignore",
                "none",
                "onestar",
                "twostars"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "startStyle": {
              "description": "Defines how doc comments should start / end:\n\t\t- ignore = accepts any start / end\n\t\t- onestar = /*\n\t\t- twostar = /**",
              "type": "string",
              "enum": [
                "ignore",
                "none",
                "onestar",
                "twostars"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "DefaultComesLastCheck": {
      "description": "Check that the `default` is after all the cases in a `switch` statement. Haxe allows `default` anywhere within the `switch` statement. But it is more readable if it comes after the last `case`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Check that the `default` is after all the cases in a `switch` statement. Haxe allows `default` anywhere within the `switch` statement. But it is more readable if it comes after the last `case`.",
          "type": "string",
          "enum": [
            "DefaultComesLast"
          ]
        },
        "props": {
          "description": "Check that the `default` is after all the cases in a `switch` statement. Haxe allows `default` anywhere within the `switch` statement. But it is more readable if it comes after the last `case`.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MethodNameCheck": {
      "description": "Checks that method names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that method names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "MethodName"
          ]
        },
        "props": {
          "description": "Checks that method names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "description": "check applies to:\n\t- PUBLIC = all public methods\n\t- PRIVATE = all private methods\n\t- STATIC = all static methods\n\t- NOTSTATIC = all non static methods\n\t- INLINE = all inline methods\n\t- NOTINLINE = all non-inline methods",
                "type": "string",
                "enum": [
                  "PUBLIC",
                  "PRIVATE",
                  "STATIC",
                  "NOTSTATIC",
                  "INLINE",
                  "NOTINLINE"
                ]
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "WhitespaceAfterCheck": {
      "description": "Checks for whitespace after a token.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for whitespace after a token.",
          "type": "string",
          "enum": [
            "WhitespaceAfter"
          ]
        },
        "props": {
          "description": "Checks for whitespace after a token.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "supported list of tokens:\n\t\t\",\", \";\", \"(\", \"[\", \"{\", \":\", \".\", \"=\", \"+\", \"-\", \"*\", \"/\", \"%\", \">\", \"<\", \">=\", \"<=\", \"==\", \"!=\",\n\t\t\"&\", \"|\", \"^\", \"&&\", \"||\", \"<<\", \">>\", \">>>\", \"+=\", \"-=\", \"*=\", \"/=\", \"%=\", \"<<=\", \">>=\", \">>>=\", \"|=\", \"&=\",\n\t\t\"^=\", \"...\", \"=>\", \"!\", \"++\", \"--\",",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "allowTrailingComma": {
              "description": "no violoation for missing whitespace after trailing commas",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "InnerAssignmentCheck": {
      "description": "Checks for assignments in subexpressions, such as in `if ((a=b) > 0) return;`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for assignments in subexpressions, such as in `if ((a=b) > 0) return;`.",
          "type": "string",
          "enum": [
            "InnerAssignment"
          ]
        },
        "props": {
          "description": "Checks for assignments in subexpressions, such as in `if ((a=b) > 0) return;`.",
          "additionalProperties": false,
          "properties": {
            "ignoreReturnAssignments": {
              "description": "ignores assignments in return statements",
              "type": "boolean",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MagicNumberCheck": {
      "description": "Checks that there are no magic numbers. By default, -1, 0, 1, and 2 are not considered to be magic numbers.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that there are no magic numbers. By default, -1, 0, 1, and 2 are not considered to be magic numbers.",
          "type": "string",
          "enum": [
            "MagicNumber"
          ]
        },
        "props": {
          "description": "Checks that there are no magic numbers. By default, -1, 0, 1, and 2 are not considered to be magic numbers.",
          "additionalProperties": false,
          "properties": {
            "ignoreNumbers": {
              "description": "list of magic numbers to ignore during checks",
              "items": {
                "type": "number"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "FieldDocCommentCheck": {
      "description": "Checks code documentation on fields",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks code documentation on fields",
          "type": "string",
          "enum": [
            "FieldDocComment"
          ]
        },
        "props": {
          "description": "Checks code documentation on fields",
          "additionalProperties": false,
          "properties": {
            "ignoreOverride": {
              "description": "ignores methods marked with override",
              "type": "boolean",
              "propertyOrder": 5
            },
            "requireReturn": {
              "description": "ignores requires a `@return` tag",
              "type": "boolean",
              "propertyOrder": 4
            },
            "requireParams": {
              "description": "ignores requires a `@param` tag for every parameter",
              "type": "boolean",
              "propertyOrder": 3
            },
            "tokens": {
              "description": "matches only comment docs for types specified in tokens list:\n\t\t- ABSTRACT_DEF = abstract definition \"abstract Test {}\"\n\t\t- CLASS_DEF = class definition \"class Test {}\"\n\t\t- ENUM_DEF = enum definition \"enum Test {}\"\n\t\t- INTERFACE_DEF = interface definition \"interface Test {}\"\n\t\t- TYPEDEF_DEF = typdef definition \"typedef Test = {}\"",
              "items": {
                "type": "string",
                "enum": [
                  "ABSTRACT_DEF",
                  "CLASS_DEF",
                  "ENUM_DEF",
                  "INTERFACE_DEF",
                  "TYPEDEF_DEF"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "modifier": {
              "description": "only check fields matching modifier\n\t\t- PUBLIC = only public fields\n\t\t- PRIVATE = only private fields\n\t\t- BOTH = public and private fields",
              "type": "string",
              "enum": [
                "PUBLIC",
                "PRIVATE",
                "BOTH"
              ],
              "propertyOrder": 2
            },
            "fieldType": {
              "description": "only check fields of type\n\t\t- VARS = only var fields\n\t\t- FUNCTIONS = only functions;\n\t\t- BOTH = both vars and functions;",
              "type": "string",
              "enum": [
                "VARS",
                "FUNCTIONS",
                "BOTH"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 7
            },
            "excludeNames": {
              "description": "exclude field names from check - default: [\"new\", \"toString\"]",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 6
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "HexadecimalLiteralCheck": {
      "description": "Checks the letter case of hexadecimal literals.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the letter case of hexadecimal literals.",
          "type": "string",
          "enum": [
            "HexadecimalLiteral"
          ]
        },
        "props": {
          "description": "Checks the letter case of hexadecimal literals.",
          "additionalProperties": false,
          "properties": {
            "option": {
              "description": "policy for hexadecimal literals\n\t\t- upperCase = use uppercase for all letters\n\t\t- lowerCase = use lowercase for all letters",
              "type": "string",
              "enum": [
                "upperCase",
                "lowerCase"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "LeftCurlyCheck": {
      "description": "Checks for the placement of left curly braces (`{`) for code blocks. The policy to verify is specified using the property `option`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for the placement of left curly braces (`{`) for code blocks. The policy to verify is specified using the property `option`.",
          "type": "string",
          "enum": [
            "LeftCurly"
          ]
        },
        "props": {
          "description": "Checks for the placement of left curly braces (`{`) for code blocks. The policy to verify is specified using the property `option`.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "matches only left curlys specified in tokens list:\n\t\t- CLASS_DEF = class definition \"class Test {}\"\n\t\t- ENUM_DEF = enum definition \"enum Test {}\"\n\t\t- ABSTRACT_DEF = abstract definition \"abstract Test {}\"\n\t\t- TYPEDEF_DEF = typdef definition \"typedef Test = {}\"\n\t\t- INTERFACE_DEF = interface definition \"interface Test {}\"\n\t\t- OBJECT_DECL = object declaration \"{ x: 0, y: 0, z: 0}\"\n\t\t- FUNCTION = function body \"funnction test () {}\"\n\t\t- FOR = for body \"for (i in 0..10) {}\"\n\t\t- IF = if / else body \"if (test) {} else {}\"\n\t\t- WHILE = while body \"while (test) {}\"\n\t\t- SWITCH = switch / case body \"switch (test) { case: {} default: {} }\"\n\t\t- TRY = try body \"try {}\"\n\t\t- CATCH = catch body \"catch (e:Dynamic) {}\"\n\t\t- REIFICATION = macro reification \"$i{}\"\n\t\t- ARRAY_COMPREHENSION = array comprehension \"[for (i in 0...10) {i * 2}]\"",
              "items": {
                "type": "string",
                "enum": [
                  "CLASS_DEF",
                  "ENUM_DEF",
                  "ABSTRACT_DEF",
                  "TYPEDEF_DEF",
                  "INTERFACE_DEF",
                  "ANON_TYPE",
                  "OBJECT_DECL",
                  "FUNCTION",
                  "FOR",
                  "IF",
                  "WHILE",
                  "SWITCH",
                  "TRY",
                  "CATCH",
                  "REIFICATION",
                  "ARRAY_COMPREHENSION"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "ignoreSingleline": {
              "description": "allow single line blocks",
              "type": "boolean",
              "propertyOrder": 3
            },
            "option": {
              "description": "placement of left curly\n\t\t- eol = should occur at end of line\n\t\t- nl = should occur on a new line\n\t\t- nlow = should occur at end of line unless in wrapped code, then it should occur on a new line",
              "type": "string",
              "enum": [
                "eol",
                "nl",
                "nlow"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 4
            },
            "ignoreEmptySingleline": {
              "description": "allow empty single line blocks",
              "type": "boolean",
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "FileLengthCheck": {
      "description": "Checks for long source files. If a source file becomes very long it is hard to understand. Therefore long classes should usually be refactored into several individual classes that focus on a specific task.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for long source files. If a source file becomes very long it is hard to understand. Therefore long classes should usually be refactored into several individual classes that focus on a specific task.",
          "type": "string",
          "enum": [
            "FileLength"
          ]
        },
        "props": {
          "description": "Checks for long source files. If a source file becomes very long it is hard to understand. Therefore long classes should usually be refactored into several individual classes that focus on a specific task.",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of lines permitted per file (default: 2000)",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "ignoreEmptyLines": {
              "description": "ignores or includes empty lines when counting total file length",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ConstantNameCheck": {
      "description": "Checks that the constants (static / static inline with initialisation) conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that the constants (static / static inline with initialisation) conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "ConstantName"
          ]
        },
        "props": {
          "description": "Checks that the constants (static / static inline with initialisation) conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "description": "supports inline and non inline constants\n\t- INLINE = \"static inline var\"\n\t- NOTINLINE = \"static var\"",
                "type": "string",
                "enum": [
                  "INLINE",
                  "NOTINLINE"
                ]
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "LocalVariableNameCheck": {
      "description": "Checks that the local variable names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that the local variable names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "LocalVariableName"
          ]
        },
        "props": {
          "description": "Checks that the local variable names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ParameterNumberCheck": {
      "description": "Checks the number of parameters of a method.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the number of parameters of a method.",
          "type": "string",
          "enum": [
            "ParameterNumber"
          ]
        },
        "props": {
          "description": "Checks the number of parameters of a method.",
          "additionalProperties": false,
          "properties": {
            "ignoreOverriddenMethods": {
              "description": "ignore methods with \"override\", only base class violates",
              "type": "boolean",
              "propertyOrder": 1
            },
            "max": {
              "description": "maximum number of parameters per method (default: 7)",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ExtendedEmptyLinesCheck": {
      "description": "Checks for consecutive empty lines.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for consecutive empty lines.",
          "type": "string",
          "enum": [
            "ExtendedEmptyLines"
          ]
        },
        "props": {
          "description": "Checks for consecutive empty lines.",
          "additionalProperties": false,
          "properties": {
            "none": {
              "description": "list of places where no empty line is permitted",
              "items": {
                "description": "empty line check supports the following places\n\t- afterAbstractVars = after abstract var block\n\t- afterClassStaticVars = after static class var block\n\t- afterClassVars = after class var block\n\t- afterImports = after all imports/usings\n\t- afterLeftCurly = after left curly\n\t- afterMultiLineComment = after multi line comment\n\t- afterPackage = after package\n\t- afterSingleLineComment = after single line comment\n\t- anywhereInFile = anywhere in file\n\t- beforePackage = before package\n\t- beforeRightCurly = before right curly\n\t- beforeUsing = before using block\n\t- beginAbstract = after abstract left curly\n\t- beginClass = after class left curly\n\t- beginEnum = after enum left curly\n\t- beforeFileEnd = before EOF\n\t- beginInterface = after interface left curly\n\t- beginTypedef = after typedef left curly\n\t- betweenAbstractMethods = between abstract methods\n\t- betweenAbstractVars = between abstract vars\n\t- betweenClassMethods = between class methods\n\t- betweenClassStaticVars = between static class vars\n\t- betweenClassVars = between class vars\n\t- betweenEnumFields = between enum fields\n\t- betweenImports = between imports/usings\n\t- betweenInterfaceFields = between interface fields\n\t- betweenTypedefFields = between typedef fields\n\t- betweenTypes = betgween two types\n\t- endClass = before class right curly\n\t- endAbstract = before abstract right curly\n\t- endInterface = before interface right curly\n\t- endEnum = before enum right curly\n\t- endTypedef = before typedef right curly\n\t- inFunction = anywhere inside function body\n\t- typeDefinition = between type and left curly",
                "type": "string",
                "enum": [
                  "beforePackage",
                  "afterPackage",
                  "betweenImports",
                  "beforeUsing",
                  "afterImports",
                  "anywhereInFile",
                  "betweenTypes",
                  "beforeFileEnd",
                  "inFunction",
                  "afterLeftCurly",
                  "beforeRightCurly",
                  "typeDefinition",
                  "beginClass",
                  "endClass",
                  "afterClassStaticVars",
                  "afterClassVars",
                  "betweenClassStaticVars",
                  "betweenClassVars",
                  "betweenClassMethods",
                  "beginAbstract",
                  "endAbstract",
                  "afterAbstractVars",
                  "betweenAbstractVars",
                  "betweenAbstractMethods",
                  "beginInterface",
                  "endInterface",
                  "betweenInterfaceFields",
                  "beginEnum",
                  "endEnum",
                  "betweenEnumFields",
                  "beginTypedef",
                  "endTypedef",
                  "betweenTypedefFields",
                  "afterSingleLineComment",
                  "afterMultiLineComment",
                  "beforeSingleLineComment",
                  "beforeMultiLineComment",
                  "afterDocCommentField"
                ]
              },
              "type": "array",
              "propertyOrder": 4
            },
            "atleast": {
              "description": "list of places where at least \"max\" empty lines are required",
              "items": {
                "description": "empty line check supports the following places\n\t- afterAbstractVars = after abstract var block\n\t- afterClassStaticVars = after static class var block\n\t- afterClassVars = after class var block\n\t- afterImports = after all imports/usings\n\t- afterLeftCurly = after left curly\n\t- afterMultiLineComment = after multi line comment\n\t- afterPackage = after package\n\t- afterSingleLineComment = after single line comment\n\t- anywhereInFile = anywhere in file\n\t- beforePackage = before package\n\t- beforeRightCurly = before right curly\n\t- beforeUsing = before using block\n\t- beginAbstract = after abstract left curly\n\t- beginClass = after class left curly\n\t- beginEnum = after enum left curly\n\t- beforeFileEnd = before EOF\n\t- beginInterface = after interface left curly\n\t- beginTypedef = after typedef left curly\n\t- betweenAbstractMethods = between abstract methods\n\t- betweenAbstractVars = between abstract vars\n\t- betweenClassMethods = between class methods\n\t- betweenClassStaticVars = between static class vars\n\t- betweenClassVars = between class vars\n\t- betweenEnumFields = between enum fields\n\t- betweenImports = between imports/usings\n\t- betweenInterfaceFields = between interface fields\n\t- betweenTypedefFields = between typedef fields\n\t- betweenTypes = betgween two types\n\t- endClass = before class right curly\n\t- endAbstract = before abstract right curly\n\t- endInterface = before interface right curly\n\t- endEnum = before enum right curly\n\t- endTypedef = before typedef right curly\n\t- inFunction = anywhere inside function body\n\t- typeDefinition = between type and left curly",
                "type": "string",
                "enum": [
                  "beforePackage",
                  "afterPackage",
                  "betweenImports",
                  "beforeUsing",
                  "afterImports",
                  "anywhereInFile",
                  "betweenTypes",
                  "beforeFileEnd",
                  "inFunction",
                  "afterLeftCurly",
                  "beforeRightCurly",
                  "typeDefinition",
                  "beginClass",
                  "endClass",
                  "afterClassStaticVars",
                  "afterClassVars",
                  "betweenClassStaticVars",
                  "betweenClassVars",
                  "betweenClassMethods",
                  "beginAbstract",
                  "endAbstract",
                  "afterAbstractVars",
                  "betweenAbstractVars",
                  "betweenAbstractMethods",
                  "beginInterface",
                  "endInterface",
                  "betweenInterfaceFields",
                  "beginEnum",
                  "endEnum",
                  "betweenEnumFields",
                  "beginTypedef",
                  "endTypedef",
                  "betweenTypedefFields",
                  "afterSingleLineComment",
                  "afterMultiLineComment",
                  "beforeSingleLineComment",
                  "beforeMultiLineComment",
                  "afterDocCommentField"
                ]
              },
              "type": "array",
              "propertyOrder": 7
            },
            "defaultPolicy": {
              "description": "\"defaultPolicy\" applies to all places not in \"ignore\", \"none\", \"exact\", \"upto\" or \"atleast\"",
              "type": "string",
              "enum": [
                "ignore",
                "none",
                "exact",
                "upto",
                "atleast"
              ],
              "propertyOrder": 2
            },
            "exact": {
              "description": "list of places where exactly \"max\" empty lines are required",
              "items": {
                "description": "empty line check supports the following places\n\t- afterAbstractVars = after abstract var block\n\t- afterClassStaticVars = after static class var block\n\t- afterClassVars = after class var block\n\t- afterImports = after all imports/usings\n\t- afterLeftCurly = after left curly\n\t- afterMultiLineComment = after multi line comment\n\t- afterPackage = after package\n\t- afterSingleLineComment = after single line comment\n\t- anywhereInFile = anywhere in file\n\t- beforePackage = before package\n\t- beforeRightCurly = before right curly\n\t- beforeUsing = before using block\n\t- beginAbstract = after abstract left curly\n\t- beginClass = after class left curly\n\t- beginEnum = after enum left curly\n\t- beforeFileEnd = before EOF\n\t- beginInterface = after interface left curly\n\t- beginTypedef = after typedef left curly\n\t- betweenAbstractMethods = between abstract methods\n\t- betweenAbstractVars = between abstract vars\n\t- betweenClassMethods = between class methods\n\t- betweenClassStaticVars = between static class vars\n\t- betweenClassVars = between class vars\n\t- betweenEnumFields = between enum fields\n\t- betweenImports = between imports/usings\n\t- betweenInterfaceFields = between interface fields\n\t- betweenTypedefFields = between typedef fields\n\t- betweenTypes = betgween two types\n\t- endClass = before class right curly\n\t- endAbstract = before abstract right curly\n\t- endInterface = before interface right curly\n\t- endEnum = before enum right curly\n\t- endTypedef = before typedef right curly\n\t- inFunction = anywhere inside function body\n\t- typeDefinition = between type and left curly",
                "type": "string",
                "enum": [
                  "beforePackage",
                  "afterPackage",
                  "betweenImports",
                  "beforeUsing",
                  "afterImports",
                  "anywhereInFile",
                  "betweenTypes",
                  "beforeFileEnd",
                  "inFunction",
                  "afterLeftCurly",
                  "beforeRightCurly",
                  "typeDefinition",
                  "beginClass",
                  "endClass",
                  "afterClassStaticVars",
                  "afterClassVars",
                  "betweenClassStaticVars",
                  "betweenClassVars",
                  "betweenClassMethods",
                  "beginAbstract",
                  "endAbstract",
                  "afterAbstractVars",
                  "betweenAbstractVars",
                  "betweenAbstractMethods",
                  "beginInterface",
                  "endInterface",
                  "betweenInterfaceFields",
                  "beginEnum",
                  "endEnum",
                  "betweenEnumFields",
                  "beginTypedef",
                  "endTypedef",
                  "betweenTypedefFields",
                  "afterSingleLineComment",
                  "afterMultiLineComment",
                  "beforeSingleLineComment",
                  "beforeMultiLineComment",
                  "afterDocCommentField"
                ]
              },
              "type": "array",
              "propertyOrder": 5
            },
            "ignore": {
              "description": "list of places to ignore",
              "items": {
                "description": "empty line check supports the following places\n\t- afterAbstractVars = after abstract var block\n\t- afterClassStaticVars = after static class var block\n\t- afterClassVars = after class var block\n\t- afterImports = after all imports/usings\n\t- afterLeftCurly = after left curly\n\t- afterMultiLineComment = after multi line comment\n\t- afterPackage = after package\n\t- afterSingleLineComment = after single line comment\n\t- anywhereInFile = anywhere in file\n\t- beforePackage = before package\n\t- beforeRightCurly = before right curly\n\t- beforeUsing = before using block\n\t- beginAbstract = after abstract left curly\n\t- beginClass = after class left curly\n\t- beginEnum = after enum left curly\n\t- beforeFileEnd = before EOF\n\t- beginInterface = after interface left curly\n\t- beginTypedef = after typedef left curly\n\t- betweenAbstractMethods = between abstract methods\n\t- betweenAbstractVars = between abstract vars\n\t- betweenClassMethods = between class methods\n\t- betweenClassStaticVars = between static class vars\n\t- betweenClassVars = between class vars\n\t- betweenEnumFields = between enum fields\n\t- betweenImports = between imports/usings\n\t- betweenInterfaceFields = between interface fields\n\t- betweenTypedefFields = between typedef fields\n\t- betweenTypes = betgween two types\n\t- endClass = before class right curly\n\t- endAbstract = before abstract right curly\n\t- endInterface = before interface right curly\n\t- endEnum = before enum right curly\n\t- endTypedef = before typedef right curly\n\t- inFunction = anywhere inside function body\n\t- typeDefinition = between type and left curly",
                "type": "string",
                "enum": [
                  "beforePackage",
                  "afterPackage",
                  "betweenImports",
                  "beforeUsing",
                  "afterImports",
                  "anywhereInFile",
                  "betweenTypes",
                  "beforeFileEnd",
                  "inFunction",
                  "afterLeftCurly",
                  "beforeRightCurly",
                  "typeDefinition",
                  "beginClass",
                  "endClass",
                  "afterClassStaticVars",
                  "afterClassVars",
                  "betweenClassStaticVars",
                  "betweenClassVars",
                  "betweenClassMethods",
                  "beginAbstract",
                  "endAbstract",
                  "afterAbstractVars",
                  "betweenAbstractVars",
                  "betweenAbstractMethods",
                  "beginInterface",
                  "endInterface",
                  "betweenInterfaceFields",
                  "beginEnum",
                  "endEnum",
                  "betweenEnumFields",
                  "beginTypedef",
                  "endTypedef",
                  "betweenTypedefFields",
                  "afterSingleLineComment",
                  "afterMultiLineComment",
                  "beforeSingleLineComment",
                  "beforeMultiLineComment",
                  "afterDocCommentField"
                ]
              },
              "type": "array",
              "propertyOrder": 3
            },
            "upto": {
              "description": "list of places where up to \"max\" empty lines are permitted",
              "items": {
                "description": "empty line check supports the following places\n\t- afterAbstractVars = after abstract var block\n\t- afterClassStaticVars = after static class var block\n\t- afterClassVars = after class var block\n\t- afterImports = after all imports/usings\n\t- afterLeftCurly = after left curly\n\t- afterMultiLineComment = after multi line comment\n\t- afterPackage = after package\n\t- afterSingleLineComment = after single line comment\n\t- anywhereInFile = anywhere in file\n\t- beforePackage = before package\n\t- beforeRightCurly = before right curly\n\t- beforeUsing = before using block\n\t- beginAbstract = after abstract left curly\n\t- beginClass = after class left curly\n\t- beginEnum = after enum left curly\n\t- beforeFileEnd = before EOF\n\t- beginInterface = after interface left curly\n\t- beginTypedef = after typedef left curly\n\t- betweenAbstractMethods = between abstract methods\n\t- betweenAbstractVars = between abstract vars\n\t- betweenClassMethods = between class methods\n\t- betweenClassStaticVars = between static class vars\n\t- betweenClassVars = between class vars\n\t- betweenEnumFields = between enum fields\n\t- betweenImports = between imports/usings\n\t- betweenInterfaceFields = between interface fields\n\t- betweenTypedefFields = between typedef fields\n\t- betweenTypes = betgween two types\n\t- endClass = before class right curly\n\t- endAbstract = before abstract right curly\n\t- endInterface = before interface right curly\n\t- endEnum = before enum right curly\n\t- endTypedef = before typedef right curly\n\t- inFunction = anywhere inside function body\n\t- typeDefinition = between type and left curly",
                "type": "string",
                "enum": [
                  "beforePackage",
                  "afterPackage",
                  "betweenImports",
                  "beforeUsing",
                  "afterImports",
                  "anywhereInFile",
                  "betweenTypes",
                  "beforeFileEnd",
                  "inFunction",
                  "afterLeftCurly",
                  "beforeRightCurly",
                  "typeDefinition",
                  "beginClass",
                  "endClass",
                  "afterClassStaticVars",
                  "afterClassVars",
                  "betweenClassStaticVars",
                  "betweenClassVars",
                  "betweenClassMethods",
                  "beginAbstract",
                  "endAbstract",
                  "afterAbstractVars",
                  "betweenAbstractVars",
                  "betweenAbstractMethods",
                  "beginInterface",
                  "endInterface",
                  "betweenInterfaceFields",
                  "beginEnum",
                  "endEnum",
                  "betweenEnumFields",
                  "beginTypedef",
                  "endTypedef",
                  "betweenTypedefFields",
                  "afterSingleLineComment",
                  "afterMultiLineComment",
                  "beforeSingleLineComment",
                  "beforeMultiLineComment",
                  "afterDocCommentField"
                ]
              },
              "type": "array",
              "propertyOrder": 6
            },
            "skipSingleLineTypes": {
              "description": "skips single line type definitions",
              "type": "boolean",
              "propertyOrder": 1
            },
            "max": {
              "description": "number of empty lines to allow / enforce (used by \"exact\", \"upto\" and \"atleast\" policies)",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 8
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "UnusedImportCheck": {
      "description": "Checks for unused or duplicate imports.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for unused or duplicate imports.",
          "type": "string",
          "enum": [
            "UnusedImport"
          ]
        },
        "props": {
          "description": "Checks for unused or duplicate imports.",
          "additionalProperties": false,
          "properties": {
            "ignoreModules": {
              "description": "list of module names to ignore, any module from \"ignoreModules\" won't show up as unused in any file during a run",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "moduleTypeMap": {
              "description": "modules that define multiple types may show up as unused, unless \"moduleTypeMap\" contains a mapping for it\n\t\te.g. \"haxe.macro.Expr\": [\"ExprDef\", \"ComplexType\"] - would allow \"import haxe.macro.Expr;\" even though you just use \"ComplexType\"",
              "type": "object",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "RedundantAllowMetaCheck": {
      "description": "Checks for redundant @:allow metadata",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for redundant @:allow metadata",
          "type": "string",
          "enum": [
            "RedundantAllowMeta"
          ]
        },
        "props": {
          "description": "Checks for redundant @:allow metadata",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "prohibitMeta": {
              "description": "switches behaviour of check to\n\t\t- false = look for redundant access modifications\n\t\t- true = to discourage its use everywhere",
              "type": "boolean",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "IndentationCharacterCheck": {
      "description": "Checks indentation character (tab/space, default is tab).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks indentation character (tab/space, default is tab).",
          "type": "string",
          "enum": [
            "IndentationCharacter"
          ]
        },
        "props": {
          "description": "Checks indentation character (tab/space, default is tab).",
          "additionalProperties": false,
          "properties": {
            "ignorePattern": {
              "description": "ignore lines that match regex",
              "type": "string",
              "propertyOrder": 1
            },
            "character": {
              "description": "set indentation to\n\t\t- tab = tab\n\t\t- space = space",
              "type": "string",
              "enum": [
                "tab",
                "space"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TraceCheck": {
      "description": "Checks for trace calls in code.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for trace calls in code.",
          "type": "string",
          "enum": [
            "Trace"
          ]
        },
        "props": {
          "description": "Checks for trace calls in code.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "OperatorWrapCheck": {
      "description": "Checks line wrapping with operators.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks line wrapping with operators.",
          "type": "string",
          "enum": [
            "OperatorWrap"
          ]
        },
        "props": {
          "description": "Checks line wrapping with operators.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "list mof wrapping tokens",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "option": {
              "description": "policy for wrapping token\n\t\t- eol = wrapping token should be at end of line\n\t\t- nl = wrapping token should start a new line",
              "type": "string",
              "enum": [
                "eol",
                "nl"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "PublicAccessorCheck": {
      "description": "Checks for public accessors.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for public accessors.",
          "type": "string",
          "enum": [
            "PublicAccessor"
          ]
        },
        "props": {
          "description": "Checks for public accessors.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NestedIfDepthCheck": {
      "description": "Restricts nested `if-else` blocks to a specified depth (default = 1).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Restricts nested `if-else` blocks to a specified depth (default = 1).",
          "type": "string",
          "enum": [
            "NestedIfDepth"
          ]
        },
        "props": {
          "description": "Restricts nested `if-else` blocks to a specified depth (default = 1).",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of nested if statements allowed\n\t\tsetting \"max\" to 1 allows one if inside another",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "AvoidTernaryOperatorCheck": {
      "description": "Detects ternary operators. Useful for developers who find ternary operators hard to read and want forbid them.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Detects ternary operators. Useful for developers who find ternary operators hard to read and want forbid them.",
          "type": "string",
          "enum": [
            "AvoidTernaryOperator"
          ]
        },
        "props": {
          "description": "Detects ternary operators. Useful for developers who find ternary operators hard to read and want forbid them.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "Threshold": {
      "description": "threshold for code complexity",
      "required": [
        "severity",
        "complexity"
      ],
      "additionalProperties": false,
      "properties": {
        "severity": {
          "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
          "type": "string",
          "enum": [
            "INFO",
            "WARNING",
            "ERROR",
            "IGNORE"
          ],
          "propertyOrder": 0
        },
        "complexity": {
          "description": "complexity value associated with \"severity\"",
          "type": "integer",
          "propertyOrder": 1
        }
      },
      "type": "object"
    },
    "CyclomaticComplexityCheck": {
      "description": "Checks the complexity of methods using McCabe simplified cyclomatic complexity check. Complexity levels can be customised using `thresholds` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the complexity of methods using McCabe simplified cyclomatic complexity check. Complexity levels can be customised using `thresholds` property.",
          "type": "string",
          "enum": [
            "CyclomaticComplexity"
          ]
        },
        "props": {
          "description": "Checks the complexity of methods using McCabe simplified cyclomatic complexity check. Complexity levels can be customised using `thresholds` property.",
          "additionalProperties": false,
          "properties": {
            "thresholds": {
              "description": "list of thresholds that define which severity level to report when complexity of method is above its limit",
              "items": {
                "$ref": "#/definitions/Threshold"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "SimplifyBooleanReturnCheck": {
      "description": "Checks for over-complicated boolean return statements.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for over-complicated boolean return statements.",
          "type": "string",
          "enum": [
            "SimplifyBooleanReturn"
          ]
        },
        "props": {
          "description": "Checks for over-complicated boolean return statements.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "SpacingCheck": {
      "description": "Spacing check on if, for, while, switch, try statements and around operators.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Spacing check on if, for, while, switch, try statements and around operators.",
          "type": "string",
          "enum": [
            "Spacing"
          ]
        },
        "props": {
          "description": "Spacing check on if, for, while, switch, try statements and around operators.",
          "additionalProperties": false,
          "properties": {
            "spaceAroundBinop": {
              "description": "require space around Binop operators (\"+\", \"-\", \"/\", etc.)",
              "type": "boolean",
              "propertyOrder": 0
            },
            "spaceSwitchCase": {
              "description": "policy for switch statements (space between \"switch\" and \"(\")\n\t\t- should = require space between statement and condition\n\t\t- shouldNot = no space should between statement and condition\n\t\t- any = ignored by space check",
              "type": "string",
              "enum": [
                "should",
                "should_not",
                "any"
              ],
              "propertyOrder": 5
            },
            "spaceWhileLoop": {
              "description": "policy for while statements (space between while\" and \"(\")\n\t\t- should = require space between statement and condition\n\t\t- shouldNot = no space should between statement and condition\n\t\t- any = ignored by space check",
              "type": "string",
              "enum": [
                "should",
                "should_not",
                "any"
              ],
              "propertyOrder": 4
            },
            "spaceCatch": {
              "description": "policy for catch statements (space between \"catch\" and \"(\")\n\t\t- should = require space between statement and condition\n\t\t- shouldNot = no space should between statement and condition\n\t\t- any = ignored by space check",
              "type": "string",
              "enum": [
                "should",
                "should_not",
                "any"
              ],
              "propertyOrder": 6
            },
            "ignoreRangeOperator": {
              "description": "exclude range operator \"...\" from \"spaceAroundBinop\"",
              "type": "boolean",
              "propertyOrder": 7
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 8
            },
            "spaceForLoop": {
              "description": "policy for for statements (space between \"for\" and \"(\")\n\t\t- should = require space between statement and condition\n\t\t- shouldNot = no space should between statement and condition\n\t\t- any = ignored by space check",
              "type": "string",
              "enum": [
                "should",
                "should_not",
                "any"
              ],
              "propertyOrder": 3
            },
            "spaceIfCondition": {
              "description": "policy for if statements (space between \"if\" and \"(\")\n\t\t- should = require space between statement and condition\n\t\t- shouldNot = no space should between statement and condition\n\t\t- any = ignored by space check",
              "type": "string",
              "enum": [
                "should",
                "should_not",
                "any"
              ],
              "propertyOrder": 2
            },
            "noSpaceAroundUnop": {
              "description": "enforce no space around Unop operators (\"++\", \"--\", \"!\", \"-\", \"~\")",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "AvoidStarImportCheck": {
      "description": "Checks for import statements that use the * notation and using directives.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for import statements that use the * notation and using directives.",
          "type": "string",
          "enum": [
            "AvoidStarImport"
          ]
        },
        "props": {
          "description": "Checks for import statements that use the * notation and using directives.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "HiddenFieldCheck": {
      "description": "Checks that a local variable or a parameter does not shadow a field that is defined in the same class.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that a local variable or a parameter does not shadow a field that is defined in the same class.",
          "type": "string",
          "enum": [
            "HiddenField"
          ]
        },
        "props": {
          "description": "Checks that a local variable or a parameter does not shadow a field that is defined in the same class.",
          "additionalProperties": false,
          "properties": {
            "ignoreConstructorParameter": {
              "description": "allow constructor parameters to shadow field names",
              "type": "boolean",
              "propertyOrder": 0
            },
            "ignoreFormat": {
              "description": "ignore function names matching \"ignoreFormat\" regex",
              "type": "string",
              "propertyOrder": 2
            },
            "ignoreSetter": {
              "description": "allow setters to shadow field names",
              "type": "boolean",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "LineLengthCheck": {
      "description": "Checks for long lines. Long lines are hard to read.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for long lines. Long lines are hard to read.",
          "type": "string",
          "enum": [
            "LineLength"
          ]
        },
        "props": {
          "description": "Checks for long lines. Long lines are hard to read.",
          "additionalProperties": false,
          "properties": {
            "ignorePattern": {
              "description": "ignore lines matching regex",
              "type": "string",
              "propertyOrder": 1
            },
            "max": {
              "description": "maximum number of characters per line (default: 160)",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "RedundantAccessMetaCheck": {
      "description": "Checks for redundant @:access metadata",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for redundant @:access metadata",
          "type": "string",
          "enum": [
            "RedundantAccessMeta"
          ]
        },
        "props": {
          "description": "Checks for redundant @:access metadata",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "prohibitMeta": {
              "description": "switches behaviour of check to\n\t\t- false = look for redundant access modifications\n\t\t- true = to discourage its use everywhere",
              "type": "boolean",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ReturnCountCheck": {
      "description": "Restricts the number of return statements in methods (2 by default). Ignores methods that matches `ignoreFormat` regex property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Restricts the number of return statements in methods (2 by default). Ignores methods that matches `ignoreFormat` regex property.",
          "type": "string",
          "enum": [
            "ReturnCount"
          ]
        },
        "props": {
          "description": "Restricts the number of return statements in methods (2 by default). Ignores methods that matches `ignoreFormat` regex property.",
          "additionalProperties": false,
          "properties": {
            "ignoreFormat": {
              "description": "ignore function names matching \"ignoreFormat\" regex",
              "type": "string",
              "propertyOrder": 1
            },
            "max": {
              "description": "maximum number of return calls a function may have",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TypeDocCommentCheck": {
      "description": "Checks code documentation on type level",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks code documentation on type level",
          "type": "string",
          "enum": [
            "TypeDocComment"
          ]
        },
        "props": {
          "description": "Checks code documentation on type level",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "matches only comment docs for types specified in tokens list:\n\t\t- ABSTRACT_DEF = abstract definition \"abstract Test {}\"\n\t\t- CLASS_DEF = class definition \"class Test {}\"\n\t\t- ENUM_DEF = enum definition \"enum Test {}\"\n\t\t- INTERFACE_DEF = interface definition \"interface Test {}\"\n\t\t- TYPEDEF_DEF = typdef definition \"typedef Test = {}\"",
              "items": {
                "type": "string",
                "enum": [
                  "ABSTRACT_DEF",
                  "CLASS_DEF",
                  "ENUM_DEF",
                  "INTERFACE_DEF",
                  "TYPEDEF_DEF"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ListenerNameCheck": {
      "description": "Checks the naming conventions of event listener functions specified using `listeners` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the naming conventions of event listener functions specified using `listeners` property.",
          "type": "string",
          "enum": [
            "ListenerName"
          ]
        },
        "props": {
          "description": "Checks the naming conventions of event listener functions specified using `listeners` property.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 1
            },
            "listeners": {
              "description": "list of function names used to register listeners",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NestedTryDepthCheck": {
      "description": "Restricts nested `try` blocks to a specified depth (default = 1).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Restricts nested `try` blocks to a specified depth (default = 1).",
          "type": "string",
          "enum": [
            "NestedTryDepth"
          ]
        },
        "props": {
          "description": "Restricts nested `try` blocks to a specified depth (default = 1).",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of nested try/catch statemenmts allowed\n\t\tsetting \"max\" to 1 allows one inner try/catch",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MultipleVariableDeclarationsCheck": {
      "description": "Checks that each variable declaration is in its own statement and on its own line.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that each variable declaration is in its own statement and on its own line.",
          "type": "string",
          "enum": [
            "MultipleVariableDeclarations"
          ]
        },
        "props": {
          "description": "Checks that each variable declaration is in its own statement and on its own line.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ArrayLiteralCheck": {
      "description": "Checks if the array is instantiated using [] which is shorter and cleaner, not with new.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks if the array is instantiated using [] which is shorter and cleaner, not with new.",
          "type": "string",
          "enum": [
            "ArrayLiteral"
          ]
        },
        "props": {
          "description": "Checks if the array is instantiated using [] which is shorter and cleaner, not with new.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "EmptyPackageCheck": {
      "description": "Checks for empty package names.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for empty package names.",
          "type": "string",
          "enum": [
            "EmptyPackage"
          ]
        },
        "props": {
          "description": "Checks for empty package names.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "enforceEmptyPackage": {
              "description": "enforce using a package declaration, even if it is empty",
              "type": "boolean",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TypeCheck": {
      "description": "Checks if type is specified or not for member variables.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks if type is specified or not for member variables.",
          "type": "string",
          "enum": [
            "Type"
          ]
        },
        "props": {
          "description": "Checks if type is specified or not for member variables.",
          "additionalProperties": false,
          "properties": {
            "ignoreEnumAbstractValues": {
              "description": "ignores fields inside abstract enums",
              "type": "boolean",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "RightCurlyCheck": {
      "description": "Checks the placement of right curly braces (`}`) for code blocks. The policy to verify is specified using the property `option`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the placement of right curly braces (`}`) for code blocks. The policy to verify is specified using the property `option`.",
          "type": "string",
          "enum": [
            "RightCurly"
          ]
        },
        "props": {
          "description": "Checks the placement of right curly braces (`}`) for code blocks. The policy to verify is specified using the property `option`.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "matches only right curlys specified in tokens list:\n\t\t- CLASS_DEF = class definition \"class Test {}\"\n\t\t- ENUM_DEF = enum definition \"enum Test {}\"\n\t\t- ABSTRACT_DEF = abstract definition \"abstract Test {}\"\n\t\t- TYPEDEF_DEF = typdef definition \"typedef Test = {}\"\n\t\t- INTERFACE_DEF = interface definition \"interface Test {}\"\n\t\t- OBJECT_DECL = object declaration \"{ x: 0, y: 0, z: 0}\"\n\t\t- FUNCTION = function body \"funnction test () {}\"\n\t\t- FOR = for body \"for (i in 0..10) {}\"\n\t\t- IF = if / else body \"if (test) {} else {}\"\n\t\t- WHILE = while body \"while (test) {}\"\n\t\t- SWITCH = switch / case body \"switch (test) { case: {} default: {} }\"\n\t\t- TRY = try body \"try {}\"\n\t\t- CATCH = catch body \"catch (e:Dynamic) {}\"\n\t\t- REIFICATION = macro reification \"$i{}\"\n\t\t- ARRAY_COMPREHENSION = array comprehension \"[for (i in 0...10) {i * 2}]\"",
              "items": {
                "type": "string",
                "enum": [
                  "CLASS_DEF",
                  "ENUM_DEF",
                  "ABSTRACT_DEF",
                  "TYPEDEF_DEF",
                  "INTERFACE_DEF",
                  "OBJECT_DECL",
                  "FUNCTION",
                  "FOR",
                  "IF",
                  "WHILE",
                  "SWITCH",
                  "TRY",
                  "CATCH",
                  "REIFICATION",
                  "ARRAY_COMPREHENSION"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "option": {
              "description": "placement of right curly\n\t\t- same = right curly must be alone on a new line, except for \"} else\" and \"} catch\"\n\t\t- alone = alone on a new line\n\t\t- aloneorsingle = right curly can occur on same line as left curly or must be alone on a new line",
              "type": "string",
              "enum": [
                "same",
                "alone",
                "aloneorsingle"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ExcludeFilterList": {
      "description": "list of path filters, e.g.\n\t- full type names\n\t- names of individual folder or subfolders\n\t- partial folder or type names\n\n\teach line can have an additional range specification:\n\t- \":<linenumber>\" = only matches a specific line number - valid line number start at 1\n\t- \":<start>-<end>\" = matches line numbers from <start> to <end> (including both)\n\t- \":<identifier>\" = matches any line or block that has <identifier> name (Haxe keywords currently unsupported)",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "OperatorWhitespaceCheck": {
      "description": "Checks that whitespace is present or absent around a operators.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that whitespace is present or absent around a operators.",
          "type": "string",
          "enum": [
            "OperatorWhitespace"
          ]
        },
        "props": {
          "description": "Checks that whitespace is present or absent around a operators.",
          "additionalProperties": false,
          "properties": {
            "oldFunctionTypePolicy": {
              "description": "policy for old haxe function type \"Int -> Void\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 10
            },
            "boolOpPolicy": {
              "description": "policy for \"&&\", \"||\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 6
            },
            "newFunctionTypePolicy": {
              "description": "policy for new haxe function type \"(param:Int) -> Void\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 11
            },
            "ternaryOpPolicy": {
              "description": "policy for \"?:\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 2
            },
            "arrowPolicy": {
              "description": "policy for \"=>\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 8
            },
            "compareOpPolicy": {
              "description": "policy for \"==\", \"!=\", \"<\", \"<=\", \">\", \">=\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 4
            },
            "intervalOpPolicy": {
              "description": "policy for \"...\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 7
            },
            "bitwiseOpPolicy": {
              "description": "policy for \"&\", \"|\", \"^\", \"<<\", \">>\", \">>>\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 5
            },
            "unaryOpPolicy": {
              "description": "policy for \"++\", \"--\", \"!\", \"~\"\n\t\t- inner = enforce whitespace between unary operator and operand\n\t\t- none = enforce no whitespace between unary operator and operand\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "inner",
                "none",
                "ignore"
              ],
              "propertyOrder": 1
            },
            "assignOpPolicy": {
              "description": "policy for \"=\", \"+=\", \"-=\", \"*=\", \"/=\", \"<<=\", \">>=\", \">>>=\", \"&=\", \"|=\", \"^=\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 12
            },
            "arithmeticOpPolicy": {
              "description": "policy for \"+\", \"-\", \"*\", \"/\", \"%\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 3
            },
            "arrowFunctionPolicy": {
              "description": "policy for arrow functions \"(i) -> i + 2\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 9
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TypeNameCheck": {
      "description": "Checks that type names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that type names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "TypeName"
          ]
        },
        "props": {
          "description": "Checks that type names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "description": "check applies to:\n\t- INTERFACE = all interface types\n\t- CLASS = all class types\n\t- ENUM = all enum types\n\t- ABSTRACT = all abstract types\n\t- TYPEDEF = all typedef types",
                "type": "string",
                "enum": [
                  "INTERFACE",
                  "CLASS",
                  "ENUM",
                  "ABSTRACT",
                  "TYPEDEF"
                ]
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "EmptyBlockCheck": {
      "description": "Checks for empty blocks. The policy to verify is specified using the property `option`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for empty blocks. The policy to verify is specified using the property `option`.",
          "type": "string",
          "enum": [
            "EmptyBlock"
          ]
        },
        "props": {
          "description": "Checks for empty blocks. The policy to verify is specified using the property `option`.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "matches only blocks specified in tokens list:\n\t\t- CLASS_DEF = class definition \"class Test {}\"\n\t\t- ENUM_DEF = enum definition \"enum Test {}\"\n\t\t- ABSTRACT_DEF = abstract definition \"abstract Test {}\"\n\t\t- TYPEDEF_DEF = typdef definition \"typedef Test = {}\"\n\t\t- INTERFACE_DEF = interface definition \"interface Test {}\"\n\t\t- OBJECT_DECL = object declaration \"{ x: 0, y: 0, z: 0}\"\n\t\t- FUNCTION = function body \"funnction test () {}\"\n\t\t- FOR = for body \"for (i in 0..10) {}\"\n\t\t- IF = if / else body \"if (test) {} else {}\"\n\t\t- WHILE = while body \"while (test) {}\"\n\t\t- SWITCH = switch / case body \"switch (test) { case: {} default: {} }\"\n\t\t- TRY = try body \"try {}\"\n\t\t- CATCH = catch body \"catch (e:Dynamic) {}\"\n\t\t- REIFICATION = macro reification \"$i{}\"",
              "items": {
                "type": "string",
                "enum": [
                  "CLASS_DEF",
                  "ENUM_DEF",
                  "ABSTRACT_DEF",
                  "TYPEDEF_DEF",
                  "INTERFACE_DEF",
                  "OBJECT_DECL",
                  "FUNCTION",
                  "FOR",
                  "IF",
                  "WHILE",
                  "SWITCH",
                  "TRY",
                  "CATCH",
                  "REIFICATION"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "option": {
              "description": "for all empty blocks matched by tokens\n\t\t- empty = allow empty blocks but enforce \"{}\" notation\n\t\t- text = must contain something apart from whitespace (comment or statement)\n\t\t- stmt = must contain at least one statement (that is not a comment)",
              "type": "string",
              "enum": [
                "empty",
                "text",
                "stmt"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NestedControlFlowCheck": {
      "description": "Checks for maximium nesting depth of control flow expressions (`if`, `for`, `while`, `do/while`, `switch` and `try`).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for maximium nesting depth of control flow expressions (`if`, `for`, `while`, `do/while`, `switch` and `try`).",
          "type": "string",
          "enum": [
            "NestedControlFlow"
          ]
        },
        "props": {
          "description": "Checks for maximium nesting depth of control flow expressions (`if`, `for`, `while`, `do/while`, `switch` and `try`).",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of nested control flow expressions allowed",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "EmptyLinesCheck": {
      "description": "Checks for consecutive empty lines (default is 1). Also have options to check empty line separators after package, single-line and multi-line comments and class/interface/abstract declarations.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for consecutive empty lines (default is 1). Also have options to check empty line separators after package, single-line and multi-line comments and class/interface/abstract declarations.",
          "type": "string",
          "enum": [
            "EmptyLines"
          ]
        },
        "props": {
          "description": "Checks for consecutive empty lines (default is 1). Also have options to check empty line separators after package, single-line and multi-line comments and class/interface/abstract declarations.",
          "additionalProperties": false,
          "properties": {
            "requireEmptyLineAfterAbstract": {
              "description": "require an empty line after abstract keyword",
              "type": "boolean",
              "propertyOrder": 6
            },
            "requireEmptyLineAfterInterface": {
              "description": "require an empty line after interface keyword",
              "type": "boolean",
              "propertyOrder": 5
            },
            "allowEmptyLineAfterSingleLineComment": {
              "description": "allow empty lines after a single line comment",
              "type": "boolean",
              "propertyOrder": 1
            },
            "max": {
              "description": "number of empty lines to allow",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 7
            },
            "requireEmptyLineAfterClass": {
              "description": "require an empty line after class keyword",
              "type": "boolean",
              "propertyOrder": 4
            },
            "allowEmptyLineAfterMultiLineComment": {
              "description": "allow empty lines after a mutli line comment",
              "type": "boolean",
              "propertyOrder": 2
            },
            "requireEmptyLineAfterPackage": {
              "description": "require an empty line after package definition",
              "type": "boolean",
              "propertyOrder": 3
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NestedForDepthCheck": {
      "description": "Restricts nested loop blocks to a specified depth (default = 1).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Restricts nested loop blocks to a specified depth (default = 1).",
          "type": "string",
          "enum": [
            "NestedForDepth"
          ]
        },
        "props": {
          "description": "Restricts nested loop blocks to a specified depth (default = 1).",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of nested loops allowed\n\t\tsetting \"max\" to 1 allows one inner loop",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ArrayAccessCheck": {
      "description": "Checks for spaces before array access or inside array elements. Finds code like `a [0], a[ 0]`, etc.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for spaces before array access or inside array elements. Finds code like `a [0], a[ 0]`, etc.",
          "type": "string",
          "enum": [
            "ArrayAccess"
          ]
        },
        "props": {
          "description": "Checks for spaces before array access or inside array elements. Finds code like `a [0], a[ 0]`, etc.",
          "additionalProperties": false,
          "properties": {
            "spaceBefore": {
              "description": "set \"spaceBefore\" to false to detect space between array and \"[\"",
              "type": "boolean",
              "propertyOrder": 0
            },
            "spaceInside": {
              "description": "set to false to detect space between brackets (\"[\" + \"]\") and index",
              "type": "boolean",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "CatchParameterNameCheck": {
      "description": "Checks that catch parameter names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that catch parameter names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "CatchParameterName"
          ]
        },
        "props": {
          "description": "Checks that catch parameter names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "WhitespaceAroundCheck": {
      "description": "Checks that a token is surrounded by whitespace.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that a token is surrounded by whitespace.",
          "type": "string",
          "enum": [
            "WhitespaceAround"
          ]
        },
        "props": {
          "description": "Checks that a token is surrounded by whitespace.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "supported list of tokens:\n\t\t\",\", \";\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", \":\", \".\", \"=\", \"+\", \"-\", \"*\", \"/\", \"%\", \">\", \"<\", \">=\", \"<=\", \"==\", \"!=\",\n\t\t\"&\", \"|\", \"^\", \"&&\", \"||\", \"<<\", \">>\", \">>>\", \"+=\", \"-=\", \"*=\", \"/=\", \"%=\", \"<<=\", \">>=\", \">>>=\", \"|=\", \"&=\",\n\t\t\"^=\", \"...\", \"=>\", \"!\", \"++\", \"--\",",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ExcludeConfig": {
      "description": "defines filters to exclude folders, types or files from all or specific checks",
      "additionalProperties": false,
      "properties": {
        "": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 3
        },
        "UnusedImport": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 77
        },
        "Dynamic": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 19
        },
        "Final": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 27
        },
        "MultipleStringLiterals": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 44
        },
        "NeedBraces": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 46
        },
        "SeparatorWhitespace": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 63
        },
        "all": {
          "$ref": "#/definitions/ExcludeFilterList"
        },
        "LocalVariableName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 37
        },
        "NestedForDepth": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 48
        },
        "Anonymous": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 4
        },
        "MultipleVariableDeclarations": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 45
        },
        "NestedTryDepth": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 50
        },
        "BlockBreakingConditional": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 11
        },
        "CatchParameterName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 12
        },
        "EmptyBlock": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 21
        },
        "ExtendedEmptyLines": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 24
        },
        "ReturnCount": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 61
        },
        "DefaultComesLast": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 17
        },
        "HexadecimalLiteral": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 28
        },
        "WhitespaceAfter": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 81
        },
        "ConstantName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 15
        },
        "EmptyPackage": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 23
        },
        "Interface": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 33
        },
        "WhitespaceAround": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 82
        },
        "NestedIfDepth": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 49
        },
        "ParameterName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 54
        },
        "NullableParameter": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 51
        },
        "AvoidStarImport": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 9
        },
        "SeparatorWrap": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 64
        },
        "AvoidIdentifier": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 8
        },
        "RedundantAllowMeta": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 58
        },
        "HiddenField": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 29
        },
        "UnnecessaryConstructor": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 76
        },
        "SimplifyBooleanExpression": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 65
        },
        "path": {
          "description": "filters excludes relative to\n\t- RELATIVE_TO_PROJECT = use project root\n\t- RELATIVE_TO_SOURCE = use path(s) specified via \"-s <path>\" command line switches",
          "type": "string",
          "enum": [
            "RELATIVE_TO_PROJECT",
            "RELATIVE_TO_SOURCE"
          ]
        },
        "MethodCount": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 40
        },
        "UnusedLocalVar": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 78
        },
        "TabForAligning": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 70
        },
        "MethodName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 42
        },
        "RightCurly": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 62
        },
        "AvoidTernaryOperator": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 10
        },
        "ParameterNumber": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 55
        },
        "ArrowFunction": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 7
        },
        "MethodLength": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 41
        },
        "ConditionalCompilation": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 14
        },
        "EmptyLines": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 22
        },
        "MemberName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 39
        },
        "ERegLiteral": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 20
        },
        "RedundantModifier": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 59
        },
        "Type": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 73
        },
        "TypeName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 75
        },
        "Indentation": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 30
        },
        "version": {
          "maximum": 1,
          "type": "integer",
          "minimum": 1
        },
        "Return": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 60
        },
        "SimplifyBooleanReturn": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 66
        },
        "TODOComment": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 69
        },
        "VarTypeHint": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 79
        },
        "NestedControlFlow": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 47
        },
        "OperatorWhitespace": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 52
        },
        "Spacing": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 67
        },
        "IndentationCharacter": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 31
        },
        "MagicNumber": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 38
        },
        "ArrayLiteral": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 6
        },
        "TrailingWhitespace": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 72
        },
        "VariableInitialisation": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 80
        },
        "LineLength": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 35
        },
        "ListenerName": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 36
        },
        "FileLength": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 26
        },
        "CyclomaticComplexity": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 16
        },
        "StringLiteral": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 68
        },
        "Trace": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 71
        },
        "ArrayAccess": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 5
        },
        "PublicAccessor": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 56
        },
        "DocCommentStyle": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 18
        },
        "InnerAssignment": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 32
        },
        "RedundantAccessMeta": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 57
        },
        "CodeSimilarity": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 13
        },
        "OperatorWrap": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 53
        },
        "TypeDocComment": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 74
        },
        "LeftCurly": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 34
        },
        "ModifierOrder": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 43
        },
        "FieldDocComment": {
          "$ref": "#/definitions/ExcludeFilterList",
          "propertyOrder": 25
        }
      },
      "type": "object"
    },
    "RedundantModifierCheck": {
      "description": "Checks for redundant modifiers.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for redundant modifiers.",
          "type": "string",
          "enum": [
            "RedundantModifier"
          ]
        },
        "props": {
          "description": "Checks for redundant modifiers.",
          "additionalProperties": false,
          "properties": {
            "enforcePrivate": {
              "description": "enforce use of \"private\" modifiers",
              "type": "boolean",
              "propertyOrder": 2
            },
            "enforcePublicPrivate": {
              "description": "enforce use of \"public\" and \"private\" modifiers\n\t\timplies enforcePublic and enforcePrivate",
              "type": "boolean",
              "propertyOrder": 0
            },
            "enforcePublic": {
              "description": "enforce use of \"public\" modifiers",
              "type": "boolean",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "TODOCommentCheck": {
      "description": "A check for TODO/FIXME/HACK/XXX/BUG comments. The format can be customised by changing `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "A check for TODO/FIXME/HACK/XXX/BUG comments. The format can be customised by changing `format` property.",
          "type": "string",
          "enum": [
            "TODOComment"
          ]
        },
        "props": {
          "description": "A check for TODO/FIXME/HACK/XXX/BUG comments. The format can be customised by changing `format` property.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "format": {
              "description": "regex todo comment format, defaults to \"^\\\\s*(TODO|FIXME|HACK|XXX|BUG)\"",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "BlockBreakingConditionalCheck": {
      "description": "Checks for block breaking conditionals.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for block breaking conditionals.",
          "type": "string",
          "enum": [
            "BlockBreakingConditional"
          ]
        },
        "props": {
          "description": "Checks for block breaking conditionals.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "VarTypeHintCheck": {
      "description": "Checks type hints of variables.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks type hints of variables.",
          "type": "string",
          "enum": [
            "VarTypeHint"
          ]
        },
        "props": {
          "description": "Checks type hints of variables.",
          "additionalProperties": false,
          "properties": {
            "ignoreEnumAbstractValues": {
              "description": "ignores fields inside abstract enums",
              "type": "boolean",
              "propertyOrder": 1
            },
            "typeHintPolicy": {
              "description": "policy for type hints on var and final",
              "type": "string",
              "enum": [
                "enforce_all",
                "infer_new_or_const",
                "infer_all"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "CodeSimilarityCheck": {
      "description": "Checks for identical or similar code.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for identical or similar code.",
          "type": "string",
          "enum": [
            "CodeSimilarity"
          ]
        },
        "props": {
          "description": "Checks for identical or similar code.",
          "additionalProperties": false,
          "properties": {
            "thresholdSimilar": {
              "description": "maximum number of tokens allowed before detecting similar code blocks",
              "type": "integer",
              "propertyOrder": 2
            },
            "thresholdIdentical": {
              "description": "maximum number of tokens allowed before detecting identical code blocks",
              "type": "integer",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "severityIdentical": {
              "description": "severity level for identical code blocks",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "UnnecessaryConstructorCheck": {
      "description": "Checks for unnecessary constructor in classes that contain only static methods or fields.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for unnecessary constructor in classes that contain only static methods or fields.",
          "type": "string",
          "enum": [
            "UnnecessaryConstructor"
          ]
        },
        "props": {
          "description": "Checks for unnecessary constructor in classes that contain only static methods or fields.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ParameterNameCheck": {
      "description": "Checks that parameter names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that parameter names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "ParameterName"
          ]
        },
        "props": {
          "description": "Checks that parameter names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "AnonymousCheck": {
      "description": "Check to find any anonymous type structures used.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Check to find any anonymous type structures used.",
          "type": "string",
          "enum": [
            "Anonymous"
          ]
        },
        "props": {
          "description": "Check to find any anonymous type structures used.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MethodCountCheck": {
      "description": "Checks the number of methods declared in each type. This includes the number of each scope (`private` and `public`) as well as an overall total.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks the number of methods declared in each type. This includes the number of each scope (`private` and `public`) as well as an overall total.",
          "type": "string",
          "enum": [
            "MethodCount"
          ]
        },
        "props": {
          "description": "Checks the number of methods declared in each type. This includes the number of each scope (`private` and `public`) as well as an overall total.",
          "additionalProperties": false,
          "properties": {
            "maxTotal": {
              "description": "maximum number of functions permitted per file (default: 100)",
              "type": "integer",
              "propertyOrder": 0
            },
            "maxPublic": {
              "description": "maximum number of public functions permitted per file (default: 100)",
              "type": "integer",
              "propertyOrder": 2
            },
            "maxPrivate": {
              "description": "maximum number of private functions permitted per file (default: 100)",
              "type": "integer",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "FinalCheck": {
      "description": "Checks for places that use var instead of final (Haxe 4+).",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for places that use var instead of final (Haxe 4+).",
          "type": "string",
          "enum": [
            "Final"
          ]
        },
        "props": {
          "description": "Checks for places that use var instead of final (Haxe 4+).",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ConditionalCompilationCheck": {
      "description": "Checks placement and indentation of conditional compilation flags.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks placement and indentation of conditional compilation flags.",
          "type": "string",
          "enum": [
            "ConditionalCompilation"
          ]
        },
        "props": {
          "description": "Checks placement and indentation of conditional compilation flags.",
          "additionalProperties": false,
          "properties": {
            "allowSingleline": {
              "description": "allows or prevents using single line conditional compilation flags.",
              "type": "boolean",
              "propertyOrder": 1
            },
            "policy": {
              "description": "indentation of conditional statements\n\t\t- startOfLine = #if, #else, #elseif and #end must start at beginning of line\n\t\t- aligned = indentation of #if, #else, #elseif and #end must match surrounding code\n\n\t\tBoth \"aligned\" and \"startOfLine\" will produce a message if conditional compilation flags are not on a separate line.\n\t\tAll #else, #elseif and #end flags must have the same indentation as their corresponding #if.",
              "type": "string",
              "enum": [
                "startOfLine",
                "aligned"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MemberNameCheck": {
      "description": "Checks that instance variable names conform to a format specified by the `format` property.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that instance variable names conform to a format specified by the `format` property.",
          "type": "string",
          "enum": [
            "MemberName"
          ]
        },
        "props": {
          "description": "Checks that instance variable names conform to a format specified by the `format` property.",
          "additionalProperties": false,
          "properties": {
            "ignoreExtern": {
              "description": "ignores names inside extern types",
              "type": "boolean",
              "propertyOrder": 2
            },
            "tokens": {
              "description": "list of tokens to limit where names should conform to \"format\"",
              "items": {
                "description": "check applies to:\n\t- PUBLIC = all public fields\n\t- PRIVATE = all private fields\n\t- ENUM = all enum fields\n\t- CLASS = all class fields, use in combination with PUBLIC and PRIVATE to only match public/private class fields\n\t- ABSTRACT = all abstract fields, use in combination with PUBLIC and PRIVATE to only match public/private abstract fields\n\t- TYPEDEF = all typedef fields",
                "type": "string",
                "enum": [
                  "PUBLIC",
                  "PRIVATE",
                  "ENUM",
                  "CLASS",
                  "ABSTRACT",
                  "TYPEDEF"
                ]
              },
              "type": "array",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "format": {
              "description": "regex name format",
              "type": "string",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ERegLiteralCheck": {
      "description": "Checks for usage of EReg literals (between ~/ and /) instead of new.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for usage of EReg literals (between ~/ and /) instead of new.",
          "type": "string",
          "enum": [
            "ERegLiteral"
          ]
        },
        "props": {
          "description": "Checks for usage of EReg literals (between ~/ and /) instead of new.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "SimplifyBooleanExpressionCheck": {
      "description": "Checks for over-complicated boolean expressions. Finds code like `if (b == true), b || true, !false`, etc.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for over-complicated boolean expressions. Finds code like `if (b == true), b || true, !false`, etc.",
          "type": "string",
          "enum": [
            "SimplifyBooleanExpression"
          ]
        },
        "props": {
          "description": "Checks for over-complicated boolean expressions. Finds code like `if (b == true), b || true, !false`, etc.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "VariableInitialisationCheck": {
      "description": "Checks for instance variables that are initialised at class level.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for instance variables that are initialised at class level.",
          "type": "string",
          "enum": [
            "VariableInitialisation"
          ]
        },
        "props": {
          "description": "Checks for instance variables that are initialised at class level.",
          "additionalProperties": false,
          "properties": {
            "allowFinal": {
              "description": "final fields must be initialised either immediately or in constructor\n\t\twhen allowFinal is true then VariableInitialisation won't complain about initialisation at class level for final fields",
              "type": "boolean",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MethodLengthCheck": {
      "description": "Checks for long methods. If a method becomes very long it is hard to understand. Therefore long methods should usually be refactored into several individual methods that focus on a specific task.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for long methods. If a method becomes very long it is hard to understand. Therefore long methods should usually be refactored into several individual methods that focus on a specific task.",
          "type": "string",
          "enum": [
            "MethodLength"
          ]
        },
        "props": {
          "description": "Checks for long methods. If a method becomes very long it is hard to understand. Therefore long methods should usually be refactored into several individual methods that focus on a specific task.",
          "additionalProperties": false,
          "properties": {
            "max": {
              "description": "maximum number of lines per method (default: 50)",
              "type": "integer",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "ignoreEmptyLines": {
              "description": "ignores or includes empty lines when counting method length",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "AvoidIdentifierCheck": {
      "description": "Checks for identifiers to avoid.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for identifiers to avoid.",
          "type": "string",
          "enum": [
            "AvoidIdentifier"
          ]
        },
        "props": {
          "description": "Checks for identifiers to avoid.",
          "additionalProperties": false,
          "properties": {
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            },
            "avoidIdentifiers": {
              "description": "list of identifiers to avoid",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NeedBracesCheck": {
      "description": "Checks for braces on function, if, for and while statements. It has an option to allow single line statements without braces using property `allowSingleLineStatement` like `if (b) return 10;`.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for braces on function, if, for and while statements. It has an option to allow single line statements without braces using property `allowSingleLineStatement` like `if (b) return 10;`.",
          "type": "string",
          "enum": [
            "NeedBraces"
          ]
        },
        "props": {
          "description": "Checks for braces on function, if, for and while statements. It has an option to allow single line statements without braces using property `allowSingleLineStatement` like `if (b) return 10;`.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "matches only statements specified in tokens list:\n\n\t\t- FUNCTION = function body \"funnction test () {}\"\n\t\t- FOR = for body \"for (i in 0..10) {}\"\n\t\t- IF = if body \"if (test) {} else {}\"\n\t\t- ELSE_IF = if body \"if (test) {} else if {}\"\n\t\t- WHILE = while body \"while (test) {}\"\n\t\t- DO_WHILE = do\u2026while body \"do {} while (test)\"\n\t\t- CATCH = catch body \"catch (e:Dynamic) {}\"",
              "items": {
                "type": "string",
                "enum": [
                  "FUNCTION",
                  "FOR",
                  "IF",
                  "ELSE_IF",
                  "WHILE",
                  "DO_WHILE",
                  "CATCH"
                ]
              },
              "type": "array",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            },
            "allowSingleLineStatement": {
              "description": "allow / disallow use of single line statements without braces",
              "type": "boolean",
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "NullableParameterCheck": {
      "description": "Enforces a style for nullable parameters.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Enforces a style for nullable parameters.",
          "type": "string",
          "enum": [
            "NullableParameter"
          ]
        },
        "props": {
          "description": "Enforces a style for nullable parameters.",
          "additionalProperties": false,
          "properties": {
            "option": {
              "description": "nullable style to enforece\n\t\t- questionMark = nullable parameters should use \"?name:Type\"\n\t\t- nullDefault = nullable parameters should use \"name:Type = null\"",
              "type": "string",
              "enum": [
                "questionMark",
                "nullDefault"
              ],
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 1
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "ReturnCheck": {
      "description": "Warns if Void is used for return or if return type is not specified when returning.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Warns if Void is used for return or if return type is not specified when returning.",
          "type": "string",
          "enum": [
            "Return"
          ]
        },
        "props": {
          "description": "Warns if Void is used for return or if return type is not specified when returning.",
          "additionalProperties": false,
          "properties": {
            "enforceReturnType": {
              "description": "enforces return type for every function",
              "type": "boolean",
              "propertyOrder": 1
            },
            "enforceReturnTypeForAnonymous": {
              "description": "enforces return type for anonymous functions",
              "type": "boolean",
              "propertyOrder": 2
            },
            "allowEmptyReturn": {
              "description": "allows empty return which is mostly used to exit functions.",
              "type": "boolean",
              "propertyOrder": 0
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "MultipleStringLiteralsCheck": {
      "description": "Checks for multiple occurrences of the same string literal within a single file. Code duplication makes maintenance more difficult, so it's better to replace the multiple occurrences with a constant.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks for multiple occurrences of the same string literal within a single file. Code duplication makes maintenance more difficult, so it's better to replace the multiple occurrences with a constant.",
          "type": "string",
          "enum": [
            "MultipleStringLiterals"
          ]
        },
        "props": {
          "description": "Checks for multiple occurrences of the same string literal within a single file. Code duplication makes maintenance more difficult, so it's better to replace the multiple occurrences with a constant.",
          "additionalProperties": false,
          "properties": {
            "ignore": {
              "description": "ignore string literals matching regex",
              "type": "string",
              "propertyOrder": 2
            },
            "minLength": {
              "description": "string literals must be \"minLength\" or more characters before including them",
              "type": "integer",
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 3
            },
            "allowDuplicates": {
              "description": "number of occurrences to allow",
              "type": "integer",
              "propertyOrder": 0
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "Config": {
      "additionalProperties": false,
      "properties": {
        "baseDefines": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "defineCombinations": {
          "items": {
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "type": "array"
        },
        "defaultSeverity": {
          "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
          "type": "string",
          "enum": [
            "INFO",
            "WARNING",
            "ERROR",
            "IGNORE"
          ]
        },
        "extendsConfigPath": {
          "type": "string"
        },
        "version": {
          "maximum": 1,
          "type": "integer",
          "minimum": 1
        },
        "checks": {
          "items": {
            "anyOf": [
              {
                "$ref": "#/definitions/AnonymousCheck"
              },
              {
                "$ref": "#/definitions/ArrayAccessCheck"
              },
              {
                "$ref": "#/definitions/ArrayLiteralCheck"
              },
              {
                "$ref": "#/definitions/ArrowFunctionCheck"
              },
              {
                "$ref": "#/definitions/AvoidIdentifierCheck"
              },
              {
                "$ref": "#/definitions/AvoidStarImportCheck"
              },
              {
                "$ref": "#/definitions/AvoidTernaryOperatorCheck"
              },
              {
                "$ref": "#/definitions/BlockBreakingConditionalCheck"
              },
              {
                "$ref": "#/definitions/CatchParameterNameCheck"
              },
              {
                "$ref": "#/definitions/CodeSimilarityCheck"
              },
              {
                "$ref": "#/definitions/ConditionalCompilationCheck"
              },
              {
                "$ref": "#/definitions/ConstantNameCheck"
              },
              {
                "$ref": "#/definitions/CyclomaticComplexityCheck"
              },
              {
                "$ref": "#/definitions/DefaultComesLastCheck"
              },
              {
                "$ref": "#/definitions/DocCommentStyleCheck"
              },
              {
                "$ref": "#/definitions/DynamicCheck"
              },
              {
                "$ref": "#/definitions/ERegLiteralCheck"
              },
              {
                "$ref": "#/definitions/EmptyBlockCheck"
              },
              {
                "$ref": "#/definitions/EmptyLinesCheck"
              },
              {
                "$ref": "#/definitions/EmptyPackageCheck"
              },
              {
                "$ref": "#/definitions/ExtendedEmptyLinesCheck"
              },
              {
                "$ref": "#/definitions/FieldDocCommentCheck"
              },
              {
                "$ref": "#/definitions/FileLengthCheck"
              },
              {
                "$ref": "#/definitions/FinalCheck"
              },
              {
                "$ref": "#/definitions/HexadecimalLiteralCheck"
              },
              {
                "$ref": "#/definitions/HiddenFieldCheck"
              },
              {
                "$ref": "#/definitions/IndentationCheck"
              },
              {
                "$ref": "#/definitions/IndentationCharacterCheck"
              },
              {
                "$ref": "#/definitions/InnerAssignmentCheck"
              },
              {
                "$ref": "#/definitions/InterfaceCheck"
              },
              {
                "$ref": "#/definitions/LeftCurlyCheck"
              },
              {
                "$ref": "#/definitions/LineLengthCheck"
              },
              {
                "$ref": "#/definitions/ListenerNameCheck"
              },
              {
                "$ref": "#/definitions/LocalVariableNameCheck"
              },
              {
                "$ref": "#/definitions/MagicNumberCheck"
              },
              {
                "$ref": "#/definitions/MemberNameCheck"
              },
              {
                "$ref": "#/definitions/MethodCountCheck"
              },
              {
                "$ref": "#/definitions/MethodLengthCheck"
              },
              {
                "$ref": "#/definitions/MethodNameCheck"
              },
              {
                "$ref": "#/definitions/ModifierOrderCheck"
              },
              {
                "$ref": "#/definitions/MultipleStringLiteralsCheck"
              },
              {
                "$ref": "#/definitions/MultipleVariableDeclarationsCheck"
              },
              {
                "$ref": "#/definitions/NeedBracesCheck"
              },
              {
                "$ref": "#/definitions/NestedControlFlowCheck"
              },
              {
                "$ref": "#/definitions/NestedForDepthCheck"
              },
              {
                "$ref": "#/definitions/NestedIfDepthCheck"
              },
              {
                "$ref": "#/definitions/NestedTryDepthCheck"
              },
              {
                "$ref": "#/definitions/NullableParameterCheck"
              },
              {
                "$ref": "#/definitions/OperatorWhitespaceCheck"
              },
              {
                "$ref": "#/definitions/OperatorWrapCheck"
              },
              {
                "$ref": "#/definitions/ParameterNameCheck"
              },
              {
                "$ref": "#/definitions/ParameterNumberCheck"
              },
              {
                "$ref": "#/definitions/PublicAccessorCheck"
              },
              {
                "$ref": "#/definitions/RedundantAccessMetaCheck"
              },
              {
                "$ref": "#/definitions/RedundantAllowMetaCheck"
              },
              {
                "$ref": "#/definitions/RedundantModifierCheck"
              },
              {
                "$ref": "#/definitions/ReturnCheck"
              },
              {
                "$ref": "#/definitions/ReturnCountCheck"
              },
              {
                "$ref": "#/definitions/RightCurlyCheck"
              },
              {
                "$ref": "#/definitions/SeparatorWhitespaceCheck"
              },
              {
                "$ref": "#/definitions/SeparatorWrapCheck"
              },
              {
                "$ref": "#/definitions/SimplifyBooleanExpressionCheck"
              },
              {
                "$ref": "#/definitions/SimplifyBooleanReturnCheck"
              },
              {
                "$ref": "#/definitions/SpacingCheck"
              },
              {
                "$ref": "#/definitions/StringLiteralCheck"
              },
              {
                "$ref": "#/definitions/TODOCommentCheck"
              },
              {
                "$ref": "#/definitions/TabForAligningCheck"
              },
              {
                "$ref": "#/definitions/TraceCheck"
              },
              {
                "$ref": "#/definitions/TrailingWhitespaceCheck"
              },
              {
                "$ref": "#/definitions/TypeCheck"
              },
              {
                "$ref": "#/definitions/TypeDocCommentCheck"
              },
              {
                "$ref": "#/definitions/TypeNameCheck"
              },
              {
                "$ref": "#/definitions/UnnecessaryConstructorCheck"
              },
              {
                "$ref": "#/definitions/UnusedImportCheck"
              },
              {
                "$ref": "#/definitions/UnusedLocalVarCheck"
              },
              {
                "$ref": "#/definitions/VarTypeHintCheck"
              },
              {
                "$ref": "#/definitions/VariableInitialisationCheck"
              },
              {
                "$ref": "#/definitions/WhitespaceAfterCheck"
              },
              {
                "$ref": "#/definitions/WhitespaceAroundCheck"
              }
            ]
          },
          "type": "array"
        },
        "exclude": {
          "$ref": "#/definitions/ExcludeConfig"
        },
        "numberOfCheckerThreads": {
          "maximum": 15,
          "type": "integer",
          "minimum": 1
        }
      },
      "type": "object"
    },
    "SeparatorWrapCheck": {
      "description": "Checks line wrapping with separators.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks line wrapping with separators.",
          "type": "string",
          "enum": [
            "SeparatorWrap"
          ]
        },
        "props": {
          "description": "Checks line wrapping with separators.",
          "additionalProperties": false,
          "properties": {
            "tokens": {
              "description": "list mof wrapping tokens",
              "items": {
                "type": "string"
              },
              "type": "array",
              "propertyOrder": 0
            },
            "option": {
              "description": "policy for wrapping token\n\t\t- eol = wrapping token should be at end of line\n\t\t- nl = wrapping token should start a new line",
              "type": "string",
              "enum": [
                "eol",
                "nl"
              ],
              "propertyOrder": 1
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    },
    "SeparatorWhitespaceCheck": {
      "description": "Checks that whitespace is present or absent around a separators.",
      "additionalProperties": false,
      "properties": {
        "type": {
          "description": "Checks that whitespace is present or absent around a separators.",
          "type": "string",
          "enum": [
            "SeparatorWhitespace"
          ]
        },
        "props": {
          "description": "Checks that whitespace is present or absent around a separators.",
          "additionalProperties": false,
          "properties": {
            "commaPolicy": {
              "description": "policy for \",\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 1
            },
            "semicolonPolicy": {
              "description": "policy for \";\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 3
            },
            "severity": {
              "description": "sets gravity of reported violations:\n\t- IGNORE = do not report violations, violations do not appear anywhere in output\n\t- INFO = all violations have info / lowest priority\n\t- WARNING = all violations have warning / medium priority\n\t- ERROR = all violations have error / highest priority",
              "type": "string",
              "enum": [
                "INFO",
                "WARNING",
                "ERROR",
                "IGNORE"
              ],
              "propertyOrder": 4
            },
            "dotPolicy": {
              "description": "policy for \".\"\n\t\t- around = enforce whitespace before and after operator\n\t\t- before = enforce whitespace before and no whitespace after operator\n\t\t- after = enforce no whitespace before and whitespace after operator\n\t\t- none = enforce no whitespace before and after operator\n\t\t- ignore = skip checks",
              "type": "string",
              "enum": [
                "before",
                "after",
                "around",
                "none",
                "ignore"
              ],
              "propertyOrder": 0
            },
            "allowTrailingComma": {
              "description": "no violoation for missing whitespace after trailing commas",
              "type": "boolean",
              "propertyOrder": 2
            }
          },
          "type": "object"
        }
      },
      "type": "object"
    }
  },
  "$ref": "#/definitions/Config"
}