feat: add package scope-manager (#1939)

.cspell.json

@@ -12,7 +12,8 @@
     "**/*.{json,snap}",
     ".cspell.json",
     "yarn.lock",
-    ".github/workflows/**"
+    ".github/workflows/**",
+    ".vscode/*.json"
   ],
   "dictionaries": [
     "typescript",
@@ -57,6 +58,7 @@
     "ESLint",
     "ESLint's",
     "espree",
+    "esrecurse",
     "estree",
     "IDE's",
     "IIFE",
@@ -75,11 +77,13 @@
     "Premade",
     "prettier's",
     "recurse",
+    "redeclared",
     "reimplement",
     "resync",
     "ROADMAP",
     "ruleset",
     "rulesets",
+    "serializers",
     "superset",
     "thenables",
     "transpiles",

.eslintrc.js

@@ -55,6 +55,11 @@ module.exports = {
     '@typescript-eslint/prefer-nullish-coalescing': 'error',
     '@typescript-eslint/prefer-optional-chain': 'error',
     '@typescript-eslint/unbound-method': 'off',
+    '@typescript-eslint/prefer-as-const': 'error',
+    '@typescript-eslint/no-unused-vars': [
+      'warn',
+      { varsIgnorePattern: '^_', argsIgnorePattern: '^_' },
+    ],
 
     // TODO - enable these new recommended rules
     '@typescript-eslint/no-floating-promises': 'off',
@@ -224,5 +229,18 @@ module.exports = {
         'no-console': 'off',
       },
     },
+    // generated files
+    {
+      files: [
+        'packages/scope-manager/src/lib/*.ts',
+        'packages/eslint-plugin/src/configs/*.ts',
+      ],
+      rules: {
+        // allow console logs in tools and tests
+        '@typescript-eslint/internal/no-poorly-typed-ts-props': 'off',
+        '@typescript-eslint/internal/no-typescript-default-import': 'off',
+        '@typescript-eslint/internal/prefer-ast-types-enum': 'off',
+      },
+    },
   ],
 };

.github/workflows/ci.yml

@@ -4,8 +4,6 @@ on:
   push:
     branches:
       - master
-      # TODO - delete this before merging v3 into master
-      - v3
   pull_request:
     branches:
       - '**'
@@ -103,6 +101,12 @@ jobs:
         env:
           CI: true
 
+      - name: Run unit tests for scope-manager
+        run: yarn test
+        working-directory: packages/scope-manager
+        env:
+          CI: true
+
       - name: Run unit tests for experimental-utils
         run: yarn test
         working-directory: packages/experimental-utils
@@ -269,6 +273,12 @@ jobs:
         env:
           CI: true
 
+      - name: Run unit tests for scope-manager
+        run: yarn test
+        working-directory: packages/scope-manager
+        env:
+          CI: true
+
       - name: Run unit tests for experimental-utils
         run: yarn test
         working-directory: packages/experimental-utils

.prettierignore

@@ -1,4 +1,5 @@
 **/tests/fixtures/**/*
+!packages/scope-manager/tests/fixtures/**/*
 **/tests/fixture-project/**/*
 **/dist
 **/coverage

.vscode/extensions.json

@@ -1,10 +1,11 @@
 {
   "recommendations": [
-      "esbenp.prettier-vscode",
+      "davidanson.vscode-markdownlint",
       "dbaeumer.vscode-eslint",
       "editorconfig.editorconfig",
+      "esbenp.prettier-vscode",
       "streetsidesoftware.code-spell-checker",
-      "davidanson.vscode-markdownlint"
+      "tlent.jest-snapshot-language-support"
   ],
   "unwantedRecommendations": ["hookyqr.beautify", "dbaeumer.jshint"]
 }

.vscode/launch.json

@@ -32,6 +32,8 @@
         "${workspaceFolder}/packages/types/dist/index.js",
         "${workspaceFolder}/packages/visitor-keys/src/index.ts",
         "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
       ],
     },
     {
@@ -62,6 +64,8 @@
         "${workspaceFolder}/packages/types/dist/index.js",
         "${workspaceFolder}/packages/visitor-keys/src/index.ts",
         "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
       ],
     },
     {
@@ -92,6 +96,8 @@
         "${workspaceFolder}/packages/types/dist/index.js",
         "${workspaceFolder}/packages/visitor-keys/src/index.ts",
         "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
       ],
     },
     {
@@ -122,6 +128,8 @@
         "${workspaceFolder}/packages/types/dist/index.js",
         "${workspaceFolder}/packages/visitor-keys/src/index.ts",
         "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
       ],
     },
     {
@@ -152,7 +160,41 @@
         "${workspaceFolder}/packages/types/dist/index.js",
         "${workspaceFolder}/packages/visitor-keys/src/index.ts",
         "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
       ],
-    }
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Run currently opened scope-manager test",
+      "cwd": "${workspaceFolder}/packages/scope-manager/",
+      "program": "${workspaceFolder}/node_modules/jest/bin/jest.js",
+      "args": [
+        "--runInBand",
+        "--no-cache",
+        "--no-coverage",
+        "${fileBasename}"
+      ],
+      "sourceMaps": true,
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "skipFiles": [
+        "${workspaceFolder}/packages/experimental-utils/src/index.ts",
+        "${workspaceFolder}/packages/experimental-utils/dist/index.js",
+        "${workspaceFolder}/packages/experimental-utils/src/ts-estree.ts",
+        "${workspaceFolder}/packages/experimental-utils/dist/ts-estree.js",
+        "${workspaceFolder}/packages/parser/src/index.ts",
+        "${workspaceFolder}/packages/parser/dist/index.js",
+        "${workspaceFolder}/packages/typescript-estree/src/index.ts",
+        "${workspaceFolder}/packages/typescript-estree/dist/index.js",
+        "${workspaceFolder}/packages/types/src/index.ts",
+        "${workspaceFolder}/packages/types/dist/index.js",
+        "${workspaceFolder}/packages/visitor-keys/src/index.ts",
+        "${workspaceFolder}/packages/visitor-keys/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+        "${workspaceFolder}/packages/scope-manager/dist/index.js",
+      ],
+    },
   ]
 }

.vscode/settings.json

@@ -18,4 +18,21 @@
   "javascript.preferences.quoteStyle": "single",
   "typescript.preferences.quoteStyle": "single",
   "editor.defaultFormatter": "esbenp.prettier-vscode",
+
+  // make the .shot files from jest-specific-snapshot act like normal snapshots
+  "files.associations": {
+    "*.shot": "jest-snapshot"
+  },
+  "vsicons.associations.files": [
+    {
+        "icon": "jest_snapshot",
+        "extensions": [
+            ".ts.shot",
+            ".tsx.shot",
+            ".js.shot",
+            ".jsx.shot",
+        ],
+        "extends": "jest_snapshot"
+    },
+  ],
 }

package.json

@@ -72,6 +72,7 @@
     "@types/jest": "^25.2.1",
     "@types/node": "^13.13.5",
     "@types/prettier": "^2.0.0",
+    "@types/rimraf": "^3.0.0",
     "all-contributors-cli": "^6.14.2",
     "cspell": "^4.0.61",
     "cz-conventional-changelog": "^3.2.0",

packages/eslint-plugin-internal/jest.config.js

@@ -1,5 +1,7 @@
 'use strict';
 
