JianMiau/VSCodeSetting
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
a8d91e7add
VSCodeSetting/globalStorage/vscode.json-language-features/json-schema-cache/50ab969b57b661ead929ae5ada1eae12.schema.json
JianMiau a8d91e7add [add] First
2022-03-16 12:29:35 +08:00

5747 lines
180 KiB
JSON
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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