tslint.report.available.json

{
  "adjacent-overload-signatures": {
    "id": "./node_modules/tslint:adjacent-overload-signatures",
    "description": "Enforces function overloads to be consecutive.",
    "rationale": "Improves readability and organization by grouping naturally related items together.",
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/adjacent-overload-signatures",
    "path": "./node_modules/tslint/lib/rules/adjacentOverloadSignaturesRule.js",
    "ruleName": "adjacent-overload-signatures",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "align": {
    "id": "./node_modules/tslint:align",
    "description": "Enforces vertical alignment.",
    "hasFix": true,
    "rationale": "\nHelps maintain a readable, consistent style in your codebase.\n\nConsistent alignment for code statements helps keep code readable and clear.\nStatements misaligned from the standard can be harder to read and understand.",
    "optionsDescription": "\nFive arguments may be optionally provided:\n\n* `\"parameters\"` checks alignment of function parameters.\n* `\"arguments\"` checks alignment of function call arguments.\n* `\"statements\"` checks alignment of statements.\n* `\"members\"` checks alignment of members of classes, interfaces, type literal, object literals and\nobject destructuring.\n* `\"elements\"` checks alignment of elements of array literals, array destructuring and tuple types.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "arguments",
          "elements",
          "members",
          "parameters",
          "statements"
        ]
      },
      "minLength": 1,
      "maxLength": 5
    },
    "optionExamples": [
      [
        true,
        "parameters",
        "statements"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/align",
    "path": "./node_modules/tslint/lib/rules/alignRule.js",
    "ruleName": "align",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "array-bracket-spacing": {
    "id": "./node_modules/tslint-eslint-rules:array-bracket-spacing",
    "description": "enforce consistent spacing inside array brackets",
    "rationale": "\nA number of style guides require or disallow spaces between array brackets and other tokens.\nThis rule applies to both array literals and destructuring assignments (ECMAScript 6).\n",
    "optionsDescription": "\nThe rule takes one or two options. The first is a string, which can be:\n\n- `\"never\"` (default) disallows spaces inside array brackets\n- `\"always\"`requires one or more spaces or newlines inside array brackets\n\nThe second option is an object for exceptions to the `\"never\"` option:\n\n- `\"singleValue\": true` requires one or more spaces or newlines inside brackets of array\n                          literals that contain a single element\n- `\"objectsInArrays\": true` requires one or more spaces or newlines between brackets of\n                              array literals and braces of their object literal elements\n                              `[ {` or `} ]`\n- `\"arraysInArrays\": true` requires one or more spaces or newlines between brackets of\n                             array literals and brackets of their array literal elements\n                             `[ [` or `] ]`\n\nWhen using the `\"always\"` option the second option takes on these exceptions:\n\n- `\"singleValue\": false` disallows spaces inside brackets of array literals that contain a\n                           single element\n- `\"objectsInArrays\": false` disallows spaces between brackets of array literals and braces\n                               of their object literal elements `[ {` or `} ]`\n- `\"arraysInArrays\": false` disallows spaces between brackets of array literals and brackets\n                              of their array literal elements `[ [` or `] ]`\n\nThis rule has build-in exceptions:\n\n- `\"never\"` (and also the exceptions to the `\"always\"` option) allows newlines inside\n              array brackets, because this is a common pattern\n- `\"always\"` does not require spaces or newlines in empty array literals `[]`\n",
    "options": {
      "anyOf": [
        {
          "type": "array",
          "items": [
            {
              "enum": [
                "always",
                "never"
              ]
            }
          ],
          "minItems": 0,
          "maxItems": 1
        },
        {
          "type": "object",
          "properties": {
            "singleValue": {
              "type": "boolean"
            },
            "objectsInArrays": {
              "type": "boolean"
            },
            "arraysInArrays": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ]
    },
    "optionExamples": [
      "\n\"array-bracket-spacing\": [true, \"always\"]\n",
      "\n\"array-bracket-spacing\": [true, \"never\"]\n",
      "\n\"array-bracket-spacing\": [true, \"never\", {\n  \"arraysInArrays\": true\n}]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/array-bracket-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/arrayBracketSpacingRule.js",
    "ruleName": "array-bracket-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "array-type": {
    "id": "./node_modules/tslint:array-type",
    "description": "Requires using either 'T[]' or 'Array<T>' for arrays.",
    "hasFix": true,
    "optionsDescription": "\nOne of the following arguments must be provided:\n\n* `\"array\"` enforces use of `T[]` for all types T.\n* `\"generic\"` enforces use of `Array<T>` for all types T.\n* `\"array-simple\"` enforces use of `T[]` if `T` is a simple type (primitive or type reference).",
    "options": {
      "type": "string",
      "enum": [
        "array",
        "generic",
        "array-simple"
      ]
    },
    "optionExamples": [
      [
        true,
        "array"
      ],
      [
        true,
        "generic"
      ],
      [
        true,
        "array-simple"
      ]
    ],
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/array-type",
    "path": "./node_modules/tslint/lib/rules/arrayTypeRule.js",
    "ruleName": "array-type",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "arrow-parens": {
    "id": "./node_modules/tslint:arrow-parens",
    "description": "Requires parentheses around the parameters of arrow function definitions.",
    "hasFix": true,
    "rationale": "Maintains stylistic consistency with other arrow function definitions.",
    "optionsDescription": "\nIf `ban-single-arg-parens` is specified, then arrow functions with one parameter\nmust not have parentheses if removing them is allowed by TypeScript.",
    "options": {
      "type": "string",
      "enum": [
        "ban-single-arg-parens"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "ban-single-arg-parens"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/arrow-parens",
    "path": "./node_modules/tslint/lib/rules/arrowParensRule.js",
    "ruleName": "arrow-parens",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "arrow-return-shorthand": {
    "id": "./node_modules/tslint:arrow-return-shorthand",
    "description": "Suggests to convert `() => { return x; }` to `() => x`.",
    "hasFix": true,
    "optionsDescription": "\nIf `multiline` is specified, then this will warn even if the function spans multiple lines.",
    "options": {
      "type": "string",
      "enum": [
        "multiline"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "multiline"
      ]
    ],
    "rationale": "\nIt's unnecessary to include `return` and `{}` brackets in arrow lambdas.\nLeaving them out results in simpler and easier to read code.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Enforces usage of the shorthand return syntax when an arrow function's body does not span multiple lines.",
        "config": "\n\"rules\": { \"arrow-return-shorthand\": true }\n        ",
        "pass": "\nconst calc = (x: number, y: number) => ({ add: x + y, sub: x - y, mul: x * y });\nconst calc2 = (x: number, y: number) => {\n    return { add: x + y, sub: x - y, mul: x * y }\n};\n        ",
        "fail": "\nconst calc = (x: number, y: number) => { return { add: x + y, sub: x - y, mul: x * y } };\nconst calc2 = (x: number, y: number) => {\n    return { add: x + y, sub: x - y, mul: x * y }\n};\n       "
      },
      {
        "description": "Enforces usage of the shorthand return syntax even when an arrow function's body spans multiple lines.",
        "config": "\n\"rules\": { \"arrow-return-shorthand\": [true, \"multiline\"] }\n        ",
        "pass": "\nconst calc = (x: number, y: number) => ({ add: x + y, sub: x - y, mul: x * y });\nconst calc2 = (x: number, y: number) =>\n    ({ add: x + y, sub: x - y, mul: x * y });\n        ",
        "fail": "\nconst calc = (x: number, y: number) => { return { add: x + y, sub: x - y, mul: x * y } };\nconst calc2 = (x: number, y: number) => {\n    return { add: x + y, sub: x - y, mul: x * y }\n};\n       "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/arrow-return-shorthand",
    "path": "./node_modules/tslint/lib/rules/arrowReturnShorthandRule.js",
    "ruleName": "arrow-return-shorthand",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "await-promise": {
    "id": "./node_modules/tslint:await-promise",
    "description": "Warns for an awaited value that is not a Promise.",
    "optionsDescription": "\nA list of 'string' names of any additional classes that should also be treated as Promises.\nFor example, if you are using a class called 'Future' that implements the Thenable interface,\nyou might tell the rule to consider type references with the name 'Future' as valid Promise-like\ntypes. Note that this rule doesn't check for type assignability or compatibility; it just checks\ntype reference names.\n        ",
    "options": {
      "type": "list",
      "listType": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "Thenable"
      ]
    ],
    "rationale": "\nWhile it is valid JavaScript to await a non-Promise-like value (it will resolve immediately),\nthis pattern is often a programmer error and the resulting semantics can be unintuitive.\n\nAwaiting non-Promise-like values often is an indication of programmer error, such as\nforgetting to add parenthesis to call a function that returns a Promise.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/await-promise",
    "path": "./node_modules/tslint/lib/rules/awaitPromiseRule.js",
    "ruleName": "await-promise",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ban": {
    "id": "./node_modules/tslint:ban",
    "description": "Bans the use of specific functions or global methods.",
    "optionsDescription": "\nA list of banned functions or methods in the following format:\n\n* banning functions:\n  * just the name of the function: `\"functionName\"`\n  * the name of the function in an array with one element: `[\"functionName\"]`\n  * an object in the following format: `{\"name\": \"functionName\", \"message\": \"optional explanation message\"}`\n* banning methods:\n  * an array with the object name, method name and optional message: `[\"objectName\", \"methodName\", \"optional message\"]`\n  * an object in the following format: `{\"name\": [\"objectName\", \"methodName\"], \"message\": \"optional message\"}`\n    * you can also ban deeply nested methods: `{\"name\": [\"foo\", \"bar\", \"baz\"]}` bans `foo.bar.baz()`\n    * the first element can contain a wildcard (`*`) that matches everything. `{\"name\": [\"*\", \"forEach\"]}` bans                  `[].forEach(...)`, `$(...).forEach(...)`, `arr.forEach(...)`, etc.\n",
    "options": {
      "type": "list",
      "listType": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "array",
            "items": {
              "type": "string"
            },
            "minLength": 1,
            "maxLength": 3
          },
          {
            "type": "object",
            "properties": {
              "name": {
                "anyOf": [
                  {
                    "type": "string"
                  },
                  {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "minLength": 1
                  }
                ]
              },
              "message": {
                "type": "string"
              }
            },
            "required": [
              "name"
            ]
          }
        ]
      }
    },
    "optionExamples": [
      [
        true,
        "eval",
        {
          "name": "$",
          "message": "please don't"
        },
        [
          "describe",
          "only"
        ],
        {
          "name": [
            "it",
            "only"
          ],
          "message": "don't focus tests"
        },
        {
          "name": [
            "chai",
            "assert",
            "equal"
          ],
          "message": "Use 'strictEqual' instead."
        },
        {
          "name": [
            "*",
            "forEach"
          ],
          "message": "Use a regular for loop instead."
        },
        {
          "name": [
            "*",
            "_id",
            "toString"
          ],
          "message": "Use 'toHexString' instead."
        }
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/ban",
    "path": "./node_modules/tslint/lib/rules/banRule.js",
    "ruleName": "ban",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ban-comma-operator": {
    "id": "./node_modules/tslint:ban-comma-operator",
    "description": "Disallows the comma operator to be used.",
    "descriptionDetails": "[Read more about the comma operator here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator).",
    "rationale": "\nUsing the comma operator can create a potential for many non-obvious bugs or lead to misunderstanding of code.\n\n### Examples\n```\nfoo((bar, baz)); // evaluates to 'foo(baz)' because of the extra parens - confusing and not obvious\n```\n\n```\nswitch (foo) {\n    case 1, 2: // equals 'case 2' - probably intended 'case 1: case2:'\n        return true;\n    case 3:\n        return false;\n}\n```\n\n```\nlet x = (y = 1, z = 2); // x is equal to 2 - this may not be immediately obvious.\n```\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/ban-comma-operator",
    "path": "./node_modules/tslint/lib/rules/banCommaOperatorRule.js",
    "ruleName": "ban-comma-operator",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ban-ts-ignore": {
    "id": "./node_modules/tslint:ban-ts-ignore",
    "description": "Bans \"// @ts-ignore\" comments from being used.",
    "type": "typescript",
    "typescriptOnly": true,
    "codeExamples": [
      {
        "description": "Disallows the use of \"@ts-ignore\"",
        "config": "\n\"rules\": { \"ban-ts-ignore\": true }\n        ",
        "pass": "\nif (false) {\n    // Compiler warns about unreachable code error\n    console.log(\"hello\");\n}\n        ",
        "fail": "\nif (false) {\n    // @ts-ignore: Unreachable code error\n    console.log(\"hello\");\n}\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/ban-ts-ignore",
    "path": "./node_modules/tslint/lib/rules/banTsIgnoreRule.js",
    "ruleName": "ban-ts-ignore",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ban-types": {
    "id": "./node_modules/tslint:ban-types",
    "description": "\nBans specific types from being used. Does not ban the\ncorresponding runtime objects from being used.",
    "options": {
      "type": "list",
      "listType": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "minLength": 1,
        "maxLength": 2
      }
    },
    "optionsDescription": "\nA list of `[\"regex\", \"optional explanation here\"]`, which bans\ntypes that match `regex`",
    "optionExamples": [
      [
        true,
        [
          "Object",
          "Use {} instead."
        ],
        [
          "String"
        ]
      ]
    ],
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/ban-types",
    "path": "./node_modules/tslint/lib/rules/banTypesRule.js",
    "ruleName": "ban-types",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "binary-expression-operand-order": {
    "id": "./node_modules/tslint:binary-expression-operand-order",
    "description": "\nIn a binary expression, a literal should always be on the right-hand side if possible.\nFor example, prefer 'x + 1' over '1 + x'.",
    "rationale": "\nExpressions like `1 + x` are sometimes referred to as \"Yoda\" expressions because they read\nopposite to how we would normally speak the expression.\n\nSticking to a consistent grammar for conditions helps keep code readable and understandable.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/binary-expression-operand-order",
    "path": "./node_modules/tslint/lib/rules/binaryExpressionOperandOrderRule.js",
    "ruleName": "binary-expression-operand-order",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "block-spacing": {
    "id": "./node_modules/tslint-eslint-rules:block-spacing",
    "documentation": "https://eslint.org/docs/rules/block-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/blockSpacingRule.js",
    "ruleName": "block-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "brace-style": {
    "id": "./node_modules/tslint-eslint-rules:brace-style",
    "documentation": "https://eslint.org/docs/rules/brace-style",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/braceStyleRule.js",
    "ruleName": "brace-style",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "callable-types": {
    "id": "./node_modules/tslint:callable-types",
    "description": "An interface or literal type with just a call signature can be written as a function type.",
    "rationale": "style",
    "type": "style",
    "typescriptOnly": true,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/callable-types",
    "path": "./node_modules/tslint/lib/rules/callableTypesRule.js",
    "ruleName": "callable-types",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "chai-prefer-contains-to-index-of": {
    "id": "./node_modules/tslint-microsoft-contrib:chai-prefer-contains-to-index-of",
    "type": "maintainability",
    "description": "Avoid Chai assertions that invoke indexOf and compare for a -1 result.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/chaiPreferContainsToIndexOfRule.js",
    "ruleName": "chai-prefer-contains-to-index-of",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "chai-vague-errors": {
    "id": "./node_modules/tslint-microsoft-contrib:chai-vague-errors",
    "type": "maintainability",
    "description": "Avoid Chai assertions that result in vague errors",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/chaiVagueErrorsRule.js",
    "ruleName": "chai-vague-errors",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "class-name": {
    "id": "./node_modules/tslint:class-name",
    "description": "Enforces PascalCased class and interface names.",
    "rationale": "\nMakes it easy to differentiate classes from regular variables at a glance.\n\nJavaScript and general programming convention is to refer to classes in PascalCase.\nIt's confusing to use camelCase or other conventions for class names.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Enforces PascalCased class and interface names.",
        "config": "\n\"rules\": { \"class-name\": true }\n        ",
        "pass": "\nclass MyClass { }\ninterface MyInterface { }\n        ",
        "fail": "\nclass myClass { }\ninterface myInterface { }\n       "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/class-name",
    "path": "./node_modules/tslint/lib/rules/classNameRule.js",
    "ruleName": "class-name",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "comment-format": {
    "id": "./node_modules/tslint:comment-format",
    "description": "Enforces formatting rules for single-line comments.",
    "rationale": "Helps maintain a consistent, readable style in your codebase.",
    "optionsDescription": "\nThree arguments may be optionally provided:\n\n* `\"check-space\"` requires that all single-line comments must begin with a space, as in `// comment`\n    * note that for comments starting with multiple slashes, e.g. `///`, leading slashes are ignored\n    * TypeScript reference comments are ignored completely\n* `\"check-lowercase\"` requires that the first non-whitespace character of a comment must be lowercase, if applicable.\n* `\"check-uppercase\"` requires that the first non-whitespace character of a comment must be uppercase, if applicable.\n\nExceptions to `\"check-lowercase\"` or `\"check-uppercase\"` can be managed with object that may be passed as last argument.\n\nOne of two options can be provided in this object:\n\n    * `\"ignore-words\"`  - array of strings - words that will be ignored at the beginning of the comment.\n    * `\"ignore-pattern\"` - string - RegExp pattern that will be ignored at the beginning of the comment.\n",
    "options": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "check-space",
              "check-lowercase",
              "check-uppercase"
            ]
          },
          {
            "type": "object",
            "properties": {
              "ignore-words": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "ignore-pattern": {
                "type": "string"
              }
            },
            "minProperties": 1,
            "maxProperties": 1
          }
        ]
      },
      "minLength": 1,
      "maxLength": 4
    },
    "optionExamples": [
      [
        true,
        "check-space",
        "check-uppercase"
      ],
      [
        true,
        "check-lowercase",
        {
          "ignore-words": [
            "TODO",
            "HACK"
          ]
        }
      ],
      [
        true,
        "check-lowercase",
        {
          "ignore-pattern": "STD\\w{2,3}\\b"
        }
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/comment-format",
    "path": "./node_modules/tslint/lib/rules/commentFormatRule.js",
    "ruleName": "comment-format",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "comment-type": {
    "id": "./node_modules/tslint:comment-type",
    "description": "Allows a limited set of comment types",
    "optionsDescription": "\nOne or more of the following mutually exclusive comment types may be provided:\n\n* `singleline`: Comments starting with `//`\n* `multiline`:  Comments between `/*` and `*/` but are not doc comments\n* `doc`:        Multiline comments that start with `/**`\n* 'directive':  Triple-slash directives that are singleline comments starting with `///`",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "singleline",
          "multiline",
          "doc",
          "directive"
        ]
      },
      "uniqueItems": true
    },
    "optionExamples": [
      [
        true,
        "doc",
        "singleline"
      ],
      [
        true,
        "singleline"
      ],
      [
        true,
        "multiline"
      ]
    ],
    "hasFix": false,
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/comment-type",
    "path": "./node_modules/tslint/lib/rules/commentTypeRule.js",
    "ruleName": "comment-type",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "completed-docs": {
    "id": "./node_modules/tslint:completed-docs",
    "description": "Enforces JSDoc comments for important items be filled out.",
    "optionsDescription": "\n`true` to enable for `[classes, functions, methods, properties]`,\nor an array with each item in one of two formats:\n\n* `string` to enable for that type\n* `object` keying types to when their documentation is required:\n    * `\"methods\"` and `\"properties\"` may specify:\n        * `\"privacies\"`:\n            * `\"all\"`\n            * `\"private\"`\n            * `\"protected\"`\n            * `\"public\"`\n        * `\"locations\"`:\n            * `\"all\"`\n            * `\"instance\"`\n            * `\"static\"`\n    * Other types may specify `\"visibilities\"`:\n        * `\"all\"`\n        * `\"exported\"`\n        * `\"internal\"`\n    * All types may also provide `\"tags\"`\n      with members specifying tags that allow the docs to not have a body.\n        * `\"content\"`: Object mapping tags to `RegExp` bodies content allowed to count as complete docs.\n        * `\"existence\"`: Array of tags that must only exist to count as complete docs.\n\nTypes that may be enabled are:\n\n* `\"classes\"`\n* `\"enums\"`\n* `\"enum-members\"`\n* `\"functions\"`\n* `\"interfaces\"`\n* `\"methods\"`\n* `\"namespaces\"`\n* `\"properties\"`\n* `\"types\"`\n* `\"variables\"`",
    "options": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "options": [
              "classes",
              "enums",
              "functions",
              "interfaces",
              "methods",
              "namespaces",
              "properties",
              "types",
              "variables"
            ],
            "type": "string"
          },
          {
            "type": "object",
            "properties": {
              "classes": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "enums": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "enum-members": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "functions": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "interfaces": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "methods": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "locations": {
                    "enum": [
                      "all",
                      "instance",
                      "static"
                    ],
                    "type": "string"
                  },
                  "privacies": {
                    "enum": [
                      "all",
                      "private",
                      "protected",
                      "public"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "namespaces": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "properties": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "locations": {
                    "enum": [
                      "all",
                      "instance",
                      "static"
                    ],
                    "type": "string"
                  },
                  "privacies": {
                    "enum": [
                      "all",
                      "private",
                      "protected",
                      "public"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "types": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              },
              "variables": {
                "properties": {
                  "tags": {
                    "properties": {
                      "content": {
                        "items": {
                          "type": "string"
                        },
                        "type": "object"
                      },
                      "existence": {
                        "items": {
                          "type": "string"
                        },
                        "type": "array"
                      }
                    }
                  },
                  "visibilities": {
                    "enum": [
                      "all",
                      "exported",
                      "internal"
                    ],
                    "type": "string"
                  }
                },
                "type": "object"
              }
            }
          }
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "enums",
        "functions",
        "methods"
      ],
      [
        true,
        {
          "enums": true,
          "functions": {
            "visibilities": [
              "exported"
            ]
          },
          "methods": {
            "locations": "instance",
            "privacies": [
              "public",
              "protected"
            ]
          },
          "properties": {
            "tags": {
              "content": {
                "see": [
                  "#.*"
                ]
              },
              "existence": [
                "inheritdoc"
              ]
            }
          }
        }
      ]
    ],
    "rationale": "\nHelps ensure important components are documented.\n\nNote: use this rule sparingly. It's better to have self-documenting names on components with single, consice responsibilities.\nComments that only restate the names of variables add nothing to code, and can easily become outdated.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/completed-docs",
    "path": "./node_modules/tslint/lib/rules/completedDocsRule.js",
    "ruleName": "completed-docs",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "curly": {
    "id": "./node_modules/tslint:curly",
    "description": "Enforces braces for `if`/`for`/`do`/`while` statements.",
    "rationale": "\n```ts\nif (foo === bar)\n    foo++;\n    bar++;\n```\n\nIn the code above, the author almost certainly meant for both `foo++` and `bar++`\nto be executed only if `foo === bar`. However, they forgot braces and `bar++` will be executed\nno matter what. This rule could prevent such a mistake.",
    "optionsDescription": "\nOne of the following options may be provided:\n\n* `\"as-needed\"` forbids any unnecessary curly braces.\n* `\"ignore-same-line\"` skips checking braces for control-flow statements\nthat are on one line and start on the same line as their control-flow keyword\n        ",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "as-needed",
          "ignore-same-line"
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "ignore-same-line"
      ],
      [
        true,
        "as-needed"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "hasFix": true,
    "codeExamples": [
      {
        "description": "Require curly braces whenever possible (default)",
        "config": "\n\"rules\": { \"curly\": true }\n        ",
        "pass": "\nif (x > 0) {\n    doStuff();\n}\n        ",
        "fail": "\nif (x > 0)\n    doStuff();\n\nif (x > 0) doStuff();\n        "
      },
      {
        "description": "Make an exception for single-line instances",
        "config": "\n\"rules\": { \"curly\": [true, \"ignore-same-line\"] }\n        ",
        "pass": "\nif (x > 0) doStuff();\n        ",
        "fail": "\nif (x > 0)\n    doStuff()\n        "
      },
      {
        "description": "Error on unnecessary curly braces",
        "config": "\n\"rules\": { \"curly\": [true, \"as-needed\"] }\n        ",
        "pass": "\nif (x > 0)\n    doStuff();\n\nif (x > 0) {\n    customerUpdates.push(getInfo(customerId));\n    return customerUpdates;\n}\n        ",
        "fail": "\nif (x > 0) {\n    doStuff();\n}\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/curly",
    "path": "./node_modules/tslint/lib/rules/curlyRule.js",
    "ruleName": "curly",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "cyclomatic-complexity": {
    "id": "./node_modules/tslint:cyclomatic-complexity",
    "description": "Enforces a threshold of cyclomatic complexity.",
    "descriptionDetails": "\nCyclomatic complexity is assessed for each function of any type. A starting value of 0\nis assigned and this value is then incremented for every statement which can branch the\ncontrol flow within the function. The following statements and expressions contribute\nto cyclomatic complexity:\n* `catch`\n* `if` and `? :`\n* `||` and `&&` due to short-circuit evaluation\n* `for`, `for in` and `for of` loops\n* `while` and `do while` loops\n* `case` clauses that contain statements",
    "rationale": "\nCyclomatic complexity is a code metric which indicates the level of complexity in a\nfunction. High cyclomatic complexity indicates confusing code which may be prone to\nerrors or difficult to modify.\n\nIt's better to have smaller, single-purpose functions with self-documenting names.",
    "optionsDescription": "\nAn optional upper limit for cyclomatic complexity can be specified. If no limit option\nis provided a default value of 20 will be used.",
    "options": {
      "type": "number",
      "minimum": 2
    },
    "optionExamples": [
      true,
      [
        true,
        20
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/cyclomatic-complexity",
    "path": "./node_modules/tslint/lib/rules/cyclomaticComplexityRule.js",
    "ruleName": "cyclomatic-complexity",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "deprecation": {
    "id": "./node_modules/tslint:deprecation",
    "description": "Warns when deprecated APIs are used.",
    "descriptionDetails": "Any usage of an identifier\n            with the @deprecated JSDoc annotation will trigger a warning.\n            See http://usejsdoc.org/tags-deprecated.html",
    "rationale": "Deprecated APIs should be avoided, and usage updated.",
    "type": "maintainability",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/deprecation",
    "path": "./node_modules/tslint/lib/rules/deprecationRule.js",
    "ruleName": "deprecation",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "encoding": {
    "id": "./node_modules/tslint:encoding",
    "description": "Enforces UTF-8 file encoding.",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/encoding",
    "path": "./node_modules/tslint/lib/rules/encodingRule.js",
    "ruleName": "encoding",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "eofline": {
    "id": "./node_modules/tslint:eofline",
    "description": "Ensures the file ends with a newline.",
    "descriptionDetails": "Fix for single-line files is not supported.",
    "rationale": "It is a [standard convention](https://stackoverflow.com/q/729692/3124288) to end files with a newline.",
    "hasFix": true,
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/eofline",
    "path": "./node_modules/tslint/lib/rules/eoflineRule.js",
    "ruleName": "eofline",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "export-name": {
    "id": "./node_modules/tslint-microsoft-contrib:export-name",
    "type": "maintainability",
    "description": "The name of the exported module must match the filename of the source file",
    "options": {
      "type": "list",
      "listType": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "object",
            "properties": {
              "ignore-case": {
                "type": "boolean"
              },
              "allow": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              }
            }
          }
        ]
      }
    },
    "optionsDescription": "",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/exportNameRule.js",
    "ruleName": "export-name",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "file-header": {
    "id": "./node_modules/tslint:file-header",
    "description": "Enforces a certain header comment for all files, matched by a regular expression.",
    "optionsDescription": "\nThe first option, which is mandatory, is a regular expression that all headers should match.\nThe second argument, which is optional, is a string that should be inserted as a header comment\nif fixing is enabled and no header that matches the first argument is found.\nThe third argument, which is optional, is a string that denotes whether or not a newline should\nexist on the header.",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string"
        },
        {
          "type": "string"
        },
        {
          "type": "string"
        }
      ],
      "additionalItems": false,
      "minLength": 1,
      "maxLength": 3
    },
    "optionExamples": [
      [
        true,
        "Copyright \\d{4}",
        "Copyright 2018",
        "enforce-trailing-newline"
      ]
    ],
    "hasFix": true,
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/file-header",
    "path": "./node_modules/tslint/lib/rules/fileHeaderRule.js",
    "ruleName": "file-header",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "file-name-casing": {
    "id": "./node_modules/tslint:file-name-casing",
    "description": "Enforces a consistent file naming convention",
    "rationale": "Helps maintain a consistent style across a file hierarchy",
    "optionsDescription": "\nOne of the following arguments must be provided:\n\n* `camel-case`: File names must be camel-cased: `fileName.ts`.\n* `pascal-case`: File names must be Pascal-cased: `FileName.ts`.\n* `kebab-case`: File names must be kebab-cased: `file-name.ts`.\n* `snake-case`: File names must be snake-cased: `file_name.ts`.\n\nOr an object, where the key represents a regular expression that\nmatches the file name, and the value is the file name rule from\nthe previous list.\n\n* { \".tsx\": \"pascal-case\", \".ts\": \"camel-case\" }\n        ",
    "options": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "array",
            "items": [
              {
                "type": "string",
                "enum": [
                  "camel-case",
                  "pascal-case",
                  "kebab-case",
                  "snake-case"
                ]
              }
            ]
          },
          {
            "type": "object",
            "additionalProperties": {
              "type": "string",
              "enum": [
                "camel-case",
                "pascal-case",
                "kebab-case",
                "snake-case"
              ]
            },
            "minProperties": 1
          }
        ]
      }
    },
    "optionExamples": [
      [
        true,
        "camel-case"
      ],
      [
        true,
        "pascal-case"
      ],
      [
        true,
        "kebab-case"
      ],
      [
        true,
        "snake-case"
      ],
      [
        true,
        {
          ".tsx": "pascal-case",
          ".ts": "camel-case"
        }
      ],
      [
        true,
        {
          ".style.ts": "kebab-case",
          ".tsx": "pascal-case",
          ".*": "camel-case"
        }
      ]
    ],
    "hasFix": false,
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/file-name-casing",
    "path": "./node_modules/tslint/lib/rules/fileNameCasingRule.js",
    "ruleName": "file-name-casing",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "forin": {
    "id": "./node_modules/tslint:forin",
    "description": "Requires a `for ... in` statement to be filtered with an `if` statement.",
    "rationale": "\n```ts\nfor (let key in someObject) {\n    if (someObject.hasOwnProperty(key)) {\n        // code here\n    }\n}\n```\nPrevents accidental iteration over properties inherited from an object's prototype.\nSee [MDN's `for...in`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in)\ndocumentation for more information about `for...in` loops.\n\nAlso consider using a [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)\nor [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)\nif you're storing collections of objects.\nUsing `Object`s can cause occasional edge case bugs, such as if a key is named \"hasOwnProperty\".\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/forin",
    "path": "./node_modules/tslint/lib/rules/forinRule.js",
    "ruleName": "forin",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "function-constructor": {
    "id": "./node_modules/tslint:function-constructor",
    "codeExamples": [
      {
        "config": "\n\"rules\": { \"function-constructor\": true }\n        ",
        "description": "Use inline lambdas instead of calling Function",
        "fail": "\nlet doesNothing = new Function();\n        ",
        "pass": "\nlet doesNothing = () => {};\n        "
      },
      {
        "config": "\n\"rules\": { \"function-constructor\": true }\n        ",
        "description": "Use parameters instead of constructor strings",
        "fail": "\nlet addNumbers = new Function(\"a\", \"b\", \"return a + b\");\n        ",
        "pass": "\nlet addNumbers = (a, b) => a + b;\n        "
      }
    ],
    "description": "\nPrevents using the built-in Function constructor.\n        ",
    "rationale": "\nCalling the constructor directly is similar to `eval`, which is a symptom of design issues.\nString inputs don't receive type checking and can cause performance issues, particularly when dynamically created.\n\nIf you need to dynamically create functions, use \"factory\" functions that themselves return functions.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/function-constructor",
    "path": "./node_modules/tslint/lib/rules/functionConstructorRule.js",
    "ruleName": "function-constructor",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "function-name": {
    "id": "./node_modules/tslint-microsoft-contrib:function-name",
    "type": "maintainability",
    "description": "Applies a naming convention to function names and method names",
    "optionsDescription": "\nFunction styles should be consistent throughout the code.\nUsers may want functions with multiple descriptors to be validated a certain way.\nAn optional argument specifies validation for private static methods:\n* `validate-private-statics-as-private` enforces validation as private.\n* `validate-private-statics-as-static` enforces validation as static.\n* `validate-private-statics-as-either` enforces validation as either.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string",
          "enum": [
            "validate-private-statics-as-private",
            "validate-private-statics-as-static",
            "validate-private-statics-as-either"
          ]
        }
      ],
      "minLength": 0,
      "maxLength": 2
    },
    "optionExamples": [
      [
        true,
        "validate-private-statics-as-either"
      ],
      [
        true,
        "validate-private-statics-as-private"
      ],
      [
        true,
        "validate-private-statics-as-static"
      ],
      [
        true
      ]
    ],
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/functionNameRule.js",
    "ruleName": "function-name",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "handle-callback-err": {
    "id": "./node_modules/tslint-eslint-rules:handle-callback-err",
    "description": "enforce error handling in callbacks",
    "rationale": "\nIn Node.js, a common pattern for dealing with asynchronous behavior is called the callback\npattern. This pattern expects an Error object or null as the first argument of the callback.\nForgetting to handle these errors can lead to some really strange behavior in your\napplication.\n",
    "optionsDescription": "\nThe rule takes a string option: the name of the error parameter. The default is\n`\"err\"`.\n\nSometimes the name of the error variable is not consistent across the project, so you need a\nmore flexible configuration to ensure that the rule reports all unhandled errors.\n\nIf the configured name of the error variable begins with a `^` it is considered to be a\nregexp pattern.\n\n- If the option is `\"^(err|error|anySpecificError)$\"`, the rule reports unhandled errors\n  where the parameter name can be `err`, `error` or `anySpecificError`.\n- If the option is `\"^.+Error$\"`, the rule reports unhandled errors where the parameter\n  name ends with `Error` (for example, `connectionError` or `validationError` will\n  match).\n- If the option is `\"^.*(e|E)rr\"`, the rule reports unhandled errors where the parameter\n  name matches any string that contains `err` or `Err` (for example, `err`, `error`,\n  `anyError`, `some_err` will match).\n\nIn addition to the string we may specify an options object with the following property:\n\n- `allowProperties`: (`true` by default) When this is set to `false` the rule will not\n  report unhandled errors as long as the error object is handled without accessing any of its\n  properties at least once. For instance, `(err) => console.log(err.stack)` would report an\n  issue when `allowProperties` is set to `false` because `err` is not handled on its\n  own.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string"
        },
        {
          "type": "object",
          "properties": {
            "allowProperties": "boolean"
          },
          "additionalProperties": false
        }
      ],
      "minLength": 0,
      "maxLength": 2
    },
    "optionExamples": [
      "\n\"handle-callback-err\": [true, \"error\"]\n",
      "\n\"handle-callback-err\": [true, \"^(err|error|anySpecificError)$\"]\n",
      "\n\"handle-callback-err\": [true, { \"allowProperties\": false }]\n",
      "\n\"handle-callback-err\": [true, \"^(err|error|anySpecificError)$\", { \"allowProperties\": false }]\n"
    ],
    "typescriptOnly": false,
    "type": "maintainability",
    "documentation": "https://eslint.org/docs/rules/handle-callback-err",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/handleCallbackErrRule.js",
    "ruleName": "handle-callback-err",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "import-blacklist": {
    "id": "./node_modules/tslint:import-blacklist",
    "description": "\nDisallows importing the specified modules via `import` and `require`,\nor importing specific named exports of the specified modules,\nor using imports matching specified regular expression patterns.",
    "rationale": "\nFor some libraries, importing the library directly can cause unused\nsubmodules to be loaded, so you may want to block these imports and\nrequire that users directly import only the submodules they need.\nIn other cases, you may simply want to ban an import because using\nit is undesirable or unsafe.",
    "optionsDescription": "A list of blacklisted modules, named imports, or regular expression patterns.",
    "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
          }
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "rxjs",
        "lodash"
      ],
      [
        true,
        "lodash",
        {
          "lodash": [
            "pull",
            "pullAll"
          ]
        }
      ],
      [
        true,
        "rxjs",
        {
          "lodash": [
            "pull",
            "pullAll"
          ]
        },
        [
          ".*\\.temp$",
          ".*\\.tmp$"
        ]
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/import-blacklist",
    "path": "./node_modules/tslint/lib/rules/importBlacklistRule.js",
    "ruleName": "import-blacklist",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "import-name": {
    "id": "./node_modules/tslint-microsoft-contrib:import-name",
    "type": "maintainability",
    "description": "The name of the imported module must match the name of the thing being imported",
    "hasFix": true,
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/importNameRule.js",
    "ruleName": "import-name",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "import-spacing": {
    "id": "./node_modules/tslint:import-spacing",
    "description": "Ensures proper spacing between import statement keywords",
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/import-spacing",
    "path": "./node_modules/tslint/lib/rules/importSpacingRule.js",
    "ruleName": "import-spacing",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "increment-decrement": {
    "id": "./node_modules/tslint:increment-decrement",
    "description": "Enforces using explicit += 1 or -= 1 operators.",
    "optionExamples": [
      true,
      [
        true,
        "allow-post"
      ]
    ],
    "options": {
      "items": {
        "enum": [
          "allow-post"
        ],
        "type": "string"
      },
      "maxLength": 1,
      "minLength": 0,
      "type": "array"
    },
    "optionsDescription": "\nIf no arguments are provided, both pre- and post-unary operators are banned.\nIf `\"allow-post\"` is provided, post-unary operators will be allowed.\n        ",
    "rationale": "\nIt's easy to type +i or -i instead of --i or ++i, and won't always result in invalid code.\nPrefer standardizing small arithmetic operations with the explicit += and -= operators.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/increment-decrement",
    "path": "./node_modules/tslint/lib/rules/incrementDecrementRule.js",
    "ruleName": "increment-decrement",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "indent": {
    "id": "./node_modules/tslint:indent",
    "description": "Enforces indentation with tabs or spaces.",
    "rationale": "\nUsing only one of tabs or spaces for indentation leads to more consistent editor behavior,\ncleaner diffs in version control, and easier programmatic manipulation.",
    "optionsDescription": "\nOne of the following arguments must be provided:\n\n* `spaces` enforces consistent spaces.\n* `tabs` enforces consistent tabs.\n\nA second optional argument specifies indentation size:\n\n* `2` enforces 2 space indentation.\n* `4` enforces 4 space indentation.\n\nIndentation size is **required** for auto-fixing, but not for rule checking.\n\n**NOTE**: auto-fixing will only convert invalid indent whitespace to the desired type, it will not fix invalid whitespace sizes.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string",
          "enum": [
            "tabs",
            "spaces"
          ]
        },
        {
          "type": "number",
          "enum": [
            2,
            4
          ]
        }
      ],
      "minLength": 0,
      "maxLength": 5
    },
    "optionExamples": [
      [
        true,
        "spaces"
      ],
      [
        true,
        "spaces",
        4
      ],
      [
        true,
        "tabs",
        2
      ]
    ],
    "hasFix": true,
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/indent",
    "path": "./node_modules/tslint/lib/rules/indentRule.js",
    "ruleName": "indent",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "informative-docs": {
    "id": "./node_modules/tslint-microsoft-contrib:informative-docs",
    "description": "Enforces that comments do more than just reiterate names of objects.",
    "rationale": "\nThe documentation for an object should not be equivalent to just the object's name.\nIf we strip out non-alphabet characters, common words such as \"the\" or \"a\",\nand lowercase everything, they shouldn't be the same.\n\nUsing informative documentation can be helpful for variables to help explain their usage.\nAlternately, if something's name is so descriptive that it doesn't need to be fully documented,\njust leave out documentation altogether.\n        ",
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "recommendation": "true,",
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/informativeDocsRule.js",
    "ruleName": "informative-docs",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "insecure-random": {
    "id": "./node_modules/tslint-microsoft-contrib:insecure-random",
    "type": "functionality",
    "description": "Do not use insecure sources for random bytes",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Security",
    "commonWeaknessEnumeration": "330",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/insecureRandomRule.js",
    "ruleName": "insecure-random",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "interface-name": {
    "id": "./node_modules/tslint:interface-name",
    "description": "Requires interface names to begin with a capital 'I'",
    "rationale": "Makes it easy to differentiate interfaces from regular classes at a glance.",
    "optionsDescription": "\nOne of the following two options must be provided:\n\n* `\"always-prefix\"` requires interface names to start with an \"I\"\n* `\"never-prefix\"` requires interface names to not have an \"I\" prefix",
    "options": {
      "type": "string",
      "enum": [
        "always-prefix",
        "never-prefix"
      ]
    },
    "optionExamples": [
      [
        true,
        "always-prefix"
      ],
      [
        true,
        "never-prefix"
      ]
    ],
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/interface-name",
    "path": "./node_modules/tslint/lib/rules/interfaceNameRule.js",
    "ruleName": "interface-name",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "interface-over-type-literal": {
    "id": "./node_modules/tslint:interface-over-type-literal",
    "description": "Prefer an interface declaration over a type literal (`type T = { ... }`)",
    "rationale": "Interfaces are generally preferred over type literals because interfaces can be implemented, extended and merged.",
    "type": "style",
    "typescriptOnly": true,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/interface-over-type-literal",
    "path": "./node_modules/tslint/lib/rules/interfaceOverTypeLiteralRule.js",
    "ruleName": "interface-over-type-literal",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "jquery-deferred-must-complete": {
    "id": "./node_modules/tslint-microsoft-contrib:jquery-deferred-must-complete",
    "type": "maintainability",
    "description": "When a JQuery Deferred instance is created, then either reject() or resolve() must be called on it within all code branches in the scope.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/jqueryDeferredMustCompleteRule.js",
    "ruleName": "jquery-deferred-must-complete",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "jsdoc-format": {
    "id": "./node_modules/tslint:jsdoc-format",
    "description": "Enforces basic format rules for JSDoc comments.",
    "descriptionDetails": "\nThe following rules are enforced for JSDoc comments (comments starting with `/**`):\n\n* each line contains an asterisk and asterisks must be aligned\n* each asterisk must be followed by either a space or a newline (except for the first and the last)\n* the only characters before the asterisk on each line must be whitespace characters\n* one line comments must start with `/** ` and end with `*/`\n* multiline comments don't allow text after `/** ` in the first line (with option `\"check-multiline-start\"`)\n        ",
    "rationale": "Helps maintain a consistent, readable style for JSDoc comments.",
    "optionsDescription": "\nYou can optionally specify the option `\"check-multiline-start\"` to enforce the first line of a\nmultiline JSDoc comment to be empty.\n        ",
    "options": {
      "type": "array",
      "minItems": 0,
      "maxItems": 1,
      "items": {
        "type": "string",
        "enum": [
          "check-multiline-start"
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "check-multiline-start"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/jsdoc-format",
    "path": "./node_modules/tslint/lib/rules/jsdocFormatRule.js",
    "ruleName": "jsdoc-format",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "jsx-alignment": {
    "id": "./node_modules/tslint-react:jsx-alignment",
    "description": "Enforces consistent and readable vertical alignment of JSX tags and attributes",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxAlignmentRule.js",
    "ruleName": "jsx-alignment",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-ban-elements": {
    "id": "./node_modules/tslint-react:jsx-ban-elements",
    "description": "\nBans specific JSX elements from being used.",
    "options": {
      "type": "list",
      "listType": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "minLength": 1,
        "maxLength": 2
      }
    },
    "optionsDescription": "\nA list of `[\"regex\", \"optional explanation here\"]`, which bans\ntypes that match `regex`",
    "optionExamples": [
      [
        true,
        [
          "Object",
          "Use {} instead."
        ],
        [
          "String"
        ]
      ]
    ],
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxBanElementsRule.js",
    "ruleName": "jsx-ban-elements",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-ban-props": {
    "id": "./node_modules/tslint-react:jsx-ban-props",
    "description": "Bans the use of specific props.",
    "optionsDescription": "\nA list of `['propName', 'optional explanation here']` which bans the prop called 'propName'.",
    "options": {
      "type": "list",
      "listType": {
        "type": "string",
        "items": {
          "type": "string"
        },
        "minLength": 1,
        "maxLength": 2
      }
    },
    "optionExamples": [
      "[true, [\"someProp], [\"anotherProp\", \"Optional explanation\"]]"
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxBanPropsRule.js",
    "ruleName": "jsx-ban-props",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-boolean-value": {
    "id": "./node_modules/tslint-react:jsx-boolean-value",
    "description": "Enforce boolean attribute notation in jsx.",
    "optionsDescription": "\nOne of the following two options must be provided:\n* `\"always\"` requires JSX boolean values to always be set.\n* `\"never\"` prevents JSX boolean values to be explicity set as `true`",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        }
      ],
      "minLength": 1,
      "maxLength": 1
    },
    "optionExamples": [
      "[true, \"always\"]",
      "[true, \"never\"]"
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxBooleanValueRule.js",
    "ruleName": "jsx-boolean-value",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-curly-spacing": {
    "id": "./node_modules/tslint-react:jsx-curly-spacing",
    "description": "Checks JSX curly braces spacing",
    "optionsDescription": "\nOne of the following two options must be provided:\n\n* `\"always\"` requires JSX attributes to have spaces between curly braces\n* `\"never\"` requires JSX attributes to NOT have spaces between curly braces",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        }
      ],
      "minLength": 1,
      "maxLength": 1
    },
    "optionExamples": [
      "[true, \"always\"]",
      "[true, \"never\"]"
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxCurlySpacingRule.js",
    "ruleName": "jsx-curly-spacing",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-equals-spacing": {
    "id": "./node_modules/tslint-react:jsx-equals-spacing",
    "description": "\nDisallow or enforce spaces around equal signs in JSX attributes",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        }
      ],
      "minLength": 1,
      "maxLength": 1
    },
    "optionExamples": [
      "[true, \"always\"]",
      "[true, \"never\"]"
    ],
    "optionsDescription": "\nOne of the following two options must be provided:\n\n* `\"always\"` requires JSX attributes to have spaces before and after the equals sign\n* `\"never\"` requires JSX attributes to NOT have spaces before and after the equals sign",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxEqualsSpacingRule.js",
    "ruleName": "jsx-equals-spacing",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-key": {
    "id": "./node_modules/tslint-react:jsx-key",
    "description": "Warn if an element that likely requires a key prop — namely,             one present in an array literal or an arrow function expression.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxKeyRule.js",
    "ruleName": "jsx-key",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-no-bind": {
    "id": "./node_modules/tslint-react:jsx-no-bind",
    "description": "Forbids function binding in JSX attributes. This has the same intent             as jsx-no-lambda in helping you avoid excessive re-renders.",
    "descriptionDetails": "Note that this currently only does a simple syntactic check,             not a semantic one (it doesn't use the type checker). So it may             have some rare false positives if you define your own .bind function             and supply this as a parameter.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxNoBindRule.js",
    "ruleName": "jsx-no-bind",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-no-lambda": {
    "id": "./node_modules/tslint-react:jsx-no-lambda",
    "description": "Checks for fresh lambda literals used in JSX attributes",
    "descriptionDetails": "Creating new anonymous functions (with either the function syntax or             ES2015 arrow syntax) inside the render call stack works against pure component             rendering. When doing an equality check between two lambdas, React will always             consider them unequal values and force the component to re-render more often than necessary.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxNoLambdaRule.js",
    "ruleName": "jsx-no-lambda",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-no-multiline-js": {
    "id": "./node_modules/tslint-react:jsx-no-multiline-js",
    "description": "Checks for multiline JS expressions inside JSX expressions",
    "descriptionDetails": "This helps reduce mental overhead when parsing JSX syntax",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxNoMultilineJsRule.js",
    "ruleName": "jsx-no-multiline-js",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-no-string-ref": {
    "id": "./node_modules/tslint-react:jsx-no-string-ref",
    "description": "Checks for string literal refs",
    "descriptionDetails": "This syntax is deprecated and will be removed in a future version of React",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxNoStringRefRule.js",
    "ruleName": "jsx-no-string-ref",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-self-close": {
    "id": "./node_modules/tslint-react:jsx-self-close",
    "description": "Checks that JSX elements with no children are self-closing",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxSelfCloseRule.js",
    "ruleName": "jsx-self-close",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-space-before-trailing-slash": {
    "id": "./node_modules/tslint-react:jsx-space-before-trailing-slash",
    "description": "Checks that self-closing JSX elements have a space before the '/>' part.",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxSpaceBeforeTrailingSlashRule.js",
    "ruleName": "jsx-space-before-trailing-slash",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-use-translation-function": {
    "id": "./node_modules/tslint-react:jsx-use-translation-function",
    "description": "\nEnforces use of a translation function. Most plain string literals are disallowed in JSX when enabled.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-punctuation",
          "allow-htmlentities"
        ]
      }
    },
    "optionsDescription": "\nWhether to allow punctuation and or HTML entities",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxUseTranslationFunctionRule.js",
    "ruleName": "jsx-use-translation-function",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "jsx-wrap-multiline": {
    "id": "./node_modules/tslint-react:jsx-wrap-multiline",
    "description": "Checks that multiline JSX elements are wrapped in parens",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://github.com/palantir/tslint-react#rules",
    "path": "./node_modules/tslint-react/rules/jsxWrapMultilineRule.js",
    "ruleName": "jsx-wrap-multiline",
    "source": "tslint-react",
    "sourcePath": "./node_modules/tslint-react"
  },
  "label-position": {
    "id": "./node_modules/tslint:label-position",
    "description": "Only allows labels in sensible locations.",
    "descriptionDetails": "This rule only allows labels to be on `do/for/while/switch` statements.",
    "rationale": "\nLabels in JavaScript only can be used in conjunction with `break` or `continue`,\nconstructs meant to be used for loop flow control. While you can theoretically use\nlabels on any block statement in JS, it is considered poor code structure to do so.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/label-position",
    "path": "./node_modules/tslint/lib/rules/labelPositionRule.js",
    "ruleName": "label-position",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "linebreak-style": {
    "id": "./node_modules/tslint:linebreak-style",
    "description": "Enforces a consistent linebreak style.",
    "optionsDescription": "\nOne of the following options must be provided:\n\n* `\"LF\"` requires LF (`\\n`) linebreaks\n* `\"CRLF\"` requires CRLF (`\\r\\n`) linebreaks",
    "options": {
      "type": "string",
      "enum": [
        "LF",
        "CRLF"
      ]
    },
    "optionExamples": [
      [
        true,
        "LF"
      ],
      [
        true,
        "CRLF"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/linebreak-style",
    "path": "./node_modules/tslint/lib/rules/linebreakStyleRule.js",
    "ruleName": "linebreak-style",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "match-default-export-name": {
    "id": "./node_modules/tslint:match-default-export-name",
    "description": "\nRequires that a default import have the same name as the declaration it imports.\nDoes nothing for anonymous default exports.",
    "type": "style",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/match-default-export-name",
    "path": "./node_modules/tslint/lib/rules/matchDefaultExportNameRule.js",
    "ruleName": "match-default-export-name",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "max-classes-per-file": {
    "id": "./node_modules/tslint:max-classes-per-file",
    "description": "\nA file may not contain more than the specified number of classes",
    "rationale": "\nEnsures that files have a single responsibility so that that classes each exist in their own files",
    "optionsDescription": "\nThe one required argument is an integer indicating the maximum number of classes that can appear in a\nfile. An optional argument `\"exclude-class-expressions\"` can be provided to exclude class expressions\nfrom the overall class count.",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "number",
          "minimum": 1
        },
        {
          "type": "string",
          "enum": [
            "exclude-class-expressions"
          ]
        }
      ],
      "additionalItems": false,
      "minLength": 1,
      "maxLength": 2
    },
    "optionExamples": [
      [
        true,
        1
      ],
      [
        true,
        5,
        "exclude-class-expressions"
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/max-classes-per-file",
    "path": "./node_modules/tslint/lib/rules/maxClassesPerFileRule.js",
    "ruleName": "max-classes-per-file",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "max-file-line-count": {
    "id": "./node_modules/tslint:max-file-line-count",
    "description": "Requires files to remain under a certain number of lines",
    "rationale": "\nLimiting the number of lines allowed in a file allows files to remain small,\nsingle purpose, and maintainable.",
    "optionsDescription": "An integer indicating the maximum number of lines.",
    "options": {
      "type": "number",
      "minimum": "1"
    },
    "optionExamples": [
      [
        true,
        300
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/max-file-line-count",
    "path": "./node_modules/tslint/lib/rules/maxFileLineCountRule.js",
    "ruleName": "max-file-line-count",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "max-func-body-length": {
    "id": "./node_modules/tslint-microsoft-contrib:max-func-body-length",
    "type": "maintainability",
    "description": "Avoid long functions.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "recommendation": "[true, 100, { \"ignore-parameters-to-function-regex\": \"^describe$\" }],",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/maxFuncBodyLengthRule.js",
    "ruleName": "max-func-body-length",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "max-line-length": {
    "id": "./node_modules/tslint:max-line-length",
    "description": "Requires lines to be under a certain max length.",
    "rationale": "\nLimiting the length of a line of code improves code readability.\nIt also makes comparing code side-by-side easier and improves compatibility with\nvarious editors, IDEs, and diff viewers.",
    "optionsDescription": "\nIt can take one argument, which can be any of the following:\n* integer indicating maximum length of lines.\n* object with keys:\n  * `limit` - number greater than 0 defining the max line length\n  * `ignore-pattern` - string defining ignore pattern for this rule, being parsed by `new RegExp()`.\n    For example:\n     * `// ` pattern will ignore all in-line comments.\n     * `^import ` pattern will ignore all import statements.\n     * `^export {(.*?)}` pattern will ignore all multiple export statements.\n     * `class [a-zA-Z]+ implements ` pattern will ignore all class declarations implementing interfaces.\n     * `^import |^export {(.*?)}|class [a-zA-Z]+ implements |// ` pattern will ignore all the cases listed above.\n ",
    "options": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "type": "number"
          },
          {
            "type": "object",
            "properties": {
              "limit": {
                "type": "number"
              },
              "ignore-pattern": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "minLength": 1,
      "maxLength": 2
    },
    "optionExamples": [
      [
        true,
        120
      ],
      [
        true,
        {
          "limit": 120,
          "ignore-pattern": "^import |^export {(.*?)}"
        }
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/max-line-length",
    "path": "./node_modules/tslint/lib/rules/maxLineLengthRule.js",
    "ruleName": "max-line-length",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "member-access": {
    "id": "./node_modules/tslint:member-access",
    "description": "Requires explicit visibility declarations for class members.",
    "rationale": "\nExplicit visibility declarations can make code more readable and accessible for those new to TS.\n\nOther languages such as C# default to `private`, unlike TypeScript's default of `public`.\nMembers lacking a visibility declaration may be an indication of an accidental leak of class internals.\n        ",
    "optionsDescription": "\nThese arguments may be optionally provided:\n\n* `\"no-public\"` forbids public accessibility to be specified, because this is the default.\n* `\"check-accessor\"` enforces explicit visibility on get/set accessors\n* `\"check-constructor\"`  enforces explicit visibility on constructors\n* `\"check-parameter-property\"`  enforces explicit visibility on parameter properties",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "no-public",
          "check-accessor",
          "check-constructor",
          "check-parameter-property"
        ]
      },
      "minLength": 0,
      "maxLength": 4
    },
    "optionExamples": [
      true,
      [
        true,
        "no-public"
      ],
      [
        true,
        "check-accessor"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": true,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/member-access",
    "path": "./node_modules/tslint/lib/rules/memberAccessRule.js",
    "ruleName": "member-access",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "member-ordering": {
    "id": "./node_modules/tslint:member-ordering",
    "description": "Enforces member ordering.",
    "hasFix": true,
    "rationale": "\nA consistent ordering for class members can make classes easier to read, navigate, and edit.\n\nA common opposite practice to `member-ordering` is to keep related groups of classes together.\nInstead of creating classes with multiple separate groups, consider splitting class responsibilities\napart across multiple single-responsibility classes.\n        ",
    "optionsDescription": "\nOne argument, which is an object, must be provided. It should contain an `order` property.\nThe `order` property should have a value of one of the following strings:\n\n* `fields-first`\n* `instance-sandwich`\n* `statics-first`\n\n`fields-first` puts, in order of precedence:\n\n    * fields before constructors before methods\n    * static members before instance members\n    * public members before protected members before private members\n\n`instance-sandwich` puts, in order of precedence:\n\n    * fields before constructors before methods\n    * static fields before instance fields, but static methods *after* instance methods\n    * public members before protected members before private members\n\n`statics-first` puts, in order of precedence:\n\n    * static members before instance members\n        * public members before protected members before private members\n        * fields before methods\n    * instance fields before constructors before instance methods\n        * fields before constructors before methods\n        * public members before protected members before private members\n\nNote that these presets, despite looking similar, can have subtly different behavior due to the order in which these\nrules are specified. A fully expanded ordering can be found in the PRESETS constant in\nhttps://github.com/palantir/tslint/blob/master/src/rules/memberOrderingRule.ts.\n(You may need to check the version of the file corresponding to your version of tslint.)\n\nAlternatively, the value for `order` may be an array consisting of the following strings:\n\n* `public-static-field`\n* `public-static-method`\n* `protected-static-field`\n* `protected-static-method`\n* `private-static-field`\n* `private-static-method`\n* `public-instance-field`\n* `protected-instance-field`\n* `private-instance-field`\n* `public-constructor`\n* `protected-constructor`\n* `private-constructor`\n* `public-instance-method`\n* `protected-instance-method`\n* `private-instance-method`\n\nYou can also omit the access modifier to refer to \"public-\", \"protected-\", and \"private-\" all at once; for example, \"static-field\".\n\nYou can also make your own categories by using an object instead of a string:\n\n    {\n        \"name\": \"static non-private\",\n        \"kinds\": [\n            \"public-static-field\",\n            \"protected-static-field\",\n            \"public-static-method\",\n            \"protected-static-method\"\n        ]\n    }\n\nThe 'alphabetize' option will enforce that members within the same category should be alphabetically sorted by name.",
    "options": {
      "type": "object",
      "properties": {
        "order": {
          "oneOf": [
            {
              "type": "string",
              "enum": [
                "fields-first",
                "instance-sandwich",
                "statics-first"
              ]
            },
            {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "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"
                ]
              },
              "maxLength": 13
            }
          ]
        },
        "alphabetize": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "optionExamples": [
      [
        true,
        {
          "order": "fields-first"
        }
      ],
      [
        true,
        {
          "order": [
            "public-static-field",
            "public-instance-field",
            "public-constructor",
            "private-static-field",
            "private-instance-field",
            "private-constructor",
            "public-instance-method",
            "protected-instance-method",
            "private-instance-method"
          ],
          "alphabetize": true
        }
      ],
      [
        true,
        {
          "order": [
            {
              "name": "static non-private",
              "kinds": [
                "public-static-field",
                "protected-static-field",
                "public-static-method",
                "protected-static-method"
              ]
            },
            "constructor"
          ]
        }
      ]
    ],
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/member-ordering",
    "path": "./node_modules/tslint/lib/rules/memberOrderingRule.js",
    "ruleName": "member-ordering",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "missing-jsdoc": {
    "id": "./node_modules/tslint-microsoft-contrib:missing-jsdoc",
    "type": "maintainability",
    "description": "All files must have a top level JSDoc comment.",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false,",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/missingJsdocRule.js",
    "ruleName": "missing-jsdoc",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "missing-optional-annotation": {
    "id": "./node_modules/tslint-microsoft-contrib:missing-optional-annotation",
    "type": "maintainability",
    "description": "Deprecated - This rule is now enforced by the TypeScript compiler",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false, // now supported by TypeScript compiler",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/missingOptionalAnnotationRule.js",
    "ruleName": "missing-optional-annotation",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "mocha-avoid-only": {
    "id": "./node_modules/tslint-microsoft-contrib:mocha-avoid-only",
    "type": "maintainability",
    "description": "Do not invoke Mocha's describe.only, it.only or context.only functions.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/mochaAvoidOnlyRule.js",
    "ruleName": "mocha-avoid-only",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "mocha-no-side-effect-code": {
    "id": "./node_modules/tslint-microsoft-contrib:mocha-no-side-effect-code",
    "type": "maintainability",
    "description": "All test logic in a Mocha test case should be within Mocha lifecycle method.",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/mochaNoSideEffectCodeRule.js",
    "ruleName": "mocha-no-side-effect-code",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "mocha-unneeded-done": {
    "id": "./node_modules/tslint-microsoft-contrib:mocha-unneeded-done",
    "type": "maintainability",
    "description": "A function declares a MochaDone parameter but only resolves it synchronously in the main function.",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/mochaUnneededDoneRule.js",
    "ruleName": "mocha-unneeded-done",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "new-parens": {
    "id": "./node_modules/tslint:new-parens",
    "description": "Requires parentheses when invoking a constructor via the `new` keyword.",
    "rationale": "Maintains stylistic consistency with other function calls.",
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/new-parens",
    "path": "./node_modules/tslint/lib/rules/newParensRule.js",
    "ruleName": "new-parens",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "newline-before-return": {
    "id": "./node_modules/tslint:newline-before-return",
    "description": "Enforces blank line before return when not the only line in the block.",
    "rationale": "Helps maintain a readable style in your codebase.",
    "hasFix": true,
    "optionsDescription": "Not configurable.",
    "options": {},
    "optionExamples": [
      true
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/newline-before-return",
    "path": "./node_modules/tslint/lib/rules/newlineBeforeReturnRule.js",
    "ruleName": "newline-before-return",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "newline-per-chained-call": {
    "id": "./node_modules/tslint:newline-per-chained-call",
    "description": "\nRequires that chained method calls be broken apart onto separate lines.",
    "rationale": "\nThis style helps to keep code 'vertical', avoiding the need for side-scrolling in IDEs or text editors.",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/newline-per-chained-call",
    "path": "./node_modules/tslint/lib/rules/newlinePerChainedCallRule.js",
    "ruleName": "newline-per-chained-call",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-absolute-import-to-own-parent": {
    "id": ".:no-absolute-import-to-own-parent",
    "description": "In a mono-repo with each folder under src being an alias, you should avoid using the alias to import things within an alias.",
    "options": [],
    "optionsDescription": "",
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://github.com/bettermarks/bm-tslint-rules#rules",
    "path": "./dist/noAbsoluteImportToOwnParentRule.js",
    "ruleName": "no-absolute-import-to-own-parent",
    "source": "bm-tslint-rules",
    "sourcePath": "."
  },
  "no-angle-bracket-type-assertion": {
    "id": "./node_modules/tslint:no-angle-bracket-type-assertion",
    "description": "Requires the use of `as Type` for type assertions instead of `<Type>`.",
    "hasFix": true,
    "rationale": "\nBoth formats of type assertions have the same effect, but only `as` type assertions\nwork in `.tsx` files. This rule ensures that you have a consistent type assertion style\nacross your codebase.",
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-angle-bracket-type-assertion",
    "path": "./node_modules/tslint/lib/rules/noAngleBracketTypeAssertionRule.js",
    "ruleName": "no-angle-bracket-type-assertion",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-any": {
    "id": "./node_modules/tslint:no-any",
    "description": "Disallows usages of `any` as a type declaration.",
    "hasFix": false,
    "rationale": "\nUsing `any` as a type declaration nullifies the compile-time benefits of the type system.\n\nIf you're dealing with data of unknown or \"any\" types, you shouldn't be accessing members of it.\nEither add type annotations for properties that may exist or change the data type to the empty object type `{}`.\n\nAlternately, if you're creating storage or handling for consistent but unknown types, such as in data structures\nor serialization, use `<T>` template types for generic type handling.\n\nAlso see the `no-unsafe-any` rule.\n        ",
    "type": "typescript",
    "typescriptOnly": true,
    "codeExamples": [
      {
        "description": "Disallows usages of `any` as a type declaration.",
        "config": "\n\"rules\": { \"no-any\": true }\n        ",
        "pass": "\nlet foo: object;\n        ",
        "fail": "\nlet foo: any;\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/no-any",
    "path": "./node_modules/tslint/lib/rules/noAnyRule.js",
    "ruleName": "no-any",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-arg": {
    "id": "./node_modules/tslint:no-arg",
    "description": "Disallows use of `arguments.callee`.",
    "rationale": "\nUsing `arguments.callee` makes various performance optimizations impossible.\nSee [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee)\nfor more details on why to avoid `arguments.callee`.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-arg",
    "path": "./node_modules/tslint/lib/rules/noArgRule.js",
    "ruleName": "no-arg",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-backbone-get-set-outside-model": {
    "id": "./node_modules/tslint-microsoft-contrib:no-backbone-get-set-outside-model",
    "type": "maintainability",
    "description": "Avoid using `model.get('x')` and `model.set('x', value)` Backbone accessors outside of the owning model.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noBackboneGetSetOutsideModelRule.js",
    "ruleName": "no-backbone-get-set-outside-model",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-banned-terms": {
    "id": "./node_modules/tslint-microsoft-contrib:no-banned-terms",
    "type": "maintainability",
    "description": "Do not use banned terms: caller, callee, eval, arguments.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "676, 242, 116",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noBannedTermsRule.js",
    "ruleName": "no-banned-terms",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-bitwise": {
    "id": "./node_modules/tslint:no-bitwise",
    "description": "Disallows bitwise operators.",
    "descriptionDetails": "\nSpecifically, the following bitwise operators are banned:\n`&`, `&=`, `|`, `|=`,\n`^`, `^=`, `<<`, `<<=`,\n`>>`, `>>=`, `>>>`, `>>>=`, and `~`.\nThis rule does not ban the use of `&` and `|` for intersection and union types.",
    "rationale": "\nBitwise operators are often typos - for example `bool1 & bool2` instead of `bool1 && bool2`.\nThey also can be an indicator of overly clever code which decreases maintainability.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-bitwise",
    "path": "./node_modules/tslint/lib/rules/noBitwiseRule.js",
    "ruleName": "no-bitwise",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-boolean-literal-compare": {
    "id": "./node_modules/tslint:no-boolean-literal-compare",
    "description": "Warns on comparison to a boolean literal, as in `x === true`.",
    "hasFix": true,
    "rationale": "\nComparing boolean values to boolean literals is unnecessary, as those expressions will result in booleans too.\nJust use the boolean values directly or negate them.\n        ",
    "type": "style",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-boolean-literal-compare",
    "path": "./node_modules/tslint/lib/rules/noBooleanLiteralCompareRule.js",
    "ruleName": "no-boolean-literal-compare",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-conditional-assignment": {
    "id": "./node_modules/tslint:no-conditional-assignment",
    "description": "Disallows any type of assignment in conditionals.",
    "descriptionDetails": "This applies to `do-while`, `for`, `if`, and `while` statements and conditional (ternary) expressions.",
    "rationale": "\nAssignments in conditionals are often typos:\nfor example `if (var1 = var2)` instead of `if (var1 == var2)`.\nThey also can be an indicator of overly clever code which decreases maintainability.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-conditional-assignment",
    "path": "./node_modules/tslint/lib/rules/noConditionalAssignmentRule.js",
    "ruleName": "no-conditional-assignment",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-consecutive-blank-lines": {
    "id": "./node_modules/tslint:no-consecutive-blank-lines",
    "description": "Disallows one or more blank lines in a row.",
    "hasFix": true,
    "rationale": "\nHelps maintain a readable style in your codebase.\n\nExtra blank lines take up extra space and add little to a semantic understanding of the code.\nIt can be harder to read through files when fewer components can fit into the screen.\nIf you find a file is so large you feel a need to split them up with extra blank lines or comments,\nconsider splitting your file into smaller files.\n        ",
    "optionsDescription": "\nAn optional number of maximum allowed sequential blanks can be specified. If no value\nis provided, a default of 1 will be used.",
    "options": {
      "type": "number",
      "minimum": "1"
    },
    "optionExamples": [
      true,
      [
        true,
        2
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-consecutive-blank-lines",
    "path": "./node_modules/tslint/lib/rules/noConsecutiveBlankLinesRule.js",
    "ruleName": "no-consecutive-blank-lines",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-console": {
    "id": "./node_modules/tslint:no-console",
    "description": "Bans the use of specified `console` methods.",
    "rationale": "In general, `console` methods aren't appropriate for production code.",
    "optionsDescription": "A list of method names to ban. If no method names are provided, all console methods are banned.",
    "options": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "optionExamples": [
      [
        true,
        "log",
        "error"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-console",
    "path": "./node_modules/tslint/lib/rules/noConsoleRule.js",
    "ruleName": "no-console",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-constant-condition": {
    "id": "./node_modules/tslint-eslint-rules:no-constant-condition",
    "description": "disallow use of constant expressions in conditions (recommended)",
    "rationale": "\nA constant expression (for example, a literal) as a test condition might be a typo or\ndevelopment trigger for a specific behavior. For example, the following code looks as if it is\nnot ready for production.\n",
    "optionsDescription": "\n- `\"checkLoops\"` Setting this option to `false` allows constant expressions in loops (default: `true`).\n",
    "options": {
      "type": "object",
      "properties": {
        "checkLoops": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "optionExamples": [
      "\n\"no-constant-condition\": true\n",
      "\n\"no-constant-condition\": [true, { \"checkLoops\": false }]\n"
    ],
    "typescriptOnly": false,
    "type": "functionality",
    "documentation": "https://eslint.org/docs/rules/no-constant-condition",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noConstantConditionRule.js",
    "ruleName": "no-constant-condition",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:no-constant-condition",
        "type": "maintainability",
        "description": "Do not use constant expressions in conditions.",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Error",
        "severity": "Critical",
        "level": "Opportunity for Excellence",
        "group": "Correctness",
        "commonWeaknessEnumeration": "398, 570, 571, 670",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/noConstantConditionRule.js",
        "ruleName": "no-constant-condition",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "no-construct": {
    "id": "./node_modules/tslint:no-construct",
    "description": "Disallows access to the constructors of `String`, `Number`, and `Boolean`.",
    "descriptionDetails": "Disallows constructor use such as `new Number(foo)` but does not disallow `Number(foo)`.",
    "rationale": "\nThere is little reason to use `String`, `Number`, or `Boolean` as constructors.\nIn almost all cases, the regular function-call version is more appropriate.\n[More details](http://stackoverflow.com/q/4719320/3124288) are available on StackOverflow.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-construct",
    "path": "./node_modules/tslint/lib/rules/noConstructRule.js",
    "ruleName": "no-construct",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-control-regex": {
    "id": "./node_modules/tslint-eslint-rules:no-control-regex",
    "documentation": "https://eslint.org/docs/rules/no-control-regex",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noControlRegexRule.js",
    "ruleName": "no-control-regex",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:no-control-regex",
        "type": "maintainability",
        "description": "Do not use control characters in regular expressions",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Warning",
        "severity": "Important",
        "level": "Opportunity for Excellence",
        "group": "Correctness",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/noControlRegexRule.js",
        "ruleName": "no-control-regex",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "no-cookies": {
    "id": "./node_modules/tslint-microsoft-contrib:no-cookies",
    "type": "maintainability",
    "description": "Do not use cookies",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "315, 539, 565, 614",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noCookiesRule.js",
    "ruleName": "no-cookies",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-debugger": {
    "id": "./node_modules/tslint:no-debugger",
    "description": "Disallows `debugger` statements.",
    "rationale": "In general, `debugger` statements aren't appropriate for production code.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-debugger",
    "path": "./node_modules/tslint/lib/rules/noDebuggerRule.js",
    "ruleName": "no-debugger",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-default-export": {
    "id": "./node_modules/tslint:no-default-export",
    "description": "Disallows default exports in ES6-style modules.",
    "descriptionDetails": "Use named exports instead.",
    "rationale": "\nNamed imports/exports [promote clarity](https://github.com/palantir/tslint/issues/1182#issue-151780453).\nIn addition, current tooling differs on the correct way to handle default imports/exports.\nAvoiding them all together can help avoid tooling bugs and conflicts.",
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-default-export",
    "path": "./node_modules/tslint/lib/rules/noDefaultExportRule.js",
    "ruleName": "no-default-export",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-default-import": {
    "id": "./node_modules/tslint:no-default-import",
    "description": "Disallows importing default members from certain ES6-style modules.",
    "descriptionDetails": "Import named members instead.",
    "rationale": "\nNamed imports/exports [promote clarity](https://github.com/palantir/tslint/issues/1182#issue-151780453).\nIn addition, current tooling differs on the correct way to handle default imports/exports.\nAvoiding them all together can help avoid tooling bugs and conflicts.\n\nThe rule supposed to narrow the scope of your changes in the case of monorepo.\nSay, you have packages `A`, `B`, `C` and `utils`, where `A`, `B`, `C` dependends on `utils`,\nwhich is full of default exports.\n`\"no-default-export\"` requires you to remove default _export_ from `utils`, which leads to changes\nin packages `A`, `B`, `C`. It's harder to get merged bigger changeset by various reasons (harder to get your code approved\ndue to a number of required reviewers; longer build time due to a number of affected packages)\nand could result in ignored `\"no-default-export\"` rule in `utils'`.\n\nUnlike `\"no-default-export\"`, the rule requires you to replace default _import_ with named only in `A` you work on,\nand `utils` you import from.",
    "optionsDescription": "optionsDescription",
    "options": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "fromModules": {
            "type": "string"
          }
        },
        "required": [
          "fromModules"
        ]
      }
    },
    "optionExamples": [
      [
        true,
        {
          "fromModules": "^palantir-|^_internal-*|^\\./|^\\.\\./"
        }
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-default-import",
    "path": "./node_modules/tslint/lib/rules/noDefaultImportRule.js",
    "ruleName": "no-default-import",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-delete-expression": {
    "id": "./node_modules/tslint-microsoft-contrib:no-delete-expression",
    "type": "maintainability",
    "description": "Do not delete expressions. Only properties should be deleted",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noDeleteExpressionRule.js",
    "ruleName": "no-delete-expression",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-disable-auto-sanitization": {
    "id": "./node_modules/tslint-microsoft-contrib:no-disable-auto-sanitization",
    "type": "maintainability",
    "description": "Do not disable auto-sanitization of HTML because this opens up your page to an XSS attack. ",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "157, 159, 75, 79, 85, 749, 676",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noDisableAutoSanitizationRule.js",
    "ruleName": "no-disable-auto-sanitization",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-document-domain": {
    "id": "./node_modules/tslint-microsoft-contrib:no-document-domain",
    "type": "maintainability",
    "description": "Do not write to document.domain. Scripts setting document.domain to any value should be validated to ensure that the value is on a list of allowed sites.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noDocumentDomainRule.js",
    "ruleName": "no-document-domain",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-document-write": {
    "id": "./node_modules/tslint-microsoft-contrib:no-document-write",
    "type": "maintainability",
    "description": "Do not use document.write",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "79, 85",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noDocumentWriteRule.js",
    "ruleName": "no-document-write",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-duplicate-case": {
    "id": "./node_modules/tslint-eslint-rules:no-duplicate-case",
    "documentation": "https://eslint.org/docs/rules/no-duplicate-case",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noDuplicateCaseRule.js",
    "ruleName": "no-duplicate-case",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:no-duplicate-case",
        "type": "maintainability",
        "description": "Do not use duplicate case labels in switch statements.",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Error",
        "severity": "Critical",
        "level": "Opportunity for Excellence",
        "recommendation": "false,",
        "group": "Deprecated",
        "commonWeaknessEnumeration": "398, 710",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/noDuplicateCaseRule.js",
        "ruleName": "no-duplicate-case",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "no-duplicate-imports": {
    "id": "./node_modules/tslint:no-duplicate-imports",
    "description": "\nDisallows multiple import statements from the same module.",
    "rationale": "\nUsing a single import statement per module will make the code clearer because you can see everything being imported\nfrom that module on one line.",
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-duplicate-imports",
    "path": "./node_modules/tslint/lib/rules/noDuplicateImportsRule.js",
    "ruleName": "no-duplicate-imports",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-duplicate-parameter-names": {
    "id": "./node_modules/tslint-microsoft-contrib:no-duplicate-parameter-names",
    "type": "maintainability",
    "description": "Deprecated - This rule is now enforced by the TypeScript compiler",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false, // now supported by TypeScript compiler",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noDuplicateParameterNamesRule.js",
    "ruleName": "no-duplicate-parameter-names",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-duplicate-super": {
    "id": "./node_modules/tslint:no-duplicate-super",
    "description": "Warns if 'super()' appears twice in a constructor.",
    "rationale": "The second call to 'super()' will fail at runtime.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-duplicate-super",
    "path": "./node_modules/tslint/lib/rules/noDuplicateSuperRule.js",
    "ruleName": "no-duplicate-super",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-duplicate-switch-case": {
    "id": "./node_modules/tslint:no-duplicate-switch-case",
    "description": "Prevents duplicate cases in switch statements.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-duplicate-switch-case",
    "path": "./node_modules/tslint/lib/rules/noDuplicateSwitchCaseRule.js",
    "ruleName": "no-duplicate-switch-case",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-duplicate-variable": {
    "id": "./node_modules/tslint:no-duplicate-variable",
    "description": "Disallows duplicate variable declarations in the same block scope.",
    "descriptionDetails": "\nThis rule is only useful when using the `var` keyword -\nthe compiler will detect redeclarations of `let` and `const` variables.",
    "rationale": "\nA variable can be reassigned if necessary -\nthere's no good reason to have a duplicate variable declaration.",
    "optionsDescription": "You can specify `\"check-parameters\"` to check for variables with the same name as a parameter.",
    "options": {
      "type": "string",
      "enum": [
        "check-parameters"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "check-parameters"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-duplicate-variable",
    "path": "./node_modules/tslint/lib/rules/noDuplicateVariableRule.js",
    "ruleName": "no-duplicate-variable",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-dynamic-delete": {
    "id": "./node_modules/tslint:no-dynamic-delete",
    "description": "Bans usage of the delete operator with computed key expressions.",
    "rationale": "\nDeleting dynamically computed keys is dangerous and not well optimized.\n\nAlso consider using a [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)\nor [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)\nif you're storing collections of objects.\nUsing `Object`s can cause occasional edge case bugs, such as if a key is named \"hasOwnProperty\".\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-dynamic-delete",
    "path": "./node_modules/tslint/lib/rules/noDynamicDeleteRule.js",
    "ruleName": "no-dynamic-delete",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-empty": {
    "id": "./node_modules/tslint:no-empty",
    "description": "Disallows empty blocks.",
    "descriptionDetails": "Blocks with a comment inside are not considered empty.",
    "rationale": "Empty blocks are often indicators of missing code.",
    "optionsDescription": "\nIf `allow-empty-catch` is specified, then catch blocks are allowed to be empty.\nIf `allow-empty-functions` is specified, then function definitions are allowed to be empty.",
    "options": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "string",
            "enum": [
              "allow-empty-catch"
            ]
          },
          {
            "type": "string",
            "enum": [
              "allow-empty-functions"
            ]
          }
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-empty-catch"
      ],
      [
        true,
        "allow-empty-functions"
      ],
      [
        true,
        "allow-empty-catch",
        "allow-empty-functions"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-empty",
    "path": "./node_modules/tslint/lib/rules/noEmptyRule.js",
    "ruleName": "no-empty",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-empty-character-class": {
    "id": "./node_modules/tslint-eslint-rules:no-empty-character-class",
    "documentation": "https://eslint.org/docs/rules/no-empty-character-class",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noEmptyCharacterClassRule.js",
    "ruleName": "no-empty-character-class",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-empty-interface": {
    "id": "./node_modules/tslint:no-empty-interface",
    "description": "Forbids empty interfaces.",
    "rationale": "An empty interface is equivalent to its supertype (or `{}`).",
    "type": "typescript",
    "typescriptOnly": true,
    "codeExamples": [
      {
        "description": "Disallows empty interfaces.",
        "config": "\n\"rules\": { \"no-empty-interface\": true }\n        ",
        "pass": "\ninterface I {\n    foo: string;\n}\n        ",
        "fail": "\ninterface I { }\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/no-empty-interface",
    "path": "./node_modules/tslint/lib/rules/noEmptyInterfaceRule.js",
    "ruleName": "no-empty-interface",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-empty-interfaces": {
    "id": "./node_modules/tslint-microsoft-contrib:no-empty-interfaces",
    "type": "maintainability",
    "description": "Do not use empty interfaces.",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false, // use tslint no-empty-interface rule instead",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noEmptyInterfacesRule.js",
    "ruleName": "no-empty-interfaces",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-empty-line-after-opening-brace": {
    "id": "./node_modules/tslint-microsoft-contrib:no-empty-line-after-opening-brace",
    "type": "maintainability",
    "description": "Avoid an empty line after an opening brace",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Whitespace",
    "recommendation": "false,",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noEmptyLineAfterOpeningBraceRule.js",
    "ruleName": "no-empty-line-after-opening-brace",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-eval": {
    "id": "./node_modules/tslint:no-eval",
    "description": "Disallows `eval` function invocations.",
    "rationale": "\n`eval()` is dangerous as it allows arbitrary code execution with full privileges. There are\n[alternatives](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval)\nfor most of the use cases for `eval()`.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-eval",
    "path": "./node_modules/tslint/lib/rules/noEvalRule.js",
    "ruleName": "no-eval",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-ex-assign": {
    "id": "./node_modules/tslint-eslint-rules:no-ex-assign",
    "documentation": "https://eslint.org/docs/rules/no-ex-assign",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noExAssignRule.js",
    "ruleName": "no-ex-assign",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-exec-script": {
    "id": "./node_modules/tslint-microsoft-contrib:no-exec-script",
    "type": "maintainability",
    "description": "Do not use the execScript functions",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95, 676",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noExecScriptRule.js",
    "ruleName": "no-exec-script",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-extra-boolean-cast": {
    "id": "./node_modules/tslint-eslint-rules:no-extra-boolean-cast",
    "documentation": "https://eslint.org/docs/rules/no-extra-boolean-cast",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noExtraBooleanCastRule.js",
    "ruleName": "no-extra-boolean-cast",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-extra-semi": {
    "id": "./node_modules/tslint-eslint-rules:no-extra-semi",
    "documentation": "https://eslint.org/docs/rules/no-extra-semi",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noExtraSemiRule.js",
    "ruleName": "no-extra-semi",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-floating-promises": {
    "id": "./node_modules/tslint:no-floating-promises",
    "description": "Promises returned by functions must be handled appropriately.",
    "descriptionDetails": "Unhandled Promises can cause unexpected behavior, such as resolving at unexpected times.",
    "optionsDescription": "\nA list of 'string' names of any additional classes that should also be handled as Promises.\n        ",
    "options": {
      "type": "list",
      "listType": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "JQueryPromise"
      ]
    ],
    "rationale": "\nCreating a Promise and not storing or returning it may let other code run independently of its result.\nThis can cause unexpected and/or non-deterministic behavior depending on external timing factors.\n\nIt's typically better to return Promises from functions that start them, then handle them in calling code.\n\nUse `no-unused-expression` in addition to this rule to reveal even more floating promises.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-floating-promises",
    "path": "./node_modules/tslint/lib/rules/noFloatingPromisesRule.js",
    "ruleName": "no-floating-promises",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-for-in": {
    "id": "./node_modules/tslint-microsoft-contrib:no-for-in",
    "type": "maintainability",
    "description": "Avoid use of for-in statements. They can be replaced by Object.keys",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noForInRule.js",
    "ruleName": "no-for-in",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-for-in-array": {
    "id": "./node_modules/tslint:no-for-in-array",
    "description": "Disallows iterating over an array with a for-in loop.",
    "descriptionDetails": "\nA for-in loop (`for (var k in o)`) iterates over the properties of an Object.\n\nWhile it is legal to use for-in loops with array types, it is not common.\nfor-in will iterate over the indices of the array as strings, omitting any \"holes\" in\nthe array.\n\nMore common is to use for-of, which iterates over the values of an array.\nIf you want to iterate over the indices, alternatives include:\n\narray.forEach((value, index) => { ... });\nfor (const [index, value] of array.entries()) { ... }\nfor (let i = 0; i < array.length; i++) { ... }\n",
    "requiresTypeInfo": true,
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-for-in-array",
    "path": "./node_modules/tslint/lib/rules/noForInArrayRule.js",
    "ruleName": "no-for-in-array",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-function-constructor-with-string-args": {
    "id": "./node_modules/tslint-microsoft-contrib:no-function-constructor-with-string-args",
    "type": "maintainability",
    "description": "Do not use the version of the Function constructor that accepts a string argument to define the body of the function",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95, 676, 242, 116",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noFunctionConstructorWithStringArgsRule.js",
    "ruleName": "no-function-constructor-with-string-args",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-function-expression": {
    "id": "./node_modules/tslint-microsoft-contrib:no-function-expression",
    "type": "maintainability",
    "description": "Do not use function expressions; use arrow functions (lambdas) instead.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noFunctionExpressionRule.js",
    "ruleName": "no-function-expression",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-http-string": {
    "id": "./node_modules/tslint-microsoft-contrib:no-http-string",
    "type": "maintainability",
    "description": "Do not use strings that start with 'http:'. URL strings should start with 'https:'. ",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "recommendation": "[true, \"http://www.example.com/?.*\", \"http://localhost:?.*\"],",
    "commonWeaknessEnumeration": "319",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noHttpStringRule.js",
    "ruleName": "no-http-string",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-implicit-dependencies": {
    "id": "./node_modules/tslint:no-implicit-dependencies",
    "description": "Disallows importing modules that are not listed as dependency in the project's package.json",
    "descriptionDetails": "\nDisallows importing transient dependencies and modules installed above your package's root directory.\n        ",
    "optionsDescription": "\nBy default the rule looks at `\"dependencies\"` and `\"peerDependencies\"`.\nBy adding the `\"dev\"` option the rule also looks at `\"devDependencies\"`.\nBy adding the `\"optional\"` option the rule also looks at `\"optionalDependencies\"`.\nAn array of whitelisted modules can be added to skip checking their existence in package.json.\n        ",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string",
          "enum": [
            "dev",
            "optional"
          ]
        },
        {
          "type": "array"
        }
      ],
      "minItems": 0,
      "maxItems": 3
    },
    "optionExamples": [
      true,
      [
        true,
        "dev"
      ],
      [
        true,
        "optional"
      ],
      [
        true,
        [
          "src",
          "app"
        ]
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-implicit-dependencies",
    "path": "./node_modules/tslint/lib/rules/noImplicitDependenciesRule.js",
    "ruleName": "no-implicit-dependencies",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-import-side-effect": {
    "id": "./node_modules/tslint:no-import-side-effect",
    "description": "Avoid import statements with side-effect.",
    "optionExamples": [
      true,
      [
        true,
        {
          "ignore-module": "(\\.html|\\.css)$"
        }
      ]
    ],
    "options": {
      "items": {
        "properties": {
          "ignore-module": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "maxLength": 1,
      "minLength": 0,
      "type": "array"
    },
    "optionsDescription": "\nOne argument may be optionally provided:\n\n* `ignore-module` allows to specify a regex and ignore modules which it matches.",
    "rationale": "Imports with side effects may have behavior which is hard for static verification.",
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-import-side-effect",
    "path": "./node_modules/tslint/lib/rules/noImportSideEffectRule.js",
    "ruleName": "no-import-side-effect",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-increment-decrement": {
    "id": "./node_modules/tslint-microsoft-contrib:no-increment-decrement",
    "type": "maintainability",
    "description": "Avoid use of increment and decrement operators particularly as part of complicated expressions",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-for-loops"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionsDescription": "One argument may be optionally provided: \n\n' +\n        '* `allow-for-loops` allows increments and decrement operators to be used in for loop headers.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noIncrementDecrementRule.js",
    "ruleName": "no-increment-decrement",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-inferrable-types": {
    "id": "./node_modules/tslint:no-inferrable-types",
    "description": "Disallows explicit type declarations for variables or parameters initialized to a number, string, or boolean.",
    "rationale": "Explicit types where they can be easily inferred by the compiler make code more verbose.",
    "optionsDescription": "\nTwo arguments may be optionally provided:\n\n* `ignore-params` allows specifying an inferrable type annotation for function params.\nThis can be useful when combining with the `typedef` rule.\n* `ignore-properties` allows specifying an inferrable type annotation for class properties.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "ignore-params",
          "ignore-properties"
        ]
      },
      "minLength": 0,
      "maxLength": 2
    },
    "hasFix": true,
    "optionExamples": [
      true,
      [
        true,
        "ignore-params"
      ],
      [
        true,
        "ignore-params",
        "ignore-properties"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-inferrable-types",
    "path": "./node_modules/tslint/lib/rules/noInferrableTypesRule.js",
    "ruleName": "no-inferrable-types",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-inferred-empty-object-type": {
    "id": "./node_modules/tslint:no-inferred-empty-object-type",
    "description": "Disallow type inference of {} (empty object type) at function and constructor call sites",
    "rationale": "\nWhen function or constructor may be called with a type parameter but one isn't supplied or inferrable,\nTypeScript defaults to `{}`.\nThis is often undesirable as the call is meant to be of a more specific type.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-inferred-empty-object-type",
    "path": "./node_modules/tslint/lib/rules/noInferredEmptyObjectTypeRule.js",
    "ruleName": "no-inferred-empty-object-type",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-inner-declarations": {
    "id": "./node_modules/tslint-eslint-rules:no-inner-declarations",
    "documentation": "https://eslint.org/docs/rules/no-inner-declarations",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noInnerDeclarationsRule.js",
    "ruleName": "no-inner-declarations",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-inner-html": {
    "id": "./node_modules/tslint-microsoft-contrib:no-inner-html",
    "type": "maintainability",
    "description": "Do not write values to innerHTML, outerHTML, or set HTML using the JQuery html() function.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "79, 85, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noInnerHtmlRule.js",
    "ruleName": "no-inner-html",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-internal-module": {
    "id": "./node_modules/tslint:no-internal-module",
    "description": "Disallows internal `module`",
    "rationale": "Using `module` leads to a confusion of concepts with external modules. Use the newer `namespace` keyword instead.",
    "type": "typescript",
    "typescriptOnly": true,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-internal-module",
    "path": "./node_modules/tslint/lib/rules/noInternalModuleRule.js",
    "ruleName": "no-internal-module",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-invalid-regexp": {
    "id": "./node_modules/tslint-eslint-rules:no-invalid-regexp",
    "documentation": "https://eslint.org/docs/rules/no-invalid-regexp",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noInvalidRegexpRule.js",
    "ruleName": "no-invalid-regexp",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:no-invalid-regexp",
        "type": "maintainability",
        "description": "Do not use invalid regular expression strings in the RegExp constructor.",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Error",
        "severity": "Critical",
        "level": "Opportunity for Excellence",
        "group": "Correctness",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/noInvalidRegexpRule.js",
        "ruleName": "no-invalid-regexp",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "no-invalid-template-strings": {
    "id": "./node_modules/tslint:no-invalid-template-strings",
    "description": "Warns on use of `${` in non-template strings.",
    "rationale": "Interpolation will only work for template strings.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-invalid-template-strings",
    "path": "./node_modules/tslint/lib/rules/noInvalidTemplateStringsRule.js",
    "ruleName": "no-invalid-template-strings",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-invalid-this": {
    "id": "./node_modules/tslint:no-invalid-this",
    "description": "Disallows using the `this` keyword outside of classes.",
    "rationale": "See [the rule's author's rationale here.](https://github.com/palantir/tslint/pull/1105#issue-147549402)",
    "optionsDescription": "\nOne argument may be optionally provided:\n\n* `check-function-in-method` disallows using the `this` keyword in functions within class methods.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "check-function-in-method"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionExamples": [
      true,
      [
        true,
        "check-function-in-method"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-invalid-this",
    "path": "./node_modules/tslint/lib/rules/noInvalidThisRule.js",
    "ruleName": "no-invalid-this",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-irregular-whitespace": {
    "id": "./node_modules/tslint:no-irregular-whitespace",
    "description": "Disallow irregular whitespace within a file, including strings and comments.",
    "hasFix": true,
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-irregular-whitespace",
    "path": "./node_modules/tslint/lib/rules/noIrregularWhitespaceRule.js",
    "ruleName": "no-irregular-whitespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-jquery-raw-elements": {
    "id": "./node_modules/tslint-microsoft-contrib:no-jquery-raw-elements",
    "type": "maintainability",
    "description": "Do not create HTML elements using JQuery and string concatenation. It is error prone and can hide subtle defects.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noJqueryRawElementsRule.js",
    "ruleName": "no-jquery-raw-elements",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-magic-numbers": {
    "id": "./node_modules/tslint:no-magic-numbers",
    "description": "\nDisallows 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.",
    "rationale": "\nMagic numbers should be avoided as they often lack documentation.\nForcing them to be stored in variables gives them implicit documentation.\n        ",
    "optionsDescription": "\nOptions may either be a list of numbers to ignore (not consider 'magic'), or an object containing up to two properties:\n* `allowed-numbers` as the list of numbers to ignore.\n* `ignore-jsx` to specify that 'magic' numbers should be allowed as JSX attributes.",
    "options": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "properties": {
        "type": "object",
        "allowed-numbers": {
          "type": "array"
        },
        "ignore-jsx": {
          "type": "boolean"
        }
      },
      "minLength": 1
    },
    "optionExamples": [
      [
        true,
        1,
        2,
        3
      ],
      [
        true,
        {
          "allowed-numbers": [
            1,
            2,
            3
          ],
          "ignore-jsx": true
        }
      ]
    ],
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-magic-numbers",
    "path": "./node_modules/tslint/lib/rules/noMagicNumbersRule.js",
    "ruleName": "no-magic-numbers",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-mergeable-namespace": {
    "id": "./node_modules/tslint:no-mergeable-namespace",
    "description": "Disallows mergeable namespaces in the same file.",
    "type": "maintainability",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-mergeable-namespace",
    "path": "./node_modules/tslint/lib/rules/noMergeableNamespaceRule.js",
    "ruleName": "no-mergeable-namespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-missing-visibility-modifiers": {
    "id": "./node_modules/tslint-microsoft-contrib:no-missing-visibility-modifiers",
    "type": "maintainability",
    "description": "Deprecated - This rule is in the TSLint product as `member-access`",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false, // use tslint member-access rule instead",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noMissingVisibilityModifiersRule.js",
    "ruleName": "no-missing-visibility-modifiers",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-misused-new": {
    "id": "./node_modules/tslint:no-misused-new",
    "description": "Warns on apparent attempts to define constructors for interfaces or `new` for classes.",
    "rationale": "\nInterfaces in TypeScript aren't meant to describe constructors on their implementations.\nThe `new` descriptor is primarily for describing JavaScript libraries.\nIf you're trying to describe a function known to be a class, it's typically better to `declare class`.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-misused-new",
    "path": "./node_modules/tslint/lib/rules/noMisusedNewRule.js",
    "ruleName": "no-misused-new",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-multi-spaces": {
    "id": "./node_modules/tslint-eslint-rules:no-multi-spaces",
    "documentation": "https://eslint.org/docs/rules/no-multi-spaces",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noMultiSpacesRule.js",
    "ruleName": "no-multi-spaces",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-multiline-string": {
    "id": "./node_modules/tslint-microsoft-contrib:no-multiline-string",
    "type": "maintainability",
    "description": "Do not declare multiline strings",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "recommendation": "false,",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noMultilineStringRule.js",
    "ruleName": "no-multiline-string",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-multiple-var-decl": {
    "id": "./node_modules/tslint-microsoft-contrib:no-multiple-var-decl",
    "type": "maintainability",
    "description": "Deprecated - This rule is now part of the base TSLint product as the rule named 'one-variable-per-declaration'",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false, // use tslint one-variable-per-declaration rule instead",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noMultipleVarDeclRule.js",
    "ruleName": "no-multiple-var-decl",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-namespace": {
    "id": "./node_modules/tslint:no-namespace",
    "description": "Disallows use of internal `module`s and `namespace`s.",
    "descriptionDetails": "This rule still allows the use of `declare module ... {}`",
    "rationale": "\nES6-style external modules are the standard way to modularize code.\nUsing `module {}` and `namespace {}` are outdated ways to organize TypeScript code.",
    "optionsDescription": "\nOne argument may be optionally provided:\n\n* `allow-declarations` allows `declare namespace ... {}` to describe external APIs.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-declarations"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-declarations"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-namespace",
    "path": "./node_modules/tslint/lib/rules/noNamespaceRule.js",
    "ruleName": "no-namespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-non-null-assertion": {
    "id": "./node_modules/tslint:no-non-null-assertion",
    "description": "Disallows non-null assertions using the `!` postfix operator.",
    "rationale": "\nUsing non-null assertion cancels the benefits of the strict null checking mode.\n\nInstead of assuming objects exist:\n\n```\nfunction foo(instance: MyClass | undefined) {\n    instance!.doWork();\n}\n```\n\nEither inform the strict type system that the object must exist:\n\n```\nfunction foo(instance: MyClass) {\n    instance.doWork();\n}\n```\n\nOr verify that the instance exists, which will inform the type checker:\n\n```\nfunction foo(instance: MyClass | undefined) {\n    if (instance !== undefined) {\n        instance.doWork();\n    }\n}\n```\n        ",
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-non-null-assertion",
    "path": "./node_modules/tslint/lib/rules/noNonNullAssertionRule.js",
    "ruleName": "no-non-null-assertion",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-null-keyword": {
    "id": "./node_modules/tslint:no-null-keyword",
    "description": "Disallows use of the `null` keyword literal.",
    "rationale": "\nInstead of having the dual concepts of `null` and`undefined` in a codebase,\nthis rule ensures that only `undefined` is used.\n\nJavaScript originally intended `undefined` to refer to a value that doesn't yet exist,\nwhile `null` was meant to refer to a value that does exist but points to nothing.\nThat's confusing.\n`undefined` is the default value when object members don't exist, and is the return value\nfor newer native collection APIs such as `Map.get` when collection values don't exist.\n\n```\nconst myObject = {};\nmyObject.doesNotExist; // undefined\n```\n\n```\nconst myMap = new Map<string, number>();\nmyMap.get(\"doesNotExist\"); // undefined\n```\n\nTo remove confusion over the two similar values, it's better to stick with just `undefined`.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-null-keyword",
    "path": "./node_modules/tslint/lib/rules/noNullKeywordRule.js",
    "ruleName": "no-null-keyword",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-object-literal-type-assertion": {
    "id": "./node_modules/tslint:no-object-literal-type-assertion",
    "description": "\nForbids an object literal to appear in a type assertion expression.\nCasting to `any` or to `unknown` is still allowed.",
    "rationale": "\nAlways prefer `const x: T = { ... };` to `const x = { ... } as T;`.\nThe type assertion in the latter case is either unnecessary or hides an error.\nThe compiler will warn for excess properties with this syntax, but not missing required fields.\nFor example: `const x: { foo: number } = {}` will fail to compile, but\n`const x = {} as { foo: number }` will succeed.",
    "type": "functionality",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-object-literal-type-assertion",
    "path": "./node_modules/tslint/lib/rules/noObjectLiteralTypeAssertionRule.js",
    "ruleName": "no-object-literal-type-assertion",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-octal-literal": {
    "id": "./node_modules/tslint-microsoft-contrib:no-octal-literal",
    "type": "maintainability",
    "description": "Do not use octal literals or escaped octal sequences",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noOctalLiteralRule.js",
    "ruleName": "no-octal-literal",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-parameter-properties": {
    "id": "./node_modules/tslint:no-parameter-properties",
    "description": "Disallows parameter properties in class constructors.",
    "rationale": "\nParameter properties can be confusing to those new to TS as they are less explicit\nthan other ways of declaring and initializing class members.\n\nIt can be cleaner to keep member variable declarations in one list directly only the class\n(instead of mixed between direct class members and constructor parameter properties).\n        ",
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-parameter-properties",
    "path": "./node_modules/tslint/lib/rules/noParameterPropertiesRule.js",
    "ruleName": "no-parameter-properties",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-parameter-reassignment": {
    "id": "./node_modules/tslint:no-parameter-reassignment",
    "description": "Disallows reassigning parameters.",
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-parameter-reassignment",
    "path": "./node_modules/tslint/lib/rules/noParameterReassignmentRule.js",
    "ruleName": "no-parameter-reassignment",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-redundant-jsdoc": {
    "id": "./node_modules/tslint:no-redundant-jsdoc",
    "description": "Forbids JSDoc which duplicates TypeScript functionality.",
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-redundant-jsdoc",
    "path": "./node_modules/tslint/lib/rules/noRedundantJsdocRule.js",
    "ruleName": "no-redundant-jsdoc",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-reference": {
    "id": "./node_modules/tslint:no-reference",
    "description": "Disallows `/// <reference path=>` imports (use ES6-style imports instead).",
    "rationale": "\nUsing `/// <reference path=>` comments to load other files is outdated.\nUse ES6-style imports to reference other files.",
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-reference",
    "path": "./node_modules/tslint/lib/rules/noReferenceRule.js",
    "ruleName": "no-reference",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-reference-import": {
    "id": "./node_modules/tslint:no-reference-import",
    "description": "Don't `<reference types=\"foo\" />` if you import `foo` anyway.",
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-reference-import",
    "path": "./node_modules/tslint/lib/rules/noReferenceImportRule.js",
    "ruleName": "no-reference-import",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-regex-spaces": {
    "id": "./node_modules/tslint-eslint-rules:no-regex-spaces",
    "documentation": "https://eslint.org/docs/rules/no-regex-spaces",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noRegexSpacesRule.js",
    "ruleName": "no-regex-spaces",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:no-regex-spaces",
        "type": "maintainability",
        "description": "Do not use multiple spaces in a regular expression literal. Similar to the ESLint no-regex-spaces rule",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Error",
        "severity": "Critical",
        "level": "Opportunity for Excellence",
        "group": "Correctness",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/noRegexSpacesRule.js",
        "ruleName": "no-regex-spaces",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "no-relative-imports": {
    "id": "./node_modules/tslint-microsoft-contrib:no-relative-imports",
    "type": "maintainability",
    "description": "Do not use relative paths when importing external modules or ES6 import declarations",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-siblings"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionsDescription": "One argument may be optionally provided: \n\n' +\n            '* `allow-siblings` allows relative imports for files in the same or nested folders.",
    "typescriptOnly": false,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noRelativeImportsRule.js",
    "ruleName": "no-relative-imports",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-require-imports": {
    "id": "./node_modules/tslint:no-require-imports",
    "description": "Disallows invocation of `require()`.",
    "rationale": "Prefer the newer ES6-style imports over `require()`.",
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-require-imports",
    "path": "./node_modules/tslint/lib/rules/noRequireImportsRule.js",
    "ruleName": "no-require-imports",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-reserved-keywords": {
    "id": "./node_modules/tslint-microsoft-contrib:no-reserved-keywords",
    "type": "maintainability",
    "description": "Do not use reserved keywords as names of local variables, fields, functions, or other identifiers.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "398",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noReservedKeywordsRule.js",
    "ruleName": "no-reserved-keywords",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-restricted-globals": {
    "id": "./node_modules/tslint:no-restricted-globals",
    "description": "Disallow specific global variables.",
    "rationale": "\n```ts\nfunction broken(evt: Event) {\n    // Meant to do something with `evt` but typed it incorrectly.\n    Event.target;  // compiler error\n    event.target;  // should be a lint failure\n}\n\nEarly Internet Explorer versions exposed the current DOM event as a global variable 'event',\nbut using this variable has been considered a bad practice for a long time.\nRestricting this will make sure this variable isn’t used in browser code.\n```\n        ",
    "descriptionDetails": "\nDisallowing usage of specific global variables can be useful if you want to allow\na set of global variables by enabling an environment, but still want to disallow\nsome of those.\n        ",
    "optionsDescription": "\nThis rule takes a list of strings, where each string is a global to be restricted.\n`event`, `name` and `length` are restricted by default.\n        ",
    "options": {
      "type": "list",
      "items": {
        "type": "string"
      }
    },
    "optionExamples": [
      [
        true,
        "name",
        "length",
        "event"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-restricted-globals",
    "path": "./node_modules/tslint/lib/rules/noRestrictedGlobalsRule.js",
    "ruleName": "no-restricted-globals",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-return-await": {
    "id": "./node_modules/tslint:no-return-await",
    "description": "Disallows unnecessary `return await`.",
    "rationale": "\nAn async function always wraps the return value in a Promise.\nUsing `return await` just adds extra time before the overreaching promise is resolved without changing the semantics.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-return-await",
    "path": "./node_modules/tslint/lib/rules/noReturnAwaitRule.js",
    "ruleName": "no-return-await",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-shadowed-variable": {
    "id": "./node_modules/tslint:no-shadowed-variable",
    "description": "Disallows shadowing variable declarations.",
    "rationale": "\nWhen a variable in a local scope and a variable in the containing scope have the same name, shadowing occurs.\nShadowing makes it impossible to access the variable in the containing scope and\nobscures to what value an identifier actually refers. Compare the following snippets:\n\n```\nconst a = 'no shadow';\nfunction print() {\n    console.log(a);\n}\nprint(); // logs 'no shadow'.\n```\n\n```\nconst a = 'no shadow';\nfunction print() {\n    const a = 'shadow'; // TSLint will complain here.\n    console.log(a);\n}\nprint(); // logs 'shadow'.\n```\n\nESLint has [an equivalent rule](https://eslint.org/docs/rules/no-shadow).\nFor more background information, refer to\n[this MDN closure doc](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures#Lexical_scoping).\n        ",
    "optionsDescription": "\nYou can optionally pass an object to disable checking for certain kinds of declarations.\nPossible keys are `\"class\"`, `\"enum\"`, `\"function\"`, `\"import\"`, `\"interface\"`, `\"namespace\"`, `\"typeAlias\"`\nand `\"typeParameter\"`. Just set the value to `false` for the check you want to disable.\nAll checks default to `true`, i.e. are enabled by default.\nNote that you cannot disable variables and parameters.\n\nThe option `\"temporalDeadZone\"` defaults to `true` which shows errors when shadowing block scoped declarations in their\ntemporal dead zone. When set to `false` parameters, classes, enums and variables declared\nwith `let` or `const` are not considered shadowed if the shadowing occurs within their\n[temporal dead zone](http://jsrocks.org/2015/01/temporal-dead-zone-tdz-demystified).\n\nThe following example shows how the `\"temporalDeadZone\"` option changes the linting result:\n\n```ts\nfunction fn(value) {\n    if (value) {\n        const tmp = value; // no error on this line if \"temporalDeadZone\" is false\n        return tmp;\n    }\n    let tmp = undefined;\n    if (!value) {\n        const tmp = value; // this line always contains an error\n        return tmp;\n    }\n}\n```\n        ",
    "options": {
      "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"
        },
        "temporalDeadZone": {
          "type": "boolean"
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "class": true,
          "enum": true,
          "function": true,
          "interface": false,
          "namespace": true,
          "typeAlias": false,
          "typeParameter": false
        }
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-shadowed-variable",
    "path": "./node_modules/tslint/lib/rules/noShadowedVariableRule.js",
    "ruleName": "no-shadowed-variable",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-single-line-block-comment": {
    "id": "./node_modules/tslint-microsoft-contrib:no-single-line-block-comment",
    "type": "maintainability",
    "description": "Avoid single line block comments; use single line comments instead",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Whitespace",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noSingleLineBlockCommentRule.js",
    "ruleName": "no-single-line-block-comment",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-sparse-arrays": {
    "id": "./node_modules/tslint:no-sparse-arrays",
    "description": "Forbids array literals to contain missing elements.",
    "rationale": "Missing elements are probably an accidentally duplicated comma.",
    "type": "functionality",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Disallows sparse arrays",
        "config": "\n\"rules\": { \"no-sparse-arrays\": true }\n        ",
        "pass": "\nconst arr: string[] = ['elemenet1', 'element2'];\n        ",
        "fail": "\nconst arr: string[] = ['elemenet1',, 'element2'];\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/no-sparse-arrays",
    "path": "./node_modules/tslint/lib/rules/noSparseArraysRule.js",
    "ruleName": "no-sparse-arrays",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-stateless-class": {
    "id": "./node_modules/tslint-microsoft-contrib:no-stateless-class",
    "type": "maintainability",
    "description": "A stateless class represents a failure in the object oriented design of the system.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "recommendation": "false,",
    "group": "Deprecated",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noStatelessClassRule.js",
    "ruleName": "no-stateless-class",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-string-based-set-immediate": {
    "id": "./node_modules/tslint-microsoft-contrib:no-string-based-set-immediate",
    "type": "maintainability",
    "description": "Do not use the version of setImmediate that accepts code as a string argument.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95, 676, 242, 116",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noStringBasedSetImmediateRule.js",
    "ruleName": "no-string-based-set-immediate",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-string-based-set-interval": {
    "id": "./node_modules/tslint-microsoft-contrib:no-string-based-set-interval",
    "type": "maintainability",
    "description": "Do not use the version of setInterval that accepts code as a string argument.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95, 676, 242, 116",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noStringBasedSetIntervalRule.js",
    "ruleName": "no-string-based-set-interval",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-string-based-set-timeout": {
    "id": "./node_modules/tslint-microsoft-contrib:no-string-based-set-timeout",
    "type": "maintainability",
    "description": "Do not use the version of setTimeout that accepts code as a string argument.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95, 676, 242, 116",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noStringBasedSetTimeoutRule.js",
    "ruleName": "no-string-based-set-timeout",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-string-literal": {
    "id": "./node_modules/tslint:no-string-literal",
    "description": "\nForbids unnecessary string literal property access.\nAllows `obj[\"prop-erty\"]` (can't be a regular property access).\nDisallows `obj[\"property\"]` (should be `obj.property`).",
    "rationale": "\nIf `--noImplicitAny` is turned off,\nproperty access via a string literal will be 'any' if the property does not exist.",
    "type": "functionality",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-string-literal",
    "path": "./node_modules/tslint/lib/rules/noStringLiteralRule.js",
    "ruleName": "no-string-literal",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-string-throw": {
    "id": "./node_modules/tslint:no-string-throw",
    "description": "Flags throwing plain strings or concatenations of strings.",
    "hasFix": true,
    "rationale": "\nExample – Doing it right\n\n```ts\n// throwing an Error from typical function, whether sync or async\nif (!productToAdd) {\n    throw new Error(\"How can I add new product when no value provided?\");\n}\n```\n\nExample – Anti Pattern\n\n```ts\n// throwing a string lacks any stack trace information and other important data properties\nif (!productToAdd) {\n    throw (\"How can I add new product when no value provided?\");\n}\n```\n\nOnly Error objects contain a `.stack` member equivalent to the current stack trace.\nPrimitives such as strings do not.\n        ",
    "codeExamples": [
      {
        "description": "Flags throwing plain strings or concatenations of strings.",
        "config": "\n\"rules\": { \"no-string-throw\": true }\n        ",
        "pass": "\ntry {\n    // ...\n} catch (e) {\n    throw e;\n}\n        ",
        "fail": "\ntry {\n    // ...\n} catch {\n    throw 'There was a problem.';\n}\n        "
      }
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-string-throw",
    "path": "./node_modules/tslint/lib/rules/noStringThrowRule.js",
    "ruleName": "no-string-throw",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-submodule-imports": {
    "id": "./node_modules/tslint:no-submodule-imports",
    "description": "\nDisallows importing any submodule.",
    "rationale": "\nSubmodules of some packages are treated as private APIs and the import\npaths may change without deprecation periods. It's best to stick with\ntop-level package exports.",
    "optionsDescription": "A list of whitelisted package or submodule names.",
    "options": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "rxjs",
        "@angular/platform-browser",
        "@angular/core/testing"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-submodule-imports",
    "path": "./node_modules/tslint/lib/rules/noSubmoduleImportsRule.js",
    "ruleName": "no-submodule-imports",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-suspicious-comment": {
    "id": "./node_modules/tslint-microsoft-contrib:no-suspicious-comment",
    "type": "maintainability",
    "description": "Do not use suspicious comments, such as BUG, HACK, FIXME, LATER, LATER2, TODO",
    "options": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "optionsDescription": "One argument may be optionally provided: \n\n' +\n            '* an array of regex that disable the warning if one or several of them\n            are found in the comment text. (Example: `['https://github.com/my-org/my-project/*']`)",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "546",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noSuspiciousCommentRule.js",
    "ruleName": "no-suspicious-comment",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-switch-case-fall-through": {
    "id": "./node_modules/tslint:no-switch-case-fall-through",
    "description": "Disallows falling through case statements.",
    "descriptionDetails": "\nFor example, the following is not allowed:\n\n```ts\nswitch(foo) {\n    case 1:\n        someFunc(foo);\n    case 2:\n        someOtherFunc(foo);\n}\n```\n\nHowever, fall through is allowed when case statements are consecutive or\na magic `/* falls through */` comment is present. The following is valid:\n\n```ts\nswitch(foo) {\n    case 1:\n        someFunc(foo);\n        /* falls through */\n    case 2:\n    case 3:\n        someOtherFunc(foo);\n}\n```",
    "rationale": "Fall though in switch statements is often unintentional and a bug.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-switch-case-fall-through",
    "path": "./node_modules/tslint/lib/rules/noSwitchCaseFallThroughRule.js",
    "ruleName": "no-switch-case-fall-through",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-this-assignment": {
    "id": "./node_modules/tslint:no-this-assignment",
    "description": "Disallows unnecessary references to `this`.",
    "optionExamples": [
      true,
      [
        true,
        {
          "allowed-names": [
            "^self$"
          ],
          "allow-destructuring": true
        }
      ]
    ],
    "options": {
      "additionalProperties": false,
      "properties": {
        "allow-destructuring": {
          "type": "boolean"
        },
        "allowed-names": {
          "listType": "string",
          "type": "list"
        }
      },
      "type": "object"
    },
    "optionsDescription": "\nTwo options may be provided on an object:\n\n* `allow-destructuring` allows using destructuring to access members of `this` (e.g. `{ foo, bar } = this;`).\n* `allowed-names` may be specified as a list of regular expressions to match allowed variable names.",
    "rationale": "\nAssigning a variable to `this` instead of properly using arrow lambdas may be a symptom of pre-ES6 practices\nor not managing scope well.\n\nInstead of storing a reference to `this` and using it inside a `function () {`:\n\n```\nconst self = this;\n\nsetTimeout(function () {\n    self.doWork();\n});\n```\n\nUse `() =>` arrow lambdas, as they preserve `this` scope for you:\n\n```\nsetTimeout(() => {\n    this.doWork();\n});\n```\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-this-assignment",
    "path": "./node_modules/tslint/lib/rules/noThisAssignmentRule.js",
    "ruleName": "no-this-assignment",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-trailing-whitespace": {
    "id": "./node_modules/tslint:no-trailing-whitespace",
    "description": "Disallows trailing whitespace at the end of a line.",
    "rationale": "Keeps version control diffs clean as it prevents accidental whitespace from being committed.",
    "optionsDescription": "\nPossible settings are:\n\n* `\"ignore-template-strings\"`: Allows trailing whitespace in template strings.\n* `\"ignore-comments\"`: Allows trailing whitespace in comments.\n* `\"ignore-jsdoc\"`: Allows trailing whitespace only in JSDoc comments.\n* `\"ignore-blank-lines\"`: Allows trailing whitespace on empty lines.",
    "hasFix": true,
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "ignore-comments",
          "ignore-jsdoc",
          "ignore-template-strings",
          "ignore-blank-lines"
        ]
      }
    },
    "optionExamples": [
      true,
      [
        true,
        "ignore-comments"
      ],
      [
        true,
        "ignore-jsdoc"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-trailing-whitespace",
    "path": "./node_modules/tslint/lib/rules/noTrailingWhitespaceRule.js",
    "ruleName": "no-trailing-whitespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-typeof-undefined": {
    "id": "./node_modules/tslint-microsoft-contrib:no-typeof-undefined",
    "type": "maintainability",
    "description": "Do not use the idiom typeof `x === 'undefined'`. You can safely use the simpler x === undefined or perhaps x == null if you want to check for either null or undefined.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noTypeofUndefinedRule.js",
    "ruleName": "no-typeof-undefined",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unbound-method": {
    "id": "./node_modules/tslint:no-unbound-method",
    "description": "Warns when a method is used outside of a method call.",
    "optionsDescription": "\nYou may additionally pass \"ignore-static\" to ignore static methods, or an options object.\n\nThe object may have three properties:\n\n* \"ignore-static\" - to ignore static methods.\n* \"allow-typeof\" - ignore methods referenced in a typeof expression.\n* \"whitelist\" - ignore method references in parameters of specifed function calls.\n\n",
    "options": {
      "anyOf": [
        {
          "type": "string",
          "enum": [
            "ignore-static"
          ]
        },
        {
          "type": "object",
          "properties": {
            "allow-typeof": {
              "type": "boolean"
            },
            "ignore-static": {
              "type": "boolean"
            },
            "whitelist": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "minLength": 1
            }
          }
        }
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "ignore-static"
      ],
      [
        true,
        {
          "ignore-static": true,
          "whitelist": [
            "expect"
          ],
          "allow-typeof": true
        }
      ]
    ],
    "rationale": "\nClass functions don't preserve the class scope when passed as standalone variables.\nFor example, this code will log the global scope (`window`/`global`), not the class instance:\n\n```\nclass MyClass {\n    public log(): void {\n        console.log(this);\n    }\n}\n\nconst instance = new MyClass();\nconst log = instance.log;\n\nlog();\n```\n\nYou need to either use an arrow lambda (`() => {...}`) or call the function with the correct scope.\n\n```\nclass MyClass {\n    public logArrowBound = (): void => {\n        console.log(bound);\n    };\n\n    public logManualBind(): void {\n        console.log(this);\n    }\n}\n\nconst instance = new MyClass();\nconst logArrowBound = instance.logArrowBound;\nconst logManualBind = instance.logManualBind.bind(instance);\n\nlogArrowBound();\nlogManualBind();\n```\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-unbound-method",
    "path": "./node_modules/tslint/lib/rules/noUnboundMethodRule.js",
    "ruleName": "no-unbound-method",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unexpected-multiline": {
    "id": "./node_modules/tslint-eslint-rules:no-unexpected-multiline",
    "documentation": "https://eslint.org/docs/rules/no-unexpected-multiline",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/noUnexpectedMultilineRule.js",
    "ruleName": "no-unexpected-multiline",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "no-unexternalized-strings": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unexternalized-strings",
    "type": "maintainability",
    "description": "Ensures that double quoted strings are passed to a localize call to provide proper strings for different locales",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Configurable",
    "recommendation": "false, // the VS Code team has a specific localization process that this rule enforces",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnexternalizedStringsRule.js",
    "ruleName": "no-unexternalized-strings",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-bind": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unnecessary-bind",
    "type": "maintainability",
    "description": "Do not bind `this` as the context for a function literal or lambda expression.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnnecessaryBindRule.js",
    "ruleName": "no-unnecessary-bind",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-callback-wrapper": {
    "id": "./node_modules/tslint:no-unnecessary-callback-wrapper",
    "description": "\nReplaces `x => f(x)` with just `f`.\nTo catch more cases, enable `only-arrow-functions` and `arrow-return-shorthand` too.",
    "rationale": "\nThere's generally no reason to wrap a function with a callback wrapper if it's directly called anyway.\nDoing so creates extra inline lambdas that slow the runtime down.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Disallows unnecessary callback wrappers",
        "config": "\n\"rules\": { \"no-unnecessary-callback-wrapper\": true }\n        ",
        "pass": "\nconst handleContent = (content) => console.log('Handle content:', content);\nconst handleError = (error) => console.log('Handle error:', error);\npromise.then(handleContent).catch(handleError);\n        ",
        "fail": "\nconst handleContent = (content) => console.log('Handle content:', content);\nconst handleError = (error) => console.log('Handle error:', error);\npromise.then((content) => handleContent(content)).catch((error) => handleError(error));\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/no-unnecessary-callback-wrapper",
    "path": "./node_modules/tslint/lib/rules/noUnnecessaryCallbackWrapperRule.js",
    "ruleName": "no-unnecessary-callback-wrapper",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unnecessary-class": {
    "id": "./node_modules/tslint:no-unnecessary-class",
    "description": "\nDisallows classes that are not strictly necessary.",
    "rationale": "\nUsers who come from a Java-style OO language may wrap\ntheir utility functions in an extra class, instead of\nputting them at the top level.",
    "optionsDescription": "\nThree arguments may be optionally provided:\n\n* `\"allow-constructor-only\"` ignores classes whose members are constructors.\n* `\"allow-empty-class\"` ignores `class DemoClass {}`.\n* `\"allow-static-only\"` ignores classes whose members are static.",
    "options": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "minLength": 0,
      "maxLength": 3
    },
    "optionExamples": [
      true,
      [
        "allow-empty-class",
        "allow-constructor-only"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-unnecessary-class",
    "path": "./node_modules/tslint/lib/rules/noUnnecessaryClassRule.js",
    "ruleName": "no-unnecessary-class",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unnecessary-field-initialization": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unnecessary-field-initialization",
    "type": "maintainability",
    "description": "Do not unnecessarily initialize the fields of a class to values they already have.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnnecessaryFieldInitializationRule.js",
    "ruleName": "no-unnecessary-field-initialization",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-initializer": {
    "id": "./node_modules/tslint:no-unnecessary-initializer",
    "description": "Forbids a 'var'/'let' statement or destructuring initializer to be initialized to 'undefined'.",
    "hasFix": true,
    "rationale": "\nValues in JavaScript default to `undefined`.\nThere's no need to do so manually.\n        ",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-unnecessary-initializer",
    "path": "./node_modules/tslint/lib/rules/noUnnecessaryInitializerRule.js",
    "ruleName": "no-unnecessary-initializer",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unnecessary-local-variable": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unnecessary-local-variable",
    "type": "maintainability",
    "description": "Do not declare a variable only to return it from the function on the next line.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "563, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnnecessaryLocalVariableRule.js",
    "ruleName": "no-unnecessary-local-variable",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-override": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unnecessary-override",
    "type": "maintainability",
    "description": "Do not write a method that only calls super() on the parent method with the same arguments.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnnecessaryOverrideRule.js",
    "ruleName": "no-unnecessary-override",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-qualifier": {
    "id": "./node_modules/tslint:no-unnecessary-qualifier",
    "description": "Warns when a namespace qualifier (`A.x`) is unnecessary.",
    "hasFix": true,
    "type": "style",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-unnecessary-qualifier",
    "path": "./node_modules/tslint/lib/rules/noUnnecessaryQualifierRule.js",
    "ruleName": "no-unnecessary-qualifier",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unnecessary-semicolons": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unnecessary-semicolons",
    "type": "maintainability",
    "description": "Remove unnecessary semicolons",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Whitespace",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnnecessarySemicolonsRule.js",
    "ruleName": "no-unnecessary-semicolons",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unnecessary-type-assertion": {
    "id": "./node_modules/tslint:no-unnecessary-type-assertion",
    "description": "Warns if a type assertion does not change the type of an expression.",
    "options": {
      "type": "list",
      "listType": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "optionsDescription": "A list of whitelisted assertion types to ignore",
    "type": "typescript",
    "hasFix": true,
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-unnecessary-type-assertion",
    "path": "./node_modules/tslint/lib/rules/noUnnecessaryTypeAssertionRule.js",
    "ruleName": "no-unnecessary-type-assertion",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unsafe-any": {
    "id": "./node_modules/tslint:no-unsafe-any",
    "description": "\nWarns when using an expression of type 'any' in a dynamic way.\nUses are only allowed if they would work for `{} | null | undefined`.\nDowncasting to unknown is always safe.\nType casts and tests are allowed.\nExpressions that work on all values (such as `\"\" + x`) are allowed.",
    "rationale": "\nIf you're dealing with data of unknown or \"any\" types, you shouldn't be accessing members of it.\nEither add type annotations for properties that may exist or change the data type to the empty object type `{}`.\n\nAlternately, if you're creating storage or handling for consistent but unknown types, such as in data structures\nor serialization, use `<T>` template types for generic type handling.\n\nAlso see the `no-any` rule.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-unsafe-any",
    "path": "./node_modules/tslint/lib/rules/noUnsafeAnyRule.js",
    "ruleName": "no-unsafe-any",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unsafe-finally": {
    "id": "./node_modules/tslint:no-unsafe-finally",
    "description": "\nDisallows control flow statements, such as `return`, `continue`,\n`break` and `throws` in finally blocks.",
    "descriptionDetails": "",
    "rationale": "\nWhen used inside `finally` blocks, control flow statements,\nsuch as `return`, `continue`, `break` and `throws`\noverride any other control flow statements in the same try/catch scope.\nThis is confusing and unexpected behavior.",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-unsafe-finally",
    "path": "./node_modules/tslint/lib/rules/noUnsafeFinallyRule.js",
    "ruleName": "no-unsafe-finally",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unsupported-browser-code": {
    "id": "./node_modules/tslint-microsoft-contrib:no-unsupported-browser-code",
    "type": "maintainability",
    "description": "Avoid writing browser-specific code for unsupported browser versions",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUnsupportedBrowserCodeRule.js",
    "ruleName": "no-unsupported-browser-code",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-unused-expression": {
    "id": "./node_modules/tslint:no-unused-expression",
    "description": "Disallows unused expression statements.",
    "descriptionDetails": "\nUnused expressions are expression statements which are not assignments or function calls\n(and thus usually no-ops).",
    "rationale": "\nDetects potential errors where an assignment or function call was intended.",
    "optionsDescription": "\nThree arguments may be optionally provided:\n\n* `allow-fast-null-checks` allows to use logical operators to perform fast null checks and perform\nmethod or function calls for side effects (e.g. `e && e.preventDefault()`).\n* `allow-new` allows 'new' expressions for side effects (e.g. `new ModifyGlobalState();`.\n* `allow-tagged-template` allows tagged templates for side effects (e.g. `this.add\\`foo\\`;`.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-fast-null-checks",
          "allow-new",
          "allow-tagged-template"
        ]
      },
      "minLength": 0,
      "maxLength": 3
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-fast-null-checks"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-unused-expression",
    "path": "./node_modules/tslint/lib/rules/noUnusedExpressionRule.js",
    "ruleName": "no-unused-expression",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-unused-expression-chai": {
    "id": "./node_modules/tslint-no-unused-expression-chai:no-unused-expression-chai",
    "description": "Disallows unused expression statements.",
    "descriptionDetails": "\nUnused expressions are expression statements which are not assignments or function calls\n(and thus usually no-ops).",
    "rationale": "\nDetects potential errors where an assignment or function call was intended.",
    "optionsDescription": "\nThe following arguments may be optionally provided:\n\n* `allow-fast-null-checks` allows to use logical operators to perform fast null checks\n  and perform method or function calls for side effects (e.g. `e && e.preventDefault()`).\n* `allow-new` allows 'new' expressions for side effects (e.g. `new ModifyGlobalState();`.\n* `allow-tagged-template` allows tagged templates for side effects\n  (e.g. `this.add\\`foo\\`;`).\n* `should` supports chai assertions using `should` in addition to `expect`;`.\n",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-fast-null-checks",
          "allow-new",
          "allow-tagged-template",
          "should"
        ]
      },
      "minLength": 0,
      "maxLength": 4
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-fast-null-checks"
      ],
      [
        true,
        "should"
      ],
      [
        true,
        "allow-fast-null-checks",
        "should"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "path": "./node_modules/tslint-no-unused-expression-chai/rules/noUnusedExpressionChaiRule.js",
    "ruleName": "no-unused-expression-chai",
    "source": "tslint-no-unused-expression-chai",
    "sourcePath": "./node_modules/tslint-no-unused-expression-chai"
  },
  "no-unused-variable": {
    "id": "./node_modules/tslint:no-unused-variable",
    "description": "\nDisallows unused imports, variables, functions and\nprivate class members. Similar to tsc's --noUnusedParameters and --noUnusedLocals\noptions, but does not interrupt code compilation.",
    "descriptionDetails": "\nIn addition to avoiding compilation errors, this rule may still be useful if you\nwish to have `tslint` automatically remove unused imports, variables, functions,\nand private class members, when using TSLint's `--fix` option.",
    "hasFix": true,
    "optionsDescription": "\nThree optional arguments may be optionally provided:\n\n* `\"check-parameters\"` disallows unused function and constructor parameters.\n    * NOTE: this option is experimental and does not work with classes\n    that use abstract method declarations, among other things.\n* `{\"ignore-pattern\": \"pattern\"}` where pattern is a case-sensitive regexp.\nVariable names and imports that match the pattern will be ignored.",
    "options": {
      "type": "array",
      "items": {
        "oneOf": [
          {
            "type": "string",
            "enum": [
              "check-parameters"
            ]
          },
          {
            "type": "object",
            "properties": {
              "ignore-pattern": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "minLength": 0,
      "maxLength": 3
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "ignore-pattern": "^_"
        }
      ]
    ],
    "rationale": "\nVariables that are declared and not used anywhere in code are likely an error due to incomplete refactoring.\nSuch variables take up space in the code, are mild performance pains, and can lead to confusion by readers.\n        ",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "deprecationMessage": "Since TypeScript 2.9. Please use the built-in compiler checks instead.",
    "documentation": "https://palantir.github.io/tslint/rules/no-unused-variable",
    "path": "./node_modules/tslint/lib/rules/noUnusedVariableRule.js",
    "ruleName": "no-unused-variable",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-use-before-declare": {
    "id": "./node_modules/tslint:no-use-before-declare",
    "description": "Disallows usage of variables before their declaration.",
    "descriptionDetails": "\nThis rule is primarily useful when using the `var` keyword since the compiler will\nautomatically detect if a block-scoped `let` and `const` variable is used before\ndeclaration. Since most modern TypeScript doesn't use `var`, this rule is generally\ndiscouraged and is kept around for legacy purposes. It is slow to compute, is not\nenabled in the built-in configuration presets, and should not be used to inform TSLint\ndesign decisions.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "codeExamples": [
      {
        "description": "Check that referenced variables are declared beforehand (default)",
        "config": "\n\"rules\": { \"no-use-before-declare\": true }\n        ",
        "pass": "\nvar hello = 'world';\nvar foo;\n\nconsole.log(hello, foo, capitalize(hello));\n// 'world', undefined, 'WORLD'\n\nfunction capitalize(val) {\n    return val.toUpperCase();\n}\n\nimport { default as foo1 } from \"./lib\";\nimport foo2 from \"./lib\";\nimport _, { map, foldl } from \"./underscore\";\nimport * as foo3 from \"./lib\";\nimport \"./lib\";\n\nfunction declaredImports() {\n    console.log(foo1);\n    console.log(foo2);\n    console.log(foo3);\n    map([], (x) => x);\n}\n        ",
        "fail": "\nconsole.log(hello, foo);\n\nvar hello = 'world';\nvar foo;\n\nfunction undeclaredImports() {\n    console.log(foo1);\n    console.log(foo2);\n    console.log(foo3);\n    map([], (x) => x);\n}\n\nimport { default as foo1 } from \"./lib\";\nimport foo2 from \"./lib\";\nimport _, { map, foldl } from \"./underscore\";\nimport * as foo3 from \"./lib\";\nimport \"./lib\";\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/no-use-before-declare",
    "path": "./node_modules/tslint/lib/rules/noUseBeforeDeclareRule.js",
    "ruleName": "no-use-before-declare",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-useless-files": {
    "id": "./node_modules/tslint-microsoft-contrib:no-useless-files",
    "type": "maintainability",
    "description": "Locates files that only contain commented out code, whitespace characters, or have no content",
    "typescriptOnly": false,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noUselessFilesRule.js",
    "ruleName": "no-useless-files",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-var-keyword": {
    "id": "./node_modules/tslint:no-var-keyword",
    "description": "Disallows usage of the `var` keyword.",
    "descriptionDetails": "Use `let` or `const` instead.",
    "hasFix": true,
    "rationale": "\nDeclaring variables using `var` has several edge case behaviors that make `var` unsuitable for modern code.\nVariables declared by `var` have their parent function block as their scope, ignoring other control flow statements.\n`var`s have declaration \"hoisting\" (similar to `function`s) and can appear to be used before declaration.\n\nVariables declared by `const` and `let` instead have as their scope the block in which they are defined,\nand are not allowed to used before declaration or be re-declared with another `const` or `let`.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-var-keyword",
    "path": "./node_modules/tslint/lib/rules/noVarKeywordRule.js",
    "ruleName": "no-var-keyword",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-var-requires": {
    "id": "./node_modules/tslint:no-var-requires",
    "description": "Disallows the use of require statements except in import statements.",
    "descriptionDetails": "\nIn other words, the use of forms such as `var module = require(\"module\")` are banned.\nInstead use ES2015-style imports or `import foo = require('foo')` imports.",
    "rationale": "\nAMD-style `require([])` and CommonJS-style `require(\"\")` statements are environment-specific\nand more difficult to statically analyze.\n\nES2015-style `import`s are part of the JavaScript language specfication and recommended as the path going forward.\nTypeScript will compile them to environment-specific forms as needed.\n        ",
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/no-var-requires",
    "path": "./node_modules/tslint/lib/rules/noVarRequiresRule.js",
    "ruleName": "no-var-requires",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-var-self": {
    "id": "./node_modules/tslint-microsoft-contrib:no-var-self",
    "type": "maintainability",
    "description": "Do not use var self = this; instead, manage scope with arrow functions/lambdas.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Deprecated",
    "recommendation": "false,",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noVarSelfRule.js",
    "ruleName": "no-var-self",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "no-void-expression": {
    "id": "./node_modules/tslint:no-void-expression",
    "description": "Requires expressions of type `void` to appear in statement position.",
    "optionsDescription": "\nIf `ignore-arrow-function-shorthand` is provided, `() => returnsVoid()` will be allowed.\nOtherwise, it must be written as `() => { returnsVoid(); }`.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "ignore-arrow-function-shorthand"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "rationale": "\nIt's misleading returning the results of an expression whose type is `void`.\nAttempting to do so is likely a symptom of expecting a different return type from a function.\nFor example, the following code will log `undefined` but looks like it logs a value:\n\n```\nconst performWork = (): void => {\n    workFirst();\n    workSecond();\n};\n\nconsole.log(performWork());\n```\n        ",
    "requiresTypeInfo": true,
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/no-void-expression",
    "path": "./node_modules/tslint/lib/rules/noVoidExpressionRule.js",
    "ruleName": "no-void-expression",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "no-with-statement": {
    "id": "./node_modules/tslint-microsoft-contrib:no-with-statement",
    "type": "maintainability",
    "description": "Do not use with statements. Assign the item to a new variable instead",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/noWithStatementRule.js",
    "ruleName": "no-with-statement",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "non-literal-fs-path": {
    "id": "./node_modules/tslint-microsoft-contrib:non-literal-fs-path",
    "type": "functionality",
    "description": "Detect calls to fs functions with a non literal filepath",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "22",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/nonLiteralFsPathRule.js",
    "ruleName": "non-literal-fs-path",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "non-literal-require": {
    "id": "./node_modules/tslint-microsoft-contrib:non-literal-require",
    "type": "functionality",
    "description": "Detect require includes that are not for string literals",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "95,676",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/nonLiteralRequireRule.js",
    "ruleName": "non-literal-require",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "number-literal-format": {
    "id": "./node_modules/tslint:number-literal-format",
    "hasFix": true,
    "description": "Checks that decimal literals should begin with '0.' instead of just '.', and should not end with a trailing '0'.",
    "rationale": "\nHelps keep a consistent style with numeric literals.\nNon-standard literals are more difficult to scan through and can be a symptom of typos.\n        ",
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/number-literal-format",
    "path": "./node_modules/tslint/lib/rules/numberLiteralFormatRule.js",
    "ruleName": "number-literal-format",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "object-curly-spacing": {
    "id": "./node_modules/tslint-eslint-rules:object-curly-spacing",
    "documentation": "https://eslint.org/docs/rules/object-curly-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/objectCurlySpacingRule.js",
    "ruleName": "object-curly-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "object-literal-key-quotes": {
    "id": "./node_modules/tslint:object-literal-key-quotes",
    "description": "Enforces consistent object literal property quote style.",
    "descriptionDetails": "\nObject literal property names can be defined in two ways: using literals or using strings.\nFor example, these two objects are equivalent:\n\nvar object1 = {\n    property: true\n};\n\nvar object2 = {\n    \"property\": true\n};\n\nIn many cases, it doesn’t matter if you choose to use an identifier instead of a string\nor vice-versa. Even so, you might decide to enforce a consistent style in your code.\n\nThis rules lets you enforce consistent quoting of property names. Either they should always\nbe quoted (default behavior) or quoted only as needed (\"as-needed\").",
    "hasFix": true,
    "optionsDescription": "\nPossible settings are:\n\n* `\"always\"`: Property names should always be quoted. (This is the default.)\n* `\"as-needed\"`: Only property names which require quotes may be quoted (e.g. those with spaces in them).\n* `\"consistent\"`: Property names should either all be quoted or unquoted.\n* `\"consistent-as-needed\"`: If any property name requires quotes, then all properties must be quoted. Otherwise, no\nproperty names may be quoted.\n\nFor ES6, computed property names (`{[name]: value}`) and methods (`{foo() {}}`) never need\nto be quoted.",
    "options": {
      "type": "string",
      "enum": [
        "always",
        "as-needed",
        "consistent",
        "consistent-as-needed"
      ]
    },
    "optionExamples": [
      [
        true,
        "as-needed"
      ],
      [
        true,
        "always"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/object-literal-key-quotes",
    "path": "./node_modules/tslint/lib/rules/objectLiteralKeyQuotesRule.js",
    "ruleName": "object-literal-key-quotes",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "object-literal-shorthand": {
    "id": "./node_modules/tslint:object-literal-shorthand",
    "description": "Enforces/disallows use of ES6 object literal shorthand.",
    "hasFix": true,
    "optionsDescription": "\nIf the 'never' option is provided, any shorthand object literal syntax will cause a failure.",
    "options": {
      "type": "string",
      "enum": [
        "never"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "never"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/object-literal-shorthand",
    "path": "./node_modules/tslint/lib/rules/objectLiteralShorthandRule.js",
    "ruleName": "object-literal-shorthand",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "object-literal-sort-keys": {
    "id": "./node_modules/tslint:object-literal-sort-keys",
    "description": "\nChecks ordering of keys in object literals.\n\nWhen using the default alphabetical ordering, additional blank lines may be used to group\nobject properties together while keeping the elements within each group in alphabetical order.\n        ",
    "rationale": "Useful in preventing merge conflicts",
    "optionsDescription": "\nBy default, this rule checks that keys are in alphabetical order.\nThe following may optionally be passed:\n\n* `ignore-case` will compare keys in a case insensitive way.\n* `locale-compare` will compare keys using the expected sort order of special characters, such as accents.\n* `match-declaration-order` will prefer to use the key ordering of the contextual type of the object literal, as in:\n\n    ```\n    interface I { foo: number; bar: number; }\n    const obj: I = { foo: 1, bar: 2 };\n    ```\n\nIf a contextual type is not found, alphabetical ordering will be used instead.\n* \"match-declaration-order-only\" exactly like \"match-declaration-order\",\n    but don't fall back to alphabetical if a contextual type is not found.\n\n    Note: If both match-declaration-order-only and match-declaration-order options are present,\n          match-declaration-order-only will take precedence and alphabetical fallback will not occur.\n\n* `shorthand-first` will enforce shorthand properties to appear first, as in:\n\n    ```\n    const obj = { a, c, b: true };\n    ```\n",
    "options": {
      "type": "string",
      "enum": [
        "ignore-case",
        "locale-compare",
        "match-declaration-order",
        "match-declaration-order-only",
        "shorthand-first"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "ignore-case",
        "locale-compare",
        "match-declaration-order",
        "shorthand-first"
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Requires that an object literal's keys be sorted alphabetically.",
        "config": "\n\"rules\": { \"object-literal-sort-keys\": true }\n        ",
        "pass": "\nlet o = {\n    bar: 2,\n    foo: 1\n};\n        ",
        "fail": "\nlet o = {\n    foo: 1,\n    bar: 2\n};\n        "
      },
      {
        "description": "Requires that an object literal's keys be sorted by interface-definition.\n            If there is no interface fallback to alphabetically.",
        "config": "\n\"rules\": {\n    \"object-literal-sort-keys\": {\n        \"options\": \"match-declaration-order\"\n    }\n}\n        ",
        "pass": "\ninterface I {\n    foo: number;\n    bar: number;\n}\n\nlet o: I = {\n    foo: 1,\n    bar: 2\n};\n        ",
        "fail": "\ninterface I {\n    foo: number;\n    bar: number;\n}\n\nlet o: I = {\n    bar: 2,\n    foo: 1\n};\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/object-literal-sort-keys",
    "path": "./node_modules/tslint/lib/rules/objectLiteralSortKeysRule.js",
    "ruleName": "object-literal-sort-keys",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "one-line": {
    "id": "./node_modules/tslint:one-line",
    "description": "Requires the specified tokens to be on the same line as the expression preceding them.",
    "optionsDescription": "\nFive arguments may be optionally provided:\n\n* `\"check-catch\"` checks that `catch` is on the same line as the closing brace for `try`.\n* `\"check-finally\"` checks that `finally` is on the same line as the closing brace for `catch`.\n* `\"check-else\"` checks that `else` is on the same line as the closing brace for `if`.\n* `\"check-open-brace\"` checks that an open brace falls on the same line as its preceding expression.\n* `\"check-whitespace\"` checks preceding whitespace for the specified tokens.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "check-catch",
          "check-finally",
          "check-else",
          "check-open-brace",
          "check-whitespace"
        ]
      },
      "minLength": 0,
      "maxLength": 5
    },
    "optionExamples": [
      [
        true,
        "check-catch",
        "check-finally",
        "check-else"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/one-line",
    "path": "./node_modules/tslint/lib/rules/oneLineRule.js",
    "ruleName": "one-line",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "one-variable-per-declaration": {
    "id": "./node_modules/tslint:one-variable-per-declaration",
    "description": "Disallows multiple variable definitions in the same declaration statement.",
    "optionsDescription": "\nOne argument may be optionally provided:\n\n* `ignore-for-loop` allows multiple variable definitions in a for loop declaration.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "ignore-for-loop"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionExamples": [
      true,
      [
        true,
        "ignore-for-loop"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Disallows multiple variable definitions in the same declaration statement.",
        "config": "\n\"rules\": { \"one-variable-per-declaration\": true }\n        ",
        "pass": "\nconst foo = 1;\nconst bar = '2';\n        ",
        "fail": "\nconst foo = 1, bar = '2';\n       "
      },
      {
        "description": "Disallows multiple variable definitions in the same declaration statement but allows them in for-loops.",
        "config": "\n\"rules\": { \"one-variable-per-declaration\": [true, \"ignore-for-loop\"] }\n        ",
        "pass": "\nfor (let i = 0, j = 10; i < 10; i++) {\n    doSomething(j, i);\n}\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/one-variable-per-declaration",
    "path": "./node_modules/tslint/lib/rules/oneVariablePerDeclarationRule.js",
    "ruleName": "one-variable-per-declaration",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "only-arrow-functions": {
    "id": "./node_modules/tslint:only-arrow-functions",
    "description": "Disallows traditional (non-arrow) function expressions.",
    "rationale": "Traditional functions don't bind lexical scope, which can lead to unexpected behavior when accessing 'this'.",
    "descriptionDetails": "\nNote that non-arrow functions are allowed if 'this' appears somewhere in its body\n(as such functions cannot be converted to arrow functions).\n        ",
    "optionsDescription": "\nTwo arguments may be optionally provided:\n\n* `\"allow-declarations\"` allows standalone function declarations.\n* `\"allow-named-functions\"` allows the expression `function foo() {}` but not `function() {}`.\n        ",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-declarations",
          "allow-named-functions"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-declarations",
        "allow-named-functions"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Disallows functions with the function keyword",
        "config": "\n\"rules\": { \"only-arrow-functions\": true }\n        ",
        "pass": "\nconst myFunc = () => {\n    // do something ...\n};\n\nconst myFunc = function() {\n    this.doSomething();\n};\n        ",
        "fail": "\nfunction myFunc() {\n    // do something ...\n};\n\nconst myFunc = function() {\n    // do something ...\n};\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/only-arrow-functions",
    "path": "./node_modules/tslint/lib/rules/onlyArrowFunctionsRule.js",
    "ruleName": "only-arrow-functions",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ordered-imports": {
    "id": "./node_modules/tslint:ordered-imports",
    "description": "Requires that import statements be alphabetized and grouped.",
    "descriptionDetails": "\nEnforce a consistent ordering for ES6 imports:\n- Named imports must be alphabetized (i.e. \"import {A, B, C} from \"foo\";\")\n    - The exact ordering can be controlled by the named-imports-order option.\n    - \"longName as name\" imports are ordered by \"longName\".\n- Import sources must be alphabetized within groups, i.e.:\n        import * as foo from \"a\";\n        import * as bar from \"b\";\n- Groups of imports are delineated by blank lines. You can use this rule to group\n    imports however you like, e.g. by first- vs. third-party or thematically or\n    you can define groups based upon patterns in import path names.",
    "hasFix": true,
    "optionsDescription": "\nYou may set the `\"import-sources-order\"` option to control the ordering of source\nimports (the `\"foo\"` in `import {A, B, C} from \"foo\"`).\n\nPossible values for `\"import-sources-order\"` are:\n\n* `\"case-insensitive'`: Correct order is `\"Bar\"`, `\"baz\"`, `\"Foo\"`. (This is the default.)\n* `\"lowercase-first\"`: Correct order is `\"baz\"`, `\"Bar\"`, `\"Foo\"`.\n* `\"lowercase-last\"`: Correct order is `\"Bar\"`, `\"Foo\"`, `\"baz\"`.\n* `\"any\"`: Allow any order.\n\nYou may set the `\"grouped-imports\"` option to control the grouping of source\nimports (the `\"foo\"` in `import {A, B, C} from \"foo\"`).  The grouping used\nis controlled by the `\"groups\"` option.\n\nPossible values for `\"grouped-imports\"` are:\n\n* `false`: Do not enforce grouping. (This is the default.)\n* `true`: Group source imports using default grouping or groups setting.\n\nThe value of `\"groups\"` is a list of group rules of the form:\n\n    [{\n        \"name\": \"optional rule name\",\n        \"match\": \"regex string\",\n        \"order\": 10\n    }, {\n        \"name\": \"pkga imports\",\n        \"match\": \"^@pkga\",\n        \"order\": 20\n    }]\n\nthere is also a simplified form where you only pass a list of patterns and\nthe order is given by the position in the list\n\n    [\"^@pkga\", \"^\\.\\.\"]\n\nThe first rule in the list to match a given import is the group that is used.\nIf no rule in matched then the import will be put in an `unmatched` group\nat the end of all groups. The groups must be ordered based upon the sequential\nvalue of the `order` value. (ie. order 0 is first)\n\nIf no `\"groups\"` options is set, a default grouping is used of third-party,\nparent directories and the current directory. (`\"bar\"`, `\"../baz\"`, `\"./foo\"`.)\n\nYou may set the `\"named-imports-order\"` option to control the ordering of named\nimports (the `{A, B, C}` in `import {A, B, C} from \"foo\"`).\n\nPossible values for `\"named-imports-order\"` are:\n\n* `\"case-insensitive'`: Correct order is `{A, b, C}`. (This is the default.)\n* `\"lowercase-first\"`: Correct order is `{b, A, C}`.\n* `\"lowercase-last\"`: Correct order is `{A, C, b}`.\n* `\"any\"`: Allow any order.\n\nYou may set the `\"module-source-path\"` option to control the ordering of imports based full path\nor just the module name\n\nPossible values for `\"module-source-path\"` are:\n\n* `\"full'`: Correct order is  `\"./a/Foo\"`, `\"./b/baz\"`, `\"./c/Bar\"`. (This is the default.)\n* `\"basename\"`: Correct order is `\"./c/Bar\"`, `\"./b/baz\"`, `\"./a/Foo\"`.\n\n        ",
    "options": {
      "type": "object",
      "properties": {
        "grouped-imports": {
          "type": "boolean"
        },
        "groups": {
          "type": "list",
          "listType": {
            "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",
            "lowercase-first",
            "lowercase-last",
            "any"
          ]
        },
        "named-imports-order": {
          "type": "string",
          "enum": [
            "case-insensitive",
            "lowercase-first",
            "lowercase-last",
            "any"
          ]
        },
        "module-source-path": {
          "type": "string",
          "enum": [
            "full",
            "basename"
          ]
        }
      },
      "additionalProperties": false
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "import-sources-order": "lowercase-last",
          "named-imports-order": "lowercase-first"
        }
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/ordered-imports",
    "path": "./node_modules/tslint/lib/rules/orderedImportsRule.js",
    "ruleName": "ordered-imports",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "possible-timing-attack": {
    "id": "./node_modules/tslint-microsoft-contrib:possible-timing-attack",
    "type": "functionality",
    "description": "Avoid timing attacks by not making direct comaprisons to sensitive data",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Security",
    "commonWeaknessEnumeration": "710,749",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/possibleTimingAttackRule.js",
    "ruleName": "possible-timing-attack",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "prefer-array-literal": {
    "id": "./node_modules/tslint-microsoft-contrib:prefer-array-literal",
    "type": "maintainability",
    "description": "Use array literal syntax when declaring or instantiating array types.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/preferArrayLiteralRule.js",
    "ruleName": "prefer-array-literal",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "prefer-conditional-expression": {
    "id": "./node_modules/tslint:prefer-conditional-expression",
    "description": "\nRecommends to use a conditional expression instead of assigning to the same thing in each branch of an if statement.",
    "rationale": "\nThis reduces duplication and can eliminate an unnecessary variable declaration.",
    "optionsDescription": "If `check-else-if` is specified, the rule also checks nested if-else-if statements.",
    "options": {
      "type": "string",
      "enum": [
        "check-else-if"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "check-else-if"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-conditional-expression",
    "path": "./node_modules/tslint/lib/rules/preferConditionalExpressionRule.js",
    "ruleName": "prefer-conditional-expression",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-const": {
    "id": "./node_modules/tslint:prefer-const",
    "description": "Requires that variable declarations use `const` instead of `let` and `var` if possible.",
    "descriptionDetails": "\nIf a variable is only assigned to once when it is declared, it should be declared using 'const'",
    "hasFix": true,
    "optionsDescription": "\nAn optional object containing the property \"destructuring\" with two possible values:\n\n* \"any\" (default) - If any variable in destructuring can be const, this rule warns for those variables.\n* \"all\" - Only warns if all variables in destructuring can be const.",
    "options": {
      "type": "object",
      "properties": {
        "destructuring": {
          "type": "string",
          "enum": [
            "all",
            "any"
          ]
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "destructuring": "all"
        }
      ]
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-const",
    "path": "./node_modules/tslint/lib/rules/preferConstRule.js",
    "ruleName": "prefer-const",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-for-of": {
    "id": "./node_modules/tslint: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.",
    "rationale": "A for(... of ...) loop is easier to implement and read when the index is not needed.",
    "type": "typescript",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-for-of",
    "path": "./node_modules/tslint/lib/rules/preferForOfRule.js",
    "ruleName": "prefer-for-of",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-function-over-method": {
    "id": "./node_modules/tslint:prefer-function-over-method",
    "description": "Warns for class methods that do not use 'this'.",
    "optionsDescription": "\n\"allow-public\" excludes checking of public methods.\n\"allow-protected\" excludes checking of protected methods.",
    "options": {
      "type": "string",
      "enum": [
        "allow-public",
        "allow-protected"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-public",
        "allow-protected"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-function-over-method",
    "path": "./node_modules/tslint/lib/rules/preferFunctionOverMethodRule.js",
    "ruleName": "prefer-function-over-method",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-method-signature": {
    "id": "./node_modules/tslint:prefer-method-signature",
    "description": "Prefer `foo(): void` over `foo: () => void` in interfaces and types.",
    "hasFix": true,
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-method-signature",
    "path": "./node_modules/tslint/lib/rules/preferMethodSignatureRule.js",
    "ruleName": "prefer-method-signature",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-object-spread": {
    "id": "./node_modules/tslint:prefer-object-spread",
    "description": "Enforces the use of the ES2018 object spread operator over `Object.assign()` where appropriate.",
    "rationale": "Object spread allows for better type checking and inference.",
    "type": "functionality",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-object-spread",
    "path": "./node_modules/tslint/lib/rules/preferObjectSpreadRule.js",
    "ruleName": "prefer-object-spread",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-readonly": {
    "id": "./node_modules/tslint:prefer-readonly",
    "description": "Requires that private variables are marked as `readonly` if they're never modified outside of the constructor.",
    "descriptionDetails": "\nIf a private variable is only assigned to in the constructor, it should be declared as `readonly`.\n        ",
    "optionExamples": [
      true,
      [
        true,
        "only-inline-lambdas"
      ]
    ],
    "options": {
      "enum": [
        "only-inline-lambdas"
      ],
      "type": "string"
    },
    "optionsDescription": "\nIf `only-inline-lambdas` is specified, only immediately-declared arrow functions are checked.",
    "rationale": "\nMarking never-modified variables as readonly helps enforce the code's intent of keeping them as never-modified.\nIt can also help prevent accidental changes of members not meant to be changed.",
    "requiresTypeInfo": true,
    "type": "maintainability",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-readonly",
    "path": "./node_modules/tslint/lib/rules/preferReadonlyRule.js",
    "ruleName": "prefer-readonly",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-switch": {
    "id": "./node_modules/tslint:prefer-switch",
    "description": "Prefer a `switch` statement to an `if` statement with simple `===` comparisons.",
    "optionsDescription": "\nAn optional object with the property 'min-cases'.\nThis is the number cases needed before a switch statement is recommended.\nDefaults to 3.",
    "options": {
      "type": "object",
      "properties": {
        "min-cases": {
          "type": "number"
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "min-cases": 2
        }
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/prefer-switch",
    "path": "./node_modules/tslint/lib/rules/preferSwitchRule.js",
    "ruleName": "prefer-switch",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-template": {
    "id": "./node_modules/tslint:prefer-template",
    "description": "Prefer a template expression over string literal concatenation.",
    "optionsDescription": "\nIf `allow-single-concat` is specified, then a single concatenation (`x + y`) is allowed, but not more (`x + y + z`).",
    "options": {
      "type": "string",
      "enum": [
        "allow-single-concat"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-single-concat"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Enforces the use of template strings whenever possible.",
        "config": "\n\"rules\": { \"prefer-template\": true }\n        ",
        "pass": "\nconst x: number = 1;\nconst y: number = 1;\nconst myString: string = `${x} is equals ${y}`;\n        ",
        "fail": "\nconst x: number = 1;\nconst y: number = 1;\nconst myString: string = x + ' is equals ' + y;\n        "
      },
      {
        "description": "Enforces the use of template strings, but allows up to one concatenation.",
        "config": "\n\"rules\": { \"prefer-template\": [true, \"allow-single-concat\"] }\n        ",
        "pass": "\nconst x: number = 1;\nconst y: number = 1;\nconst myString: string = x + ' is equals 1';\nconst myString: string = `${x} is equals ${y}`;\n        ",
        "fail": "\nconst x: number = 1;\nconst y: number = 1;\nconst myString: string = x + ' is equals ' + y;\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/prefer-template",
    "path": "./node_modules/tslint/lib/rules/preferTemplateRule.js",
    "ruleName": "prefer-template",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "prefer-type-cast": {
    "id": "./node_modules/tslint-microsoft-contrib:prefer-type-cast",
    "type": "maintainability",
    "description": "Prefer the tradition type casts instead of the new 'as-cast' syntax",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Configurable",
    "recommendation": "true, // pick either type-cast format and use it consistently",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/preferTypeCastRule.js",
    "ruleName": "prefer-type-cast",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "prefer-while": {
    "id": "./node_modules/tslint:prefer-while",
    "description": "Prefer `while` loops instead of `for` loops without an initializer and incrementor.",
    "rationale": "Simplifies the readability of the loop statement, while maintaining the same functionality.",
    "hasFix": true,
    "type": "style",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Prefer `while` loops instead of `for` loops without an initializer and incrementor.",
        "config": "\n\"rules\": { \"prefer-while\": true }\n        ",
        "pass": "\nfor(let i = 1; i < 10; i++) {\n    console.log(i);\n}\n\nfor (let i = 0; i < 10; i+=1) {\n    console.log(i);\n}\n\nfor (let i = 0; i < 10;) {\n    i += 1;\n}\n        ",
        "fail": "\nfor(;;) {\n    console.log('Hello World');\n}\n\nfor(;true===true;) {\n    console.log('Hello World');\n}\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/prefer-while",
    "path": "./node_modules/tslint/lib/rules/preferWhileRule.js",
    "ruleName": "prefer-while",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "promise-function-async": {
    "id": "./node_modules/tslint:promise-function-async",
    "description": "Requires any function or method that returns a promise to be marked async.",
    "rationale": "\nEnsures that each function is only capable of 1) returning a rejected promise, or 2)\nthrowing an Error object. In contrast, non-`async` `Promise`-returning functions\nare technically capable of either. This practice removes a requirement for consuming\ncode to handle both cases.\n\nIf no optional arguments are provided then all function types are checked,\notherwise the specific function types are checked:\n\n* `\"check-function-declaration\"` check function declarations.\n* `\"check-function-expression\"` check function expressions.\n* `\"check-arrow-function\"` check arrow functions.\n* `\"check-method-declaration\"` check method declarations.\n        ",
    "optionsDescription": "Not configurable.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "check-function-declaration",
          "check-function-expression",
          "check-arrow-function",
          "check-method-declaration"
        ]
      },
      "minLength": 0,
      "maxLength": 4
    },
    "optionExamples": [
      true,
      [
        true,
        "check-function-declaration",
        "check-method-declaration"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/promise-function-async",
    "path": "./node_modules/tslint/lib/rules/promiseFunctionAsyncRule.js",
    "ruleName": "promise-function-async",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "promise-must-complete": {
    "id": "./node_modules/tslint-microsoft-contrib:promise-must-complete",
    "type": "maintainability",
    "description": "When a Promise instance is created, then either the reject() or resolve() parameter must be called on it within all code branches in the scope.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/promiseMustCompleteRule.js",
    "ruleName": "promise-must-complete",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "quotemark": {
    "id": "./node_modules/tslint:quotemark",
    "description": "Enforces quote character for string literals.",
    "hasFix": true,
    "optionsDescription": "\nFive arguments may be optionally provided:\n\n* `\"single\"` enforces single quotes.\n* `\"double\"` enforces double quotes.\n* `\"backtick\"` enforces backticks.\n* `\"jsx-single\"` enforces single quotes for JSX attributes.\n* `\"jsx-double\"` enforces double quotes for JSX attributes.\n* `\"avoid-template\"` forbids single-line untagged template strings that do not contain string interpolations.\n    Note that backticks may still be used if `\"avoid-escape\"` is enabled and both single and double quotes are\n    present in the string (the latter option takes precedence).\n* `\"avoid-escape\"` allows you to use the \"other\" quotemark in cases where escaping would normally be required.\n    For example, `[true, \"double\", \"avoid-escape\"]` would not report a failure on the string literal\n    `'Hello \"World\"'`.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "single",
          "double",
          "backtick",
          "jsx-single",
          "jsx-double",
          "avoid-escape",
          "avoid-template"
        ]
      },
      "minLength": 0,
      "maxLength": 5
    },
    "optionExamples": [
      [
        true,
        "single",
        "avoid-escape",
        "avoid-template"
      ],
      [
        true,
        "single",
        "jsx-double"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/quotemark",
    "path": "./node_modules/tslint/lib/rules/quotemarkRule.js",
    "ruleName": "quotemark",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "radix": {
    "id": "./node_modules/tslint:radix",
    "description": "Requires the radix parameter to be specified when calling `parseInt`.",
    "rationale": "\nFrom [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt):\n> Always specify this parameter to eliminate reader confusion and to guarantee predictable behavior.\n> Different implementations produce different results when a radix is not specified, usually defaulting the value to 10.",
    "type": "functionality",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Requires the inclusion of the radix parameter when calling `parseInt`.",
        "config": "\n\"rules\": { \"radix\": true }\n        ",
        "pass": "\nconst x: string = '11';\nconst dec: number = parseInt(x, 10);\nconst bin: number = parseInt(x, 2);\nconst hex: number = parseInt(x, 16);\n        ",
        "fail": "\nconst x: string = '11';\nconst dec: number = parseInt(x);\nconst bin: number = parseInt(x, 2);\nconst hex: number = parseInt(x, 16);\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/radix",
    "path": "./node_modules/tslint/lib/rules/radixRule.js",
    "ruleName": "radix",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "react-a11y-anchors": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-anchors",
    "type": "functionality",
    "description": "For accessibility of your website, anchor elements must have a href different from # and a text longer than 4.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "ignore-case",
          "ignore-whitespace"
        ]
      },
      "minLength": 0,
      "maxLength": 2
    },
    "optionsDescription": "\nOptional arguments to relax the same HREF same link text rule are provided:\n* `ignore-case` ignore differences in cases.\n* `{\"ignore-whitespace\": \"trim\"}` ignore differences only in leading/trailing whitespace.\n* `{\"ignore-whitespace\": \"all\"}` ignore differences in all whitespace.\n",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yAnchorsRule.js",
    "ruleName": "react-a11y-anchors",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-aria-unsupported-elements": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-aria-unsupported-elements",
    "type": "maintainability",
    "description": "Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yAriaUnsupportedElementsRule.js",
    "ruleName": "react-a11y-aria-unsupported-elements",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-event-has-role": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-event-has-role",
    "type": "maintainability",
    "description": "Elements with event handlers must have role attribute.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yEventHasRoleRule.js",
    "ruleName": "react-a11y-event-has-role",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-image-button-has-alt": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-image-button-has-alt",
    "type": "maintainability",
    "description": "Enforce that inputs element with type=\"image\" must have alt attribute.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yImageButtonHasAltRule.js",
    "ruleName": "react-a11y-image-button-has-alt",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-img-has-alt": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-img-has-alt",
    "type": "maintainability",
    "description": "Enforce that an img element contains the non-empty alt attribute. For decorative images, using empty alt attribute and role=\"presentation\".",
    "options": "string[]",
    "optionsDescription": "",
    "optionExamples": [
      "true",
      "[true, [\"Image\"]]"
    ],
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yImgHasAltRule.js",
    "ruleName": "react-a11y-img-has-alt",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-input-elements": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-input-elements",
    "type": "functionality",
    "description": "For accessibility of your website, HTML input boxes and text areas must include default, place-holding characters.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yInputElementsRule.js",
    "ruleName": "react-a11y-input-elements",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-lang": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-lang",
    "type": "functionality",
    "description": "For accessibility of your website, html elements must have a valid lang attribute.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yLangRule.js",
    "ruleName": "react-a11y-lang",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-meta": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-meta",
    "type": "functionality",
    "description": "For accessibility of your website, HTML meta elements must not have http-equiv=\"refresh\".",
    "typescriptOnly": true,
    "issueClass": "Ignored",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yMetaRule.js",
    "ruleName": "react-a11y-meta",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-no-onchange": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-no-onchange",
    "type": "functionality",
    "description": "For accessibility of your website, enforce usage of onBlur over onChange on select menus.",
    "options": "string[]",
    "optionsDescription": "Additional tag names to validate.",
    "optionExamples": [
      "true",
      "[true, [\"Select\"]]"
    ],
    "typescriptOnly": false,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yNoOnchangeRule.js",
    "ruleName": "react-a11y-no-onchange",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-props": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-props",
    "type": "maintainability",
    "description": "Enforce all `aria-*` attributes are valid. Elements cannot use an invalid `aria-*` attribute.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yPropsRule.js",
    "ruleName": "react-a11y-props",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-proptypes": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-proptypes",
    "type": "maintainability",
    "description": "Enforce ARIA state and property values are valid.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yProptypesRule.js",
    "ruleName": "react-a11y-proptypes",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-required": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-required",
    "type": "functionality",
    "description": "Enforce that required input elements must have aria-required set to true",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yRequiredRule.js",
    "ruleName": "react-a11y-required",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-role": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-role",
    "type": "maintainability",
    "description": "Elements with aria roles must use a **valid**, **non-abstract** aria role.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yRoleRule.js",
    "ruleName": "react-a11y-role",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-role-has-required-aria-props": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-role-has-required-aria-props",
    "type": "maintainability",
    "description": "Elements with aria roles must have all required attributes according to the role.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yRoleHasRequiredAriaPropsRule.js",
    "ruleName": "react-a11y-role-has-required-aria-props",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-role-supports-aria-props": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-role-supports-aria-props",
    "type": "maintainability",
    "description": "Enforce that elements with explicit or implicit roles defined contain only `aria-*` properties supported by that `role`.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yRoleSupportsAriaPropsRule.js",
    "ruleName": "react-a11y-role-supports-aria-props",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-tabindex-no-positive": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-tabindex-no-positive",
    "type": "maintainability",
    "description": "Enforce tabindex value is **not greater than zero**.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yTabindexNoPositiveRule.js",
    "ruleName": "react-a11y-tabindex-no-positive",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-a11y-titles": {
    "id": "./node_modules/tslint-microsoft-contrib:react-a11y-titles",
    "type": "functionality",
    "description": "For accessibility of your website, HTML title elements must be concise and non-empty.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Moderate",
    "level": "Opportunity for Excellence",
    "group": "Accessibility",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactA11yTitlesRule.js",
    "ruleName": "react-a11y-titles",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-anchor-blank-noopener": {
    "id": "./node_modules/tslint-microsoft-contrib:react-anchor-blank-noopener",
    "type": "functionality",
    "description": "Anchor tags with target=\"_blank\" should also include rel=\"noreferrer\"",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "force-rel-redundancy"
        ]
      },
      "minLength": 0,
      "maxLength": 1
    },
    "optionsDescription": "One argument may be optionally provided: \n\n' +\n            '* `force-rel-redundancy` ignores the default `rel=\"noreferrer\"`\n            behaviour which implies `rel=\"noreferrer noopener\"`. Instead, force redundancy\n            for `rel` attribute.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "242,676",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactAnchorBlankNoopenerRule.js",
    "ruleName": "react-anchor-blank-noopener",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-hooks-nesting": {
    "id": "./node_modules/tslint-react-hooks:react-hooks-nesting",
    "description": "Enforces Rules of Hooks",
    "descriptionDetails": "See https://reactjs.org/docs/hooks-rules.html",
    "optionsDescription": "\nAn optional object with the property detect-hooks-from-non-react-namespace.\nWhen set to true, violations will be reported for hooks from namespaces other\nthan the React namespace (e.g. `MyHooks.useHook` will be treated as a hook).\n    ",
    "options": {
      "type": "object",
      "properties": {
        "detect-hooks-from-non-react-namespace": {
          "type": "boolean"
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "detect-hooks-from-non-react-namespace": true
        }
      ]
    ],
    "hasFix": false,
    "type": "functionality",
    "typescriptOnly": false,
    "requiresTypeInfo": false,
    "path": "./node_modules/tslint-react-hooks/dist/reactHooksNestingRule.js",
    "ruleName": "react-hooks-nesting",
    "source": "tslint-react-hooks",
    "sourcePath": "./node_modules/tslint-react-hooks"
  },
  "react-iframe-missing-sandbox": {
    "id": "./node_modules/tslint-microsoft-contrib:react-iframe-missing-sandbox",
    "type": "functionality",
    "description": "React iframes must specify a sandbox attribute",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Opportunity for Excellence",
    "group": "Security",
    "commonWeaknessEnumeration": "915",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactIframeMissingSandboxRule.js",
    "ruleName": "react-iframe-missing-sandbox",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-no-dangerous-html": {
    "id": "./node_modules/tslint-microsoft-contrib:react-no-dangerous-html",
    "type": "maintainability",
    "description": "Do not use React's dangerouslySetInnerHTML API.",
    "typescriptOnly": true,
    "issueClass": "SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Mandatory",
    "group": "Security",
    "commonWeaknessEnumeration": "79, 85, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactNoDangerousHtmlRule.js",
    "ruleName": "react-no-dangerous-html",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-this-binding-issue": {
    "id": "./node_modules/tslint-microsoft-contrib:react-this-binding-issue",
    "type": "maintainability",
    "description": "When using React components you must be careful to correctly bind the `this` reference on any methods that you pass off to child components as callbacks.",
    "options": {
      "type": "object",
      "properties": {
        "allow-anonymous-listeners": {
          "type": "boolean"
        },
        "bind-decorators": {
          "type": "list",
          "listType": {
            "anyOf": {
              "type": "string"
            }
          }
        }
      }
    },
    "optionExamples": [
      true,
      [
        true,
        {
          "bind-decorators": [
            "autobind"
          ]
        }
      ]
    ],
    "optionsDescription": "",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Error",
    "severity": "Critical",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactThisBindingIssueRule.js",
    "ruleName": "react-this-binding-issue",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-tsx-curly-spacing": {
    "id": "./node_modules/tslint-microsoft-contrib:react-tsx-curly-spacing",
    "type": "style",
    "description": "Consistently use spaces around the brace characters of JSX attributes.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "recommendation": "false,",
    "group": "Deprecated",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactTsxCurlySpacingRule.js",
    "ruleName": "react-tsx-curly-spacing",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "react-unused-props-and-state": {
    "id": "./node_modules/tslint-microsoft-contrib:react-unused-props-and-state",
    "type": "maintainability",
    "description": "Remove unneeded properties defined in React Props and State interfaces",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "398",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/reactUnusedPropsAndStateRule.js",
    "ruleName": "react-unused-props-and-state",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "restrict-plus-operands": {
    "id": "./node_modules/tslint:restrict-plus-operands",
    "description": "When adding two variables, operands must both be of type number or of type string.",
    "type": "functionality",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/restrict-plus-operands",
    "path": "./node_modules/tslint/lib/rules/restrictPlusOperandsRule.js",
    "ruleName": "restrict-plus-operands",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "return-undefined": {
    "id": "./node_modules/tslint:return-undefined",
    "description": "Prefer `return;` in void functions and `return undefined;` in value-returning functions.",
    "type": "style",
    "typescriptOnly": false,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/return-undefined",
    "path": "./node_modules/tslint/lib/rules/returnUndefinedRule.js",
    "ruleName": "return-undefined",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "semicolon": {
    "id": "./node_modules/tslint:semicolon",
    "description": "Enforces consistent semicolon usage at the end of every statement.",
    "hasFix": true,
    "optionsDescription": "\nOne of the following arguments must be provided:\n\n* `\"always\"` enforces semicolons at the end of every statement.\n* `\"never\"` disallows semicolons at the end of every statement except for when they are necessary.\n\nThe following arguments may be optionally provided:\n\n* `\"ignore-interfaces\"` skips checking semicolons at the end of interface members.\n* `\"ignore-bound-class-methods\"` skips checking semicolons at the end of bound class methods.\n* `\"strict-bound-class-methods\"` disables any special handling of bound class methods and treats them as any\nother assignment. This option overrides `\"ignore-bound-class-methods\"`.\n        ",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "string",
          "enum": [
            "always",
            "never"
          ]
        },
        {
          "type": "string",
          "enum": [
            "ignore-interfaces"
          ]
        }
      ],
      "additionalItems": false
    },
    "optionExamples": [
      [
        true,
        "always"
      ],
      [
        true,
        "never"
      ],
      [
        true,
        "always",
        "ignore-interfaces"
      ],
      [
        true,
        "always",
        "ignore-bound-class-methods"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/semicolon",
    "path": "./node_modules/tslint/lib/rules/semicolonRule.js",
    "ruleName": "semicolon",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "sort-imports": {
    "id": "./node_modules/tslint-eslint-rules:sort-imports",
    "description": "enforce sorting import declarations within module",
    "rationale": "\nWhen declaring multiple imports, a sorted list of import declarations make it easier for developers to\nread the code and find necessary imports later. This rule is purely a matter of style.\n\nThis rule checks all import declarations and verifies that all imports are first sorted by the used member\nsyntax and then alphabetically by the first member or alias name.\n",
    "optionsDescription": "\n- `\"ignore-case\"` does case-insensitive comparisons (default: `false`)\n- `\"ignore-member-sort\"` allows members in multiple type imports to occur in any order (default: `false`)\n- `\"member-syntax-sort-order\"` (default: `[\"none\", \"all\", \"multiple\", \"single\", \"alias\"]`); all 5 items must be\npresent in the array, but you can change the order:\n  - `none` = import module without exported bindings.\n  - `all` = import all members provided by exported bindings.\n  - `multiple` = import multiple members.\n  - `single` = import a single member.\n  - `alias` = creates an alias for a member. This is unique to TER and not in ESLint's `sort-imports`.\n",
    "options": {
      "type": "object",
      "properties": {
        "member-syntax-sort-order": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "none",
              "all",
              "multiple",
              "single",
              "alias"
            ]
          },
          "minLength": 5,
          "maxLength": 5
        },
        "ignore-case": {
          "type": "boolean"
        },
        "ignore-member-sort": {
          "type": "boolean"
        }
      }
    },
    "optionExamples": [
      "\n\"sort-imports\": [true]\n",
      "\n\"sort-imports\": [true, { \"ignore-case\" }]\n",
      "\n\"sort-imports\": [true, { \"ignore-member-sort\" }]\n",
      "\n\"sort-imports\": [true, { \"member-syntax-sort-order\": [\"all\", \"single\", \"multiple\", \"none\", \"alias\"] }]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/sort-imports",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/sortImportsRule.js",
    "ruleName": "sort-imports",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "space-before-function-paren": {
    "id": "./node_modules/tslint:space-before-function-paren",
    "description": "Require or disallow a space before function parenthesis",
    "hasFix": true,
    "optionExamples": [
      true,
      [
        true,
        "always"
      ],
      [
        true,
        "never"
      ],
      [
        true,
        {
          "anonymous": "always",
          "named": "never",
          "asyncArrow": "always"
        }
      ]
    ],
    "options": {
      "properties": {
        "anonymous": {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        },
        "asyncArrow": {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        },
        "constructor": {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        },
        "method": {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        },
        "named": {
          "enum": [
            "always",
            "never"
          ],
          "type": "string"
        }
      },
      "type": "object"
    },
    "optionsDescription": "\nOne argument which is an object which may contain the keys `anonymous`, `named`, and `asyncArrow`\nThese should be set to either `\"always\"` or `\"never\"`.\n\n* `\"anonymous\"` checks before the opening paren in anonymous functions\n* `\"named\"` checks before the opening paren in named functions\n* `\"asyncArrow\"` checks before the opening paren in async arrow functions\n* `\"method\"` checks before the opening paren in class methods\n* `\"constructor\"` checks before the opening paren in class constructors\n        ",
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/space-before-function-paren",
    "path": "./node_modules/tslint/lib/rules/spaceBeforeFunctionParenRule.js",
    "ruleName": "space-before-function-paren",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "space-in-parens": {
    "id": "./node_modules/tslint-eslint-rules:space-in-parens",
    "description": "require or disallow spaces inside parentheses",
    "rationale": "\nThis rule will enforce consistency of spacing directly inside of parentheses,\nby disallowing or requiring one or more spaces to the right of (and to the\nleft of). In either case, () will still be allowed.\n",
    "optionsDescription": "\nThere are two options for this rule:\n\n- `\"never\"` (default) enforces zero spaces inside of parentheses\n- `\"always\"` enforces a space inside of parentheses\n\nDepending on your coding conventions, you can choose either option by specifying\nit in your configuration.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ]
        },
        {
          "type": "object",
          "properties": {
            "exceptions": {
              "type": "array",
              "items": [
                {
                  "enum": [
                    "{}",
                    "[]",
                    "()",
                    "empty"
                  ]
                }
              ],
              "uniqueItems": true
            }
          },
          "additionalProperties": false
        }
      ],
      "minItems": 0,
      "maxItems": 2
    },
    "optionExamples": [
      "\n\"space-in-parens\": [true, \"always\"]\n",
      "\n\"space-in-parens\": [true, \"never\"]\n",
      "\n\"space-in-parens\": [true, \"always\", { \"exceptions\": [ \"{}\", \"[]\", \"()\", \"empty\" ] }]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/space-in-parens",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/spaceInParensRule.js",
    "ruleName": "space-in-parens",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "space-within-parens": {
    "id": "./node_modules/tslint:space-within-parens",
    "description": "Enforces spaces within parentheses or disallow them.  Empty parentheses () are always allowed.",
    "hasFix": true,
    "optionsDescription": "\nYou may enforce the amount of whitespace within parentheses.\n        ",
    "options": {
      "type": "number",
      "min": 0
    },
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/space-within-parens",
    "path": "./node_modules/tslint/lib/rules/spaceWithinParensRule.js",
    "ruleName": "space-within-parens",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "strict-boolean-expressions": {
    "id": "./node_modules/tslint:strict-boolean-expressions",
    "description": "\nRestricts the types allowed in boolean expressions. By default only booleans are allowed.\n\nThe following nodes are checked:\n\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.",
    "optionsDescription": "\nThese options may be provided:\n\n* `allow-null-union` allows union types containing `null`.\n  - It does *not* allow `null` itself.\n  - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n* `allow-undefined-union` allows union types containing `undefined`.\n  - It does *not* allow `undefined` itself.\n  - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n* `allow-string` allows strings.\n  - It does *not* allow unions containing `string`.\n  - It does *not* allow string literal types.\n* `allow-enum` allows enums.\n  - It does *not* allow unions containing `enum`.\n* `allow-number` allows numbers.\n  - It does *not* allow unions containing `number`.\n  - It does *not* allow enums or number literal types.\n* `allow-mix` allows multiple of the above to appear together.\n  - For example, `string | number` or `RegExp | null | undefined` would normally not be allowed.\n  - A type like `\"foo\" | \"bar\" | undefined` is always allowed, because it has only one way to be false.\n* `allow-boolean-or-undefined` allows `boolean | undefined`.\n  - Also allows `true | false | undefined`.\n  - Does not allow `false | undefined`.\n  - This option is a subset of `allow-undefined-union`, so you don't need to enable both options at the same time.\n* `ignore-rhs` ignores the right-hand operand of `&&` and `||'\n        ",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-null-union",
          "allow-undefined-union",
          "allow-string",
          "allow-enum",
          "allow-number",
          "allow-boolean-or-undefined",
          "ignore-rhs"
        ]
      },
      "minLength": 0,
      "maxLength": 7
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-null-union",
        "allow-undefined-union",
        "allow-string",
        "allow-enum",
        "allow-number"
      ],
      [
        true,
        "allow-boolean-or-undefined"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/strict-boolean-expressions",
    "path": "./node_modules/tslint/lib/rules/strictBooleanExpressionsRule.js",
    "ruleName": "strict-boolean-expressions",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "strict-type-predicates": {
    "id": "./node_modules/tslint:strict-type-predicates",
    "description": "\nWarns 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.",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/strict-type-predicates",
    "path": "./node_modules/tslint/lib/rules/strictTypePredicatesRule.js",
    "ruleName": "strict-type-predicates",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "switch-default": {
    "id": "./node_modules/tslint:switch-default",
    "description": "Require a `default` case in all `switch` statements.",
    "type": "functionality",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Requires a `default` case in `switch` statements.",
        "config": "\n\"rules\": { \"switch-default\": true }\n        ",
        "pass": "\nlet foo: number = 1;\nswitch (foo) {\n    case 1:\n        doSomething();\n        break;\n    case 2:\n        doSomething2();\n        break;\n    default:\n        console.log('default');\n        break;\n}\n        ",
        "fail": "\nlet foo: number = 1;\nswitch (foo) {\n    case 1:\n        doSomething();\n        break;\n    case 2:\n        doSomething2();\n        break;\n}\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/switch-default",
    "path": "./node_modules/tslint/lib/rules/switchDefaultRule.js",
    "ruleName": "switch-default",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "switch-final-break": {
    "id": "./node_modules/tslint:switch-final-break",
    "description": "Checks whether the final clause of a switch statement ends in `break;`.",
    "hasFix": true,
    "optionsDescription": "\nIf no options are passed, a final 'break;' is forbidden.\nIf the \"always\" option is passed this will require a 'break;' to always be present\nunless control flow is escaped in some other way.",
    "options": {
      "type": "string",
      "enum": [
        "always"
      ]
    },
    "optionExamples": [
      true,
      [
        true,
        "always"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/switch-final-break",
    "path": "./node_modules/tslint/lib/rules/switchFinalBreakRule.js",
    "ruleName": "switch-final-break",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "ter-arrow-body-style": {
    "id": "./node_modules/tslint-eslint-rules:ter-arrow-body-style",
    "description": "require braces in arrow function body",
    "rationale": "\nArrow functions have two syntactic forms for their function bodies. They may be defined with\na block body (denoted by curly braces) `() => { ... }` or with a single expression\n`() => ...`, whose value is implicitly returned.\n",
    "optionsDescription": "\nThe rule takes one or two options. The first is a string, which can be:\n\n- `\"always\"` enforces braces around the function body\n- `\"as-needed\"` enforces no braces where they can be omitted (default)\n- `\"never\"` enforces no braces around the function body (constrains arrow functions to the\n              role of returning an expression)\n\nThe second one is an object for more fine-grained configuration when the first option is\n`\"as-needed\"`. Currently, the only available option is `requireReturnForObjectLiteral`, a\nboolean property. It’s false by default. If set to true, it requires braces and an explicit\nreturn for object literals.\n",
    "options": {
      "anyOf": [
        {
          "type": "array",
          "items": [
            {
              "enum": [
                "always",
                "never"
              ]
            }
          ],
          "minItems": 0,
          "maxItems": 1
        },
        {
          "type": "array",
          "items": [
            {
              "enum": [
                "as-needed"
              ]
            },
            {
              "type": "object",
              "properties": {
                "requireReturnForObjectLiteral": {
                  "type": "boolean"
                }
              },
              "additionalProperties": false
            }
          ],
          "minItems": 0,
          "maxItems": 2
        }
      ]
    },
    "optionExamples": [
      "\n\"ter-arrow-body-style\": [true, \"always\"]\n",
      "\n\"ter-arrow-body-style\": [true, \"never\"]\n",
      "\n\"ter-arrow-body-style\": [true, \"as-needed\", {\n  \"requireReturnForObjectLiteral\": true\n}]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-arrow-body-style",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terArrowBodyStyleRule.js",
    "ruleName": "ter-arrow-body-style",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-arrow-parens": {
    "id": "./node_modules/tslint-eslint-rules:ter-arrow-parens",
    "description": "require parens in arrow function arguments",
    "rationale": "\nArrow functions can omit parentheses when they have exactly one parameter. In all other cases\nthe parameter(s) must be wrapped in parentheses. This rule enforces the consistent use of\nparentheses in arrow functions.\n",
    "optionsDescription": "\nThis rule has a string option and an object one.\n\nString options are:\n\n- `\"always\"` (default) requires parentheses around arguments in all cases.\n- `\"as-needed\"` allows omitting parentheses when there is only one argument.\n\nObject properties for variants of the `\"as-needed\"` option:\n\n- `\"requireForBlockBody\": true` modifies the as-needed rule in order to require\n  parentheses if the function body is in an instructions block (surrounded by braces).\n",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "as-needed"
          ]
        },
        {
          "type": "object",
          "properties": {
            "requireForBlockBody": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-arrow-parens\": [true]\n",
      "\n\"ter-arrow-parens\": [true, \"always\"]\n",
      "\n\"ter-arrow-parens\": [true, \"as-needed\"]\n",
      "\n\"ter-arrow-parens\": [true, \"as-needed\", { \"requireForBlockBody\": true }]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-arrow-parens",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terArrowParensRule.js",
    "ruleName": "ter-arrow-parens",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-arrow-spacing": {
    "id": "./node_modules/tslint-eslint-rules:ter-arrow-spacing",
    "description": "require space before/after arrow function's arrow",
    "rationale": "\nThis rule normalizes the style of spacing before/after an arrow function’s arrow(`=>`).\n",
    "optionsDescription": "\nThis rule takes an object argument with `before` and `after` properties, each with a\nBoolean value.\n\nThe default configuration is `{ \"before\": true, \"after\": true }`.\n\n`true` means there should be one or more spaces and `false` means no spaces.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "object",
          "properties": {
            "before": {
              "type": "boolean"
            },
            "after": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-arrow-spacing\": [true]\n",
      "\n\"ter-arrow-spacing\": [true, {\n  \"before\": false,\n  \"after\": false\n}]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-arrow-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terArrowSpacingRule.js",
    "ruleName": "ter-arrow-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-computed-property-spacing": {
    "id": "./node_modules/tslint-eslint-rules:ter-computed-property-spacing",
    "hasFix": true,
    "description": "require or disallow padding inside computed properties",
    "rationale": "\nWhile formatting preferences are very personal, a number of style guides require or disallow spaces between computed properties in the following situations:\n    ",
    "optionsDescription": "\nThe rule takes in one option, which defines to require or forbid whitespace.\n\n* `\"never\"` (default) disallows spaces inside computed property brackets\n* `\"always\"` requires one or more spaces inside computed property brackets\n    ",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ]
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-computed-property-spacing\": [true]\n",
      "\n\"ter-computed-property-spacing\": [true, \"always\"]\n      ",
      "\n\"ter-computed-property-spacing\": [true, \"never\"]\n      "
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-computed-property-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terComputedPropertySpacingRule.js",
    "ruleName": "ter-computed-property-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-func-call-spacing": {
    "id": "./node_modules/tslint-eslint-rules:ter-func-call-spacing",
    "hasFix": true,
    "description": "require or disallow spacing between function identifiers and their invocations",
    "rationale": "\nThis rule will enforce consistency of spacing in function calls,\nby disallowing or requiring one or more spaces before the open paren.\n",
    "optionsDescription": "\nThis rule has a string option:\n\n* `\"never\"` (default) disallows space between the function name and the opening parenthesis.\n* `\"always\"` requires space between the function name and the opening parenthesis.\n\nFurther, in `\"always\"` mode, a second object option is available that contains a single boolean `allowNewlines` property.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ]
        },
        {
          "type": "object",
          "properties": {
            "allowNewlines": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "minItems": 0,
      "maxItems": 2
    },
    "optionExamples": [
      "\n\"ter-func-call-spacing\": [true]\n",
      "\n\"ter-func-call-spacing\": [true, \"always\"]\n",
      "\n\"ter-func-call-spacing\": [true, \"always\", { allowNewlines: true }]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-func-call-spacing",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terFuncCallSpacingRule.js",
    "ruleName": "ter-func-call-spacing",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-indent": {
    "id": "./node_modules/tslint-eslint-rules:ter-indent",
    "hasFix": true,
    "description": "enforce consistent indentation",
    "rationale": "\nUsing only one of tabs or spaces for indentation leads to more consistent editor behavior,\ncleaner diffs in version control, and easier programmatic manipulation.\n",
    "optionsDescription": "\nThe string 'tab' or an integer indicating the number of spaces to use per tab.\n\nAn object may be provided to fine tune the indentation rules:\n\n  * `\"SwitchCase\"` (default: 0) enforces indentation level for `case` clauses in\n                     `switch` statements\n  * `\"VariableDeclarator\"` (default: 1) enforces indentation level for `var` declarators;\n                             can also take an object to define separate rules for `var`,\n                             `let` and `const` declarations.\n  * `\"outerIIFEBody\"` (default: 1) enforces indentation level for file-level IIFEs.\n  * `\"MemberExpression\"` (off by default) enforces indentation level for multi-line\n                           property chains (except in variable declarations and assignments)\n  * `\"FunctionDeclaration\"` takes an object to define rules for function declarations.\n      * `\"parameters\"` (off by default) enforces indentation level for parameters in a\n                         function declaration. This can either be a number indicating\n                         indentation level, or the string `\"first\"` indicating that all\n                         parameters of the declaration must be aligned with the first parameter.\n      * `\"body\"` (default: 1) enforces indentation level for the body of a function expression.\n  * `\"FunctionExpression\"` takes an object to define rules for function declarations.\n      * `\"parameters\"` (off by default) enforces indentation level for parameters in a\n                         function declaration. This can either be a number indicating\n                         indentation level, or the string `\"first\"` indicating that all\n                         parameters of the declaration must be aligned with the first parameter.\n      * `\"body\"` (default: 1) enforces indentation level for the body of a function expression.\n  * `\"CallExpression\"` takes an object to define rules for function call expressions.\n      * `\"arguments\"` (off by default) enforces indentation level for arguments in a call\n                        expression. This can either be a number indicating indentation level,\n                        or the string `\"first\"` indicating that all arguments of the\n                        expression must be aligned with the first argument.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "number",
          "minimum": "0"
        },
        {
          "type": "string",
          "enum": [
            "tab"
          ]
        },
        {
          "type": "object",
          "properties": {
            "SwitchCase": {
              "type": "number",
              "minimum": 0
            },
            "VariableDeclarator": {
              "type": "object",
              "properties": {
                "var": {
                  "type": "number",
                  "minimum": 0
                },
                "let": {
                  "type": "number",
                  "minimum": 0
                },
                "const": {
                  "type": "number",
                  "minimum": 0
                }
              }
            },
            "outerIIFEBody": {
              "type": "number"
            },
            "FunctionDeclaration": {
              "type": "object",
              "properties": {
                "parameters": {
                  "type": "number",
                  "minimum": 0
                },
                "body": {
                  "type": "number",
                  "minimum": 0
                }
              }
            },
            "FunctionExpression": {
              "type": "object",
              "properties": {
                "parameters": {
                  "type": "number",
                  "minimum": 0
                },
                "body": {
                  "type": "number",
                  "minimum": 0
                }
              }
            },
            "MemberExpression": {
              "type": "number"
            },
            "CallExpression": {
              "type": "object",
              "properties": {
                "arguments": {
                  "type": "number",
                  "minimum": 0
                }
              }
            }
          },
          "additionalProperties": false
        }
      ],
      "minLength": 1,
      "maxLength": 2
    },
    "optionExamples": [
      "\n\"ter-indent\": [true, \"tab\"]\n",
      "\n\"ter-indent\": [true, 2]\n",
      "\n\"ter-indent\": [\n  true,\n  2,\n  {\n    \"FunctionExpression\": {\n      \"parameters\": 1,\n      \"body\": 1\n    }\n  }\n]\n"
    ],
    "typescriptOnly": false,
    "type": "maintainability",
    "documentation": "https://eslint.org/docs/rules/ter-indent",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terIndentRule.js",
    "ruleName": "ter-indent",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-max-len": {
    "id": "./node_modules/tslint-eslint-rules:ter-max-len",
    "description": "enforce a maximum line length",
    "rationale": "\nLimiting the length of a line of code improves code readability.\nIt also makes comparing code side-by-side easier and improves compatibility with\nvarious editors, IDEs, and diff viewers.\n",
    "optionsDescription": "\nAn integer indicating the maximum length of lines followed by an optional integer specifying\nthe character width for tab characters.\n\nAn optional object may be provided to fine tune the rule:\n\n* `\"code\"`: (default 80) enforces a maximum line length\n* `\"tabWidth\"`: (default 4) specifies the character width for tab characters\n* `\"comments\"`: enforces a maximum line length for comments; defaults to value of code\n* `\"ignorePattern\"`: ignores lines matching a regular expression; can only match a single\n                           line and need to be double escaped when written in JSON\n* `\"ignoreComments\"`: true ignores all trailing comments and comments on their own line\n* `\"ignoreTrailingComments\"`: true ignores only trailing comments\n* `\"ignoreUrls\"`: true ignores lines that contain a URL\n* `\"ignoreStrings\"`: true ignores lines that contain a double-quoted or single-quoted string\n* `\"ignoreTemplateLiterals\"`: true ignores lines that contain a template literal\n* `\"ignoreRegExpLiterals\"`: true ignores lines that contain a RegExp literal\n* `\"ignoreImports\"`: true ignores lines that contain an import module specifier\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "number",
          "minimum": "0"
        },
        {
          "type": "object",
          "properties": {
            "code": {
              "type": "number",
              "minumum": "1"
            },
            "comments": {
              "type": "number",
              "minumum": "1"
            },
            "tabWidth": {
              "type": "number",
              "minumum": "1"
            },
            "ignorePattern": {
              "type": "string"
            },
            "ignoreComments": {
              "type": "boolean"
            },
            "ignoreStrings": {
              "type": "boolean"
            },
            "ignoreUrls": {
              "type": "boolean"
            },
            "ignoreTemplateLiterals": {
              "type": "boolean"
            },
            "ignoreRegExpLiterals": {
              "type": "boolean"
            },
            "ignoreTrailingComments": {
              "type": "boolean"
            },
            "ignoreImports": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "minLength": 1,
      "maxLength": 3
    },
    "optionExamples": [
      "\n\"ter-max-len\": [true, 100]\n",
      "\n\"ter-max-len\": [\n  true,\n  100,\n  2,\n  {\n    \"ignoreUrls\": true,\n    \"ignorePattern\": \"^\\\\s*(let|const)\\\\s.+=\\\\s*require\\\\s*\\\\(\"\n  }\n]\n",
      "\n\"ter-max-len\": [\n  true,\n  {\n    \"code\": 100,\n    \"tabWidth\": 2,\n    \"ignoreImports\": true,\n    \"ignoreUrls\": true,\n    \"ignorePattern\": \"^\\\\s*(let|const)\\\\s.+=\\\\s*require\\\\s*\\\\(\"\n  }\n]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-max-len",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terMaxLenRule.js",
    "ruleName": "ter-max-len",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-newline-after-var": {
    "id": "./node_modules/tslint-eslint-rules:ter-newline-after-var",
    "hasFix": true,
    "description": "require or disallow an empty line after variable declarations",
    "rationale": "\nThis rule enforces a coding style where empty lines are required or disallowed after `var`, `let`, or `const`\nstatements to achieve a consistent coding style across the project.\n",
    "optionsDescription": "\nThis rule has a string option:\n\n* `\"always\"` (default) requires an empty line after `var`, `let`, or `const`.\n  Comments on a line directly after var statements are treated like additional var statements.\n* `\"never\"` disallows empty lines after `var`, `let`, or `const`.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ]
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-newline-after-var\": [true]\n",
      "\n\"ter-newline-after-var\": [true, \"always\"]\n",
      "\n\"ter-newline-after-var\": [true, \"never\"]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-newline-after-var",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNewlineAfterVarRule.js",
    "ruleName": "ter-newline-after-var",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-irregular-whitespace": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-irregular-whitespace",
    "description": "disallow irregular whitespace (recommended)",
    "rationale": "\nInvalid or irregular whitespace causes issues with ECMAScript 5 parsers and also makes code\nharder to debug in a similar nature to mixed tabs and spaces.\n",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-irregular-whitespace\": [true]\n"
    ],
    "typescriptOnly": false,
    "type": "typescript",
    "documentation": "https://eslint.org/docs/rules/ter-no-irregular-whitespace",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoIrregularWhitespaceRule.js",
    "ruleName": "ter-no-irregular-whitespace",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-mixed-spaces-and-tabs": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-mixed-spaces-and-tabs",
    "description": "Enforces indentation with unmixed tabs or spaces.",
    "rationale": "\nUsing only one of tabs or spaces for indentation leads to more consistent editor behavior,\ncleaner diffs in version control, and easier programmatic manipulation.",
    "optionsDescription": "\nThis rule takes an object argument with an optional `type` property which can be set to:\n\n* `spaces` enforces consistent spaces for indentation.\n* `tabs` enforces consistent tabs for indentation.\n\nIf the above is not provided, the rule will enforce either all tabs or all spaces on each\nline, although different lines may differ between tabs and spaces.\n\nOptionally, a `smartTabs` boolean property can be specified.  If set to true, smart tabs\nallow mixing tabs and spaces if tabs are used for indentation and spaces for alignment, eg.\n\n    function main() {\n    // --->const a = 1,\n    // --->......b = 2;\n\n        const a = 1,\n              b = 2;\n    }\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "enum": [
                "tabs",
                "spaces"
              ]
            },
            "smartTabs": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "minLength": 0,
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-no-mixed-spaces-and-tabs\": { \"type\": \"tabs\" } ]\n",
      "\n\"ter-no-mixed-spaces-and-tabs\": { \"type\": \"spaces\" } ]\n",
      "\n\"ter-no-mixed-spaces-and-tabs\": { \"smartTabs\": true } ]\n",
      "\n\"ter-no-mixed-spaces-and-tabs\": { \"type\": \"tabs\", \"smartTabs\": true } ]\n"
    ],
    "type": "maintainability",
    "typescriptOnly": false,
    "documentation": "https://eslint.org/docs/rules/ter-no-mixed-spaces-and-tabs",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoMixedSpacesAndTabsRule.js",
    "ruleName": "ter-no-mixed-spaces-and-tabs",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-proto": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-proto",
    "hasFix": false,
    "description": "disallow the use of `__proto__` property",
    "rationale": "`__proto__` property has been deprecated as of ECMAScript 3.1 and shouldn’t be used in the code. Use getPrototypeOf method instead.",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-proto\": true\n"
    ],
    "typescriptOnly": false,
    "type": "functionality",
    "documentation": "https://eslint.org/docs/rules/ter-no-proto",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoProtoRule.js",
    "ruleName": "ter-no-proto",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-script-url": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-script-url",
    "hasFix": false,
    "description": "disallow use of `javascript:` urls.",
    "rationale": "Using `javascript:` URLs is considered by some as a form of `eval`. Code passed in `javascript:` URLs has to be parsed and evaluated by the browser in the same way that eval is processed.",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-script-url\": true\n"
    ],
    "typescriptOnly": false,
    "type": "functionality",
    "documentation": "https://eslint.org/docs/rules/ter-no-script-url",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoScriptUrlRule.js",
    "ruleName": "ter-no-script-url",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-self-compare": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-self-compare",
    "hasFix": false,
    "description": "disallow comparisons where both sides are exactly the same",
    "rationale": "Comparing a variable against itself is usually an error, either a typo or refactoring error. It is confusing to the reader and may potentially introduce a runtime error.",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-self-compare\": true\n"
    ],
    "typescriptOnly": false,
    "type": "maintainability",
    "documentation": "https://eslint.org/docs/rules/ter-no-self-compare",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoSelfCompareRule.js",
    "ruleName": "ter-no-self-compare",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-sparse-arrays": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-sparse-arrays",
    "description": "disallow sparse arrays (recommended)",
    "rationale": "\nInvalid or irregular whitespace causes issues with ECMAScript 5 parsers and also makes code\nharder to debug in a similar nature to mixed tabs and spaces.\n",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-sparse-arrays\": [true]\n"
    ],
    "typescriptOnly": false,
    "type": "typescript",
    "documentation": "https://eslint.org/docs/rules/ter-no-sparse-arrays",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoSparseArraysRule.js",
    "ruleName": "ter-no-sparse-arrays",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-no-tabs": {
    "id": "./node_modules/tslint-eslint-rules:ter-no-tabs",
    "hasFix": false,
    "description": "disallow all tabs",
    "rationale": "\nThis rule looks for tabs anywhere inside a file: code, comments or anything else, and disallows their usage.\n",
    "optionsDescription": "",
    "options": {},
    "optionExamples": [
      "\n\"ter-no-tabs\": true\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-no-tabs",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terNoTabsRule.js",
    "ruleName": "ter-no-tabs",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-padded-blocks": {
    "id": "./node_modules/tslint-eslint-rules:ter-padded-blocks",
    "hasFix": false,
    "description": "enforces consistent empty line padding within blocks",
    "rationale": "\nSome style guides require block statements to start and end with blank\nlines. The goal is to improve readability by visually separating the\nblock content and the surrounding code.\n",
    "optionsDescription": "This rule has one option, which can be a string option or an object option",
    "options": {
      "type": "array",
      "items": [
        {
          "enum": [
            "always",
            "never"
          ]
        },
        {
          "type": "object",
          "properties": {
            "blocks": {
              "enum": [
                "always",
                "never"
              ]
            },
            "classes": {
              "enum": [
                "always",
                "never"
              ]
            },
            "switches": {
              "enum": [
                "always",
                "never"
              ]
            }
          },
          "additionalProperties": false
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-padded-blocks\": [true]\n",
      "\n\"ter-padded-blocks\": [true, \"always\"]\n",
      "\n\"ter-padded-blocks\": [true, \"never\"]\n",
      "\n\"ter-padded-blocks\": [true, { \"blocks\": \"always\" }]\n",
      "\n\"ter-padded-blocks\": [true, { \"blocks\": \"never\" }]\n"
    ],
    "typescriptOnly": false,
    "type": "style",
    "documentation": "https://eslint.org/docs/rules/ter-padded-blocks",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terPaddedBlocksRule.js",
    "ruleName": "ter-padded-blocks",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "ter-prefer-arrow-callback": {
    "id": "./node_modules/tslint-eslint-rules:ter-prefer-arrow-callback",
    "description": "require arrow functions as callbacks",
    "rationale": "\nArrow functions are suited to callbacks, because:\n\n* `this` keywords in arrow functions bind to the upper scope’s.\n* The notation of the arrow function is shorter than function expression’s.\n",
    "optionsDescription": "\nThis rule takes one optional argument, an object which is an options object. This object\nmay specify the following properties:\n\n* `\"allowNamedFunctions\"` (default false) When set to `true`, the rule doesn't warn on\n                            named functions used as callback.\n* `\"allowUnboundThis\"` (default true) When set to `false`, this option allows the use of\n                         `this` without restriction and checks for dynamically assigned\n                         `this` values such as when using `Array.prototype.map` with a\n                         `context` argument. Normally, the rule will flag the use of this\n                         whenever a function does not use `bind()` to specify the value of\n                         `this` constantly.\n",
    "options": {
      "type": "array",
      "items": [
        {
          "type": "object",
          "properties": {
            "allowNamedFunctions": {
              "type": "boolean"
            },
            "allowUnboundThis": {
              "type": "boolean"
            }
          },
          "additionalProperties": false
        }
      ],
      "maxLength": 1
    },
    "optionExamples": [
      "\n\"ter-prefer-arrow-callback\": [true]\n",
      "\n\"ter-prefer-arrow-callback\": [true, {\n  \"allowNamedFunctions\": true\n}]\n",
      "\n\"ter-prefer-arrow-callback\": [true, {\n  \"allowUnboundThis\": false\n}]\n",
      "\n\"ter-prefer-arrow-callback\": [true, {\n  \"allowNamedFunctions\": true,\n  \"allowUnboundThis\": false\n}]\n"
    ],
    "typescriptOnly": false,
    "type": "typescript",
    "documentation": "https://eslint.org/docs/rules/ter-prefer-arrow-callback",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/terPreferArrowCallbackRule.js",
    "ruleName": "ter-prefer-arrow-callback",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "trailing-comma": {
    "id": "./node_modules/tslint:trailing-comma",
    "description": "\nRequires or disallows trailing commas in array and object literals, destructuring assignments, function typings,\nnamed imports and exports and function parameters.",
    "hasFix": true,
    "optionsDescription": "\nOne argument which is an object with the keys `multiline` and `singleline`.\nBoth can be set to a string (`\"always\"` or `\"never\"`) or an object.\n\nThe object can contain any of the following keys: `\"arrays\"`, `\"objects\"`, `\"functions\"`,\n`\"imports\"`, `\"exports\"`, and `\"typeLiterals\"`; each key can have one of the following\nvalues: `\"always\"`, `\"never\"`, and `\"ignore\"`. Any missing keys will default to `\"ignore\"`.\n\n* `\"multiline\"` checks multi-line object literals.\n* `\"singleline\"` checks single-line object literals.\n\nAn array is considered \"multiline\" if its closing bracket is on a line\nafter the last array element. The same general logic is followed for\nobject literals, function typings, named import statements\nand function parameters.\n\nTo align this rule with the ECMAScript specification that is implemented in modern JavaScript VMs,\nthere is a third option `esSpecCompliant`. Set this option to `true` to disallow trailing comma on\nobject and array rest and rest parameters.\n        ",
    "options": {
      "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"
                  ]
                }
              }
            }
          ]
        },
        "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"
                  ]
                }
              }
            }
          ]
        },
        "esSpecCompliant": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "optionExamples": [
      [
        true,
        {
          "multiline": "always",
          "singleline": "never"
        }
      ],
      [
        true,
        {
          "multiline": {
            "objects": "always",
            "arrays": "always",
            "functions": "never",
            "typeLiterals": "ignore"
          },
          "esSpecCompliant": true
        }
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/trailing-comma",
    "path": "./node_modules/tslint/lib/rules/trailingCommaRule.js",
    "ruleName": "trailing-comma",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "triple-equals": {
    "id": "./node_modules/tslint:triple-equals",
    "description": "Requires `===` and `!==` in place of `==` and `!=`.",
    "optionsDescription": "\nTwo arguments may be optionally provided:\n\n* `\"allow-null-check\"` allows `==` and `!=` when comparing to `null`.\n* `\"allow-undefined-check\"` allows `==` and `!=` when comparing to `undefined`.",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "allow-null-check",
          "allow-undefined-check"
        ]
      },
      "minLength": 0,
      "maxLength": 2
    },
    "optionExamples": [
      true,
      [
        true,
        "allow-null-check"
      ],
      [
        true,
        "allow-undefined-check"
      ]
    ],
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/triple-equals",
    "path": "./node_modules/tslint/lib/rules/tripleEqualsRule.js",
    "ruleName": "triple-equals",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "type-literal-delimiter": {
    "id": "./node_modules/tslint:type-literal-delimiter",
    "description": "\nChecks that type literal members are separated by semicolons.\nEnforces a trailing semicolon for multiline type literals.",
    "optionsDescription": "`{singleLine: \"always\"}` enforces semicolon for one liners",
    "options": {
      "type": "object",
      "properties": {
        "singleLine": {
          "type": "string",
          "enum": [
            "always",
            "never"
          ]
        }
      }
    },
    "hasFix": true,
    "optionExamples": [
      true
    ],
    "type": "style",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/type-literal-delimiter",
    "path": "./node_modules/tslint/lib/rules/typeLiteralDelimiterRule.js",
    "ruleName": "type-literal-delimiter",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "typedef": {
    "id": "./node_modules/tslint:typedef",
    "description": "Requires type definitions to exist.",
    "optionsDescription": "\nSeveral arguments may be optionally provided:\n\n* `\"call-signature\"` checks return type of functions.\n* `\"arrow-call-signature\"` checks return type of arrow functions.\n* `\"parameter\"` checks type specifier of function parameters for non-arrow functions.\n* `\"arrow-parameter\"` checks type specifier of function parameters for arrow functions.\n* `\"property-declaration\"` checks return types of interface properties.\n* `\"variable-declaration\"` checks non-binding variable declarations.\n* `\"member-variable-declaration\"` checks member variable declarations.\n* `\"object-destructuring\"` checks object destructuring declarations.\n* `\"array-destructuring\"` checks array destructuring declarations.",
    "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"
        ]
      },
      "minLength": 0,
      "maxLength": 7
    },
    "optionExamples": [
      [
        true,
        "call-signature",
        "parameter",
        "member-variable-declaration"
      ]
    ],
    "type": "typescript",
    "typescriptOnly": true,
    "codeExamples": [
      {
        "description": "Requires type definitions for call signatures",
        "config": "\n\"rules\": { \"typedef\": [true, \"call-signature\"] }\n        ",
        "pass": "\nfunction add(x, y): number {\n    return x + y;\n}\n        ",
        "fail": "\nfunction add(x, y) {\n    return x + y;\n}\n        "
      },
      {
        "description": "Requires type definitions for arrow call signatures",
        "config": "\n\"rules\": { \"typedef\": [true, \"arrow-call-signature\"] }\n        ",
        "pass": "\nconst add = (x, y): number => x + y;\n        ",
        "fail": "\nconst add = (x, y) => x + y;\n        "
      },
      {
        "description": "Requires type definitions for parameters",
        "config": "\n\"rules\": { \"typedef\": [true, \"parameter\"] }\n        ",
        "pass": "\nfunction add(x: number, y: number) {\n    return x + y;\n}\n        ",
        "fail": "\nfunction add(x, y) {\n    return x + y;\n}\n        "
      },
      {
        "description": "Requires type definitions for arrow function parameters",
        "config": "\n\"rules\": { \"typedef\": [true, \"arrow-parameter\"] }\n        ",
        "pass": "\nconst add = (x: number, y: number) => x + y;\n        ",
        "fail": "\nconst add = (x, y) => x + y;\n        "
      },
      {
        "description": "Requires type definitions for property declarations",
        "config": "\n\"rules\": { \"typedef\": [true, \"property-declaration\"] }\n        ",
        "pass": "\ninterface I {\n    foo: number;\n    bar: string;\n}\n    ",
        "fail": "\ninterface I {\n    foo;\n    bar;\n}\n        "
      },
      {
        "description": "Requires type definitions for variable declarations",
        "config": "\n\"rules\": { \"typedef\": [true, \"variable-declaration\"] }\n        ",
        "pass": "\nlet x: number;\n        ",
        "fail": "\nlet x;\n        "
      },
      {
        "description": "Requires type definitions for member variable declarations",
        "config": "\n\"rules\": { \"typedef\": [true, \"member-variable-declaration\"] }\n        ",
        "pass": "\nclass MyClass {\n    x: number;\n}\n        ",
        "fail": "\nclass MyClass {\n    x;\n}\n        "
      },
      {
        "description": "Requires type definitions when destructuring objects.",
        "config": "\n\"rules\": { \"typedef\": [true, \"object-destructuring\"] }\n        ",
        "pass": "\ninterface FooBar {\n    foo: number;\n    bar: string;\n}\nconst foobar = { foo: 1, bar: '2' };\nconst { foo, bar }: FooBar = foobar;\n        ",
        "fail": "\ninterface FooBar {\n    foo: number;\n    bar: string;\n}\nconst foobar = { foo: 1, bar: '2' };\nconst { foo, bar } = foobar;\n        "
      },
      {
        "description": "Requires type definitions when destructuring arrays.",
        "config": "\n\"rules\": { \"typedef\": [true, \"array-destructuring\"] }\n        ",
        "pass": "\nconst foobar = [1, '2'];\nconst [foo, bar]: Array<number | string> = foobar;\n        ",
        "fail": "\nconst foobar = [1, '2'];\nconst [foo, bar] = foobar;\n        "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/typedef",
    "path": "./node_modules/tslint/lib/rules/typedefRule.js",
    "ruleName": "typedef",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "typedef-whitespace": {
    "id": "./node_modules/tslint:typedef-whitespace",
    "description": "Requires or disallows whitespace for type definitions.",
    "descriptionDetails": "Determines if a space is required or not before the colon in a type specifier.",
    "optionsDescription": "\nTwo arguments which are both objects.\nThe first argument specifies how much space should be to the _left_ of a typedef colon.\nThe second argument specifies how much space should be to the _right_ of a typedef colon.\nEach key should have a value of `\"onespace\"`, `\"space\"` or `\"nospace\"`.\nPossible keys are:\n\n* `\"call-signature\"` checks return type of functions.\n* `\"index-signature\"` checks index type specifier of indexers.\n* `\"parameter\"` checks function parameters.\n* `\"property-declaration\"` checks object property declarations.\n* `\"variable-declaration\"` checks variable declaration.",
    "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
        }
      ],
      "additionalItems": false
    },
    "optionExamples": [
      [
        true,
        {
          "call-signature": "nospace",
          "index-signature": "nospace",
          "parameter": "nospace",
          "property-declaration": "nospace",
          "variable-declaration": "nospace"
        },
        {
          "call-signature": "onespace",
          "index-signature": "onespace",
          "parameter": "onespace",
          "property-declaration": "onespace",
          "variable-declaration": "onespace"
        }
      ]
    ],
    "type": "formatting",
    "typescriptOnly": true,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/typedef-whitespace",
    "path": "./node_modules/tslint/lib/rules/typedefWhitespaceRule.js",
    "ruleName": "typedef-whitespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "typeof-compare": {
    "id": "./node_modules/tslint:typeof-compare",
    "description": "Makes sure result of `typeof` is compared to correct string values",
    "type": "functionality",
    "typescriptOnly": false,
    "deprecationMessage": "Starting from TypeScript 2.2 the compiler includes this check which makes this rule redundant.",
    "documentation": "https://palantir.github.io/tslint/rules/typeof-compare",
    "path": "./node_modules/tslint/lib/rules/typeofCompareRule.js",
    "ruleName": "typeof-compare",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "underscore-consistent-invocation": {
    "id": "./node_modules/tslint-microsoft-contrib:underscore-consistent-invocation",
    "type": "maintainability",
    "description": "Enforce a consistent usage of the _ functions",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Low",
    "level": "Opportunity for Excellence",
    "group": "Clarity",
    "commonWeaknessEnumeration": "398, 710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/underscoreConsistentInvocationRule.js",
    "ruleName": "underscore-consistent-invocation",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "unified-signatures": {
    "id": "./node_modules/tslint:unified-signatures",
    "description": "Warns for any two overloads that could be unified into one by using a union or an optional/rest parameter.",
    "type": "typescript",
    "typescriptOnly": true,
    "documentation": "https://palantir.github.io/tslint/rules/unified-signatures",
    "path": "./node_modules/tslint/lib/rules/unifiedSignaturesRule.js",
    "ruleName": "unified-signatures",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "unnecessary-bind": {
    "id": "./node_modules/tslint:unnecessary-bind",
    "description": "Prevents unnecessary and/or misleading scope bindings on functions.",
    "rationale": "\n`function` expressions that are immediately bound to `this` are equivalent to `() =>` arrow lambdas.\nAdditionally, there's no use in binding a scope to an arrow lambda, as it already has one.\n        ",
    "requiresTypeInfo": true,
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/unnecessary-bind",
    "path": "./node_modules/tslint/lib/rules/unnecessaryBindRule.js",
    "ruleName": "unnecessary-bind",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "unnecessary-constructor": {
    "id": "./node_modules/tslint:unnecessary-constructor",
    "description": "Prevents blank constructors, as they are redundant.",
    "rationale": "\nJavaScript implicitly adds a blank constructor when there isn't one.\nIt's not necessary to manually add one in.\n        ",
    "type": "functionality",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/unnecessary-constructor",
    "path": "./node_modules/tslint/lib/rules/unnecessaryConstructorRule.js",
    "ruleName": "unnecessary-constructor",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "use-default-type-parameter": {
    "id": "./node_modules/tslint:use-default-type-parameter",
    "description": "Warns if an explicitly specified type argument is the default for that type parameter.",
    "type": "functionality",
    "typescriptOnly": true,
    "requiresTypeInfo": true,
    "documentation": "https://palantir.github.io/tslint/rules/use-default-type-parameter",
    "path": "./node_modules/tslint/lib/rules/useDefaultTypeParameterRule.js",
    "ruleName": "use-default-type-parameter",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "use-isnan": {
    "id": "./node_modules/tslint:use-isnan",
    "description": "Enforces use of the `isNaN()` function to check for NaN references instead of a comparison to the `NaN` constant.",
    "rationale": "\nSince `NaN !== NaN`, comparisons with regular operators will produce unexpected results.\nSo, instead of `if (myVar === NaN)`, do `if (isNaN(myVar))`.",
    "type": "functionality",
    "typescriptOnly": false,
    "codeExamples": [
      {
        "description": "Enforces usage of `isNan()`.",
        "config": "\n\"rules\": { \"use-isnan\": true }\n        ",
        "pass": "\nif (isNaN(parseInt('_4711'))) {\n    doSomething();\n}\n        ",
        "fail": "\nif (parseInt('_4711') === NaN) {\n    doSomething();\n}\n       "
      }
    ],
    "documentation": "https://palantir.github.io/tslint/rules/use-isnan",
    "path": "./node_modules/tslint/lib/rules/useIsnanRule.js",
    "ruleName": "use-isnan",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "use-named-parameter": {
    "id": "./node_modules/tslint-microsoft-contrib:use-named-parameter",
    "type": "maintainability",
    "description": "Do not reference the arguments object by numerical index; instead, use a named parameter.",
    "typescriptOnly": true,
    "issueClass": "Non-SDL",
    "issueType": "Warning",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "commonWeaknessEnumeration": "710",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/useNamedParameterRule.js",
    "ruleName": "use-named-parameter",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "use-simple-attributes": {
    "id": "./node_modules/tslint-microsoft-contrib:use-simple-attributes",
    "type": "functionality",
    "description": "Enforce usage of only simple attribute types.",
    "rationale": "Simpler attributes in JSX and TSX files helps keep code clean and readable.            Separate complex expressions into their own line and use clear variable names to make your code more understandable.",
    "typescriptOnly": false,
    "issueClass": "Non-SDL",
    "issueType": "Error",
    "severity": "Important",
    "level": "Opportunity for Excellence",
    "group": "Correctness",
    "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
    "path": "./node_modules/tslint-microsoft-contrib/useSimpleAttributesRule.js",
    "ruleName": "use-simple-attributes",
    "source": "tslint-microsoft-contrib",
    "sourcePath": "./node_modules/tslint-microsoft-contrib"
  },
  "valid-jsdoc": {
    "id": "./node_modules/tslint-eslint-rules:valid-jsdoc",
    "hasFix": false,
    "description": "enforce valid JSDoc comments",
    "rationale": "\n[JSDoc](http://usejsdoc.org/) generates application programming interface (API) documentation\nfrom specially-formatted comments in JavaScript code. So does [typedoc](http://typedoc.org/).\n\nIf comments are invalid because of typing mistakes, then documentation will be incomplete.\n\nIf comments are inconsistent because they are not updated when function definitions are\nmodified, then readers might become confused.\n",
    "optionsDescription": "\nThis rule has an object option:\n\n* `\"prefer\"` enforces consistent documentation tags specified by an object whose properties\n               mean instead of key use value (for example, `\"return\": \"returns\"` means\n               instead of `@return` use `@returns`)\n* `\"preferType\"` enforces consistent type strings specified by an object whose properties\n                   mean instead of key use value (for example, `\"object\": \"Object\"` means\n                   instead of `object` use `Object`)\n* `\"requireReturn\"` requires a return tag:\n  * `true` (default) *even if* the function or method does not have a return statement\n             (this option value does not apply to constructors)\n  * `false` *if and only if* the function or method has a return statement (this option\n              value does apply to constructors)\n* `\"requireParamType\"`: `false` allows missing type in param tags\n* `\"requireReturnType\"`: `false` allows missing type in return tags\n* `\"matchDescription\"` specifies (as a string) a regular expression to match the description\n                         in each JSDoc comment (for example, `\".+\"` requires a description;\n                         this option does not apply to descriptions in parameter or return\n                         tags)\n* `\"requireParamDescription\"`: `false` allows missing description in parameter tags\n* `\"requireReturnDescription\"`: `false` allows missing description in return tags\n",
    "options": {
      "type": "object",
      "properties": {
        "prefer": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "preferType": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          }
        },
        "requireReturn": {
          "type": "boolean"
        },
        "requireParamDescription": {
          "type": "boolean"
        },
        "requireReturnDescription": {
          "type": "boolean"
        },
        "matchDescription": {
          "type": "string"
        },
        "requireParamType": {
          "type": "boolean"
        },
        "requireReturnType": {
          "type": "boolean"
        }
      },
      "additionalProperties": false
    },
    "optionExamples": [
      "\n\"valid-jsdoc\": [true]\n",
      "\n\"valid-jsdoc\": [true, {\n  \"prefer\": {\n    \"return\": \"returns\"\n  },\n  \"requireReturn\": false,\n  \"requireParamDescription\": true,\n  \"requireReturnDescription\": true,\n  \"matchDescription\": \"^[A-Z][A-Za-z0-9\\\\s]*[.]$\"\n}]\n"
    ],
    "typescriptOnly": false,
    "type": "maintainability",
    "documentation": "https://eslint.org/docs/rules/valid-jsdoc",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/validJsdocRule.js",
    "ruleName": "valid-jsdoc",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules"
  },
  "valid-typeof": {
    "id": "./node_modules/tslint-eslint-rules:valid-typeof",
    "documentation": "https://eslint.org/docs/rules/valid-typeof",
    "path": "./node_modules/tslint-eslint-rules/dist/rules/validTypeofRule.js",
    "ruleName": "valid-typeof",
    "source": "tslint-eslint-rules",
    "sourcePath": "./node_modules/tslint-eslint-rules",
    "sameName": [
      {
        "id": "./node_modules/tslint-microsoft-contrib:valid-typeof",
        "type": "maintainability",
        "description": "Ensures that the results of typeof are compared against a valid string.",
        "typescriptOnly": true,
        "issueClass": "Non-SDL",
        "issueType": "Error",
        "severity": "Critical",
        "level": "Opportunity for Excellence",
        "recommendation": "false,",
        "group": "Deprecated",
        "documentation": "https://github.com/Microsoft/tslint-microsoft-contrib#supported-rules",
        "path": "./node_modules/tslint-microsoft-contrib/validTypeofRule.js",
        "ruleName": "valid-typeof",
        "source": "tslint-microsoft-contrib",
        "sourcePath": "./node_modules/tslint-microsoft-contrib"
      }
    ]
  },
  "variable-name": {
    "id": "./node_modules/tslint:variable-name",
    "description": "Checks variable names for various errors.",
    "optionsDescription": "\nFive arguments may be optionally provided:\n\n* `\"check-format\"`: allows only lowerCamelCased or UPPER_CASED variable names\n  * `\"allow-leading-underscore\"` allows underscores at the beginning (only has an effect if \"check-format\" specified)\n  * `\"allow-trailing-underscore\"` allows underscores at the end. (only has an effect if \"check-format\" specified)\n  * `\"allow-pascal-case\"` allows PascalCase in addition to lowerCamelCase.\n  * `\"allow-snake-case\"` allows snake_case in addition to lowerCamelCase.\n* `\"ban-keywords\"`: disallows the use of certain TypeScript keywords as variable or parameter names.\n  * These are: `any`, `Number`, `number`, `String`, `string`, `Boolean`, `boolean`, `Undefined`, `undefined`",
    "options": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "check-format",
          "allow-leading-underscore",
          "allow-trailing-underscore",
          "allow-pascal-case",
          "allow-snake-case",
          "ban-keywords"
        ]
      },
      "minLength": 0,
      "maxLength": 5
    },
    "optionExamples": [
      [
        true,
        "ban-keywords",
        "check-format",
        "allow-leading-underscore"
      ]
    ],
    "type": "style",
    "typescriptOnly": false,
    "documentation": "https://palantir.github.io/tslint/rules/variable-name",
    "path": "./node_modules/tslint/lib/rules/variableNameRule.js",
    "ruleName": "variable-name",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  },
  "whitespace": {
    "id": "./node_modules/tslint:whitespace",
    "description": "Enforces whitespace style conventions.",
    "rationale": "Helps maintain a readable, consistent style in your codebase.",
    "optionsDescription": "\nTen arguments may be optionally provided:\n\n* `\"check-branch\"` checks branching statements (`if`/`else`/`for`/`while`) are followed by whitespace.\n* `\"check-decl\"`checks that variable declarations have whitespace around the equals token.\n* `\"check-operator\"` checks for whitespace around operator tokens.\n* `\"check-module\"` checks for whitespace in import & export statements.\n* `\"check-separator\"` checks for whitespace after separator tokens (`,`/`;`).\n* `\"check-rest-spread\"` checks that there is no whitespace after rest/spread operator (`...`).\n* `\"check-type\"` checks for whitespace before a variable type specification.\n* `\"check-typecast\"` checks for whitespace between a typecast and its target.\n* `\"check-type-operator\"` checks for whitespace between type operators `|` and `&`.\n* `\"check-preblock\"` checks for whitespace before the opening brace of a block.\n* `\"check-postbrace\"` checks for whitespace after an opening brace.",
    "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"
        ]
      },
      "minLength": 0,
      "maxLength": 11
    },
    "optionExamples": [
      [
        true,
        "check-branch",
        "check-operator",
        "check-typecast"
      ]
    ],
    "type": "formatting",
    "typescriptOnly": false,
    "hasFix": true,
    "documentation": "https://palantir.github.io/tslint/rules/whitespace",
    "path": "./node_modules/tslint/lib/rules/whitespaceRule.js",
    "ruleName": "whitespace",
    "source": "tslint",
    "sourcePath": "./node_modules/tslint"
  }
}