+// @ts-check
+/** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
   globals: {
     'ts-jest': {

packages/eslint-plugin-tslint/jest.config.js

@@ -1,5 +1,7 @@
 'use strict';
 
+// @ts-check
+/** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
   globals: {
     'ts-jest': {

packages/eslint-plugin/jest.config.js

@@ -1,5 +1,7 @@
 'use strict';
 
+// @ts-check
+/** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
   globals: {
     'ts-jest': {

packages/eslint-plugin/src/configs/all.ts

@@ -1,3 +1,7 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+
 export = {
   extends: ['./configs/base', './configs/eslint-recommended'],
   rules: {

packages/eslint-plugin/src/configs/base.ts

@@ -1,3 +1,7 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+
 export = {
   parser: '@typescript-eslint/parser',
   parserOptions: { sourceType: 'module' },

packages/eslint-plugin/src/configs/recommended-requiring-type-checking.ts

@@ -1,3 +1,7 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+
 export = {
   extends: ['./configs/base', './configs/eslint-recommended'],
   rules: {

packages/eslint-plugin/src/configs/recommended.ts

@@ -1,3 +1,7 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:configs
+
 export = {
   extends: ['./configs/base', './configs/eslint-recommended'],
   rules: {

packages/eslint-plugin/tools/generate-configs.ts

@@ -5,6 +5,16 @@ import path from 'path';
 import { format, resolveConfig } from 'prettier';
 import rules from '../src/rules';
 
+function addAutoGeneratedComment(code: string): string {
+  return [
+    '// THIS CODE WAS AUTOMATICALLY GENERATED',
+    '// DO NOT EDIT THIS CODE BY HAND',
+    '// YOU CAN REGENERATE IT USING yarn generate:configs',
+    '',
+    code,
+  ].join('\n');
+}
+
 const prettierConfig = resolveConfig.sync(__dirname);
 
 interface LinterConfigRules {
@@ -117,8 +127,9 @@ function reducer<TMessageIds extends string>(
  * Helper function writes configuration.
  */
 function writeConfig(config: LinterConfig, filePath: string): void {
+  // note: we use `export =` because ESLint will import these configs via a commonjs import
   const code = `export = ${JSON.stringify(config)};`;
-  const configStr = format(code, {
+  const configStr = format(addAutoGeneratedComment(code), {
     parser: 'typescript',
     ...prettierConfig,
   });

packages/experimental-utils/jest.config.js

@@ -1,5 +1,7 @@
 'use strict';
 
+// @ts-check
+/** @type {import('@jest/types').Config.InitialOptions} */
 module.exports = {
   globals: {
     'ts-jest': {

packages/scope-manager/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 TypeScript ESLint and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/scope-manager/README.md

@@ -0,0 +1,98 @@
+<h1 align="center">TypeScript Scope Manager</h1>
+
+<p align="center">
+    <img src="https://github.com/typescript-eslint/typescript-eslint/workflows/CI/badge.svg" alt="CI" />
+    <a href="https://www.npmjs.com/package/@typescript-eslint/scope-manager"><img src="https://img.shields.io/npm/v/@typescript-eslint/scope-manager.svg?style=flat-square" alt="NPM Version" /></a>
+    <a href="https://www.npmjs.com/package/@typescript-eslint/scope-manager"><img src="https://img.shields.io/npm/dm/@typescript-eslint/scope-manager.svg?style=flat-square" alt="NPM Downloads" /></a>
+</p>
+
+This is a fork of [`eslint-scope`](https://github.com/eslint/eslint-scope), enhanced to support TypeScript functionality.
+[You can view the original licence for the code here](https://github.com/eslint/eslint-scope/blob/dbddf14d5771b21b5da704213e4508c660ca1c64/LICENSE).
+
+This package is consumed automatically by [`@typescript-eslint/parser`](../parser).
+You probably don't want to use it directly.
+
+## Getting Started
+
+**[You can find our Getting Started docs here](../../docs/getting-started/linting/README.md)**
+
+## Installation
+
+```bash
+$ yarn add -D typescript @typescript-eslint/scope-manager
+$ npm i --save-dev typescript @typescript-eslint/scope-manager
+```
+
+## API
+
+### `analyze(tree, options)`
+
+Analyses a given AST and returns the resulting `ScopeManager`.
+
+```ts
+interface AnalyzeOptions {
+  /**
+   * Known visitor keys.
+   */
+  childVisitorKeys?: Record<string, string[]> | null;
+
+  /**
+   * Which ECMAScript version is considered.
+   * Defaults to `2018`.
+   */
+  ecmaVersion?: EcmaVersion;
+
+  /**
+   * Whether the whole script is executed under node.js environment.
+   * When enabled, the scope manager adds a function scope immediately following the global scope.
+   * Defaults to `false`.
+   */
+  globalReturn?: boolean;
+
+  /**
+   * Implied strict mode (if ecmaVersion >= 5).
+   * Defaults to `false`.
+   */
+  impliedStrict?: boolean;
+
+  /**
+   * The lib used by the project.
+   * This automatically defines a type variable for any types provided by the configured TS libs.
+   * For more information, see https://www.typescriptlang.org/tsconfig#lib
+   *
+   * Defaults to the lib for the provided `ecmaVersion`.
+   */
+  lib?: Lib[];
+
+  /**
+   * The source type of the script.
+   */
+  sourceType?: 'script' | 'module';
+}
+```
+
+Example usage:
+
+```ts
+import { analyze } from '@typescript-eslint/scope-manager';
+import { parse } from '@typescript-eslint/typescript-estree';
+
+const code = `const hello: string = 'world';`;
+const ast = parse(code, {
+  // note that scope-manager requires ranges on the AST
+  range: true,
+});
+const scope = analyze(ast, {
+  ecmaVersion: 2020,
+  sourceType: 'module',
+});
+```
+
+## References
+
+- https://eslint.org/docs/developer-guide/scope-manager-interface
+- https://github.com/eslint/eslint-scope
+
+## Contributing
+
+[See the contributing guide here](../../CONTRIBUTING.md)

packages/scope-manager/jest.config.js

@@ -0,0 +1,24 @@
+'use strict';
+
+// @ts-check
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  globals: {
+    'ts-jest': {
+      isolatedModules: true,
+    },
+  },
+  testEnvironment: 'node',
+  transform: {
+    [/^.+\.tsx?$/.source]: 'ts-jest',
+  },
+  testRegex: [
+    /.\/tests\/.+\.test\.ts$/.source,
+    /.\/tests\/eslint-scope\/[^/]+\.test\.ts$/.source,
+  ],
+  collectCoverage: false,
+  collectCoverageFrom: ['src/**/*.{js,jsx,ts,tsx}'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  coverageReporters: ['text-summary', 'lcov'],
+  setupFilesAfterEnv: ['./tests/util/serializers/index.ts'],
+};

packages/scope-manager/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@typescript-eslint/scope-manager",
+  "version": "3.4.0",
+  "description": "TypeScript scope analyser for ESLint",
+  "keywords": [
+    "eslint",
+    "typescript",
+    "estree"
+  ],
+  "engines": {
+    "node": "^8.10.0 || ^10.13.0 || >=11.10.1"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/typescript-eslint/typescript-eslint.git",
+    "directory": "packages/scope-manager"
+  },
+  "bugs": {
+    "url": "https://github.com/typescript-eslint/typescript-eslint/issues"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "postbuild": "downlevel-dts dist _ts3.4/dist",
+    "clean": "tsc -b tsconfig.build.json --clean",
+    "format": "prettier --write \"./**/*.{ts,js,json,md}\" --ignore-path ../../.prettierignore",
+    "generate:lib": "../../node_modules/.bin/ts-node --files --transpile-only tools/generate-lib.ts",
+    "lint": "eslint . --ext .js,.ts --ignore-path='../../.eslintignore'",
+    "test": "jest --coverage",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@typescript-eslint/types": "3.4.0",
+    "@typescript-eslint/visitor-keys": "3.4.0"
+  },
+  "devDependencies": {
+    "@types/jest-specific-snapshot": "^0.5.4",
+    "@types/mkdirp": "^1.0.0",
+    "@typescript-eslint/typescript-estree": "3.4.0",
+    "glob": "^7.1.6",
+    "jest-specific-snapshot": "^3.0.0",
+    "make-dir": "^3.1.0",
+    "prettier": "*",
+    "pretty-format": "^25.5.0",
+    "rimraf": "*",
+    "typescript": "*"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/typescript-eslint"
+  },
+  "typesVersions": {
+    "<3.8": {
+      "*": [
+        "_ts3.4/*"
+      ]
+    }
+  }
+}

packages/scope-manager/src/ID.ts

@@ -0,0 +1,20 @@
+const ID_CACHE = new Map<number, number>();
+let NEXT_KEY = 0;
+
+function createIdGenerator(): () => number {
+  const key = (NEXT_KEY += 1);
+  ID_CACHE.set(key, 0);
+
+  return (): number => {
+    const current = ID_CACHE.get(key) ?? 0;
+    const next = current + 1;
+    ID_CACHE.set(key, next);
+    return next;
+  };
+}
+
+function resetIds(): void {
+  ID_CACHE.clear();
+}
+
+export { createIdGenerator, resetIds };

packages/scope-manager/src/ScopeManager.ts

@@ -0,0 +1,251 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { assert } from './assert';
+import {
+  BlockScope,
+  CatchScope,
+  ClassScope,
+  ConditionalTypeScope,
+  ForScope,
+  FunctionExpressionNameScope,
+  FunctionScope,
+  FunctionTypeScope,
+  GlobalScope,
+  MappedTypeScope,
+  ModuleScope,
+  Scope,
+  SwitchScope,
+  TSEnumScope,
+  TSModuleScope,
+  TypeScope,
+  WithScope,
+} from './scope';
+
+import { Variable } from './variable';
+
+interface ScopeManagerOptions {
+  globalReturn?: boolean;
+  sourceType?: 'module' | 'script';
+  impliedStrict?: boolean;
+  ecmaVersion?: number;
+}
+
+class ScopeManager {
+  public currentScope: Scope | null;
+  public readonly declaredVariables: WeakMap<TSESTree.Node, Variable[]>;
+  /**
+   * The root scope
+   * @public
+   */
+  public globalScope: GlobalScope | null;
+  public readonly nodeToScope: WeakMap<TSESTree.Node, Scope[]>;
+  readonly #options: ScopeManagerOptions;
+  /**
+   * All scopes
+   * @public
+   */
+  public readonly scopes: Scope[];
+
+  public get variables(): Variable[] {
+    const variables = new Set<Variable>();
+    function recurse(scope: Scope): void {
+      scope.variables.forEach(v => variables.add(v));
+      scope.childScopes.forEach(recurse);
+    }
+    this.scopes.forEach(recurse);
+    return Array.from(variables).sort((a, b) => a.$id - b.$id);
+  }
+
+  constructor(options: ScopeManagerOptions) {
+    this.scopes = [];
+    this.globalScope = null;
+    this.nodeToScope = new WeakMap();
+    this.currentScope = null;
+    this.#options = options;
+    this.declaredVariables = new WeakMap();
+  }
+
+  public isGlobalReturn(): boolean {
+    return this.#options.globalReturn === true;
+  }
+
+  public isModule(): boolean {
+    return this.#options.sourceType === 'module';
+  }
+
+  public isImpliedStrict(): boolean {
+    return this.#options.impliedStrict === true;
+  }
+  public isStrictModeSupported(): boolean {
+    return this.#options.ecmaVersion != null && this.#options.ecmaVersion >= 5;
+  }
+
+  public isES6(): boolean {
+    return this.#options.ecmaVersion != null && this.#options.ecmaVersion >= 6;
+  }
+
+  /**
+   * Get the variables that a given AST node defines. The gotten variables' `def[].node`/`def[].parent` property is the node.
+   * If the node does not define any variable, this returns an empty array.
+   * @param node An AST node to get their variables.
+   * @public
+   */
+  public getDeclaredVariables(node: TSESTree.Node): Variable[] {
+    return this.declaredVariables.get(node) ?? [];
+  }
+
+  /**
+   * Get the scope of a given AST node. The gotten scope's `block` property is the node.
+   * This method never returns `function-expression-name` scope. If the node does not have their scope, this returns `null`.
+   *
+   * @param node An AST node to get their scope.
+   * @param inner If the node has multiple scopes, this returns the outermost scope normally.
+   *                If `inner` is `true` then this returns the innermost scope.
+   * @public
+   */
+  public acquire(node: TSESTree.Node, inner = false): Scope | null {
+    function predicate(testScope: Scope): boolean {
+      if (testScope.type === 'function' && testScope.functionExpressionScope) {
+        return false;
+      }
+      return true;
+    }
+
+    const scopes = this.nodeToScope.get(node);
+
+    if (!scopes || scopes.length === 0) {
+      return null;
+    }
+
+    // Heuristic selection from all scopes.
+    // If you would like to get all scopes, please use ScopeManager#acquireAll.
+    if (scopes.length === 1) {
+      return scopes[0];
+    }
+
+    if (inner) {
+      for (let i = scopes.length - 1; i >= 0; --i) {
+        const scope = scopes[i];
+
+        if (predicate(scope)) {
+          return scope;
+        }
+      }
+    } else {
+      for (let i = 0; i < scopes.length; ++i) {
+        const scope = scopes[i];
+
+        if (predicate(scope)) {
+          return scope;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  protected nestScope<T extends Scope>(scope: T): T;
+  protected nestScope(scope: Scope): Scope {
+    if (scope instanceof GlobalScope) {
+      assert(this.currentScope === null);
+      this.globalScope = scope;
+    }
+    this.currentScope = scope;
+    return scope;
+  }
+
+  public nestBlockScope(node: BlockScope['block']): BlockScope {
+    assert(this.currentScope);
+    return this.nestScope(new BlockScope(this, this.currentScope, node));
+  }
+
+  public nestCatchScope(node: CatchScope['block']): CatchScope {
+    assert(this.currentScope);
+    return this.nestScope(new CatchScope(this, this.currentScope, node));
+  }
+
+  public nestClassScope(node: ClassScope['block']): ClassScope {
+    assert(this.currentScope);
+    return this.nestScope(new ClassScope(this, this.currentScope, node));
+  }
+
+  public nestConditionalTypeScope(
+    node: ConditionalTypeScope['block'],
+  ): ConditionalTypeScope {
+    assert(this.currentScope);
+    return this.nestScope(
+      new ConditionalTypeScope(this, this.currentScope, node),
+    );
+  }
+
+  public nestForScope(node: ForScope['block']): ForScope {
+    assert(this.currentScope);
+    return this.nestScope(new ForScope(this, this.currentScope, node));
+  }
+
+  public nestFunctionExpressionNameScope(
+    node: FunctionExpressionNameScope['block'],
+  ): FunctionExpressionNameScope {
+    assert(this.currentScope);
+    return this.nestScope(
+      new FunctionExpressionNameScope(this, this.currentScope, node),
+    );
+  }
+
+  public nestFunctionScope(
+    node: FunctionScope['block'],
+    isMethodDefinition: boolean,
+  ): FunctionScope {
+    assert(this.currentScope);
+    return this.nestScope(
+      new FunctionScope(this, this.currentScope, node, isMethodDefinition),
+    );
+  }
+
+  public nestFunctionTypeScope(
+    node: FunctionTypeScope['block'],
+  ): FunctionTypeScope {
+    assert(this.currentScope);
+    return this.nestScope(new FunctionTypeScope(this, this.currentScope, node));
+  }
+
+  public nestGlobalScope(node: GlobalScope['block']): GlobalScope {
+    return this.nestScope(new GlobalScope(this, node));
+  }
+
+  public nestMappedTypeScope(node: MappedTypeScope['block']): MappedTypeScope {
+    assert(this.currentScope);
+    return this.nestScope(new MappedTypeScope(this, this.currentScope, node));
+  }
+
+  public nestModuleScope(node: ModuleScope['block']): ModuleScope {
+    assert(this.currentScope);
+    return this.nestScope(new ModuleScope(this, this.currentScope, node));
+  }
+
+  public nestSwitchScope(node: SwitchScope['block']): SwitchScope {
+    assert(this.currentScope);
+    return this.nestScope(new SwitchScope(this, this.currentScope, node));
+  }
+
+  public nestTSEnumScope(node: TSEnumScope['block']): TSEnumScope {
+    assert(this.currentScope);
+    return this.nestScope(new TSEnumScope(this, this.currentScope, node));
+  }
+
+  public nestTSModuleScope(node: TSModuleScope['block']): TSModuleScope {
+    assert(this.currentScope);
+    return this.nestScope(new TSModuleScope(this, this.currentScope, node));
+  }
+
+  public nestTypeScope(node: TypeScope['block']): TypeScope {
+    assert(this.currentScope);
+    return this.nestScope(new TypeScope(this, this.currentScope, node));
+  }
+
+  public nestWithScope(node: WithScope['block']): WithScope {
+    assert(this.currentScope);
+    return this.nestScope(new WithScope(this, this.currentScope, node));
+  }
+}
+
+export { ScopeManager };

packages/scope-manager/src/analyze.ts

@@ -0,0 +1,103 @@
+import { TSESTree, EcmaVersion, Lib } from '@typescript-eslint/types';
+import { visitorKeys } from '@typescript-eslint/visitor-keys';
+import { Referencer, ReferencerOptions } from './referencer';
+import { ScopeManager } from './ScopeManager';
+
+////////////////////////////////////////////////////
+// MAKE SURE THIS IS KEPT IN SYNC WITH THE README //
+////////////////////////////////////////////////////
+
+interface AnalyzeOptions {
+  /**
+   * Known visitor keys.
+   */
+  childVisitorKeys?: ReferencerOptions['childVisitorKeys'];
+
+  /**
+   * Which ECMAScript version is considered.
+   * Defaults to `2018`.
+   */
+  ecmaVersion?: EcmaVersion;
+
+  /**
+   * Whether the whole script is executed under node.js environment.
+   * When enabled, the scope manager adds a function scope immediately following the global scope.
+   * Defaults to `false`.
+   */
+  globalReturn?: boolean;
+
+  /**
+   * Implied strict mode (if ecmaVersion >= 5).
+   * Defaults to `false`.
+   */
+  impliedStrict?: boolean;
+
+  /**
+   * The lib used by the project.
+   * This automatically defines a type variable for any types provided by the configured TS libs.
+   * Defaults to the lib for the provided `ecmaVersion`.
+   *
+   * https://www.typescriptlang.org/tsconfig#lib
+   */
+  lib?: Lib[];
+
+  /**
+   * The source type of the script.
+   */
+  sourceType?: 'script' | 'module';
+}
+
+const DEFAULT_OPTIONS: Required<AnalyzeOptions> = {
+  childVisitorKeys: visitorKeys,
+  ecmaVersion: 2018,
+  globalReturn: false,
+  impliedStrict: false,
+  lib: ['es2018'],
+  sourceType: 'script',
+};
+
+function mapEcmaVersion(version: EcmaVersion | undefined): Lib {
+  if (version == null || version === 3 || version === 5) {
+    return 'es5';
+  }
+
+  if (version > 2000) {
+    return `es${version}` as Lib;
+  }
+
+  const year = 2015 + (version - 6);
+  return `es${year}` as Lib;
+}
+
+/**
+ * Takes an AST and returns the analyzed scopes.
+ */
+function analyze(
+  tree: TSESTree.Node,
+  providedOptions?: AnalyzeOptions,
+): ScopeManager {
+  const ecmaVersion =
+    providedOptions?.ecmaVersion ?? DEFAULT_OPTIONS.ecmaVersion;
+  const options: Required<AnalyzeOptions> = {
+    globalReturn: providedOptions?.globalReturn ?? DEFAULT_OPTIONS.globalReturn,
+    impliedStrict:
+      providedOptions?.impliedStrict ?? DEFAULT_OPTIONS.impliedStrict,
+    sourceType: providedOptions?.sourceType ?? DEFAULT_OPTIONS.sourceType,
+    ecmaVersion,
+    childVisitorKeys:
+      providedOptions?.childVisitorKeys ?? DEFAULT_OPTIONS.childVisitorKeys,
+    lib: providedOptions?.lib ?? [mapEcmaVersion(ecmaVersion)],
+  };
+
+  // ensure the option is lower cased
+  options.lib = options.lib.map(l => l.toLowerCase() as Lib);
+
+  const scopeManager = new ScopeManager(options);
+  const referencer = new Referencer(options, scopeManager);
+
+  referencer.visit(tree);
+
+  return scopeManager;
+}
+
+export { analyze, AnalyzeOptions };

packages/scope-manager/src/assert.ts

@@ -0,0 +1,8 @@
+// the base assert module doesn't use ts assertion syntax
+function assert(value: unknown, message?: string): asserts value {
+  if (value == null) {
+    throw new Error(message);
+  }
+}
+
+export { assert };

packages/scope-manager/src/definition/CatchClauseDefinition.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class CatchClauseDefinition extends DefinitionBase<
+  DefinitionType.CatchClause,
+  TSESTree.CatchClause,
+  null,
+  TSESTree.BindingName
+> {
+  constructor(name: TSESTree.BindingName, node: CatchClauseDefinition['node']) {
+    super(DefinitionType.CatchClause, name, node, null);
+  }
+
+  public readonly isTypeDefinition = false;
+  public readonly isVariableDefinition = true;
+}
+
+export { CatchClauseDefinition };

packages/scope-manager/src/definition/ClassNameDefinition.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class ClassNameDefinition extends DefinitionBase<
+  DefinitionType.ClassName,
+  TSESTree.ClassDeclaration | TSESTree.ClassExpression,
+  null,
+  TSESTree.Identifier
+> {
+  constructor(name: TSESTree.Identifier, node: ClassNameDefinition['node']) {
+    super(DefinitionType.ClassName, name, node, null);
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition = true;
+}
+
+export { ClassNameDefinition };

packages/scope-manager/src/definition/Definition.ts

@@ -0,0 +1,26 @@
+import { CatchClauseDefinition } from './CatchClauseDefinition';
+import { ClassNameDefinition } from './ClassNameDefinition';
+import { FunctionNameDefinition } from './FunctionNameDefinition';
+import { ImplicitGlobalVariableDefinition } from './ImplicitGlobalVariableDefinition';
+import { ImportBindingDefinition } from './ImportBindingDefinition';
+import { ParameterDefinition } from './ParameterDefinition';
+import { TSEnumMemberDefinition } from './TSEnumMemberDefinition';
+import { TSEnumNameDefinition } from './TSEnumNameDefinition';
+import { TSModuleNameDefinition } from './TSModuleNameDefinition';
+import { TypeDefinition } from './TypeDefinition';
+import { VariableDefinition } from './VariableDefinition';
+
+type Definition =
+  | CatchClauseDefinition
+  | ClassNameDefinition
+  | FunctionNameDefinition
+  | ImplicitGlobalVariableDefinition
+  | ImportBindingDefinition
+  | ParameterDefinition
+  | TSEnumMemberDefinition
+  | TSEnumNameDefinition
+  | TSModuleNameDefinition
+  | TypeDefinition
+  | VariableDefinition;
+
+export { Definition };

packages/scope-manager/src/definition/DefinitionBase.ts

@@ -0,0 +1,60 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { createIdGenerator } from '../ID';
+
+const generator = createIdGenerator();
+
+abstract class DefinitionBase<
+  TType extends DefinitionType,
+  TNode extends TSESTree.Node,
+  TParent extends TSESTree.Node | null,
+  TName extends TSESTree.Node = TSESTree.BindingName
+> {
+  /**
+   * A unique ID for this instance - primarily used to help debugging and testing
+   */
+  public readonly $id: number = generator();
+
+  /**
+   * The type of the definition
+   * @public
+   */
+  public readonly type: TType;
+
+  /**
+   * The `Identifier` node of this definition
+   * @public
+   */
+  public readonly name: TName;
+
+  /**
+   * The enclosing node of the name.
+   * @public
+   */
+  public readonly node: TNode;
+
+  /**
+   * the enclosing statement node of the identifier.
+   * @public
+   */
+  public readonly parent: TParent;
+
+  constructor(type: TType, name: TName, node: TNode, parent: TParent) {
+    this.type = type;
+    this.name = name;
+    this.node = node;
+    this.parent = parent;
+  }
+
+  /**
+   * `true` if the variable is valid in a type context, false otherwise
+   */
+  public abstract readonly isTypeDefinition: boolean;
+
+  /**
+   * `true` if the variable is valid in a value context, false otherwise
+   */
+  public abstract readonly isVariableDefinition: boolean;
+}
+
+export { DefinitionBase };

packages/scope-manager/src/definition/DefinitionType.ts

@@ -0,0 +1,16 @@
+enum DefinitionType {
+  // eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
+  CatchClause = 'CatchClause',
+  ClassName = 'ClassName',
+  FunctionName = 'FunctionName',
+  ImplicitGlobalVariable = 'ImplicitGlobalVariable',
+  ImportBinding = 'ImportBinding',
+  Parameter = 'Parameter',
+  TSEnumName = 'TSEnumName',
+  TSEnumMember = 'TSEnumMemberName',
+  TSModuleName = 'TSModuleName',
+  Type = 'Type',
+  Variable = 'Variable',
+}
+
+export { DefinitionType };

packages/scope-manager/src/definition/FunctionNameDefinition.ts

@@ -0,0 +1,22 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class FunctionNameDefinition extends DefinitionBase<
+  DefinitionType.FunctionName,
+  | TSESTree.FunctionDeclaration
+  | TSESTree.FunctionExpression
+  | TSESTree.TSDeclareFunction
+  | TSESTree.TSEmptyBodyFunctionExpression,
+  null,
+  TSESTree.Identifier
+> {
+  constructor(name: TSESTree.Identifier, node: FunctionNameDefinition['node']) {
+    super(DefinitionType.FunctionName, name, node, null);
+  }
+
+  public readonly isTypeDefinition = false;
+  public readonly isVariableDefinition = true;
+}
+
+export { FunctionNameDefinition };

packages/scope-manager/src/definition/ImplicitGlobalVariableDefinition.ts

@@ -0,0 +1,22 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class ImplicitGlobalVariableDefinition extends DefinitionBase<
+  DefinitionType.ImplicitGlobalVariable,
+  TSESTree.Node,
+  null,
+  TSESTree.BindingName
+> {
+  constructor(
+    name: TSESTree.BindingName,
+    node: ImplicitGlobalVariableDefinition['node'],
+  ) {
+    super(DefinitionType.ImplicitGlobalVariable, name, node, null);
+  }
+
+  public readonly isTypeDefinition = false;
+  public readonly isVariableDefinition = true;
+}
+
+export { ImplicitGlobalVariableDefinition };

packages/scope-manager/src/definition/ImportBindingDefinition.ts

@@ -0,0 +1,44 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class ImportBindingDefinition extends DefinitionBase<
+  DefinitionType.ImportBinding,
+  | TSESTree.ImportSpecifier
+  | TSESTree.ImportDefaultSpecifier
+  | TSESTree.ImportNamespaceSpecifier
+  | TSESTree.TSImportEqualsDeclaration,
+  TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration,
+  TSESTree.Identifier
+> {
+  constructor(
+    name: TSESTree.Identifier,
+    node: TSESTree.TSImportEqualsDeclaration,
+    decl: TSESTree.TSImportEqualsDeclaration,
+  );
+  constructor(
+    name: TSESTree.Identifier,
+    node: Exclude<
+      ImportBindingDefinition['node'],
+      TSESTree.TSImportEqualsDeclaration
+    >,
+    decl: TSESTree.ImportDeclaration,
+  );
+  constructor(
+    name: TSESTree.Identifier,
+    node: ImportBindingDefinition['node'],
+    decl: TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration,
+  ) {
+    super(DefinitionType.ImportBinding, name, node, decl);
+    if ('importKind' in this.parent && this.parent.importKind === 'type') {
+      this.isVariableDefinition = false;
+    } else {
+      this.isVariableDefinition = true;
+    }
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition: boolean;
+}
+
+export { ImportBindingDefinition };

packages/scope-manager/src/definition/ParameterDefinition.ts

@@ -0,0 +1,37 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class ParameterDefinition extends DefinitionBase<
+  DefinitionType.Parameter,
+  | TSESTree.ArrowFunctionExpression
+  | TSESTree.FunctionDeclaration
+  | TSESTree.FunctionExpression
+  | TSESTree.TSCallSignatureDeclaration
+  | TSESTree.TSConstructorType
+  | TSESTree.TSConstructSignatureDeclaration
+  | TSESTree.TSDeclareFunction
+  | TSESTree.TSEmptyBodyFunctionExpression
+  | TSESTree.TSFunctionType
+  | TSESTree.TSMethodSignature,
+  null,
+  TSESTree.BindingName
+> {
+  /**
+   * Whether the parameter definition is a part of a rest parameter.
+   */
+  public readonly rest: boolean;
+  constructor(
+    name: TSESTree.BindingName,
+    node: ParameterDefinition['node'],
+    rest: boolean,
+  ) {
+    super(DefinitionType.Parameter, name, node, null);
+    this.rest = rest;
+  }
+
+  public readonly isTypeDefinition = false;
+  public readonly isVariableDefinition = true;
+}
+
+export { ParameterDefinition };

packages/scope-manager/src/definition/TSEnumMemberDefinition.ts

@@ -0,0 +1,22 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class TSEnumMemberDefinition extends DefinitionBase<
+  DefinitionType.TSEnumMember,
+  TSESTree.TSEnumMember,
+  null,
+  TSESTree.Identifier | TSESTree.StringLiteral
+> {
+  constructor(
+    name: TSESTree.Identifier | TSESTree.StringLiteral,
+    node: TSEnumMemberDefinition['node'],
+  ) {
+    super(DefinitionType.TSEnumMember, name, node, null);
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition = true;
+}
+
+export { TSEnumMemberDefinition };

packages/scope-manager/src/definition/TSEnumNameDefinition.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class TSEnumNameDefinition extends DefinitionBase<
+  DefinitionType.TSEnumName,
+  TSESTree.TSEnumDeclaration,
+  null,
+  TSESTree.Identifier
+> {
+  constructor(name: TSESTree.Identifier, node: TSEnumNameDefinition['node']) {
+    super(DefinitionType.TSEnumName, name, node, null);
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition = true;
+}
+
+export { TSEnumNameDefinition };

packages/scope-manager/src/definition/TSModuleNameDefinition.ts

@@ -0,0 +1,19 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class TSModuleNameDefinition extends DefinitionBase<
+  DefinitionType.TSModuleName,
+  TSESTree.TSModuleDeclaration,
+  null,
+  TSESTree.Identifier
+> {
+  constructor(name: TSESTree.Identifier, node: TSModuleNameDefinition['node']) {
+    super(DefinitionType.TSModuleName, name, node, null);
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition = true;
+}
+
+export { TSModuleNameDefinition };

packages/scope-manager/src/definition/TypeDefinition.ts

@@ -0,0 +1,21 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class TypeDefinition extends DefinitionBase<
+  DefinitionType.Type,
+  | TSESTree.TSInterfaceDeclaration
+  | TSESTree.TSTypeAliasDeclaration
+  | TSESTree.TSTypeParameter,
+  null,
+  TSESTree.Identifier
+> {
+  constructor(name: TSESTree.Identifier, node: TypeDefinition['node']) {
+    super(DefinitionType.Type, name, node, null);
+  }
+
+  public readonly isTypeDefinition = true;
+  public readonly isVariableDefinition = false;
+}
+
+export { TypeDefinition };

packages/scope-manager/src/definition/VariableDefinition.ts

@@ -0,0 +1,23 @@
+import { TSESTree } from '@typescript-eslint/types';
+import { DefinitionType } from './DefinitionType';
+import { DefinitionBase } from './DefinitionBase';
+
+class VariableDefinition extends DefinitionBase<
+  DefinitionType.Variable,
+  TSESTree.VariableDeclarator,
+  TSESTree.VariableDeclaration,
+  TSESTree.Identifier
+> {
+  constructor(
+    name: TSESTree.Identifier,
+    node: VariableDefinition['node'],
+    decl: TSESTree.VariableDeclaration,
+  ) {
+    super(DefinitionType.Variable, name, node, decl);
+  }
+
+  public readonly isTypeDefinition = false;
+  public readonly isVariableDefinition = true;
+}
+
+export { VariableDefinition };

packages/scope-manager/src/definition/index.ts

@@ -0,0 +1,13 @@
+export * from './CatchClauseDefinition';
+export * from './ClassNameDefinition';
+export * from './Definition';
+export * from './DefinitionType';
+export * from './FunctionNameDefinition';
+export * from './ImplicitGlobalVariableDefinition';
+export * from './ImportBindingDefinition';
+export * from './ParameterDefinition';
+export * from './TSEnumMemberDefinition';
+export * from './TSEnumNameDefinition';
+export * from './TSModuleNameDefinition';
+export * from './TypeDefinition';
+export * from './VariableDefinition';

packages/scope-manager/src/index.ts

@@ -0,0 +1,12 @@
+export { analyze, AnalyzeOptions } from './analyze';
+export * from './definition';
+export { Reference } from './referencer/Reference';
+export { Visitor } from './referencer/Visitor';
+export {
+  PatternVisitor,
+  PatternVisitorCallback,
+  PatternVisitorOptions,
+} from './referencer/PatternVisitor';
+export * from './scope';
+export { ScopeManager } from './ScopeManager';
+export * from './variable';

packages/scope-manager/src/lib/dom.iterable.ts

@@ -0,0 +1,372 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const dom_iterable = {
+  AudioParam: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AudioParam',
+    writeable: false,
+  },
+  AudioParamMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AudioParamMap',
+    writeable: false,
+  },
+  BaseAudioContext: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BaseAudioContext',
+    writeable: false,
+  },
+  CSSRuleList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'CSSRuleList',
+    writeable: false,
+  },
+  CSSStyleDeclaration: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'CSSStyleDeclaration',
+    writeable: false,
+  },
+  Cache: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Cache',
+    writeable: false,
+  },
+  CanvasPathDrawingStyles: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'CanvasPathDrawingStyles',
+    writeable: false,
+  },
+  ClientRectList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ClientRectList',
+    writeable: false,
+  },
+  DOMRectList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DOMRectList',
+    writeable: false,
+  },
+  DOMStringList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DOMStringList',
+    writeable: false,
+  },
+  DOMTokenList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DOMTokenList',
+    writeable: false,
+  },
+  DataTransferItemList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DataTransferItemList',
+    writeable: false,
+  },
+  FileList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'FileList',
+    writeable: false,
+  },
+  FormData: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'FormData',
+    writeable: false,
+  },
+  HTMLAllCollection: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'HTMLAllCollection',
+    writeable: false,
+  },
+  HTMLCollectionBase: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'HTMLCollectionBase',
+    writeable: false,
+  },
+  HTMLCollectionOf: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'HTMLCollectionOf',
+    writeable: false,
+  },
+  HTMLFormElement: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'HTMLFormElement',
+    writeable: false,
+  },
+  HTMLSelectElement: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'HTMLSelectElement',
+    writeable: false,
+  },
+  Headers: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Headers',
+    writeable: false,
+  },
+  IDBObjectStore: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IDBObjectStore',
+    writeable: false,
+  },
+  MediaKeyStatusMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MediaKeyStatusMap',
+    writeable: false,
+  },
+  MediaList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MediaList',
+    writeable: false,
+  },
+  MimeTypeArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MimeTypeArray',
+    writeable: false,
+  },
+  NamedNodeMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NamedNodeMap',
+    writeable: false,
+  },
+  Navigator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Navigator',
+    writeable: false,
+  },
+  NodeList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NodeList',
+    writeable: false,
+  },
+  NodeListOf: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NodeListOf',
+    writeable: false,
+  },
+  Plugin: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Plugin',
+    writeable: false,
+  },
+  PluginArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PluginArray',
+    writeable: false,
+  },
+  RTCRtpTransceiver: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RTCRtpTransceiver',
+    writeable: false,
+  },
+  RTCStatsReport: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RTCStatsReport',
+    writeable: false,
+  },
+  SVGLengthList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SVGLengthList',
+    writeable: false,
+  },
+  SVGNumberList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SVGNumberList',
+    writeable: false,
+  },
+  SVGPointList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SVGPointList',
+    writeable: false,
+  },
+  SVGStringList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SVGStringList',
+    writeable: false,
+  },
+  SourceBufferList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SourceBufferList',
+    writeable: false,
+  },
+  SpeechGrammarList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SpeechGrammarList',
+    writeable: false,
+  },
+  SpeechRecognitionResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SpeechRecognitionResult',
+    writeable: false,
+  },
+  SpeechRecognitionResultList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SpeechRecognitionResultList',
+    writeable: false,
+  },
+  StyleSheetList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'StyleSheetList',
+    writeable: false,
+  },
+  TextTrackCueList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TextTrackCueList',
+    writeable: false,
+  },
+  TextTrackList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TextTrackList',
+    writeable: false,
+  },
+  TouchList: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TouchList',
+    writeable: false,
+  },
+  URLSearchParams: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'URLSearchParams',
+    writeable: false,
+  },
+  VRDisplay: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'VRDisplay',
+    writeable: false,
+  },
+  WEBGL_draw_buffers: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WEBGL_draw_buffers',
+    writeable: false,
+  },
+  WebAuthentication: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WebAuthentication',
+    writeable: false,
+  },
+  WebGL2RenderingContextBase: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WebGL2RenderingContextBase',
+    writeable: false,
+  },
+  WebGL2RenderingContextOverloads: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WebGL2RenderingContextOverloads',
+    writeable: false,
+  },
+  WebGLRenderingContextBase: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WebGLRenderingContextBase',
+    writeable: false,
+  },
+  WebGLRenderingContextOverloads: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WebGLRenderingContextOverloads',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.collection.ts

