{
  "compilerOptions": {
    "plugins": [
      {
        "name": "typescript-tslint-plugin",
        "alwaysShowRuleFailuresAsWarnings": false,
        "ignoreDefinitionFiles": true,
        "configFile": "../tslint.json",
        "suppressWhileTypeErrorsPresent": false,
        "mockTypeScriptVersion": false
      }
    ]
  },
  "rules": {
    // Force function overloads to be declared together. This ensures readers understand APIs.
    "adjacent-overload-signatures": true,

    // Checks variable names for various errors.
    "variable-name": [true, "ban-keywords", "check-format", "allow-leading-underscore"],

    // Enforces braces for if/for/do/while statements.
    "curly": [true, "ignore-same-line"],

    // Warns for an awaited value that is not a Promise.
    "await-promise": true,

    // Enforces indentation with tabs or spaces.
    "indent": [true, "spaces", 2],

    // Bans “// @ts-ignore” comments from being used.
    "ban-ts-ignore": true,

    // Ensures the file ends with a newline.
    "eofline": true,

    // Enforces explicit visibility on get/set accessors
    "member-access": [true, "check-accessor"],

    // Do not allow the subtle/obscure comma operator.
    "ban-comma-operator": true,

    // Disallows the use of require statements except in import statements.
    "no-var-requires": false,

    // Do not allow internal modules or namespaces . These are deprecated in favor of ES6 modules.
    "no-namespace": true,

    // Do not allow parameters to be reassigned. To avoid bugs, developers should instead assign new values to new vars.
    "no-parameter-reassignment": true,

    // Force the use of ES6-style imports instead of /// <reference path=> imports.
    "no-reference": true,

    // Do not allow type assertions that do nothing. This is a big warning that the developer may not understand the
    // code currently being edited (they may be incorrectly handling a different type case that does not exist).
    "no-unnecessary-type-assertion": true,

    // Disallow nonsensical label usage.
    "label-position": true,

    // Disallows the (often typo) syntax if (var1 = var2). Replace with if (var2) { var1 = var2 }.
    "no-conditional-assignment": true,

    // Disallows constructors for primitive types (e.g. new Number('123'), though Number('123') is still allowed).
    "no-construct": true,

    // Do not allow super() to be called twice in a constructor.
    "no-duplicate-super": true,

    // Do not allow the same case to appear more than once in a switch block.
    "no-duplicate-switch-case": true,

    // Do not allow a variable to be declared more than once in the same block. Consider function parameters in this
    // rule.
    "no-duplicate-variable": [true, "check-parameters"],

    // Disallows a variable definition in an inner scope from shadowing a variable in an outer scope. Developers should
    // instead use a separate variable name.
    "no-shadowed-variable": true,

    // Empty blocks are almost never needed. Allow the one general exception: empty catch blocks.
    "no-empty": true,

    // Functions must either be handled directly (e.g. with a catch() handler) or returned to another function.
    // This is a major source of errors in Cloud Functions and the team strongly recommends leaving this rule on.
    "no-floating-promises": true,

    // The 'this' keyword can only be used inside of classes.
    "no-invalid-this": true,

    // Do not allow strings to be thrown because they will not include stack traces. Throw Errors instead.
    "no-string-throw": true,

    // Disallow control flow statements, such as return, continue, break, and throw in finally blocks.
    "no-unsafe-finally": true,

    // Expressions must always return a value. Avoids common errors like const myValue = functionReturningVoid();
    "no-void-expression": [true, "ignore-arrow-function-shorthand"],

    // Disallow duplicate imports in the same file.
    "no-duplicate-imports": true,

    // Warns on apparent attempts to define constructors for interfaces or new for classes.
    "no-misused-new": true,

    // Enforces consistent semicolon usage at the end of every statement.
    "semicolon": [true, "always"],


    // -- Strong Warnings --
    // These rules should almost never be needed, but may be included due to legacy code.
    // They are left as a warning to avoid frustration with blocked deploys when the developer
    // understand the warning and wants to deploy anyway.

    // Warn when an empty interface is defined. These are generally not useful.
    "no-empty-interface": {"severity": "warning"},

    // Warn when an import will have side effects.
    "no-import-side-effect": {"severity": "warning"},

    // Warn when variables are defined with var. Var has subtle meaning that can lead to bugs. Strongly prefer const for
    // most values and let for values that will change.
    "no-var-keyword": {"severity": "warning"},

    // Prefer === and !== over == and !=. The latter operators support overloads that are often accidental.
    "triple-equals": [true, "allow-null-check"],

    // Warn when using deprecated APIs.
    "deprecation": {"severity": "warning"},

    // -- Light Warnings --
    // These rules are intended to help developers use better style. Simpler code has fewer bugs. These would be "info"
    // if TSLint supported such a level.

    // prefer for( ... of ... ) to an index loop when the index is only used to fetch an object from an array.
    // (Even better: check out utils like .map if transforming an array!)
    "prefer-for-of": {"severity": "warning"},

    // Warns if function overloads could be unified into a single function with optional or rest parameters.
    "unified-signatures": {"severity": "warning"},

    // Prefer const for values that will not change. This better documents code.
    "prefer-const": {"severity": "warning"},

    // Multi-line object literals and function calls should have a trailing comma. This helps avoid merge conflicts.
    "trailing-comma": {"severity": "warning"}
  },

  "defaultSeverity": "error"
}