@@ -0,0 +1,78 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_collection = {
+  Map: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Map',
+    writeable: false,
+  },
+  MapConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MapConstructor',
+    writeable: false,
+  },
+  ReadonlyMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyMap',
+    writeable: false,
+  },
+  WeakMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'WeakMap',
+    writeable: false,
+  },
+  WeakMapConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakMapConstructor',
+    writeable: false,
+  },
+  Set: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Set',
+    writeable: false,
+  },
+  SetConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SetConstructor',
+    writeable: false,
+  },
+  ReadonlySet: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlySet',
+    writeable: false,
+  },
+  WeakSet: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'WeakSet',
+    writeable: false,
+  },
+  WeakSetConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakSetConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.core.ts

@@ -0,0 +1,92 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_core = {
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+  ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayConstructor',
+    writeable: false,
+  },
+  DateConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DateConstructor',
+    writeable: false,
+  },
+  Function: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Function',
+    writeable: false,
+  },
+  Math: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Math',
+    writeable: false,
+  },
+  NumberConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NumberConstructor',
+    writeable: false,
+  },
+  ObjectConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ObjectConstructor',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  RegExp: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExp',
+    writeable: false,
+  },
+  RegExpConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpConstructor',
+    writeable: false,
+  },
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+  StringConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'StringConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.generator.ts

@@ -0,0 +1,31 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_iterable } from './es2015.iterable';
+
+export const es2015_generator = {
+  ...es2015_iterable,
+  Generator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Generator',
+    writeable: false,
+  },
+  GeneratorFunction: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'GeneratorFunction',
+    writeable: false,
+  },
+  GeneratorFunctionConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'GeneratorFunctionConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.iterable.ts

@@ -0,0 +1,311 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_symbol } from './es2015.symbol';
+
+export const es2015_iterable = {
+  ...es2015_symbol,
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+  IteratorYieldResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IteratorYieldResult',
+    writeable: false,
+  },
+  IteratorReturnResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IteratorReturnResult',
+    writeable: false,
+  },
+  IteratorResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IteratorResult',
+    writeable: false,
+  },
+  Iterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Iterator',
+    writeable: false,
+  },
+  Iterable: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Iterable',
+    writeable: false,
+  },
+  IterableIterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IterableIterator',
+    writeable: false,
+  },
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+  ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayConstructor',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  IArguments: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IArguments',
+    writeable: false,
+  },
+  Map: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Map',
+    writeable: false,
+  },
+  ReadonlyMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyMap',
+    writeable: false,
+  },
+  MapConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MapConstructor',
+    writeable: false,
+  },
+  WeakMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakMap',
+    writeable: false,
+  },
+  WeakMapConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakMapConstructor',
+    writeable: false,
+  },
+  Set: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Set',
+    writeable: false,
+  },
+  ReadonlySet: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlySet',
+    writeable: false,
+  },
+  SetConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SetConstructor',
+    writeable: false,
+  },
+  WeakSet: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakSet',
+    writeable: false,
+  },
+  WeakSetConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakSetConstructor',
+    writeable: false,
+  },
+  Promise: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Promise',
+    writeable: false,
+  },
+  PromiseConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructor',
+    writeable: false,
+  },
+  Reflect: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Reflect',
+    writeable: false,
+  },
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+  Int8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8Array',
+    writeable: false,
+  },
+  Int8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8Array',
+    writeable: false,
+  },
+  Uint8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8ClampedArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArray',
+    writeable: false,
+  },
+  Uint8ClampedArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArrayConstructor',
+    writeable: false,
+  },
+  Int16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16Array',
+    writeable: false,
+  },
+  Int16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16ArrayConstructor',
+    writeable: false,
+  },
+  Uint16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16Array',
+    writeable: false,
+  },
+  Uint16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16ArrayConstructor',
+    writeable: false,
+  },
+  Int32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32Array',
+    writeable: false,
+  },
+  Int32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32ArrayConstructor',
+    writeable: false,
+  },
+  Uint32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32Array',
+    writeable: false,
+  },
+  Uint32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32ArrayConstructor',
+    writeable: false,
+  },
+  Float32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32Array',
+    writeable: false,
+  },
+  Float32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32ArrayConstructor',
+    writeable: false,
+  },
+  Float64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64Array',
+    writeable: false,
+  },
+  Float64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64ArrayConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.promise.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_promise = {
+  PromiseConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.proxy.ts

@@ -0,0 +1,22 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_proxy = {
+  ProxyHandler: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ProxyHandler',
+    writeable: false,
+  },
+  ProxyConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ProxyConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.reflect.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_reflect = {
+  Reflect: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Reflect',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.symbol.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2015_symbol = {
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.symbol.wellknown.ts

@@ -0,0 +1,234 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_symbol } from './es2015.symbol';
+
+export const es2015_symbol_wellknown = {
+  ...es2015_symbol,
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+  Symbol: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Symbol',
+    writeable: false,
+  },
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+  Date: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Date',
+    writeable: false,
+  },
+  Map: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Map',
+    writeable: false,
+  },
+  WeakMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakMap',
+    writeable: false,
+  },
+  Set: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Set',
+    writeable: false,
+  },
+  WeakSet: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'WeakSet',
+    writeable: false,
+  },
+  JSON: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'JSON',
+    writeable: false,
+  },
+  Function: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Function',
+    writeable: false,
+  },
+  GeneratorFunction: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'GeneratorFunction',
+    writeable: false,
+  },
+  Math: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Math',
+    writeable: false,
+  },
+  Promise: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Promise',
+    writeable: false,
+  },
+  PromiseConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructor',
+    writeable: false,
+  },
+  RegExp: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExp',
+    writeable: false,
+  },
+  RegExpConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpConstructor',
+    writeable: false,
+  },
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+  ArrayBuffer: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBuffer',
+    writeable: false,
+  },
+  DataView: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DataView',
+    writeable: false,
+  },
+  Int8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8Array',
+    writeable: false,
+  },
+  Uint8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8Array',
+    writeable: false,
+  },
+  Uint8ClampedArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArray',
+    writeable: false,
+  },
+  Int16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16Array',
+    writeable: false,
+  },
+  Uint16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16Array',
+    writeable: false,
+  },
+  Int32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32Array',
+    writeable: false,
+  },
+  Uint32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32Array',
+    writeable: false,
+  },
+  Float32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32Array',
+    writeable: false,
+  },
+  Float64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64Array',
+    writeable: false,
+  },
+  ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayConstructor',
+    writeable: false,
+  },
+  MapConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MapConstructor',
+    writeable: false,
+  },
+  SetConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SetConstructor',
+    writeable: false,
+  },
+  ArrayBufferConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2015.ts

@@ -0,0 +1,28 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es5 } from './es5';
+import { es2015_core } from './es2015.core';
+import { es2015_collection } from './es2015.collection';
+import { es2015_iterable } from './es2015.iterable';
+import { es2015_generator } from './es2015.generator';
+import { es2015_promise } from './es2015.promise';
+import { es2015_proxy } from './es2015.proxy';
+import { es2015_reflect } from './es2015.reflect';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
+
+export const es2015 = {
+  ...es5,
+  ...es2015_core,
+  ...es2015_collection,
+  ...es2015_iterable,
+  ...es2015_generator,
+  ...es2015_promise,
+  ...es2015_proxy,
+  ...es2015_reflect,
+  ...es2015_symbol,
+  ...es2015_symbol_wellknown,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2016.array.include.ts

@@ -0,0 +1,85 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2016_array_include = {
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  Int8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8Array',
+    writeable: false,
+  },
+  Uint8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8Array',
+    writeable: false,
+  },
+  Uint8ClampedArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArray',
+    writeable: false,
+  },
+  Int16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16Array',
+    writeable: false,
+  },
+  Uint16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16Array',
+    writeable: false,
+  },
+  Int32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32Array',
+    writeable: false,
+  },
+  Uint32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32Array',
+    writeable: false,
+  },
+  Float32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32Array',
+    writeable: false,
+  },
+  Float64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64Array',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2016.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2016 } from './es2016';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const es2016_full = {
+  ...es2016,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2016.ts

@@ -0,0 +1,12 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015 } from './es2015';
+import { es2016_array_include } from './es2016.array.include';
+
+export const es2016 = {
+  ...es2015,
+  ...es2016_array_include,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2017 } from './es2017';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const es2017_full = {
+  ...es2017,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.intl.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2017_intl = {
+  Intl: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Intl',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.object.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2017_object = {
+  ObjectConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ObjectConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.sharedmemory.ts

@@ -0,0 +1,40 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
+
+export const es2017_sharedmemory = {
+  ...es2015_symbol,
+  ...es2015_symbol_wellknown,
+  SharedArrayBuffer: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'SharedArrayBuffer',
+    writeable: false,
+  },
+  SharedArrayBufferConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SharedArrayBufferConstructor',
+    writeable: false,
+  },
+  ArrayBufferTypes: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferTypes',
+    writeable: false,
+  },
+  Atomics: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Atomics',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.string.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2017_string = {
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.ts

@@ -0,0 +1,20 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2016 } from './es2016';
+import { es2017_object } from './es2017.object';
+import { es2017_sharedmemory } from './es2017.sharedmemory';
+import { es2017_string } from './es2017.string';
+import { es2017_intl } from './es2017.intl';
+import { es2017_typedarrays } from './es2017.typedarrays';
+
+export const es2017 = {
+  ...es2016,
+  ...es2017_object,
+  ...es2017_sharedmemory,
+  ...es2017_string,
+  ...es2017_intl,
+  ...es2017_typedarrays,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2017.typedarrays.ts

@@ -0,0 +1,71 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2017_typedarrays = {
+  Int8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8ClampedArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArrayConstructor',
+    writeable: false,
+  },
+  Int16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16ArrayConstructor',
+    writeable: false,
+  },
+  Uint16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16ArrayConstructor',
+    writeable: false,
+  },
+  Int32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32ArrayConstructor',
+    writeable: false,
+  },
+  Uint32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32ArrayConstructor',
+    writeable: false,
+  },
+  Float32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32ArrayConstructor',
+    writeable: false,
+  },
+  Float64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64ArrayConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.asyncgenerator.ts

@@ -0,0 +1,31 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2018_asynciterable } from './es2018.asynciterable';
+
+export const es2018_asyncgenerator = {
+  ...es2018_asynciterable,
+  AsyncGenerator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncGenerator',
+    writeable: false,
+  },
+  AsyncGeneratorFunction: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncGeneratorFunction',
+    writeable: false,
+  },
+  AsyncGeneratorFunctionConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncGeneratorFunctionConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.asynciterable.ts

@@ -0,0 +1,40 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_iterable } from './es2015.iterable';
+
+export const es2018_asynciterable = {
+  ...es2015_symbol,
+  ...es2015_iterable,
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+  AsyncIterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterator',
+    writeable: false,
+  },
+  AsyncIterable: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterable',
+    writeable: false,
+  },
+  AsyncIterableIterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterableIterator',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2018 } from './es2018';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const es2018_full = {
+  ...es2018,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.intl.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2018_intl = {
+  Intl: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Intl',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.promise.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2018_promise = {
+  Promise: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Promise',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.regexp.ts

@@ -0,0 +1,29 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2018_regexp = {
+  RegExpMatchArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpMatchArray',
+    writeable: false,
+  },
+  RegExpExecArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpExecArray',
+    writeable: false,
+  },
+  RegExp: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExp',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2018.ts

@@ -0,0 +1,20 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2017 } from './es2017';
+import { es2018_asynciterable } from './es2018.asynciterable';
+import { es2018_asyncgenerator } from './es2018.asyncgenerator';
+import { es2018_promise } from './es2018.promise';
+import { es2018_regexp } from './es2018.regexp';
+import { es2018_intl } from './es2018.intl';
+
+export const es2018 = {
+  ...es2017,
+  ...es2018_asynciterable,
+  ...es2018_asyncgenerator,
+  ...es2018_promise,
+  ...es2018_regexp,
+  ...es2018_intl,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.array.ts

@@ -0,0 +1,29 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2019_array = {
+  FlatArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'FlatArray',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2019 } from './es2019';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const es2019_full = {
+  ...es2019,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.object.ts

@@ -0,0 +1,17 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_iterable } from './es2015.iterable';
+
+export const es2019_object = {
+  ...es2015_iterable,
+  ObjectConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ObjectConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.string.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2019_string = {
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.symbol.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2019_symbol = {
+  Symbol: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Symbol',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2019.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2018 } from './es2018';
+import { es2019_array } from './es2019.array';
+import { es2019_object } from './es2019.object';
+import { es2019_string } from './es2019.string';
+import { es2019_symbol } from './es2019.symbol';
+
+export const es2019 = {
+  ...es2018,
+  ...es2019_array,
+  ...es2019_object,
+  ...es2019_string,
+  ...es2019_symbol,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.bigint.ts

@@ -0,0 +1,57 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2020_bigint = {
+  BigInt: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigInt',
+    writeable: false,
+  },
+  BigIntConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigIntConstructor',
+    writeable: false,
+  },
+  BigInt64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigInt64Array',
+    writeable: false,
+  },
+  BigInt64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigInt64ArrayConstructor',
+    writeable: false,
+  },
+  BigUint64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigUint64Array',
+    writeable: false,
+  },
+  BigUint64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigUint64ArrayConstructor',
+    writeable: false,
+  },
+  DataView: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DataView',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2020 } from './es2020';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const es2020_full = {
+  ...es2020,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.promise.ts

@@ -0,0 +1,36 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es2020_promise = {
+  PromiseFulfilledResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseFulfilledResult',
+    writeable: false,
+  },
+  PromiseRejectedResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseRejectedResult',
+    writeable: false,
+  },
+  PromiseSettledResult: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseSettledResult',
+    writeable: false,
+  },
+  PromiseConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.string.ts

@@ -0,0 +1,17 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_iterable } from './es2015.iterable';
+
+export const es2020_string = {
+  ...es2015_iterable,
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.symbol.wellknown.ts

@@ -0,0 +1,26 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_iterable } from './es2015.iterable';
+import { es2015_symbol } from './es2015.symbol';
+
+export const es2020_symbol_wellknown = {
+  ...es2015_iterable,
+  ...es2015_symbol,
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+  RegExp: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExp',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es2020.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2019 } from './es2019';
+import { es2020_bigint } from './es2020.bigint';
+import { es2020_promise } from './es2020.promise';
+import { es2020_string } from './es2020.string';
+import { es2020_symbol_wellknown } from './es2020.symbol.wellknown';
+
+export const es2020 = {
+  ...es2019,
+  ...es2020_bigint,
+  ...es2020_promise,
+  ...es2020_string,
+  ...es2020_symbol_wellknown,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es5.ts

@@ -0,0 +1,680 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const es5 = {
+  Symbol: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Symbol',
+    writeable: false,
+  },
+  PropertyKey: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PropertyKey',
+    writeable: false,
+  },
+  PropertyDescriptor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PropertyDescriptor',
+    writeable: false,
+  },
+  PropertyDescriptorMap: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PropertyDescriptorMap',
+    writeable: false,
+  },
+  Object: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Object',
+    writeable: false,
+  },
+  ObjectConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ObjectConstructor',
+    writeable: false,
+  },
+  Function: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Function',
+    writeable: false,
+  },
+  FunctionConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'FunctionConstructor',
+    writeable: false,
+  },
+  ThisParameterType: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ThisParameterType',
+    writeable: false,
+  },
+  OmitThisParameter: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'OmitThisParameter',
+    writeable: false,
+  },
+  CallableFunction: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'CallableFunction',
+    writeable: false,
+  },
+  NewableFunction: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NewableFunction',
+    writeable: false,
+  },
+  IArguments: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'IArguments',
+    writeable: false,
+  },
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'String',
+    writeable: false,
+  },
+  StringConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'StringConstructor',
+    writeable: false,
+  },
+  Boolean: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Boolean',
+    writeable: false,
+  },
+  BooleanConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BooleanConstructor',
+    writeable: false,
+  },
+  Number: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Number',
+    writeable: false,
+  },
+  NumberConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NumberConstructor',
+    writeable: false,
+  },
+  TemplateStringsArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TemplateStringsArray',
+    writeable: false,
+  },
+  ImportMeta: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ImportMeta',
+    writeable: false,
+  },
+  Math: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Math',
+    writeable: false,
+  },
+  Date: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Date',
+    writeable: false,
+  },
+  DateConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DateConstructor',
+    writeable: false,
+  },
+  RegExpMatchArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpMatchArray',
+    writeable: false,
+  },
+  RegExpExecArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpExecArray',
+    writeable: false,
+  },
+  RegExp: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'RegExp',
+    writeable: false,
+  },
+  RegExpConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RegExpConstructor',
+    writeable: false,
+  },
+  Error: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Error',
+    writeable: false,
+  },
+  ErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ErrorConstructor',
+    writeable: false,
+  },
+  EvalError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'EvalError',
+    writeable: false,
+  },
+  EvalErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'EvalErrorConstructor',
+    writeable: false,
+  },
+  RangeError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'RangeError',
+    writeable: false,
+  },
+  RangeErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'RangeErrorConstructor',
+    writeable: false,
+  },
+  ReferenceError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'ReferenceError',
+    writeable: false,
+  },
+  ReferenceErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReferenceErrorConstructor',
+    writeable: false,
+  },
+  SyntaxError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'SyntaxError',
+    writeable: false,
+  },
+  SyntaxErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SyntaxErrorConstructor',
+    writeable: false,
+  },
+  TypeError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'TypeError',
+    writeable: false,
+  },
+  TypeErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TypeErrorConstructor',
+    writeable: false,
+  },
+  URIError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'URIError',
+    writeable: false,
+  },
+  URIErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'URIErrorConstructor',
+    writeable: false,
+  },
+  JSON: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'JSON',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  ConcatArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ConcatArray',
+    writeable: false,
+  },
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Array',
+    writeable: false,
+  },
+  ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayConstructor',
+    writeable: false,
+  },
+  TypedPropertyDescriptor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TypedPropertyDescriptor',
+    writeable: false,
+  },
+  ClassDecorator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ClassDecorator',
+    writeable: false,
+  },
+  PropertyDecorator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PropertyDecorator',
+    writeable: false,
+  },
+  MethodDecorator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'MethodDecorator',
+    writeable: false,
+  },
+  ParameterDecorator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ParameterDecorator',
+    writeable: false,
+  },
+  PromiseConstructorLike: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructorLike',
+    writeable: false,
+  },
+  PromiseLike: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseLike',
+    writeable: false,
+  },
+  Promise: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Promise',
+    writeable: false,
+  },
+  ArrayLike: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayLike',
+    writeable: false,
+  },
+  Partial: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Partial',
+    writeable: false,
+  },
+  Required: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Required',
+    writeable: false,
+  },
+  Readonly: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Readonly',
+    writeable: false,
+  },
+  Pick: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Pick',
+    writeable: false,
+  },
+  Record: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Record',
+    writeable: false,
+  },
+  Exclude: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Exclude',
+    writeable: false,
+  },
+  Extract: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Extract',
+    writeable: false,
+  },
+  Omit: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Omit',
+    writeable: false,
+  },
+  NonNullable: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'NonNullable',
+    writeable: false,
+  },
+  Parameters: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Parameters',
+    writeable: false,
+  },
+  ConstructorParameters: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ConstructorParameters',
+    writeable: false,
+  },
+  ReturnType: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReturnType',
+    writeable: false,
+  },
+  InstanceType: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'InstanceType',
+    writeable: false,
+  },
+  ThisType: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ThisType',
+    writeable: false,
+  },
+  ArrayBuffer: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'ArrayBuffer',
+    writeable: false,
+  },
+  ArrayBufferTypes: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferTypes',
+    writeable: false,
+  },
+  ArrayBufferLike: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferLike',
+    writeable: false,
+  },
+  ArrayBufferConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferConstructor',
+    writeable: false,
+  },
+  ArrayBufferView: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ArrayBufferView',
+    writeable: false,
+  },
+  DataView: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'DataView',
+    writeable: false,
+  },
+  DataViewConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DataViewConstructor',
+    writeable: false,
+  },
+  Int8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Int8Array',
+    writeable: false,
+  },
+  Int8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Uint8Array',
+    writeable: false,
+  },
+  Uint8ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ArrayConstructor',
+    writeable: false,
+  },
+  Uint8ClampedArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Uint8ClampedArray',
+    writeable: false,
+  },
+  Uint8ClampedArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint8ClampedArrayConstructor',
+    writeable: false,
+  },
+  Int16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Int16Array',
+    writeable: false,
+  },
+  Int16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int16ArrayConstructor',
+    writeable: false,
+  },
+  Uint16Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Uint16Array',
+    writeable: false,
+  },
+  Uint16ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint16ArrayConstructor',
+    writeable: false,
+  },
+  Int32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Int32Array',
+    writeable: false,
+  },
+  Int32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Int32ArrayConstructor',
+    writeable: false,
+  },
+  Uint32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Uint32Array',
+    writeable: false,
+  },
+  Uint32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Uint32ArrayConstructor',
+    writeable: false,
+  },
+  Float32Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Float32Array',
+    writeable: false,
+  },
+  Float32ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float32ArrayConstructor',
+    writeable: false,
+  },
+  Float64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Float64Array',
+    writeable: false,
+  },
+  Float64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Float64ArrayConstructor',
+    writeable: false,
+  },
+  Intl: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Intl',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es6.ts

@@ -0,0 +1,28 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es5 } from './es5';
+import { es2015_core } from './es2015.core';
+import { es2015_collection } from './es2015.collection';
+import { es2015_iterable } from './es2015.iterable';
+import { es2015_generator } from './es2015.generator';
+import { es2015_promise } from './es2015.promise';
+import { es2015_proxy } from './es2015.proxy';
+import { es2015_reflect } from './es2015.reflect';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
+
+export const es6 = {
+  ...es5,
+  ...es2015_core,
+  ...es2015_collection,
+  ...es2015_iterable,
+  ...es2015_generator,
+  ...es2015_promise,
+  ...es2015_proxy,
+  ...es2015_reflect,
+  ...es2015_symbol,
+  ...es2015_symbol_wellknown,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/es7.ts

@@ -0,0 +1,12 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015 } from './es2015';
+import { es2016_array_include } from './es2016.array.include';
+
+export const es7 = {
+  ...es2015,
+  ...es2016_array_include,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.array.ts

@@ -0,0 +1,29 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_array = {
+  FlatArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'FlatArray',
+    writeable: false,
+  },
+  ReadonlyArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ReadonlyArray',
+    writeable: false,
+  },
+  Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Array',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.asynciterable.ts

@@ -0,0 +1,40 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_iterable } from './es2015.iterable';
+
+export const esnext_asynciterable = {
+  ...es2015_symbol,
+  ...es2015_iterable,
+  SymbolConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'SymbolConstructor',
+    writeable: false,
+  },
+  AsyncIterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterator',
+    writeable: false,
+  },
+  AsyncIterable: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterable',
+    writeable: false,
+  },
+  AsyncIterableIterator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AsyncIterableIterator',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.bigint.ts

@@ -0,0 +1,57 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_bigint = {
+  BigInt: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigInt',
+    writeable: false,
+  },
+  BigIntConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigIntConstructor',
+    writeable: false,
+  },
+  BigInt64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigInt64Array',
+    writeable: false,
+  },
+  BigInt64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigInt64ArrayConstructor',
+    writeable: false,
+  },
+  BigUint64Array: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'BigUint64Array',
+    writeable: false,
+  },
+  BigUint64ArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'BigUint64ArrayConstructor',
+    writeable: false,
+  },
+  DataView: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DataView',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.full.ts

@@ -0,0 +1,18 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { esnext } from './esnext';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { dom_iterable } from './dom.iterable';
+
+export const esnext_full = {
+  ...esnext,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+  ...dom_iterable,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.intl.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_intl = {
+  Intl: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Intl',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.promise.ts

@@ -0,0 +1,29 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_promise = {
+  AggregateError: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'AggregateError',
+    writeable: false,
+  },
+  AggregateErrorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'AggregateErrorConstructor',
+    writeable: false,
+  },
+  PromiseConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'PromiseConstructor',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.string.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_string = {
+  String: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'String',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.symbol.ts

@@ -0,0 +1,15 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const esnext_symbol = {
+  Symbol: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Symbol',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/esnext.ts

@@ -0,0 +1,16 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es2020 } from './es2020';
+import { esnext_intl } from './esnext.intl';
+import { esnext_string } from './esnext.string';
+import { esnext_promise } from './esnext.promise';
+
+export const esnext = {
+  ...es2020,
+  ...esnext_intl,
+  ...esnext_string,
+  ...esnext_promise,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/index.ts

@@ -0,0 +1,123 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { es5 } from './es5';
+import { es6 } from './es6';
+import { es2015 } from './es2015';
+import { es7 } from './es7';
+import { es2016 } from './es2016';
+import { es2017 } from './es2017';
+import { es2018 } from './es2018';
+import { es2019 } from './es2019';
+import { es2020 } from './es2020';
+import { esnext } from './esnext';
+import { dom } from './dom';
+import { dom_iterable } from './dom.iterable';
+import { webworker } from './webworker';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+import { es2015_core } from './es2015.core';
+import { es2015_collection } from './es2015.collection';
+import { es2015_generator } from './es2015.generator';
+import { es2015_iterable } from './es2015.iterable';
+import { es2015_promise } from './es2015.promise';
+import { es2015_proxy } from './es2015.proxy';
+import { es2015_reflect } from './es2015.reflect';
+import { es2015_symbol } from './es2015.symbol';
+import { es2015_symbol_wellknown } from './es2015.symbol.wellknown';
+import { es2016_array_include } from './es2016.array.include';
+import { es2017_object } from './es2017.object';
+import { es2017_sharedmemory } from './es2017.sharedmemory';
+import { es2017_string } from './es2017.string';
+import { es2017_intl } from './es2017.intl';
+import { es2017_typedarrays } from './es2017.typedarrays';
+import { es2018_asyncgenerator } from './es2018.asyncgenerator';
+import { es2018_asynciterable } from './es2018.asynciterable';
+import { es2018_intl } from './es2018.intl';
+import { es2018_promise } from './es2018.promise';
+import { es2018_regexp } from './es2018.regexp';
+import { es2019_array } from './es2019.array';
+import { es2019_object } from './es2019.object';
+import { es2019_string } from './es2019.string';
+import { es2019_symbol } from './es2019.symbol';
+import { es2020_bigint } from './es2020.bigint';
+import { es2020_promise } from './es2020.promise';
+import { es2020_string } from './es2020.string';
+import { es2020_symbol_wellknown } from './es2020.symbol.wellknown';
+import { esnext_array } from './esnext.array';
+import { esnext_symbol } from './esnext.symbol';
+import { esnext_asynciterable } from './esnext.asynciterable';
+import { esnext_intl } from './esnext.intl';
+import { esnext_bigint } from './esnext.bigint';
+import { esnext_string } from './esnext.string';
+import { esnext_promise } from './esnext.promise';
+import { es2016_full } from './es2016.full';
+import { es2017_full } from './es2017.full';
+import { es2018_full } from './es2018.full';
+import { es2019_full } from './es2019.full';
+import { es2020_full } from './es2020.full';
+import { esnext_full } from './esnext.full';
+import { lib as libBase } from './lib';
+
+const lib = {
+  es5,
+  es6,
+  es2015,
+  es7,
+  es2016,
+  es2017,
+  es2018,
+  es2019,
+  es2020,
+  esnext,
+  dom,
+  'dom.iterable': dom_iterable,
+  webworker,
+  'webworker.importscripts': webworker_importscripts,
+  scripthost,
+  'es2015.core': es2015_core,
+  'es2015.collection': es2015_collection,
+  'es2015.generator': es2015_generator,
+  'es2015.iterable': es2015_iterable,
+  'es2015.promise': es2015_promise,
+  'es2015.proxy': es2015_proxy,
+  'es2015.reflect': es2015_reflect,
+  'es2015.symbol': es2015_symbol,
+  'es2015.symbol.wellknown': es2015_symbol_wellknown,
+  'es2016.array.include': es2016_array_include,
+  'es2017.object': es2017_object,
+  'es2017.sharedmemory': es2017_sharedmemory,
+  'es2017.string': es2017_string,
+  'es2017.intl': es2017_intl,
+  'es2017.typedarrays': es2017_typedarrays,
+  'es2018.asyncgenerator': es2018_asyncgenerator,
+  'es2018.asynciterable': es2018_asynciterable,
+  'es2018.intl': es2018_intl,
+  'es2018.promise': es2018_promise,
+  'es2018.regexp': es2018_regexp,
+  'es2019.array': es2019_array,
+  'es2019.object': es2019_object,
+  'es2019.string': es2019_string,
+  'es2019.symbol': es2019_symbol,
+  'es2020.bigint': es2020_bigint,
+  'es2020.promise': es2020_promise,
+  'es2020.string': es2020_string,
+  'es2020.symbol.wellknown': es2020_symbol_wellknown,
+  'esnext.array': esnext_array,
+  'esnext.symbol': esnext_symbol,
+  'esnext.asynciterable': esnext_asynciterable,
+  'esnext.intl': esnext_intl,
+  'esnext.bigint': esnext_bigint,
+  'esnext.string': esnext_string,
+  'esnext.promise': esnext_promise,
+  'es2016.full': es2016_full,
+  'es2017.full': es2017_full,
+  'es2018.full': es2018_full,
+  'es2019.full': es2019_full,
+  'es2020.full': es2020_full,
+  'esnext.full': esnext_full,
+  lib: libBase,
+} as const;
+
+export { lib };

packages/scope-manager/src/lib/lib.ts

@@ -0,0 +1,16 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+import { es5 } from './es5';
+import { dom } from './dom';
+import { webworker_importscripts } from './webworker.importscripts';
+import { scripthost } from './scripthost';
+
+export const lib = {
+  ...es5,
+  ...dom,
+  ...webworker_importscripts,
+  ...scripthost,
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/scripthost.ts

@@ -0,0 +1,99 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const scripthost = {
+  ActiveXObject: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'ActiveXObject',
+    writeable: false,
+  },
+  ITextWriter: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'ITextWriter',
+    writeable: false,
+  },
+  TextStreamBase: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TextStreamBase',
+    writeable: false,
+  },
+  TextStreamWriter: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TextStreamWriter',
+    writeable: false,
+  },
+  TextStreamReader: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'TextStreamReader',
+    writeable: false,
+  },
+  SafeArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'SafeArray',
+    writeable: false,
+  },
+  Enumerator: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'Enumerator',
+    writeable: false,
+  },
+  EnumeratorConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'EnumeratorConstructor',
+    writeable: false,
+  },
+  VBArray: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'VBArray',
+    writeable: false,
+  },
+  VBArrayConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'VBArrayConstructor',
+    writeable: false,
+  },
+  VarDate: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: true,
+    name: 'VarDate',
+    writeable: false,
+  },
+  DateConstructor: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'DateConstructor',
+    writeable: false,
+  },
+  Date: {
+    eslintImplicitGlobalSetting: 'readonly',
+    isTypeVariable: true,
+    isValueVariable: false,
+    name: 'Date',
+    writeable: false,
+  },
+} as Record<string, ImplicitLibVariableOptions>;

packages/scope-manager/src/lib/webworker.importscripts.ts

@@ -0,0 +1,10 @@
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// YOU CAN REGENERATE IT USING yarn generate:lib
+
+import { ImplicitLibVariableOptions } from '../variable';
+
+export const webworker_importscripts = {} as Record<
+  string,
+  ImplicitLibVariableOptions
+>;

packages/scope-manager/src/referencer/ExportVisitor.ts

@@ -0,0 +1,72 @@
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/types';
+import { Referencer } from './Referencer';
+import { Visitor } from './Visitor';
+
+type ExportNode =
+  | TSESTree.ExportAllDeclaration
+  | TSESTree.ExportDefaultDeclaration
+  | TSESTree.ExportNamedDeclaration;
+
+class ExportVisitor extends Visitor {
+  readonly #referencer: Referencer;
+  readonly #exportNode: ExportNode;
+
+  constructor(node: ExportNode, referencer: Referencer) {
+    super(referencer);
+    this.#exportNode = node;
+    this.#referencer = referencer;
+  }
+
+  static visit(referencer: Referencer, node: ExportNode): void {
+    const exportReferencer = new ExportVisitor(node, referencer);
+    exportReferencer.visit(node);
+  }
+
+  protected Identifier(node: TSESTree.Identifier): void {
+    if (this.#exportNode.exportKind === 'type') {
+      // type exports can only reference types
+      this.#referencer.currentScope().referenceType(node);
+    } else {
+      this.#referencer.currentScope().referenceDualValueType(node);
+    }
+  }
+
+  protected ExportDefaultDeclaration(
+    node: TSESTree.ExportDefaultDeclaration,
+  ): void {
+    if (node.declaration.type === AST_NODE_TYPES.Identifier) {
+      // export default A;
+      // this could be a type or a variable
+      this.visit(node.declaration);
+    } else {
+      // export const a = 1;
+      // export something();
+      // etc
+      // these not included in the scope of this visitor as they are all guaranteed to be values or declare variables
+    }
+  }
+
+  protected ExportNamedDeclaration(
+    node: TSESTree.ExportNamedDeclaration,
+  ): void {
+    if (node.source) {
+      // export ... from 'foo';
+      // these are external identifiers so there shouldn't be references or defs
+      return;
+    }
+
+    if (!node.declaration) {
+      // export { x };
+      this.visitChildren(node);
+    } else {
+      // export const x = 1;
+      // this is not included in the scope of this visitor as it creates a variable
+    }
+  }
+
+  protected ExportSpecifier(node: TSESTree.ExportSpecifier): void {
+    this.visit(node.local);
+  }
+}
+
+export { ExportVisitor };