diff --git a/packages/eslint-plugin-tslint/src/index.ts b/packages/eslint-plugin-tslint/src/index.ts
index 78e946af6294..f2ae0e55efd3 100644
--- a/packages/eslint-plugin-tslint/src/index.ts
+++ b/packages/eslint-plugin-tslint/src/index.ts
@@ -3,20 +3,12 @@ import memoize from 'lodash.memoize';
 import { Configuration, RuleSeverity } from 'tslint';
 import { Program } from 'typescript';
 import { CustomLinter } from './custom-linter';
+import { ParserServices } from '@typescript-eslint/typescript-estree';
 
 //------------------------------------------------------------------------------
 // Plugin Definition
 //------------------------------------------------------------------------------
 
-/**
- * @todo share types between packages
- */
-interface ParserServices {
-  program: Program | undefined;
-  esTreeNodeToTSNodeMap: WeakMap<object, any> | undefined;
-  tsNodeToESTreeNodeMap: WeakMap<object, any> | undefined;
-}
-
 type RawRuleConfig =
   | null
   | undefined
diff --git a/packages/parser/package.json b/packages/parser/package.json
index 26de602491a7..8cadc1c74159 100644
--- a/packages/parser/package.json
+++ b/packages/parser/package.json
@@ -43,7 +43,6 @@
   "devDependencies": {
     "@types/eslint": "^4.16.5",
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@types/estree": "^0.0.39",
     "@typescript-eslint/shared-fixtures": "1.2.0"
   }
 }
diff --git a/packages/parser/src/analyze-scope.ts b/packages/parser/src/analyze-scope.ts
index 2e8ae2e0a3cd..f3a6b5f78ac1 100644
--- a/packages/parser/src/analyze-scope.ts
+++ b/packages/parser/src/analyze-scope.ts
@@ -11,7 +11,7 @@ import {
   PatternVisitorCallback,
   PatternVisitorOptions
 } from 'eslint-scope/lib/options';
-import { Node } from 'estree';
+import { TSESTree } from '@typescript-eslint/typescript-estree';
 
 /**
  * Define the override function of `Scope#__define` for global augmentation.
@@ -35,7 +35,7 @@ class EnumScope extends Scope {
   constructor(
     scopeManager: ScopeManager,
     upperScope: Scope,
-    block: Node | null
+    block: TSESTree.Node | null
   ) {
     // @ts-ignore
     super(scopeManager, 'enum', upperScope, block, false);
@@ -51,7 +51,7 @@ class PatternVisitor extends OriginalPatternVisitor {
     super(options, rootPattern, callback);
   }
 
-  Identifier(node: any) {
+  Identifier(node: TSESTree.Identifier): void {
     super.Identifier(node);
     if (node.decorators) {
       this.rightHandNodes.push(...node.decorators);
@@ -61,7 +61,7 @@ class PatternVisitor extends OriginalPatternVisitor {
     }
   }
 
-  ArrayPattern(node: any) {
+  ArrayPattern(node: TSESTree.ArrayPattern): void {
     node.elements.forEach(this.visit, this);
     if (node.decorators) {
       this.rightHandNodes.push(...node.decorators);
@@ -71,7 +71,7 @@ class PatternVisitor extends OriginalPatternVisitor {
     }
   }
 
-  ObjectPattern(node: any) {
+  ObjectPattern(node: TSESTree.ObjectPattern): void {
     node.properties.forEach(this.visit, this);
     if (node.decorators) {
       this.rightHandNodes.push(...node.decorators);
@@ -81,8 +81,11 @@ class PatternVisitor extends OriginalPatternVisitor {
     }
   }
 
-  RestElement(node: any) {
+  RestElement(node: TSESTree.RestElement): void {
     super.RestElement(node);
+    if (node.decorators) {
+      this.rightHandNodes.push(...node.decorators);
+    }
     if (node.typeAnnotation) {
       this.rightHandNodes.push(node.typeAnnotation);
     }
@@ -99,16 +102,15 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Override to use PatternVisitor we overrode.
-   * @param {Identifier} node The Identifier node to visit.
-   * @param {Object} [options] The flag to visit right-hand side nodes.
-   * @param {Function} callback The callback function for left-hand side nodes.
-   * @returns {void}
+   * @param node The Identifier node to visit.
+   * @param [options] The flag to visit right-hand side nodes.
+   * @param callback The callback function for left-hand side nodes.
    */
-  visitPattern(
-    node: any,
+  visitPattern<T extends TSESTree.BaseNode>(
+    node: T,
     options: PatternVisitorOptions,
     callback: PatternVisitorCallback
-  ) {
+  ): void {
     if (!node) {
       return;
     }
@@ -130,10 +132,14 @@ class Referencer extends OriginalReferencer {
   /**
    * Override.
    * Visit `node.typeParameters` and `node.returnType` additionally to find `typeof` expressions.
-   * @param {FunctionDeclaration|FunctionExpression|ArrowFunctionExpression} node The function node to visit.
-   * @returns {void}
-   */
-  visitFunction(node: any) {
+   * @param node The function node to visit.
+   */
+  visitFunction(
+    node:
+      | TSESTree.FunctionDeclaration
+      | TSESTree.FunctionExpression
+      | TSESTree.ArrowFunctionExpression
+  ): void {
     const { type, id, typeParameters, params, returnType, body } = node;
     const scopeManager = this.scopeManager;
     const upperScope = this.currentScope();
@@ -189,7 +195,7 @@ class Referencer extends OriginalReferencer {
     this.visit(returnType);
 
     // Process the body.
-    if (body.type === 'BlockStatement') {
+    if (body && body.type === 'BlockStatement') {
       this.visitChildren(body);
     } else {
       this.visit(body);
@@ -202,10 +208,9 @@ class Referencer extends OriginalReferencer {
   /**
    * Override.
    * Visit decorators.
-   * @param {ClassDeclaration|ClassExpression} node The class node to visit.
-   * @returns {void}
+   * @param node The class node to visit.
    */
-  visitClass(node: any) {
+  visitClass(node: TSESTree.ClassDeclaration | TSESTree.ClassExpression): void {
     this.visitDecorators(node.decorators);
 
     const upperTypeMode = this.typeMode;
@@ -214,7 +219,7 @@ class Referencer extends OriginalReferencer {
       this.visit(node.superTypeParameters);
     }
     if (node.implements) {
-      this.visit(node.implements);
+      node.implements.forEach(this.visit, this);
     }
     this.typeMode = upperTypeMode;
 
@@ -223,10 +228,13 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Visit typeParameters.
-   * @param {*} node The node to visit.
-   * @returns {void}
+   * @param node The node to visit.
    */
-  visitTypeParameters(node: any) {
+  visitTypeParameters(node: {
+    typeParameters?:
+      | TSESTree.TSTypeParameterDeclaration
+      | TSESTree.TSTypeParameterInstantiation;
+  }): void {
     if (node.typeParameters) {
       const upperTypeMode = this.typeMode;
       this.typeMode = true;
@@ -238,7 +246,7 @@ class Referencer extends OriginalReferencer {
   /**
    * Override.
    */
-  JSXOpeningElement(node: any) {
+  JSXOpeningElement(node: TSESTree.JSXOpeningElement): void {
     this.visit(node.name);
     this.visitTypeParameters(node);
     node.attributes.forEach(this.visit, this);
@@ -247,10 +255,9 @@ class Referencer extends OriginalReferencer {
   /**
    * Override.
    * Don't create the reference object in the type mode.
-   * @param {Identifier} node The Identifier node to visit.
-   * @returns {void}
+   * @param node The Identifier node to visit.
    */
-  Identifier(node: any) {
+  Identifier(node: TSESTree.Identifier): void {
     this.visitDecorators(node.decorators);
 
     if (!this.typeMode) {
@@ -263,20 +270,22 @@ class Referencer extends OriginalReferencer {
   /**
    * Override.
    * Visit decorators.
-   * @param {MethodDefinition} node The MethodDefinition node to visit.
-   * @returns {void}
+   * @param node The MethodDefinition node to visit.
    */
-  MethodDefinition(node: any) {
+  MethodDefinition(
+    node: TSESTree.MethodDefinition | TSESTree.TSAbstractMethodDefinition
+  ): void {
     this.visitDecorators(node.decorators);
     super.MethodDefinition(node);
   }
 
   /**
    * Don't create the reference object for the key if not computed.
-   * @param {ClassProperty} node The ClassProperty node to visit.
-   * @returns {void}
+   * @param node The ClassProperty node to visit.
    */
-  ClassProperty(node: any) {
+  ClassProperty(
+    node: TSESTree.ClassProperty | TSESTree.TSAbstractClassProperty
+  ): void {
     const upperTypeMode = this.typeMode;
     const { computed, decorators, key, typeAnnotation, value } = node;
 
@@ -295,39 +304,34 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Visit new expression.
-   * @param {NewExpression} node The NewExpression node to visit.
-   * @returns {void}
+   * @param node The NewExpression node to visit.
    */
-  NewExpression(node: any) {
+  NewExpression(node: TSESTree.NewExpression): void {
     this.visitTypeParameters(node);
     this.visit(node.callee);
-    if (node.arguments) {
-      node.arguments.forEach(this.visit, this);
-    }
+
+    node.arguments.forEach(this.visit, this);
   }
 
   /**
    * Override.
    * Visit call expression.
-   * @param {CallExpression} node The CallExpression node to visit.
-   * @returns {void}
+   * @param node The CallExpression node to visit.
    */
-  CallExpression(node: any) {
+  CallExpression(node: TSESTree.CallExpression): void {
     this.visitTypeParameters(node);
 
     this.visit(node.callee);
-    if (node.arguments) {
-      node.arguments.forEach(this.visit, this);
-    }
+
+    node.arguments.forEach(this.visit, this);
   }
 
   /**
    * Define the variable of this function declaration only once.
    * Because to avoid confusion of `no-redeclare` rule by overloading.
-   * @param {TSDeclareFunction} node The TSDeclareFunction node to visit.
-   * @returns {void}
+   * @param node The TSDeclareFunction node to visit.
    */
-  TSDeclareFunction(node: any) {
+  TSDeclareFunction(node: TSESTree.TSDeclareFunction): void {
     const upperTypeMode = this.typeMode;
     const scope = this.currentScope();
     const { id, typeParameters, params, returnType } = node;
@@ -355,10 +359,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Create reference objects for the references in parameters and return type.
-   * @param {TSEmptyBodyFunctionExpression} node The TSEmptyBodyFunctionExpression node to visit.
-   * @returns {void}
+   * @param node The TSEmptyBodyFunctionExpression node to visit.
    */
-  TSEmptyBodyFunctionExpression(node: any) {
+  TSEmptyBodyFunctionExpression(node: TSESTree.FunctionExpression): void {
     const upperTypeMode = this.typeMode;
     const { typeParameters, params, returnType } = node;
 
@@ -372,39 +375,35 @@ class Referencer extends OriginalReferencer {
   /**
    * Don't make variable because it declares only types.
    * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
-   * @param {TSInterfaceDeclaration} node The TSInterfaceDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSInterfaceDeclaration node to visit.
    */
-  TSInterfaceDeclaration(node: any) {
+  TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Don't make variable because it declares only types.
    * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
-   * @param {TSClassImplements} node The TSClassImplements node to visit.
-   * @returns {void}
+   * @param node The TSClassImplements node to visit.
    */
-  TSClassImplements(node: any) {
+  TSClassImplements(node: TSESTree.TSClassImplements): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Don't make variable because it declares only types.
    * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
-   * @param {TSIndexSignature} node The TSIndexSignature node to visit.
-   * @returns {void}
+   * @param node The TSIndexSignature node to visit.
    */
-  TSIndexSignature(node: any) {
+  TSIndexSignature(node: TSESTree.TSIndexSignature): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Visit type assertion.
-   * @param {TSTypeAssertion} node The TSTypeAssertion node to visit.
-   * @returns {void}
+   * @param node The TSTypeAssertion node to visit.
    */
-  TSTypeAssertion(node: any) {
+  TSTypeAssertion(node: TSESTree.TSTypeAssertion): void {
     if (this.typeMode) {
       this.visit(node.typeAnnotation);
     } else {
@@ -418,10 +417,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Visit as expression.
-   * @param {TSAsExpression} node The TSAsExpression node to visit.
-   * @returns {void}
+   * @param node The TSAsExpression node to visit.
    */
-  TSAsExpression(node: any) {
+  TSAsExpression(node: TSESTree.TSAsExpression): void {
     this.visit(node.expression);
 
     if (this.typeMode) {
@@ -435,28 +433,25 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
-   * @param {TSTypeAnnotation} node The TSTypeAnnotation node to visit.
-   * @returns {void}
+   * @param node The TSTypeAnnotation node to visit.
    */
-  TSTypeAnnotation(node: any) {
+  TSTypeAnnotation(node: TSESTree.TSTypeAnnotation): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Switch to the type mode and visit child nodes to find `typeof x` expression in type declarations.
-   * @param {TSTypeParameterDeclaration} node The TSTypeParameterDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSTypeParameterDeclaration node to visit.
    */
-  TSTypeParameterDeclaration(node: any) {
+  TSTypeParameterDeclaration(node: TSESTree.TSTypeParameterDeclaration): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Create reference objects for the references in `typeof` expression.
-   * @param {TSTypeQuery} node The TSTypeQuery node to visit.
-   * @returns {void}
+   * @param node The TSTypeQuery node to visit.
    */
-  TSTypeQuery(node: any) {
+  TSTypeQuery(node: TSESTree.TSTypeQuery): void {
     if (this.typeMode) {
       this.typeMode = false;
       this.visitChildren(node);
@@ -467,124 +462,109 @@ class Referencer extends OriginalReferencer {
   }
 
   /**
-   * @param {TSTypeParameter} node The TSTypeParameter node to visit.
-   * @returns {void}
+   * @param node The TSTypeParameter node to visit.
    */
-  TSTypeParameter(node: any) {
+  TSTypeParameter(node: TSESTree.TSTypeParameter): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSInferType} node The TSInferType node to visit.
-   * @returns {void}
+   * @param node The TSInferType node to visit.
    */
-  TSInferType(node: any) {
+  TSInferType(node: TSESTree.TSInferType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSTypeReference} node The TSTypeReference node to visit.
-   * @returns {void}
+   * @param node The TSTypeReference node to visit.
    */
-  TSTypeReference(node: any) {
+  TSTypeReference(node: TSESTree.TSTypeReference): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSTypeLiteral} node The TSTypeLiteral node to visit.
-   * @returns {void}
+   * @param node The TSTypeLiteral node to visit.
    */
-  TSTypeLiteral(node: any) {
+  TSTypeLiteral(node: TSESTree.TSTypeLiteral): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSLiteralType} node The TSLiteralType node to visit.
-   * @returns {void}
+   * @param node The TSLiteralType node to visit.
    */
-  TSLiteralType(node: any) {
+  TSLiteralType(node: TSESTree.TSLiteralType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSIntersectionType} node The TSIntersectionType node to visit.
-   * @returns {void}
+   * @param node The TSIntersectionType node to visit.
    */
-  TSIntersectionType(node: any) {
+  TSIntersectionType(node: TSESTree.TSIntersectionType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSConditionalType} node The TSConditionalType node to visit.
-   * @returns {void}
+   * @param node The TSConditionalType node to visit.
    */
-  TSConditionalType(node: any) {
+  TSConditionalType(node: TSESTree.TSConditionalType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSIndexedAccessType} node The TSIndexedAccessType node to visit.
-   * @returns {void}
+   * @param node The TSIndexedAccessType node to visit.
    */
-  TSIndexedAccessType(node: any) {
+  TSIndexedAccessType(node: TSESTree.TSIndexedAccessType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSMappedType} node The TSMappedType node to visit.
-   * @returns {void}
+   * @param node The TSMappedType node to visit.
    */
-  TSMappedType(node: any) {
+  TSMappedType(node: TSESTree.TSMappedType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSOptionalType} node The TSOptionalType node to visit.
-   * @returns {void}
+   * @param node The TSOptionalType node to visit.
    */
-  TSOptionalType(node: any) {
+  TSOptionalType(node: TSESTree.TSOptionalType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSParenthesizedType} node The TSParenthesizedType node to visit.
-   * @returns {void}
+   * @param node The TSParenthesizedType node to visit.
    */
-  TSParenthesizedType(node: any) {
+  TSParenthesizedType(node: TSESTree.TSParenthesizedType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSRestType} node The TSRestType node to visit.
-   * @returns {void}
+   * @param node The TSRestType node to visit.
    */
-  TSRestType(node: any) {
+  TSRestType(node: TSESTree.TSRestType): void {
     this.visitTypeNodes(node);
   }
 
   /**
-   * @param {TSTupleType} node The TSTupleType node to visit.
-   * @returns {void}
+   * @param node The TSTupleType node to visit.
    */
-  TSTupleType(node: any) {
+  TSTupleType(node: TSESTree.TSTupleType): void {
     this.visitTypeNodes(node);
   }
 
   /**
    * Create reference objects for the object part. (This is `obj.prop`)
-   * @param {TSQualifiedName} node The TSQualifiedName node to visit.
-   * @returns {void}
+   * @param node The TSQualifiedName node to visit.
    */
-  TSQualifiedName(node: any) {
+  TSQualifiedName(node: TSESTree.TSQualifiedName): void {
     this.visit(node.left);
   }
 
   /**
    * Create reference objects for the references in computed keys.
-   * @param {TSPropertySignature} node The TSPropertySignature node to visit.
-   * @returns {void}
+   * @param node The TSPropertySignature node to visit.
    */
-  TSPropertySignature(node: any) {
+  TSPropertySignature(node: TSESTree.TSPropertySignature): void {
     const upperTypeMode = this.typeMode;
     const { computed, key, typeAnnotation, initializer } = node;
 
@@ -604,10 +584,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Create reference objects for the references in computed keys.
-   * @param {TSMethodSignature} node The TSMethodSignature node to visit.
-   * @returns {void}
+   * @param node The TSMethodSignature node to visit.
    */
-  TSMethodSignature(node: any) {
+  TSMethodSignature(node: TSESTree.TSMethodSignature): void {
     const upperTypeMode = this.typeMode;
     const { computed, key, typeParameters, params, returnType } = node;
 
@@ -641,10 +620,9 @@ class Referencer extends OriginalReferencer {
    *   A = a // a is above constant.
    * }
    *
-   * @param {TSEnumDeclaration} node The TSEnumDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSEnumDeclaration node to visit.
    */
-  TSEnumDeclaration(node: any) {
+  TSEnumDeclaration(node: TSESTree.TSEnumDeclaration): void {
     const { id, members } = node;
     const scopeManager = this.scopeManager;
     const scope = this.currentScope();
@@ -664,10 +642,9 @@ class Referencer extends OriginalReferencer {
    * Create variable object for the enum member and create reference object for the initializer.
    * And visit the initializer.
    *
-   * @param {TSEnumMember} node The TSEnumMember node to visit.
-   * @returns {void}
+   * @param node The TSEnumMember node to visit.
    */
-  TSEnumMember(node: any) {
+  TSEnumMember(node: TSESTree.TSEnumMember): void {
     const { id, initializer } = node;
     const scope = this.currentScope();
 
@@ -680,10 +657,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Create the variable object for the module name, and visit children.
-   * @param {TSModuleDeclaration} node The TSModuleDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSModuleDeclaration node to visit.
    */
-  TSModuleDeclaration(node: any) {
+  TSModuleDeclaration(node: TSESTree.TSModuleDeclaration): void {
     const scope = this.currentScope();
     const { id, body } = node;
 
@@ -701,7 +677,7 @@ class Referencer extends OriginalReferencer {
     this.visit(body);
   }
 
-  TSTypeAliasDeclaration(node: any) {
+  TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration): void {
     this.typeMode = true;
     this.visitChildren(node);
     this.typeMode = false;
@@ -709,28 +685,26 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Process the module block.
-   * @param {TSModuleBlock} node The TSModuleBlock node to visit.
-   * @returns {void}
+   * @param node The TSModuleBlock node to visit.
    */
-  TSModuleBlock(node: any) {
+  TSModuleBlock(node: TSESTree.TSModuleBlock): void {
     this.scopeManager.__nestBlockScope(node);
     this.visitChildren(node);
     this.close(node);
   }
 
-  TSAbstractClassProperty(node: any) {
+  TSAbstractClassProperty(node: TSESTree.TSAbstractClassProperty): void {
     this.ClassProperty(node);
   }
-  TSAbstractMethodDefinition(node: any) {
+  TSAbstractMethodDefinition(node: TSESTree.TSAbstractMethodDefinition): void {
     this.MethodDefinition(node);
   }
 
   /**
    * Process import equal declaration
-   * @param {TSImportEqualsDeclaration} node The TSImportEqualsDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSImportEqualsDeclaration node to visit.
    */
-  TSImportEqualsDeclaration(node: any) {
+  TSImportEqualsDeclaration(node: TSESTree.TSImportEqualsDeclaration): void {
     const { id, moduleReference } = node;
     if (id && id.type === 'Identifier') {
       this.currentScope().__define(
@@ -745,10 +719,9 @@ class Referencer extends OriginalReferencer {
    * Process the global augmentation.
    * 1. Set the global scope as the current scope.
    * 2. Configure the global scope to set `variable.eslintUsed = true` for all defined variables. This means `no-unused-vars` doesn't warn those.
-   * @param {TSModuleDeclaration} node The TSModuleDeclaration node to visit.
-   * @returns {void}
+   * @param node The TSModuleDeclaration node to visit.
    */
-  visitGlobalAugmentation(node: any) {
+  visitGlobalAugmentation(node: TSESTree.TSModuleDeclaration): void {
     const scopeManager = this.scopeManager;
     const currentScope = this.currentScope();
     const globalScope = scopeManager.globalScope;
@@ -758,8 +731,8 @@ class Referencer extends OriginalReferencer {
     scopeManager.__currentScope = globalScope;
 
     // Skip TSModuleBlock to avoid to create that block scope.
-    for (const moduleItem of node.body.body) {
-      this.visit(moduleItem);
+    if (node.body && node.body.type === 'TSModuleBlock') {
+      node.body.body.forEach(this.visit, this);
     }
 
     scopeManager.__currentScope = currentScope;
@@ -768,10 +741,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Process decorators.
-   * @param {Decorator[]|undefined} decorators The decorator nodes to visit.
-   * @returns {void}
+   * @param decorators The decorator nodes to visit.
    */
-  visitDecorators(decorators?: any[]) {
+  visitDecorators(decorators?: TSESTree.Decorator[]): void {
     if (decorators) {
       decorators.forEach(this.visit, this);
     }
@@ -779,10 +751,9 @@ class Referencer extends OriginalReferencer {
 
   /**
    * Process all child of type nodes
-   * @param {any} node node to be processed
-   * @returns {void}
+   * @param node node to be processed
    */
-  visitTypeNodes(node: any) {
+  visitTypeNodes(node: TSESTree.Node): void {
     if (this.typeMode) {
       this.visitChildren(node);
     } else {
diff --git a/packages/parser/src/typings.d.ts b/packages/parser/src/eslint-scope.d.ts
similarity index 57%
rename from packages/parser/src/typings.d.ts
rename to packages/parser/src/eslint-scope.d.ts
index 08f92526c823..28de7f8c759e 100644
--- a/packages/parser/src/typings.d.ts
+++ b/packages/parser/src/eslint-scope.d.ts
@@ -2,6 +2,7 @@
 // Project: http://github.com/eslint/eslint-scope
 // Definitions by: Armano <https://github.com/armano2>
 declare module 'eslint-scope/lib/options' {
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   export type PatternVisitorCallback = (pattern: any, info: any) => void;
 
   export interface PatternVisitorOptions {
@@ -9,76 +10,75 @@ declare module 'eslint-scope/lib/options' {
   }
 
   export abstract class Visitor {
-    visitChildren(node: Node): void;
-    visit(node: Node): void;
+    visitChildren<T extends TSESTree.BaseNode | undefined | null>(
+      node?: T
+    ): void;
+    visit<T extends TSESTree.BaseNode | undefined | null>(node?: T): void;
   }
 }
 
 declare module 'eslint-scope/lib/variable' {
-  import * as eslint from 'eslint';
-  import { Identifier } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import Reference from 'eslint-scope/lib/reference';
+  import { Definition } from 'eslint-scope/lib/definition';
 
-  class Variable implements eslint.Scope.Variable {
+  export default class Variable {
     name: string;
-    identifiers: Identifier[];
+    identifiers: TSESTree.Identifier[];
     references: Reference[];
-    defs: eslint.Scope.Definition[];
+    defs: Definition[];
   }
-  export default Variable;
 }
 
 declare module 'eslint-scope/lib/definition' {
-  import { Identifier, Node } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
 
-  class Definition {
+  export class Definition {
     type: string;
-    name: Identifier;
-    node: Node;
-    parent?: Node | null;
+    name: TSESTree.BindingName;
+    node: TSESTree.Node;
+    parent?: TSESTree.Node | null;
     index?: number | null;
     kind?: string | null;
 
     constructor(
       type: string,
-      name: Identifier,
-      node: Node,
-      parent?: Node | null,
+      name: TSESTree.BindingName | TSESTree.PropertyName,
+      node: TSESTree.Node,
+      parent?: TSESTree.Node | null,
       index?: number | null,
       kind?: string | null
     );
   }
 
-  class ParameterDefinition extends Definition {
+  export class ParameterDefinition extends Definition {
     rest?: boolean;
 
     constructor(
-      name: Identifier,
-      node: Node,
+      name: TSESTree.BindingName | TSESTree.PropertyName,
+      node: TSESTree.Node,
       index?: number | null,
       rest?: boolean
     );
   }
-
-  export { ParameterDefinition, Definition };
 }
 
 declare module 'eslint-scope/lib/pattern-visitor' {
   import ScopeManager from 'eslint-scope/lib/scope-manager';
-  import { Node } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import {
     PatternVisitorCallback,
     PatternVisitorOptions,
     Visitor
   } from 'eslint-scope/lib/options';
 
-  class PatternVisitor extends Visitor {
+  export default class PatternVisitor extends Visitor {
     protected options: any;
     protected scopeManager: ScopeManager;
-    protected parent?: Node;
-    public rightHandNodes: Node[];
+    protected parent?: TSESTree.Node;
+    public rightHandNodes: TSESTree.Node[];
 
-    static isPattern(node: Node): boolean;
+    static isPattern(node: TSESTree.Node): boolean;
 
     constructor(
       options: PatternVisitorOptions,
@@ -86,41 +86,39 @@ declare module 'eslint-scope/lib/pattern-visitor' {
       callback: PatternVisitorCallback
     );
 
-    Identifier(pattern: Node): void;
-    Property(property: Node): void;
-    ArrayPattern(pattern: Node): void;
-    AssignmentPattern(pattern: Node): void;
-    RestElement(pattern: Node): void;
-    MemberExpression(node: Node): void;
-    SpreadElement(node: Node): void;
-    ArrayExpression(node: Node): void;
-    AssignmentExpression(node: Node): void;
-    CallExpression(node: Node): void;
+    Identifier(pattern: TSESTree.Node): void;
+    Property(property: TSESTree.Node): void;
+    ArrayPattern(pattern: TSESTree.Node): void;
+    AssignmentPattern(pattern: TSESTree.Node): void;
+    RestElement(pattern: TSESTree.Node): void;
+    MemberExpression(node: TSESTree.Node): void;
+    SpreadElement(node: TSESTree.Node): void;
+    ArrayExpression(node: TSESTree.Node): void;
+    AssignmentExpression(node: TSESTree.Node): void;
+    CallExpression(node: TSESTree.Node): void;
   }
-
-  export default PatternVisitor;
 }
 
 declare module 'eslint-scope/lib/referencer' {
   import { Scope } from 'eslint-scope/lib/scope';
   import ScopeManager from 'eslint-scope/lib/scope-manager';
-  import { Node } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import {
     PatternVisitorCallback,
     PatternVisitorOptions,
     Visitor
   } from 'eslint-scope/lib/options';
 
-  class Referencer extends Visitor {
+  export default class Referencer extends Visitor {
     protected isInnerMethodDefinition: boolean;
     protected options: any;
     protected scopeManager: ScopeManager;
-    protected parent?: Node;
+    protected parent?: TSESTree.Node;
 
     constructor(options: any, scopeManager: ScopeManager);
 
     currentScope(): Scope;
-    close(node: Node): void;
+    close(node: TSESTree.Node): void;
     pushInnerMethodDefinition(isInnerMethodDefinition: boolean): boolean;
     popInnerMethodDefinition(isInnerMethodDefinition: boolean): void;
 
@@ -131,66 +129,63 @@ declare module 'eslint-scope/lib/referencer' {
       init: boolean
     ): void;
     visitPattern(
-      node: Node,
+      node: TSESTree.Node,
       options: PatternVisitorOptions,
       callback: PatternVisitorCallback
     ): void;
-    visitFunction(node: Node): void;
-    visitClass(node: Node): void;
-    visitProperty(node: Node): void;
-    visitForIn(node: Node): void;
+    visitFunction(node: TSESTree.Node): void;
+    visitClass(node: TSESTree.Node): void;
+    visitProperty(node: TSESTree.Node): void;
+    visitForIn(node: TSESTree.Node): void;
     visitVariableDeclaration(
       variableTargetScope: any,
       type: any,
-      node: Node,
+      node: TSESTree.Node,
       index: any
     ): void;
 
-    AssignmentExpression(node: Node): void;
-    CatchClause(node: Node): void;
-    Program(node: Node): void;
-    Identifier(node: Node): void;
-    UpdateExpression(node: Node): void;
-    MemberExpression(node: Node): void;
-    Property(node: Node): void;
-    MethodDefinition(node: Node): void;
+    AssignmentExpression(node: TSESTree.Node): void;
+    CatchClause(node: TSESTree.Node): void;
+    Program(node: TSESTree.Node): void;
+    Identifier(node: TSESTree.Node): void;
+    UpdateExpression(node: TSESTree.Node): void;
+    MemberExpression(node: TSESTree.Node): void;
+    Property(node: TSESTree.Node): void;
+    MethodDefinition(node: TSESTree.Node): void;
     BreakStatement(): void;
     ContinueStatement(): void;
-    LabeledStatement(node: Node): void;
-    ForStatement(node: Node): void;
-    ClassExpression(node: Node): void;
-    ClassDeclaration(node: Node): void;
-    CallExpression(node: Node): void;
-    BlockStatement(node: Node): void;
+    LabeledStatement(node: TSESTree.Node): void;
+    ForStatement(node: TSESTree.Node): void;
+    ClassExpression(node: TSESTree.Node): void;
+    ClassDeclaration(node: TSESTree.Node): void;
+    CallExpression(node: TSESTree.Node): void;
+    BlockStatement(node: TSESTree.Node): void;
     ThisExpression(): void;
-    WithStatement(node: Node): void;
-    VariableDeclaration(node: Node): void;
-    SwitchStatement(node: Node): void;
-    FunctionDeclaration(node: Node): void;
-    FunctionExpression(node: Node): void;
-    ForOfStatement(node: Node): void;
-    ForInStatement(node: Node): void;
-    ArrowFunctionExpression(node: Node): void;
-    ImportDeclaration(node: Node): void;
-    visitExportDeclaration(node: Node): void;
-    ExportDeclaration(node: Node): void;
-    ExportNamedDeclaration(node: Node): void;
-    ExportSpecifier(node: Node): void;
+    WithStatement(node: TSESTree.Node): void;
+    VariableDeclaration(node: TSESTree.Node): void;
+    SwitchStatement(node: TSESTree.Node): void;
+    FunctionDeclaration(node: TSESTree.Node): void;
+    FunctionExpression(node: TSESTree.Node): void;
+    ForOfStatement(node: TSESTree.Node): void;
+    ForInStatement(node: TSESTree.Node): void;
+    ArrowFunctionExpression(node: TSESTree.Node): void;
+    ImportDeclaration(node: TSESTree.Node): void;
+    visitExportDeclaration(node: TSESTree.Node): void;
+    ExportDeclaration(node: TSESTree.Node): void;
+    ExportNamedDeclaration(node: TSESTree.Node): void;
+    ExportSpecifier(node: TSESTree.Node): void;
     MetaProperty(): void;
   }
-
-  export default Referencer;
 }
 
 declare module 'eslint-scope/lib/scope' {
-  import * as eslint from 'eslint';
-  import { Node } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import Reference from 'eslint-scope/lib/reference';
   import Variable from 'eslint-scope/lib/variable';
   import ScopeManager from 'eslint-scope/lib/scope-manager';
   import { Definition } from 'eslint-scope/lib/definition';
 
-  type ScopeType =
+  export type ScopeType =
     | 'block'
     | 'catch'
     | 'class'
@@ -203,13 +198,13 @@ declare module 'eslint-scope/lib/scope' {
     | 'with'
     | 'TDZ';
 
-  class Scope implements eslint.Scope.Scope {
+  export class Scope {
     type: ScopeType;
     isStrict: boolean;
     upper: Scope | null;
     childScopes: Scope[];
     variableScope: Scope;
-    block: Node;
+    block: TSESTree.Node;
     variables: Variable[];
     set: Map<string, Variable>;
     references: Reference[];
@@ -221,7 +216,7 @@ declare module 'eslint-scope/lib/scope' {
       scopeManager: ScopeManager,
       type: ScopeType,
       upperScope: Scope | null,
-      block: Node | null,
+      block: TSESTree.Node | null,
       isMethodDefinition: boolean
     );
 
@@ -234,7 +229,7 @@ declare module 'eslint-scope/lib/scope' {
     __isValidResolution(ref: any, variable: any): boolean;
     __resolve(ref: any): boolean;
     __delegateToUpperScope(ref: any): void;
-    __addDeclaredVariablesOfNode(variable: any, node: Node): void;
+    __addDeclaredVariablesOfNode(variable: any, node: TSESTree.Node): void;
     __defineGeneric(
       name: any,
       set: any,
@@ -243,12 +238,12 @@ declare module 'eslint-scope/lib/scope' {
       def: Definition
     ): void;
 
-    __define(node: Node, def: Definition): void;
+    __define(node: TSESTree.Node, def: Definition): void;
 
     __referencing(
-      node: Node,
+      node: TSESTree.Node,
       assign: number,
-      writeExpr: Node,
+      writeExpr: TSESTree.Node,
       maybeImplicitGlobal: any,
       partial: any,
       init: any
@@ -263,7 +258,7 @@ declare module 'eslint-scope/lib/scope' {
      * @param {Espree.Identifier} ident - identifier to be resolved.
      * @returns {Reference} reference
      */
-    resolve(ident: Node): Reference;
+    resolve(ident: TSESTree.Node): Reference;
 
     /**
      * returns this scope is static
@@ -289,109 +284,94 @@ declare module 'eslint-scope/lib/scope' {
     isUsedName(name: any): boolean;
   }
 
-  class GlobalScope extends Scope {
-    constructor(scopeManager: ScopeManager, block: Node | null);
+  export class GlobalScope extends Scope {
+    constructor(scopeManager: ScopeManager, block: TSESTree.Node | null);
   }
 
-  class ModuleScope extends Scope {
+  export class ModuleScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class FunctionExpressionNameScope extends Scope {
+  export class FunctionExpressionNameScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class CatchScope extends Scope {
+  export class CatchScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class WithScope extends Scope {
+  export class WithScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class BlockScope extends Scope {
+  export class BlockScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class SwitchScope extends Scope {
+  export class SwitchScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class FunctionScope extends Scope {
+  export class FunctionScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null,
+      block: TSESTree.Node | null,
       isMethodDefinition: boolean
     );
   }
 
-  class ForScope extends Scope {
+  export class ForScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
 
-  class ClassScope extends Scope {
+  export class ClassScope extends Scope {
     constructor(
       scopeManager: ScopeManager,
       upperScope: Scope,
-      block: Node | null
+      block: TSESTree.Node | null
     );
   }
-
-  export {
-    Scope,
-    GlobalScope,
-    ModuleScope,
-    FunctionExpressionNameScope,
-    CatchScope,
-    WithScope,
-    BlockScope,
-    SwitchScope,
-    FunctionScope,
-    ForScope,
-    ClassScope
-  };
 }
 
 declare module 'eslint-scope/lib/reference' {
-  import * as eslint from 'eslint';
-  import { Identifier, Node } from 'estree';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import { Scope } from 'eslint-scope/lib/scope';
   import Variable from 'eslint-scope/lib/variable';
 
-  class Reference implements eslint.Scope.Reference {
-    identifier: Identifier;
+  export default class Reference {
+    identifier: TSESTree.Identifier;
     from: Scope;
     resolved: Variable | null;
-    writeExpr: Node | null;
+    writeExpr: TSESTree.Node | null;
     init: boolean;
 
     isWrite(): boolean;
@@ -404,15 +384,14 @@ declare module 'eslint-scope/lib/reference' {
     static WRITE: 0x2;
     static RW: 0x3;
   }
-  export default Reference;
 }
 
 declare module 'eslint-scope/lib/scope-manager' {
-  import * as eslint from 'eslint';
+  import { TSESTree } from '@typescript-eslint/typescript-estree';
   import { Scope } from 'eslint-scope/lib/scope';
   import Variable from 'eslint-scope/lib/variable';
 
-  interface ScopeManagerOptions {
+  export interface ScopeManagerOptions {
     directive?: boolean;
     optimistic?: boolean;
     ignoreEval?: boolean;
@@ -422,7 +401,7 @@ declare module 'eslint-scope/lib/scope-manager' {
     ecmaVersion?: number;
   }
 
-  class ScopeManager implements eslint.Scope.ScopeManager {
+  export default class ScopeManager {
     __options: ScopeManagerOptions;
     __currentScope: Scope;
     scopes: Scope[];
@@ -439,29 +418,31 @@ declare module 'eslint-scope/lib/scope-manager' {
     isStrictModeSupported(): boolean;
 
     // Returns appropriate scope for this node.
-    __get(node: Node): Scope;
-    getDeclaredVariables(node: {}): Variable[];
-    acquire(node: {}, inner?: boolean): Scope | null;
-    acquireAll(node: Node): Scope | null;
-    release(node: Node, inner?: boolean): Scope | null;
+    __get(node: TSESTree.Node): Scope;
+    getDeclaredVariables(node: TSESTree.Node): Variable[];
+    acquire(node: TSESTree.Node, inner?: boolean): Scope | null;
+    acquireAll(node: TSESTree.Node): Scope | null;
+    release(node: TSESTree.Node, inner?: boolean): Scope | null;
     attach(): void;
     detach(): void;
 
     __nestScope(scope: Scope): Scope;
-    __nestGlobalScope(node: Node): Scope;
-    __nestBlockScope(node: Node): Scope;
-    __nestFunctionScope(node: Node, isMethodDefinition: boolean): Scope;
-    __nestForScope(node: Node): Scope;
-    __nestCatchScope(node: Node): Scope;
-    __nestWithScope(node: Node): Scope;
-    __nestClassScope(node: Node): Scope;
-    __nestSwitchScope(node: Node): Scope;
-    __nestModuleScope(node: Node): Scope;
-    __nestFunctionExpressionNameScope(node: Node): Scope;
+    __nestGlobalScope(node: TSESTree.Node): Scope;
+    __nestBlockScope(node: TSESTree.Node): Scope;
+    __nestFunctionScope(
+      node: TSESTree.Node,
+      isMethodDefinition: boolean
+    ): Scope;
+    __nestForScope(node: TSESTree.Node): Scope;
+    __nestCatchScope(node: TSESTree.Node): Scope;
+    __nestWithScope(node: TSESTree.Node): Scope;
+    __nestClassScope(node: TSESTree.Node): Scope;
+    __nestSwitchScope(node: TSESTree.Node): Scope;
+    __nestModuleScope(node: TSESTree.Node): Scope;
+    __nestFunctionExpressionNameScope(node: TSESTree.Node): Scope;
 
     __isES6(): boolean;
   }
-  export default ScopeManager;
 }
 
 declare module 'eslint-scope' {
diff --git a/packages/parser/src/parser.ts b/packages/parser/src/parser.ts
index be3c3e7506ef..78d71197e9f9 100644
--- a/packages/parser/src/parser.ts
+++ b/packages/parser/src/parser.ts
@@ -2,21 +2,15 @@ import traverser from 'eslint/lib/util/traverser';
 import {
   AST_NODE_TYPES,
   parseAndGenerateServices,
-  ParserOptions as ParserOptionsTsESTree
+  ParserOptions as ParserOptionsTsESTree,
+  ParserServices
 } from '@typescript-eslint/typescript-estree';
 import { analyzeScope } from './analyze-scope';
 import { ParserOptions } from './parser-options';
 import { visitorKeys } from './visitor-keys';
-import { Program } from 'typescript';
 
 const packageJSON = require('../package.json');
 
-interface ParserServices {
-  program: Program | undefined;
-  esTreeNodeToTSNodeMap: WeakMap<object, any> | undefined;
-  tsNodeToESTreeNodeMap: WeakMap<object, any> | undefined;
-}
-
 interface ParseForESLintResult {
   ast: any;
   services: ParserServices;
diff --git a/packages/typescript-estree/src/convert-comments.ts b/packages/typescript-estree/src/convert-comments.ts
index 59a2326122c8..1efff92648dc 100644
--- a/packages/typescript-estree/src/convert-comments.ts
+++ b/packages/typescript-estree/src/convert-comments.ts
@@ -7,7 +7,7 @@
 
 import ts from 'typescript';
 import { getLocFor, getNodeContainer } from './node-utils';
-import * as es from './typedefs';
+import { TSESTree } from './ts-estree';
 
 /**
  * Converts a TypeScript comment to an Esprima comment.
@@ -25,10 +25,10 @@ function convertTypeScriptCommentToEsprimaComment(
   text: string,
   start: number,
   end: number,
-  startLoc: es.LineAndColumnData,
-  endLoc: es.LineAndColumnData
-): es.Comment {
-  const comment: es.OptionalRangeAndLoc<es.Comment> = {
+  startLoc: TSESTree.LineAndColumnData,
+  endLoc: TSESTree.LineAndColumnData
+): TSESTree.Comment {
+  const comment: TSESTree.OptionalRangeAndLoc<TSESTree.Comment> = {
     type: block ? 'Block' : 'Line',
     value: text
   };
@@ -44,7 +44,7 @@ function convertTypeScriptCommentToEsprimaComment(
     };
   }
 
-  return comment as es.Comment;
+  return comment as TSESTree.Comment;
 }
 
 /**
@@ -59,7 +59,7 @@ function getCommentFromTriviaScanner(
   triviaScanner: ts.Scanner,
   ast: ts.SourceFile,
   code: string
-): es.Comment {
+): TSESTree.Comment {
   const kind = triviaScanner.getToken();
   const isBlock = kind === ts.SyntaxKind.MultiLineCommentTrivia;
   const range = {
@@ -94,8 +94,8 @@ function getCommentFromTriviaScanner(
 export function convertComments(
   ast: ts.SourceFile,
   code: string
-): es.Comment[] {
-  const comments: es.Comment[] = [];
+): TSESTree.Comment[] {
+  const comments: TSESTree.Comment[] = [];
 
   /**
    * Create a TypeScript Scanner, with skipTrivia set to false so that
diff --git a/packages/typescript-estree/src/convert.ts b/packages/typescript-estree/src/convert.ts
index eb2e69a60ece..4fbc5446b8f8 100644
--- a/packages/typescript-estree/src/convert.ts
+++ b/packages/typescript-estree/src/convert.ts
@@ -6,7 +6,7 @@
  * MIT License
  */
 import ts from 'typescript';
-import * as es from './typedefs';
+import { TSESTree } from './ts-estree';
 import {
   canContainDirective,
   createError,
@@ -78,8 +78,8 @@ export class Converter {
     };
   }
 
-  convertProgram(): es.Program {
-    return this.converter(this.ast) as es.Program;
+  convertProgram(): TSESTree.Program {
+    return this.converter(this.ast) as TSESTree.Program;
   }
 
   /**
@@ -112,7 +112,7 @@ export class Converter {
       this.allowPattern = allowPattern;
     }
 
-    let result: es.BaseNode | null = this.convertNode(
+    let result: TSESTree.BaseNode | null = this.convertNode(
       node as TSNode,
       parent || node.parent
     );
@@ -157,9 +157,9 @@ export class Converter {
     return this.converter(child, parent, true, false);
   }
 
-  private createNode<T extends es.BaseNode = es.BaseNode>(
+  private createNode<T extends TSESTree.BaseNode = TSESTree.BaseNode>(
     node: ts.Node,
-    data: es.OptionalRangeAndLoc<T>
+    data: TSESTree.OptionalRangeAndLoc<T>
   ): T {
     const result = data;
     if (!result.range) {
@@ -182,7 +182,7 @@ export class Converter {
   private convertTypeAnnotation(
     child: ts.TypeNode,
     parent: ts.Node
-  ): es.TSTypeAnnotation {
+  ): TSESTree.TSTypeAnnotation {
     // in FunctionType and ConstructorType typeAnnotation has 2 characters `=>` and in other places is just colon
     const offset =
       parent.kind === SyntaxKind.FunctionType ||
@@ -244,7 +244,7 @@ export class Converter {
    */
   private convertTypeArgumentsToTypeParameters(
     typeArguments: ts.NodeArray<ts.TypeNode>
-  ): es.TSTypeParameterInstantiation {
+  ): TSESTree.TSTypeParameterInstantiation {
     const greaterThanToken = findNextToken(typeArguments, this.ast, this.ast)!;
 
     return {
@@ -262,7 +262,7 @@ export class Converter {
    */
   private convertTSTypeParametersToTypeParametersDeclaration(
     typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>
-  ): es.TSTypeParameterDeclaration {
+  ): TSESTree.TSTypeParameterDeclaration {
     const greaterThanToken = findNextToken(typeParameters, this.ast, this.ast)!;
 
     return {
@@ -282,12 +282,12 @@ export class Converter {
    */
   private convertParameters(
     parameters: ts.NodeArray<ts.ParameterDeclaration>
-  ): es.Parameter[] {
+  ): TSESTree.Parameter[] {
     if (!parameters || !parameters.length) {
       return [];
     }
     return parameters.map(param => {
-      const convertedParam = this.convertChild(param) as es.Parameter;
+      const convertedParam = this.convertChild(param) as TSESTree.Parameter;
 
       if (param.decorators && param.decorators.length) {
         convertedParam.decorators = param.decorators.map(el =>
@@ -375,28 +375,28 @@ export class Converter {
   private convertJSXTagName(
     node: ts.JsxTagNameExpression,
     parent: ts.Node
-  ): es.JSXMemberExpression | es.JSXIdentifier {
-    let result: es.JSXMemberExpression | es.JSXIdentifier;
+  ): TSESTree.JSXMemberExpression | TSESTree.JSXIdentifier {
+    let result: TSESTree.JSXMemberExpression | TSESTree.JSXIdentifier;
     switch (node.kind) {
       case SyntaxKind.PropertyAccessExpression:
-        result = this.createNode<es.JSXMemberExpression>(node, {
+        result = this.createNode<TSESTree.JSXMemberExpression>(node, {
           type: AST_NODE_TYPES.JSXMemberExpression,
           object: this.convertJSXTagName(node.expression, parent),
           property: this.convertJSXTagName(
             node.name,
             parent
-          ) as es.JSXIdentifier
+          ) as TSESTree.JSXIdentifier
         });
         break;
       case SyntaxKind.ThisKeyword:
-        result = this.createNode<es.JSXIdentifier>(node, {
+        result = this.createNode<TSESTree.JSXIdentifier>(node, {
           type: AST_NODE_TYPES.JSXIdentifier,
           name: 'this'
         });
         break;
       case SyntaxKind.Identifier:
       default:
-        result = this.createNode<es.JSXIdentifier>(node, {
+        result = this.createNode<TSESTree.JSXIdentifier>(node, {
           type: AST_NODE_TYPES.JSXIdentifier,
           name: node.text
         });
@@ -419,7 +419,7 @@ export class Converter {
    * @deprecated This method adds not standardized `modifiers` property in nodes
    */
   private applyModifiersToResult(
-    result: es.TSEnumDeclaration | es.TSModuleDeclaration,
+    result: TSESTree.TSEnumDeclaration | TSESTree.TSModuleDeclaration,
     modifiers?: ts.ModifiersArray
   ): void {
     if (!modifiers || !modifiers.length) {
@@ -474,7 +474,7 @@ export class Converter {
    * @param childRange The child node range used to expand location
    */
   private fixParentLocation(
-    result: es.BaseNode,
+    result: TSESTree.BaseNode,
     childRange: [number, number]
   ): void {
     if (childRange[0] < result.range[0]) {
@@ -495,10 +495,10 @@ export class Converter {
    * @param parent parentNode
    * @returns the converted ESTree node
    */
-  private convertNode(node: TSNode, parent: ts.Node): es.Node | null {
+  private convertNode(node: TSNode, parent: ts.Node): TSESTree.Node | null {
     switch (node.kind) {
       case SyntaxKind.SourceFile: {
-        return this.createNode<es.Program>(node, {
+        return this.createNode<TSESTree.Program>(node, {
           type: AST_NODE_TYPES.Program,
           body: this.convertBodyExpressions(node.statements, node),
           // externalModuleIndicator is internal field in TSC
@@ -510,21 +510,21 @@ export class Converter {
       }
 
       case SyntaxKind.Block: {
-        return this.createNode<es.BlockStatement>(node, {
+        return this.createNode<TSESTree.BlockStatement>(node, {
           type: AST_NODE_TYPES.BlockStatement,
           body: this.convertBodyExpressions(node.statements, node)
         });
       }
 
       case SyntaxKind.Identifier: {
-        return this.createNode<es.Identifier>(node, {
+        return this.createNode<TSESTree.Identifier>(node, {
           type: AST_NODE_TYPES.Identifier,
           name: node.text
         });
       }
 
       case SyntaxKind.WithStatement:
-        return this.createNode<es.WithStatement>(node, {
+        return this.createNode<TSESTree.WithStatement>(node, {
           type: AST_NODE_TYPES.WithStatement,
           object: this.convertChild(node.expression),
           body: this.convertChild(node.statement)
@@ -533,26 +533,26 @@ export class Converter {
       // Control Flow
 
       case SyntaxKind.ReturnStatement:
-        return this.createNode<es.ReturnStatement>(node, {
+        return this.createNode<TSESTree.ReturnStatement>(node, {
           type: AST_NODE_TYPES.ReturnStatement,
           argument: this.convertChild(node.expression)
         });
 
       case SyntaxKind.LabeledStatement:
-        return this.createNode<es.LabeledStatement>(node, {
+        return this.createNode<TSESTree.LabeledStatement>(node, {
           type: AST_NODE_TYPES.LabeledStatement,
           label: this.convertChild(node.label),
           body: this.convertChild(node.statement)
         });
 
       case SyntaxKind.ContinueStatement:
-        return this.createNode<es.ContinueStatement>(node, {
+        return this.createNode<TSESTree.ContinueStatement>(node, {
           type: AST_NODE_TYPES.ContinueStatement,
           label: this.convertChild(node.label)
         });
 
       case SyntaxKind.BreakStatement:
-        return this.createNode<es.BreakStatement>(node, {
+        return this.createNode<TSESTree.BreakStatement>(node, {
           type: AST_NODE_TYPES.BreakStatement,
           label: this.convertChild(node.label)
         });
@@ -560,7 +560,7 @@ export class Converter {
       // Choice
 
       case SyntaxKind.IfStatement:
-        return this.createNode<es.IfStatement>(node, {
+        return this.createNode<TSESTree.IfStatement>(node, {
           type: AST_NODE_TYPES.IfStatement,
           test: this.convertChild(node.expression),
           consequent: this.convertChild(node.thenStatement),
@@ -568,7 +568,7 @@ export class Converter {
         });
 
       case SyntaxKind.SwitchStatement:
-        return this.createNode<es.SwitchStatement>(node, {
+        return this.createNode<TSESTree.SwitchStatement>(node, {
           type: AST_NODE_TYPES.SwitchStatement,
           discriminant: this.convertChild(node.expression),
           cases: node.caseBlock.clauses.map(el => this.convertChild(el))
@@ -576,7 +576,7 @@ export class Converter {
 
       case SyntaxKind.CaseClause:
       case SyntaxKind.DefaultClause:
-        return this.createNode<es.SwitchCase>(node, {
+        return this.createNode<TSESTree.SwitchCase>(node, {
           type: AST_NODE_TYPES.SwitchCase,
           // expression is present in case only
           test:
@@ -589,13 +589,13 @@ export class Converter {
       // Exceptions
 
       case SyntaxKind.ThrowStatement:
-        return this.createNode<es.ThrowStatement>(node, {
+        return this.createNode<TSESTree.ThrowStatement>(node, {
           type: AST_NODE_TYPES.ThrowStatement,
           argument: this.convertChild(node.expression)
         });
 
       case SyntaxKind.TryStatement:
-        return this.createNode<es.TryStatement>(node, {
+        return this.createNode<TSESTree.TryStatement>(node, {
           type: AST_NODE_TYPES.TryStatement,
           block: this.convertChild(node.tryBlock),
           handler: this.convertChild(node.catchClause),
@@ -603,7 +603,7 @@ export class Converter {
         });
 
       case SyntaxKind.CatchClause:
-        return this.createNode<es.CatchClause>(node, {
+        return this.createNode<TSESTree.CatchClause>(node, {
           type: AST_NODE_TYPES.CatchClause,
           param: node.variableDeclaration
             ? this.convertChild(node.variableDeclaration.name)
@@ -614,7 +614,7 @@ export class Converter {
       // Loops
 
       case SyntaxKind.WhileStatement:
-        return this.createNode<es.WhileStatement>(node, {
+        return this.createNode<TSESTree.WhileStatement>(node, {
           type: AST_NODE_TYPES.WhileStatement,
           test: this.convertChild(node.expression),
           body: this.convertChild(node.statement)
@@ -625,14 +625,14 @@ export class Converter {
        * a "DoStatement"
        */
       case SyntaxKind.DoStatement:
-        return this.createNode<es.DoWhileStatement>(node, {
+        return this.createNode<TSESTree.DoWhileStatement>(node, {
           type: AST_NODE_TYPES.DoWhileStatement,
           test: this.convertChild(node.expression),
           body: this.convertChild(node.statement)
         });
 
       case SyntaxKind.ForStatement:
-        return this.createNode<es.ForStatement>(node, {
+        return this.createNode<TSESTree.ForStatement>(node, {
           type: AST_NODE_TYPES.ForStatement,
           init: this.convertChild(node.initializer),
           test: this.convertChild(node.condition),
@@ -641,7 +641,7 @@ export class Converter {
         });
 
       case SyntaxKind.ForInStatement:
-        return this.createNode<es.ForInStatement>(node, {
+        return this.createNode<TSESTree.ForInStatement>(node, {
           type: AST_NODE_TYPES.ForInStatement,
           left: this.convertPattern(node.initializer),
           right: this.convertChild(node.expression),
@@ -649,7 +649,7 @@ export class Converter {
         });
 
       case SyntaxKind.ForOfStatement:
-        return this.createNode<es.ForOfStatement>(node, {
+        return this.createNode<TSESTree.ForOfStatement>(node, {
           type: AST_NODE_TYPES.ForOfStatement,
           left: this.convertPattern(node.initializer),
           right: this.convertChild(node.expression),
@@ -666,7 +666,7 @@ export class Converter {
         const isDeclare = hasModifier(SyntaxKind.DeclareKeyword, node);
 
         const result = this.createNode<
-          es.TSDeclareFunction | es.FunctionDeclaration
+          TSESTree.TSDeclareFunction | TSESTree.FunctionDeclaration
         >(node, {
           type:
             isDeclare || !node.body
@@ -701,7 +701,7 @@ export class Converter {
       }
 
       case SyntaxKind.VariableDeclaration: {
-        const result = this.createNode<es.VariableDeclarator>(node, {
+        const result = this.createNode<TSESTree.VariableDeclarator>(node, {
           type: AST_NODE_TYPES.VariableDeclarator,
           id: this.convertPattern(node.name),
           init: this.convertChild(node.initializer)
@@ -722,7 +722,7 @@ export class Converter {
       }
 
       case SyntaxKind.VariableStatement: {
-        const result = this.createNode<es.VariableDeclaration>(node, {
+        const result = this.createNode<TSESTree.VariableDeclaration>(node, {
           type: AST_NODE_TYPES.VariableDeclaration,
           declarations: node.declarationList.declarations.map(el =>
             this.convertChild(el)
@@ -740,7 +740,7 @@ export class Converter {
 
       // mostly for for-of, for-in
       case SyntaxKind.VariableDeclarationList:
-        return this.createNode<es.VariableDeclaration>(node, {
+        return this.createNode<TSESTree.VariableDeclaration>(node, {
           type: AST_NODE_TYPES.VariableDeclaration,
           declarations: node.declarations.map(el => this.convertChild(el)),
           kind: getDeclarationKind(node)
@@ -749,25 +749,25 @@ export class Converter {
       // Expressions
 
       case SyntaxKind.ExpressionStatement:
-        return this.createNode<es.ExpressionStatement>(node, {
+        return this.createNode<TSESTree.ExpressionStatement>(node, {
           type: AST_NODE_TYPES.ExpressionStatement,
           expression: this.convertChild(node.expression)
         });
 
       case SyntaxKind.ThisKeyword:
-        return this.createNode<es.ThisExpression>(node, {
+        return this.createNode<TSESTree.ThisExpression>(node, {
           type: AST_NODE_TYPES.ThisExpression
         });
 
       case SyntaxKind.ArrayLiteralExpression: {
         // TypeScript uses ArrayLiteralExpression in destructuring assignment, too
         if (this.allowPattern) {
-          return this.createNode<es.ArrayPattern>(node, {
+          return this.createNode<TSESTree.ArrayPattern>(node, {
             type: AST_NODE_TYPES.ArrayPattern,
             elements: node.elements.map(el => this.convertPattern(el))
           });
         } else {
-          return this.createNode<es.ArrayExpression>(node, {
+          return this.createNode<TSESTree.ArrayExpression>(node, {
             type: AST_NODE_TYPES.ArrayExpression,
             elements: node.elements.map(el => this.convertChild(el))
           });
@@ -777,12 +777,12 @@ export class Converter {
       case SyntaxKind.ObjectLiteralExpression: {
         // TypeScript uses ObjectLiteralExpression in destructuring assignment, too
         if (this.allowPattern) {
-          return this.createNode<es.ObjectPattern>(node, {
+          return this.createNode<TSESTree.ObjectPattern>(node, {
             type: AST_NODE_TYPES.ObjectPattern,
             properties: node.properties.map(el => this.convertPattern(el))
           });
         } else {
-          return this.createNode<es.ObjectExpression>(node, {
+          return this.createNode<TSESTree.ObjectExpression>(node, {
             type: AST_NODE_TYPES.ObjectExpression,
             properties: node.properties.map(el => this.convertChild(el))
           });
@@ -790,7 +790,7 @@ export class Converter {
       }
 
       case SyntaxKind.PropertyAssignment:
-        return this.createNode<es.Property>(node, {
+        return this.createNode<TSESTree.Property>(node, {
           type: AST_NODE_TYPES.Property,
           key: this.convertChild(node.name),
           value: this.converter(
@@ -807,10 +807,10 @@ export class Converter {
 
       case SyntaxKind.ShorthandPropertyAssignment: {
         if (node.objectAssignmentInitializer) {
-          return this.createNode<es.Property>(node, {
+          return this.createNode<TSESTree.Property>(node, {
             type: AST_NODE_TYPES.Property,
             key: this.convertChild(node.name),
-            value: this.createNode<es.AssignmentPattern>(node, {
+            value: this.createNode<TSESTree.AssignmentPattern>(node, {
               type: AST_NODE_TYPES.AssignmentPattern,
               left: this.convertPattern(node.name),
               right: this.convertChild(node.objectAssignmentInitializer)
@@ -821,7 +821,7 @@ export class Converter {
             kind: 'init'
           });
         } else {
-          return this.createNode<es.Property>(node, {
+          return this.createNode<TSESTree.Property>(node, {
             type: AST_NODE_TYPES.Property,
             key: this.convertChild(node.name),
             value: this.convertChild(node.name),
@@ -839,7 +839,7 @@ export class Converter {
       case SyntaxKind.PropertyDeclaration: {
         const isAbstract = hasModifier(SyntaxKind.AbstractKeyword, node);
         const result = this.createNode<
-          es.TSAbstractClassProperty | es.ClassProperty
+          TSESTree.TSAbstractClassProperty | TSESTree.ClassProperty
         >(node, {
           type: isAbstract
             ? AST_NODE_TYPES.TSAbstractClassProperty
@@ -881,7 +881,7 @@ export class Converter {
       case SyntaxKind.GetAccessor:
       case SyntaxKind.SetAccessor:
       case SyntaxKind.MethodDeclaration: {
-        const method = this.createNode<es.FunctionExpression>(node, {
+        const method = this.createNode<TSESTree.FunctionExpression>(node, {
           type: AST_NODE_TYPES.FunctionExpression,
           id: null,
           generator: !!node.asteriskToken,
@@ -905,14 +905,14 @@ export class Converter {
         }
 
         let result:
-          | es.Property
-          | es.TSAbstractMethodDefinition
-          | es.MethodDefinition;
+          | TSESTree.Property
+          | TSESTree.TSAbstractMethodDefinition
+          | TSESTree.MethodDefinition;
 
         if (parent.kind === SyntaxKind.ObjectLiteralExpression) {
           method.params = node.parameters.map(el => this.convertChild(el));
 
-          result = this.createNode<es.Property>(node, {
+          result = this.createNode<TSESTree.Property>(node, {
             type: AST_NODE_TYPES.Property,
             key: this.convertChild(node.name),
             value: method,
@@ -940,7 +940,7 @@ export class Converter {
             : AST_NODE_TYPES.MethodDefinition;
 
           result = this.createNode<
-            es.TSAbstractMethodDefinition | es.MethodDefinition
+            TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
           >(node, {
             type: methodDefinitionType,
             key: this.convertChild(node.name),
@@ -974,7 +974,7 @@ export class Converter {
         } else if (node.kind === SyntaxKind.SetAccessor) {
           result.kind = 'set';
         } else if (
-          !(result as es.MethodDefinition).static &&
+          !(result as TSESTree.MethodDefinition).static &&
           node.name.kind === SyntaxKind.StringLiteral &&
           node.name.text === 'constructor' &&
           result.type !== AST_NODE_TYPES.Property
@@ -991,7 +991,7 @@ export class Converter {
           (lastModifier && findNextToken(lastModifier, node, this.ast)) ||
           node.getFirstToken()!;
 
-        const constructor = this.createNode<es.FunctionExpression>(node, {
+        const constructor = this.createNode<TSESTree.FunctionExpression>(node, {
           type: AST_NODE_TYPES.FunctionExpression,
           id: null,
           params: this.convertParameters(node.parameters),
@@ -1015,7 +1015,7 @@ export class Converter {
           constructor.returnType = this.convertTypeAnnotation(node.type, node);
         }
 
-        const constructorKey = this.createNode<es.Identifier>(node, {
+        const constructorKey = this.createNode<TSESTree.Identifier>(node, {
           type: AST_NODE_TYPES.Identifier,
           name: 'constructor',
           range: [constructorToken.getStart(this.ast), constructorToken.end]
@@ -1023,7 +1023,7 @@ export class Converter {
 
         const isStatic = hasModifier(SyntaxKind.StaticKeyword, node);
         const result = this.createNode<
-          es.TSAbstractMethodDefinition | es.MethodDefinition
+          TSESTree.TSAbstractMethodDefinition | TSESTree.MethodDefinition
         >(node, {
           type: hasModifier(SyntaxKind.AbstractKeyword, node)
             ? AST_NODE_TYPES.TSAbstractMethodDefinition
@@ -1044,7 +1044,7 @@ export class Converter {
       }
 
       case SyntaxKind.FunctionExpression: {
-        const result = this.createNode<es.FunctionExpression>(node, {
+        const result = this.createNode<TSESTree.FunctionExpression>(node, {
           type: AST_NODE_TYPES.FunctionExpression,
           id: this.convertChild(node.name),
           generator: !!node.asteriskToken,
@@ -1069,12 +1069,12 @@ export class Converter {
       }
 
       case SyntaxKind.SuperKeyword:
-        return this.createNode<es.Super>(node, {
+        return this.createNode<TSESTree.Super>(node, {
           type: AST_NODE_TYPES.Super
         });
 
       case SyntaxKind.ArrayBindingPattern:
-        return this.createNode<es.ArrayPattern>(node, {
+        return this.createNode<TSESTree.ArrayPattern>(node, {
           type: AST_NODE_TYPES.ArrayPattern,
           elements: node.elements.map(el => this.convertPattern(el))
         });
@@ -1084,7 +1084,7 @@ export class Converter {
         return null;
 
       case SyntaxKind.ObjectBindingPattern:
-        return this.createNode<es.ObjectPattern>(node, {
+        return this.createNode<TSESTree.ObjectPattern>(node, {
           type: AST_NODE_TYPES.ObjectPattern,
           properties: node.elements.map(el => this.convertPattern(el))
         });
@@ -1094,13 +1094,13 @@ export class Converter {
           const arrayItem = this.convertChild(node.name, parent);
 
           if (node.initializer) {
-            return this.createNode<es.AssignmentPattern>(node, {
+            return this.createNode<TSESTree.AssignmentPattern>(node, {
               type: AST_NODE_TYPES.AssignmentPattern,
               left: arrayItem,
               right: this.convertChild(node.initializer)
             });
           } else if (node.dotDotDotToken) {
-            return this.createNode<es.RestElement>(node, {
+            return this.createNode<TSESTree.RestElement>(node, {
               type: AST_NODE_TYPES.RestElement,
               argument: arrayItem
             });
@@ -1108,14 +1108,14 @@ export class Converter {
             return arrayItem;
           }
         } else if (parent.kind === SyntaxKind.ObjectBindingPattern) {
-          let result: es.RestElement | es.Property;
+          let result: TSESTree.RestElement | TSESTree.Property;
           if (node.dotDotDotToken) {
-            result = this.createNode<es.RestElement>(node, {
+            result = this.createNode<TSESTree.RestElement>(node, {
               type: AST_NODE_TYPES.RestElement,
               argument: this.convertChild(node.propertyName || node.name)
             });
           } else {
-            result = this.createNode<es.Property>(node, {
+            result = this.createNode<TSESTree.Property>(node, {
               type: AST_NODE_TYPES.Property,
               key: this.convertChild(node.propertyName || node.name),
               value: this.convertChild(node.name),
@@ -1130,7 +1130,7 @@ export class Converter {
           }
 
           if (node.initializer) {
-            result.value = this.createNode<es.AssignmentPattern>(node, {
+            result.value = this.createNode<TSESTree.AssignmentPattern>(node, {
               type: AST_NODE_TYPES.AssignmentPattern,
               left: this.convertChild(node.name),
               right: this.convertChild(node.initializer),
@@ -1143,7 +1143,7 @@ export class Converter {
       }
 
       case SyntaxKind.ArrowFunction: {
-        const result = this.createNode<es.ArrowFunctionExpression>(node, {
+        const result = this.createNode<TSESTree.ArrowFunctionExpression>(node, {
           type: AST_NODE_TYPES.ArrowFunctionExpression,
           generator: false,
           id: null,
@@ -1168,14 +1168,14 @@ export class Converter {
       }
 
       case SyntaxKind.YieldExpression:
-        return this.createNode<es.YieldExpression>(node, {
+        return this.createNode<TSESTree.YieldExpression>(node, {
           type: AST_NODE_TYPES.YieldExpression,
           delegate: !!node.asteriskToken,
           argument: this.convertChild(node.expression)
         });
 
       case SyntaxKind.AwaitExpression:
-        return this.createNode<es.AwaitExpression>(node, {
+        return this.createNode<TSESTree.AwaitExpression>(node, {
           type: AST_NODE_TYPES.AwaitExpression,
           argument: this.convertChild(node.expression)
         });
@@ -1183,10 +1183,10 @@ export class Converter {
       // Template Literals
 
       case SyntaxKind.NoSubstitutionTemplateLiteral:
-        return this.createNode<es.TemplateLiteral>(node, {
+        return this.createNode<TSESTree.TemplateLiteral>(node, {
           type: AST_NODE_TYPES.TemplateLiteral,
           quasis: [
-            this.createNode<es.TemplateElement>(node, {
+            this.createNode<TSESTree.TemplateElement>(node, {
               type: AST_NODE_TYPES.TemplateElement,
               value: {
                 raw: this.ast.text.slice(
@@ -1202,7 +1202,7 @@ export class Converter {
         });
 
       case SyntaxKind.TemplateExpression: {
-        const result = this.createNode<es.TemplateLiteral>(node, {
+        const result = this.createNode<TSESTree.TemplateLiteral>(node, {
           type: AST_NODE_TYPES.TemplateLiteral,
           quasis: [this.convertChild(node.head)],
           expressions: []
@@ -1216,7 +1216,7 @@ export class Converter {
       }
 
       case SyntaxKind.TaggedTemplateExpression:
-        return this.createNode<es.TaggedTemplateExpression>(node, {
+        return this.createNode<TSESTree.TaggedTemplateExpression>(node, {
           type: AST_NODE_TYPES.TaggedTemplateExpression,
           typeParameters: node.typeArguments
             ? this.convertTypeArgumentsToTypeParameters(node.typeArguments)
@@ -1229,7 +1229,7 @@ export class Converter {
       case SyntaxKind.TemplateMiddle:
       case SyntaxKind.TemplateTail: {
         const tail = node.kind === SyntaxKind.TemplateTail;
-        return this.createNode<es.TemplateElement>(node, {
+        return this.createNode<TSESTree.TemplateElement>(node, {
           type: AST_NODE_TYPES.TemplateElement,
           value: {
             raw: this.ast.text.slice(
@@ -1247,12 +1247,12 @@ export class Converter {
       case SyntaxKind.SpreadAssignment:
       case SyntaxKind.SpreadElement: {
         if (this.allowPattern) {
-          return this.createNode<es.RestElement>(node, {
+          return this.createNode<TSESTree.RestElement>(node, {
             type: AST_NODE_TYPES.RestElement,
             argument: this.convertPattern(node.expression)
           });
         } else {
-          return this.createNode<es.SpreadElement>(node, {
+          return this.createNode<TSESTree.SpreadElement>(node, {
             type: AST_NODE_TYPES.SpreadElement,
             argument: this.convertChild(node.expression)
           });
@@ -1261,16 +1261,16 @@ export class Converter {
 
       case SyntaxKind.Parameter: {
         let parameter: any;
-        let result: es.RestElement | es.AssignmentPattern;
+        let result: TSESTree.RestElement | TSESTree.AssignmentPattern;
 
         if (node.dotDotDotToken) {
-          parameter = result = this.createNode<es.RestElement>(node, {
+          parameter = result = this.createNode<TSESTree.RestElement>(node, {
             type: AST_NODE_TYPES.RestElement,
             argument: this.convertChild(node.name)
           });
         } else if (node.initializer) {
           parameter = this.convertChild(node.name);
-          result = this.createNode<es.AssignmentPattern>(node, {
+          result = this.createNode<TSESTree.AssignmentPattern>(node, {
             type: AST_NODE_TYPES.AssignmentPattern,
             left: parameter,
             right: this.convertChild(node.initializer)
@@ -1305,7 +1305,7 @@ export class Converter {
         }
 
         if (node.modifiers) {
-          return this.createNode<es.TSParameterProperty>(node, {
+          return this.createNode<TSESTree.TSParameterProperty>(node, {
             type: AST_NODE_TYPES.TSParameterProperty,
             accessibility: getTSNodeAccessibility(node) || undefined,
             readonly:
@@ -1337,11 +1337,11 @@ export class Converter {
         );
 
         const result = this.createNode<
-          es.ClassDeclaration | es.ClassExpression
+          TSESTree.ClassDeclaration | TSESTree.ClassExpression
         >(node, {
           type: classNodeType,
           id: this.convertChild(node.name),
-          body: this.createNode<es.ClassBody>(node, {
+          body: this.createNode<TSESTree.ClassBody>(node, {
             type: AST_NODE_TYPES.ClassBody,
             body: [],
             range: [node.members.pos - 1, node.end]
@@ -1407,13 +1407,13 @@ export class Converter {
 
       // Modules
       case SyntaxKind.ModuleBlock:
-        return this.createNode<es.TSModuleBlock>(node, {
+        return this.createNode<TSESTree.TSModuleBlock>(node, {
           type: AST_NODE_TYPES.TSModuleBlock,
           body: this.convertBodyExpressions(node.statements, node)
         });
 
       case SyntaxKind.ImportDeclaration: {
-        const result = this.createNode<es.ImportDeclaration>(node, {
+        const result = this.createNode<TSESTree.ImportDeclaration>(node, {
           type: AST_NODE_TYPES.ImportDeclaration,
           source: this.convertChild(node.moduleSpecifier),
           specifiers: []
@@ -1445,20 +1445,20 @@ export class Converter {
       }
 
       case SyntaxKind.NamespaceImport:
-        return this.createNode<es.ImportNamespaceSpecifier>(node, {
+        return this.createNode<TSESTree.ImportNamespaceSpecifier>(node, {
           type: AST_NODE_TYPES.ImportNamespaceSpecifier,
           local: this.convertChild(node.name)
         });
 
       case SyntaxKind.ImportSpecifier:
-        return this.createNode<es.ImportSpecifier>(node, {
+        return this.createNode<TSESTree.ImportSpecifier>(node, {
           type: AST_NODE_TYPES.ImportSpecifier,
           local: this.convertChild(node.name),
           imported: this.convertChild(node.propertyName || node.name)
         });
 
       case SyntaxKind.ImportClause:
-        return this.createNode<es.ImportDefaultSpecifier>(node, {
+        return this.createNode<TSESTree.ImportDefaultSpecifier>(node, {
           type: AST_NODE_TYPES.ImportDefaultSpecifier,
           local: this.convertChild(node.name),
           range: [node.getStart(this.ast), node.name!.end]
@@ -1466,7 +1466,7 @@ export class Converter {
 
       case SyntaxKind.ExportDeclaration:
         if (node.exportClause) {
-          return this.createNode<es.ExportNamedDeclaration>(node, {
+          return this.createNode<TSESTree.ExportNamedDeclaration>(node, {
             type: AST_NODE_TYPES.ExportNamedDeclaration,
             source: this.convertChild(node.moduleSpecifier),
             specifiers: node.exportClause.elements.map(el =>
@@ -1475,14 +1475,14 @@ export class Converter {
             declaration: null
           });
         } else {
-          return this.createNode<es.ExportAllDeclaration>(node, {
+          return this.createNode<TSESTree.ExportAllDeclaration>(node, {
             type: AST_NODE_TYPES.ExportAllDeclaration,
             source: this.convertChild(node.moduleSpecifier)
           });
         }
 
       case SyntaxKind.ExportSpecifier:
-        return this.createNode<es.ExportSpecifier>(node, {
+        return this.createNode<TSESTree.ExportSpecifier>(node, {
           type: AST_NODE_TYPES.ExportSpecifier,
           local: this.convertChild(node.propertyName || node.name),
           exported: this.convertChild(node.name)
@@ -1490,12 +1490,12 @@ export class Converter {
 
       case SyntaxKind.ExportAssignment:
         if (node.isExportEquals) {
-          return this.createNode<es.TSExportAssignment>(node, {
+          return this.createNode<TSESTree.TSExportAssignment>(node, {
             type: AST_NODE_TYPES.TSExportAssignment,
             expression: this.convertChild(node.expression)
           });
         } else {
-          return this.createNode<es.ExportDefaultDeclaration>(node, {
+          return this.createNode<TSESTree.ExportDefaultDeclaration>(node, {
             type: AST_NODE_TYPES.ExportDefaultDeclaration,
             declaration: this.convertChild(node.expression)
           });
@@ -1510,14 +1510,14 @@ export class Converter {
          * ESTree uses UpdateExpression for ++/--
          */
         if (/^(?:\+\+|--)$/.test(operator)) {
-          return this.createNode<es.UpdateExpression>(node, {
+          return this.createNode<TSESTree.UpdateExpression>(node, {
             type: AST_NODE_TYPES.UpdateExpression,
             operator,
             prefix: node.kind === SyntaxKind.PrefixUnaryExpression,
             argument: this.convertChild(node.operand)
           });
         } else {
-          return this.createNode<es.UnaryExpression>(node, {
+          return this.createNode<TSESTree.UnaryExpression>(node, {
             type: AST_NODE_TYPES.UnaryExpression,
             operator,
             prefix: node.kind === SyntaxKind.PrefixUnaryExpression,
@@ -1527,7 +1527,7 @@ export class Converter {
       }
 
       case SyntaxKind.DeleteExpression:
-        return this.createNode<es.UnaryExpression>(node, {
+        return this.createNode<TSESTree.UnaryExpression>(node, {
           type: AST_NODE_TYPES.UnaryExpression,
           operator: 'delete',
           prefix: true,
@@ -1535,7 +1535,7 @@ export class Converter {
         });
 
       case SyntaxKind.VoidExpression:
-        return this.createNode<es.UnaryExpression>(node, {
+        return this.createNode<TSESTree.UnaryExpression>(node, {
           type: AST_NODE_TYPES.UnaryExpression,
           operator: 'void',
           prefix: true,
@@ -1543,7 +1543,7 @@ export class Converter {
         });
 
       case SyntaxKind.TypeOfExpression:
-        return this.createNode<es.UnaryExpression>(node, {
+        return this.createNode<TSESTree.UnaryExpression>(node, {
           type: AST_NODE_TYPES.UnaryExpression,
           operator: 'typeof',
           prefix: true,
@@ -1551,7 +1551,7 @@ export class Converter {
         });
 
       case SyntaxKind.TypeOperator:
-        return this.createNode<es.TSTypeOperator>(node, {
+        return this.createNode<TSESTree.TSTypeOperator>(node, {
           type: AST_NODE_TYPES.TSTypeOperator,
           operator: getTextForTokenKind(node.operator) as any,
           typeAnnotation: this.convertChild(node.type)
@@ -1562,7 +1562,7 @@ export class Converter {
       case SyntaxKind.BinaryExpression: {
         // TypeScript uses BinaryExpression for sequences as well
         if (isComma(node.operatorToken)) {
-          const result = this.createNode<es.SequenceExpression>(node, {
+          const result = this.createNode<TSESTree.SequenceExpression>(node, {
             type: AST_NODE_TYPES.SequenceExpression,
             expressions: []
           });
@@ -1588,14 +1588,16 @@ export class Converter {
             this.allowPattern &&
             type === AST_NODE_TYPES.AssignmentExpression
           ) {
-            return this.createNode<es.AssignmentPattern>(node, {
+            return this.createNode<TSESTree.AssignmentPattern>(node, {
               type: AST_NODE_TYPES.AssignmentPattern,
               left: this.convertPattern(node.left, node),
               right: this.convertChild(node.right)
             });
           }
           return this.createNode<
-            es.AssignmentExpression | es.LogicalExpression | es.BinaryExpression
+            | TSESTree.AssignmentExpression
+            | TSESTree.LogicalExpression
+            | TSESTree.BinaryExpression
           >(node, {
             type: type,
             operator: getTextForTokenKind(node.operatorToken.kind)!,
@@ -1611,7 +1613,7 @@ export class Converter {
       }
 
       case SyntaxKind.PropertyAccessExpression:
-        return this.createNode<es.MemberExpression>(node, {
+        return this.createNode<TSESTree.MemberExpression>(node, {
           type: AST_NODE_TYPES.MemberExpression,
           object: this.convertChild(node.expression),
           property: this.convertChild(node.name),
@@ -1619,7 +1621,7 @@ export class Converter {
         });
 
       case SyntaxKind.ElementAccessExpression:
-        return this.createNode<es.MemberExpression>(node, {
+        return this.createNode<TSESTree.MemberExpression>(node, {
           type: AST_NODE_TYPES.MemberExpression,
           object: this.convertChild(node.expression),
           property: this.convertChild(node.argumentExpression),
@@ -1627,7 +1629,7 @@ export class Converter {
         });
 
       case SyntaxKind.ConditionalExpression:
-        return this.createNode<es.ConditionalExpression>(node, {
+        return this.createNode<TSESTree.ConditionalExpression>(node, {
           type: AST_NODE_TYPES.ConditionalExpression,
           test: this.convertChild(node.condition),
           consequent: this.convertChild(node.whenTrue),
@@ -1635,7 +1637,7 @@ export class Converter {
         });
 
       case SyntaxKind.CallExpression: {
-        const result = this.createNode<es.CallExpression>(node, {
+        const result = this.createNode<TSESTree.CallExpression>(node, {
           type: AST_NODE_TYPES.CallExpression,
           callee: this.convertChild(node.expression),
           arguments: node.arguments.map(el => this.convertChild(el))
@@ -1649,7 +1651,7 @@ export class Converter {
       }
 
       case SyntaxKind.NewExpression: {
-        const result = this.createNode<es.NewExpression>(node, {
+        const result = this.createNode<TSESTree.NewExpression>(node, {
           type: AST_NODE_TYPES.NewExpression,
           callee: this.convertChild(node.expression),
           arguments: node.arguments
@@ -1665,9 +1667,9 @@ export class Converter {
       }
 
       case SyntaxKind.MetaProperty: {
-        return this.createNode<es.MetaProperty>(node, {
+        return this.createNode<TSESTree.MetaProperty>(node, {
           type: AST_NODE_TYPES.MetaProperty,
-          meta: this.createNode<es.Identifier>(node.getFirstToken()!, {
+          meta: this.createNode<TSESTree.Identifier>(node.getFirstToken()!, {
             type: AST_NODE_TYPES.Identifier,
             name: getTextForTokenKind(node.keywordToken)!
           }),
@@ -1676,7 +1678,7 @@ export class Converter {
       }
 
       case SyntaxKind.Decorator: {
-        return this.createNode<es.Decorator>(node, {
+        return this.createNode<TSESTree.Decorator>(node, {
           type: AST_NODE_TYPES.Decorator,
           expression: this.convertChild(node.expression)
         });
@@ -1685,7 +1687,7 @@ export class Converter {
       // Literals
 
       case SyntaxKind.StringLiteral: {
-        const result = this.createNode<es.Literal>(node, {
+        const result = this.createNode<TSESTree.Literal>(node, {
           type: AST_NODE_TYPES.Literal,
           raw: '',
           value: ''
@@ -1700,7 +1702,7 @@ export class Converter {
       }
 
       case SyntaxKind.NumericLiteral: {
-        return this.createNode<es.Literal>(node, {
+        return this.createNode<TSESTree.Literal>(node, {
           type: AST_NODE_TYPES.Literal,
           value: Number(node.text),
           raw: node.getText()
@@ -1708,7 +1710,7 @@ export class Converter {
       }
 
       case SyntaxKind.BigIntLiteral: {
-        const result = this.createNode<es.BigIntLiteral>(node, {
+        const result = this.createNode<TSESTree.BigIntLiteral>(node, {
           type: AST_NODE_TYPES.BigIntLiteral,
           raw: '',
           value: ''
@@ -1729,7 +1731,7 @@ export class Converter {
           regex = null;
         }
 
-        return this.createNode<es.Literal>(node, {
+        return this.createNode<TSESTree.Literal>(node, {
           type: AST_NODE_TYPES.Literal,
           value: regex,
           raw: node.text,
@@ -1741,14 +1743,14 @@ export class Converter {
       }
 
       case SyntaxKind.TrueKeyword:
-        return this.createNode<es.Literal>(node, {
+        return this.createNode<TSESTree.Literal>(node, {
           type: AST_NODE_TYPES.Literal,
           value: true,
           raw: 'true'
         });
 
       case SyntaxKind.FalseKeyword:
-        return this.createNode<es.Literal>(node, {
+        return this.createNode<TSESTree.Literal>(node, {
           type: AST_NODE_TYPES.Literal,
           value: false,
           raw: 'false'
@@ -1756,11 +1758,11 @@ export class Converter {
 
       case SyntaxKind.NullKeyword: {
         if (this.inTypeMode) {
-          return this.createNode<es.TSNullKeyword>(node, {
+          return this.createNode<TSESTree.TSNullKeyword>(node, {
             type: AST_NODE_TYPES.TSNullKeyword
           });
         } else {
-          return this.createNode<es.Literal>(node, {
+          return this.createNode<TSESTree.Literal>(node, {
             type: AST_NODE_TYPES.Literal,
             value: null,
             raw: 'null'
@@ -1769,24 +1771,24 @@ export class Converter {
       }
 
       case SyntaxKind.ImportKeyword:
-        return this.createNode<es.Import>(node, {
+        return this.createNode<TSESTree.Import>(node, {
           type: AST_NODE_TYPES.Import
         });
 
       case SyntaxKind.EmptyStatement:
-        return this.createNode<es.EmptyStatement>(node, {
+        return this.createNode<TSESTree.EmptyStatement>(node, {
           type: AST_NODE_TYPES.EmptyStatement
         });
 
       case SyntaxKind.DebuggerStatement:
-        return this.createNode<es.DebuggerStatement>(node, {
+        return this.createNode<TSESTree.DebuggerStatement>(node, {
           type: AST_NODE_TYPES.DebuggerStatement
         });
 
       // JSX
 
       case SyntaxKind.JsxElement:
-        return this.createNode<es.JSXElement>(node, {
+        return this.createNode<TSESTree.JSXElement>(node, {
           type: AST_NODE_TYPES.JSXElement,
           openingElement: this.convertChild(node.openingElement),
           closingElement: this.convertChild(node.closingElement),
@@ -1794,7 +1796,7 @@ export class Converter {
         });
 
       case SyntaxKind.JsxFragment:
-        return this.createNode<es.JSXFragment>(node, {
+        return this.createNode<TSESTree.JSXFragment>(node, {
           type: AST_NODE_TYPES.JSXFragment,
           openingFragment: this.convertChild(node.openingFragment),
           closingFragment: this.convertChild(node.closingFragment),
@@ -1802,13 +1804,13 @@ export class Converter {
         });
 
       case SyntaxKind.JsxSelfClosingElement: {
-        return this.createNode<es.JSXElement>(node, {
+        return this.createNode<TSESTree.JSXElement>(node, {
           type: AST_NODE_TYPES.JSXElement,
           /**
            * Convert SyntaxKind.JsxSelfClosingElement to SyntaxKind.JsxOpeningElement,
            * TypeScript does not seem to have the idea of openingElement when tag is self-closing
            */
-          openingElement: this.createNode<es.JSXOpeningElement>(node, {
+          openingElement: this.createNode<TSESTree.JSXOpeningElement>(node, {
             type: AST_NODE_TYPES.JSXOpeningElement,
             typeParameters: node.typeArguments
               ? this.convertTypeArgumentsToTypeParameters(node.typeArguments)
@@ -1826,7 +1828,7 @@ export class Converter {
       }
 
       case SyntaxKind.JsxOpeningElement:
-        return this.createNode<es.JSXOpeningElement>(node, {
+        return this.createNode<TSESTree.JSXOpeningElement>(node, {
           type: AST_NODE_TYPES.JSXOpeningElement,
           typeParameters: node.typeArguments
             ? this.convertTypeArgumentsToTypeParameters(node.typeArguments)
@@ -1839,36 +1841,36 @@ export class Converter {
         });
 
       case SyntaxKind.JsxClosingElement:
-        return this.createNode<es.JSXClosingElement>(node, {
+        return this.createNode<TSESTree.JSXClosingElement>(node, {
           type: AST_NODE_TYPES.JSXClosingElement,
           name: this.convertJSXTagName(node.tagName, node)
         });
 
       case SyntaxKind.JsxOpeningFragment:
-        return this.createNode<es.JSXOpeningFragment>(node, {
+        return this.createNode<TSESTree.JSXOpeningFragment>(node, {
           type: AST_NODE_TYPES.JSXOpeningFragment
         });
 
       case SyntaxKind.JsxClosingFragment:
-        return this.createNode<es.JSXClosingFragment>(node, {
+        return this.createNode<TSESTree.JSXClosingFragment>(node, {
           type: AST_NODE_TYPES.JSXClosingFragment
         });
 
       case SyntaxKind.JsxExpression: {
         const expression = node.expression
           ? this.convertChild(node.expression)
-          : this.createNode<es.JSXEmptyExpression>(node, {
+          : this.createNode<TSESTree.JSXEmptyExpression>(node, {
               type: AST_NODE_TYPES.JSXEmptyExpression,
               range: [node.getStart(this.ast) + 1, node.getEnd() - 1]
             });
 
         if (node.dotDotDotToken) {
-          return this.createNode<es.JSXSpreadChild>(node, {
+          return this.createNode<TSESTree.JSXSpreadChild>(node, {
             type: AST_NODE_TYPES.JSXSpreadChild,
             expression
           });
         } else {
-          return this.createNode<es.JSXExpressionContainer>(node, {
+          return this.createNode<TSESTree.JSXExpressionContainer>(node, {
             type: AST_NODE_TYPES.JSXExpressionContainer,
             expression
           });
@@ -1879,7 +1881,7 @@ export class Converter {
         const attributeName = this.convertChild(node.name);
         attributeName.type = AST_NODE_TYPES.JSXIdentifier;
 
-        return this.createNode<es.JSXAttribute>(node, {
+        return this.createNode<TSESTree.JSXAttribute>(node, {
           type: AST_NODE_TYPES.JSXAttribute,
           name: attributeName,
           value: this.convertChild(node.initializer)
@@ -1897,14 +1899,14 @@ export class Converter {
         const end = node.getEnd();
 
         if (this.options.useJSXTextNode) {
-          return this.createNode<es.JSXText>(node, {
+          return this.createNode<TSESTree.JSXText>(node, {
             type: AST_NODE_TYPES.JSXText,
             value: this.ast.text.slice(start, end),
             raw: this.ast.text.slice(start, end),
             range: [start, end]
           });
         } else {
-          return this.createNode<es.Literal>(node, {
+          return this.createNode<TSESTree.Literal>(node, {
             type: AST_NODE_TYPES.Literal,
             value: this.ast.text.slice(start, end),
             raw: this.ast.text.slice(start, end),
@@ -1914,13 +1916,13 @@ export class Converter {
       }
 
       case SyntaxKind.JsxSpreadAttribute:
-        return this.createNode<es.JSXSpreadAttribute>(node, {
+        return this.createNode<TSESTree.JSXSpreadAttribute>(node, {
           type: AST_NODE_TYPES.JSXSpreadAttribute,
           argument: this.convertChild(node.expression)
         });
 
       case SyntaxKind.QualifiedName: {
-        return this.createNode<es.TSQualifiedName>(node, {
+        return this.createNode<TSESTree.TSQualifiedName>(node, {
           type: AST_NODE_TYPES.TSQualifiedName,
           left: this.convertChild(node.left),
           right: this.convertChild(node.right)
@@ -1930,7 +1932,7 @@ export class Converter {
       // TypeScript specific
 
       case SyntaxKind.TypeReference: {
-        return this.createNode<es.TSTypeReference>(node, {
+        return this.createNode<TSESTree.TSTypeReference>(node, {
           type: AST_NODE_TYPES.TSTypeReference,
           typeName: this.convertType(node.typeName),
           typeParameters: node.typeArguments
@@ -1940,7 +1942,7 @@ export class Converter {
       }
 
       case SyntaxKind.TypeParameter: {
-        return this.createNode<es.TSTypeParameter>(node, {
+        return this.createNode<TSESTree.TSTypeParameter>(node, {
           type: AST_NODE_TYPES.TSTypeParameter,
           name: this.convertType(node.name),
           constraint: node.constraint
@@ -1968,28 +1970,28 @@ export class Converter {
       }
 
       case SyntaxKind.NonNullExpression: {
-        return this.createNode<es.TSNonNullExpression>(node, {
+        return this.createNode<TSESTree.TSNonNullExpression>(node, {
           type: AST_NODE_TYPES.TSNonNullExpression,
           expression: this.convertChild(node.expression)
         });
       }
 
       case SyntaxKind.TypeLiteral: {
-        return this.createNode<es.TSTypeLiteral>(node, {
+        return this.createNode<TSESTree.TSTypeLiteral>(node, {
           type: AST_NODE_TYPES.TSTypeLiteral,
           members: node.members.map(el => this.convertChild(el))
         });
       }
 
       case SyntaxKind.ArrayType: {
-        return this.createNode<es.TSArrayType>(node, {
+        return this.createNode<TSESTree.TSArrayType>(node, {
           type: AST_NODE_TYPES.TSArrayType,
           elementType: this.convertType(node.elementType)
         });
       }
 
       case SyntaxKind.IndexedAccessType: {
-        return this.createNode<es.TSIndexedAccessType>(node, {
+        return this.createNode<TSESTree.TSIndexedAccessType>(node, {
           type: AST_NODE_TYPES.TSIndexedAccessType,
           objectType: this.convertType(node.objectType),
           indexType: this.convertType(node.indexType)
@@ -1997,7 +1999,7 @@ export class Converter {
       }
 
       case SyntaxKind.ConditionalType: {
-        return this.createNode<es.TSConditionalType>(node, {
+        return this.createNode<TSESTree.TSConditionalType>(node, {
           type: AST_NODE_TYPES.TSConditionalType,
           checkType: this.convertType(node.checkType),
           extendsType: this.convertType(node.extendsType),
@@ -2007,14 +2009,14 @@ export class Converter {
       }
 
       case SyntaxKind.TypeQuery: {
-        return this.createNode<es.TSTypeQuery>(node, {
+        return this.createNode<TSESTree.TSTypeQuery>(node, {
           type: AST_NODE_TYPES.TSTypeQuery,
           exprName: this.convertType(node.exprName)
         });
       }
 
       case SyntaxKind.MappedType: {
-        const result = this.createNode<es.TSMappedType>(node, {
+        const result = this.createNode<TSESTree.TSMappedType>(node, {
           type: AST_NODE_TYPES.TSMappedType,
           typeParameter: this.convertType(node.typeParameter)
         });
@@ -2049,7 +2051,7 @@ export class Converter {
         return this.convertChild(node.expression, parent);
 
       case SyntaxKind.TypeAliasDeclaration: {
-        const result = this.createNode<es.TSTypeAliasDeclaration>(node, {
+        const result = this.createNode<TSESTree.TSTypeAliasDeclaration>(node, {
           type: AST_NODE_TYPES.TSTypeAliasDeclaration,
           id: this.convertChild(node.name),
           typeAnnotation: this.convertType(node.type)
@@ -2071,7 +2073,7 @@ export class Converter {
       }
 
       case SyntaxKind.MethodSignature: {
-        const result = this.createNode<es.TSMethodSignature>(node, {
+        const result = this.createNode<TSESTree.TSMethodSignature>(node, {
           type: AST_NODE_TYPES.TSMethodSignature,
           computed: isComputedProperty(node.name),
           key: this.convertChild(node.name),
@@ -2112,7 +2114,7 @@ export class Converter {
       }
 
       case SyntaxKind.PropertySignature: {
-        const result = this.createNode<es.TSPropertySignature>(node, {
+        const result = this.createNode<TSESTree.TSPropertySignature>(node, {
           type: AST_NODE_TYPES.TSPropertySignature,
           optional: isOptional(node) || undefined,
           computed: isComputedProperty(node.name),
@@ -2135,7 +2137,7 @@ export class Converter {
       }
 
       case SyntaxKind.IndexSignature: {
-        const result = this.createNode<es.TSIndexSignature>(node, {
+        const result = this.createNode<TSESTree.TSIndexSignature>(node, {
           type: AST_NODE_TYPES.TSIndexSignature,
           parameters: node.parameters.map(el => this.convertChild(el))
         });
@@ -2183,10 +2185,10 @@ export class Converter {
             break;
         }
         const result = this.createNode<
-          | es.TSConstructSignatureDeclaration
-          | es.TSCallSignatureDeclaration
-          | es.TSFunctionType
-          | es.TSConstructorType
+          | TSESTree.TSConstructSignatureDeclaration
+          | TSESTree.TSCallSignatureDeclaration
+          | TSESTree.TSFunctionType
+          | TSESTree.TSConstructorType
         >(node, {
           type: type,
           params: this.convertParameters(node.parameters)
@@ -2207,7 +2209,7 @@ export class Converter {
 
       case SyntaxKind.ExpressionWithTypeArguments: {
         const result = this.createNode<
-          es.TSInterfaceHeritage | es.TSClassImplements
+          TSESTree.TSInterfaceHeritage | TSESTree.TSClassImplements
         >(node, {
           type:
             parent && parent.kind === SyntaxKind.InterfaceDeclaration
@@ -2226,9 +2228,9 @@ export class Converter {
 
       case SyntaxKind.InterfaceDeclaration: {
         const interfaceHeritageClauses = node.heritageClauses || [];
-        const result = this.createNode<es.TSInterfaceDeclaration>(node, {
+        const result = this.createNode<TSESTree.TSInterfaceDeclaration>(node, {
           type: AST_NODE_TYPES.TSInterfaceDeclaration,
-          body: this.createNode<es.TSInterfaceBody>(node, {
+          body: this.createNode<TSESTree.TSInterfaceBody>(node, {
             type: AST_NODE_TYPES.TSInterfaceBody,
             body: node.members.map(member => this.convertChild(member)),
             range: [node.members.pos - 1, node.end]
@@ -2286,7 +2288,7 @@ export class Converter {
       }
 
       case SyntaxKind.FirstTypeNode: {
-        const result = this.createNode<es.TSTypePredicate>(node, {
+        const result = this.createNode<TSESTree.TSTypePredicate>(node, {
           type: AST_NODE_TYPES.TSTypePredicate,
           parameterName: this.convertChild(node.parameterName),
           typeAnnotation: this.convertTypeAnnotation(node.type, node)
@@ -2301,7 +2303,7 @@ export class Converter {
       }
 
       case SyntaxKind.ImportType:
-        return this.createNode<es.TSImportType>(node, {
+        return this.createNode<TSESTree.TSImportType>(node, {
           type: AST_NODE_TYPES.TSImportType,
           isTypeOf: !!node.isTypeOf,
           parameter: this.convertChild(node.argument),
@@ -2312,7 +2314,7 @@ export class Converter {
         });
 
       case SyntaxKind.EnumDeclaration: {
-        const result = this.createNode<es.TSEnumDeclaration>(node, {
+        const result = this.createNode<TSESTree.TSEnumDeclaration>(node, {
           type: AST_NODE_TYPES.TSEnumDeclaration,
           id: this.convertChild(node.name),
           members: node.members.map(el => this.convertChild(el))
@@ -2332,7 +2334,7 @@ export class Converter {
       }
 
       case SyntaxKind.EnumMember: {
-        const result = this.createNode<es.TSEnumMember>(node, {
+        const result = this.createNode<TSESTree.TSEnumMember>(node, {
           type: AST_NODE_TYPES.TSEnumMember,
           id: this.convertChild(node.name)
         });
@@ -2343,7 +2345,7 @@ export class Converter {
       }
 
       case SyntaxKind.ModuleDeclaration: {
-        const result = this.createNode<es.TSModuleDeclaration>(node, {
+        const result = this.createNode<TSESTree.TSModuleDeclaration>(node, {
           type: AST_NODE_TYPES.TSModuleDeclaration,
           id: this.convertChild(node.name)
         });
@@ -2361,69 +2363,69 @@ export class Converter {
 
       // TypeScript specific types
       case SyntaxKind.OptionalType: {
-        return this.createNode<es.TSOptionalType>(node, {
+        return this.createNode<TSESTree.TSOptionalType>(node, {
           type: AST_NODE_TYPES.TSOptionalType,
           typeAnnotation: this.convertType(node.type)
         });
       }
       case SyntaxKind.ParenthesizedType: {
-        return this.createNode<es.TSParenthesizedType>(node, {
+        return this.createNode<TSESTree.TSParenthesizedType>(node, {
           type: AST_NODE_TYPES.TSParenthesizedType,
           typeAnnotation: this.convertType(node.type)
         });
       }
       case SyntaxKind.TupleType: {
-        return this.createNode<es.TSTupleType>(node, {
+        return this.createNode<TSESTree.TSTupleType>(node, {
           type: AST_NODE_TYPES.TSTupleType,
           elementTypes: node.elementTypes.map(el => this.convertType(el))
         });
       }
       case SyntaxKind.UnionType: {
-        return this.createNode<es.TSUnionType>(node, {
+        return this.createNode<TSESTree.TSUnionType>(node, {
           type: AST_NODE_TYPES.TSUnionType,
           types: node.types.map(el => this.convertType(el))
         });
       }
       case SyntaxKind.IntersectionType: {
-        return this.createNode<es.TSIntersectionType>(node, {
+        return this.createNode<TSESTree.TSIntersectionType>(node, {
           type: AST_NODE_TYPES.TSIntersectionType,
           types: node.types.map(el => this.convertType(el))
         });
       }
       case SyntaxKind.RestType: {
-        return this.createNode<es.TSRestType>(node, {
+        return this.createNode<TSESTree.TSRestType>(node, {
           type: AST_NODE_TYPES.TSRestType,
           typeAnnotation: this.convertType(node.type)
         });
       }
       case SyntaxKind.AsExpression: {
-        return this.createNode<es.TSAsExpression>(node, {
+        return this.createNode<TSESTree.TSAsExpression>(node, {
           type: AST_NODE_TYPES.TSAsExpression,
           expression: this.convertChild(node.expression),
           typeAnnotation: this.convertType(node.type)
         });
       }
       case SyntaxKind.InferType: {
-        return this.createNode<es.TSInferType>(node, {
+        return this.createNode<TSESTree.TSInferType>(node, {
           type: AST_NODE_TYPES.TSInferType,
           typeParameter: this.convertType(node.typeParameter)
         });
       }
       case SyntaxKind.LiteralType: {
-        return this.createNode<es.TSLiteralType>(node, {
+        return this.createNode<TSESTree.TSLiteralType>(node, {
           type: AST_NODE_TYPES.TSLiteralType,
           literal: this.convertType(node.literal)
         });
       }
       case SyntaxKind.TypeAssertionExpression: {
-        return this.createNode<es.TSTypeAssertion>(node, {
+        return this.createNode<TSESTree.TSTypeAssertion>(node, {
           type: AST_NODE_TYPES.TSTypeAssertion,
           typeAnnotation: this.convertType(node.type),
           expression: this.convertChild(node.expression)
         });
       }
       case SyntaxKind.ImportEqualsDeclaration: {
-        return this.createNode<es.TSImportEqualsDeclaration>(node, {
+        return this.createNode<TSESTree.TSImportEqualsDeclaration>(node, {
           type: AST_NODE_TYPES.TSImportEqualsDeclaration,
           id: this.convertChild(node.name),
           moduleReference: this.convertChild(node.moduleReference),
@@ -2431,13 +2433,13 @@ export class Converter {
         });
       }
       case SyntaxKind.ExternalModuleReference: {
-        return this.createNode<es.TSExternalModuleReference>(node, {
+        return this.createNode<TSESTree.TSExternalModuleReference>(node, {
           type: AST_NODE_TYPES.TSExternalModuleReference,
           expression: this.convertChild(node.expression)
         });
       }
       case SyntaxKind.NamespaceExportDeclaration: {
-        return this.createNode<es.TSNamespaceExportDeclaration>(node, {
+        return this.createNode<TSESTree.TSNamespaceExportDeclaration>(node, {
           type: AST_NODE_TYPES.TSNamespaceExportDeclaration,
           id: this.convertChild(node.name)
         });
diff --git a/packages/typescript-estree/src/node-utils.ts b/packages/typescript-estree/src/node-utils.ts
index aa5a10418c76..4ab71cf5e9a4 100644
--- a/packages/typescript-estree/src/node-utils.ts
+++ b/packages/typescript-estree/src/node-utils.ts
@@ -6,7 +6,7 @@
  */
 import ts from 'typescript';
 import unescape from 'lodash.unescape';
-import * as es from './typedefs';
+import { TSESTree } from './ts-estree';
 import { AST_NODE_TYPES } from './ast-node-types';
 
 const SyntaxKind = ts.SyntaxKind;
@@ -224,7 +224,7 @@ export function getBinaryExpressionType(
 export function getLineAndCharacterFor(
   pos: number,
   ast: ts.SourceFile
-): es.LineAndColumnData {
+): TSESTree.LineAndColumnData {
   const loc = ast.getLineAndCharacterOfPosition(pos);
   return {
     line: loc.line + 1,
@@ -244,7 +244,7 @@ export function getLocFor(
   start: number,
   end: number,
   ast: ts.SourceFile
-): es.SourceLocation {
+): TSESTree.SourceLocation {
   return {
     start: getLineAndCharacterFor(start, ast),
     end: getLineAndCharacterFor(end, ast)
@@ -455,11 +455,11 @@ export function isOptional(node: {
  * @param ast    the AST
  * @returns the ESTreeNode with fixed exports
  */
-export function fixExports<T extends es.BaseNode>(
+export function fixExports<T extends TSESTree.BaseNode>(
   node: ts.Node,
   result: T,
   ast: ts.SourceFile
-): es.ExportDefaultDeclaration | es.ExportNamedDeclaration | T {
+): TSESTree.ExportDefaultDeclaration | TSESTree.ExportNamedDeclaration | T {
   // check for exports
   if (node.modifiers && node.modifiers[0].kind === SyntaxKind.ExportKeyword) {
     const exportKeyword = node.modifiers[0];
@@ -501,7 +501,7 @@ export function fixExports<T extends es.BaseNode>(
  * @param token the ts.Token
  * @returns the token type
  */
-export function getTokenType(token: any): es.TokenType {
+export function getTokenType(token: any): TSESTree.TokenType {
   // Need two checks for keywords since some are also identifiers
   if (token.originalKeywordKind) {
     switch (token.originalKeywordKind) {
@@ -607,16 +607,19 @@ export function getTokenType(token: any): es.TokenType {
  * Extends and formats a given ts.Token, for a given AST
  * @param token the ts.Token
  * @param ast   the AST object
- * @returns the converted es.Token
+ * @returns the converted Token
  */
-export function convertToken(token: ts.Node, ast: ts.SourceFile): es.Token {
+export function convertToken(
+  token: ts.Node,
+  ast: ts.SourceFile
+): TSESTree.Token {
   const start =
       token.kind === SyntaxKind.JsxText
         ? token.getFullStart()
         : token.getStart(ast),
     end = token.getEnd(),
     value = ast.text.slice(start, end),
-    newToken: es.Token = {
+    newToken: TSESTree.Token = {
       type: getTokenType(token),
       value,
       range: [start, end],
@@ -638,8 +641,8 @@ export function convertToken(token: ts.Node, ast: ts.SourceFile): es.Token {
  * @param ast the AST object
  * @returns the converted Tokens
  */
-export function convertTokens(ast: ts.SourceFile): es.Token[] {
-  const result: es.Token[] = [];
+export function convertTokens(ast: ts.SourceFile): TSESTree.Token[] {
+  const result: TSESTree.Token[] = [];
   /**
    * @param node the ts.Node
    */
diff --git a/packages/typescript-estree/src/parser-options.ts b/packages/typescript-estree/src/parser-options.ts
index a838db4af139..6ec07b902cd1 100644
--- a/packages/typescript-estree/src/parser-options.ts
+++ b/packages/typescript-estree/src/parser-options.ts
@@ -1,4 +1,6 @@
-import { Token, Comment } from './typedefs';
+import { Program } from 'typescript';
+import { Token, Comment, Node } from './typedefs';
+import { TSNode } from './ts-nodes';
 
 export interface Extra {
   errorOnUnknownASTType: boolean;
@@ -33,3 +35,13 @@ export interface ParserOptions {
   tsconfigRootDir?: string;
   extraFileExtensions?: string[];
 }
+
+export interface ParserWeakMap<TKey, TValueBase> {
+  get<TValue extends TValueBase>(key: TKey): TValue;
+}
+
+export interface ParserServices {
+  program: Program | undefined;
+  esTreeNodeToTSNodeMap: ParserWeakMap<Node, TSNode> | undefined;
+  tsNodeToESTreeNodeMap: ParserWeakMap<TSNode, Node> | undefined;
+}
diff --git a/packages/typescript-estree/src/parser.ts b/packages/typescript-estree/src/parser.ts
index bad5cdd6fd50..bb77a186171a 100644
--- a/packages/typescript-estree/src/parser.ts
+++ b/packages/typescript-estree/src/parser.ts
@@ -14,8 +14,8 @@ import ts from 'typescript';
 import convert from './ast-converter';
 import { convertError } from './convert';
 import { firstDefined } from './node-utils';
-import * as es from './typedefs';
-import { Extra, ParserOptions } from './parser-options';
+import { TSESTree } from './ts-estree';
+import { Extra, ParserOptions, ParserServices } from './parser-options';
 import { getFirstSemanticOrSyntacticError } from './semantic-errors';
 
 /**
@@ -271,18 +271,14 @@ function warnAboutTSVersion(): void {
 // Parser
 //------------------------------------------------------------------------------
 
-type AST<T extends ParserOptions> = es.Program &
+type AST<T extends ParserOptions> = TSESTree.Program &
   (T['range'] extends true ? { range: [number, number] } : {}) &
-  (T['tokens'] extends true ? { tokens: es.Token[] } : {}) &
-  (T['comment'] extends true ? { comments: es.Comment[] } : {});
+  (T['tokens'] extends true ? { tokens: TSESTree.Token[] } : {}) &
+  (T['comment'] extends true ? { comments: TSESTree.Comment[] } : {});
 
 interface ParseAndGenerateServicesResult<T extends ParserOptions> {
   ast: AST<T>;
-  services: {
-    program: ts.Program | undefined;
-    esTreeNodeToTSNodeMap: WeakMap<object, any> | undefined;
-    tsNodeToESTreeNodeMap: WeakMap<object, any> | undefined;
-  };
+  services: ParserServices;
 }
 
 //------------------------------------------------------------------------------
@@ -419,3 +415,5 @@ export function parseAndGenerateServices<
 
 export { AST_NODE_TYPES } from './ast-node-types';
 export { ParserOptions };
+export { ParserServices };
+export { TSESTree };
diff --git a/packages/typescript-estree/src/ts-estree.ts b/packages/typescript-estree/src/ts-estree.ts
new file mode 100644
index 000000000000..846392c54430
--- /dev/null
+++ b/packages/typescript-estree/src/ts-estree.ts
@@ -0,0 +1,2 @@
+import * as TSESTree from './typedefs';
+export { TSESTree };
diff --git a/packages/typescript-estree/src/typedefs.ts b/packages/typescript-estree/src/typedefs.ts
index a9a100e64623..af8d17e0157a 100644
--- a/packages/typescript-estree/src/typedefs.ts
+++ b/packages/typescript-estree/src/typedefs.ts
@@ -1185,7 +1185,7 @@ export interface TSModuleBlock extends BaseNode {
 export interface TSModuleDeclaration extends BaseNode {
   type: AST_NODE_TYPES.TSModuleDeclaration;
   id: Identifier | Literal;
-  body?: TSModuleBlock | Identifier;
+  body?: TSModuleBlock | TSModuleDeclaration;
   global?: boolean;
   declare?: boolean;
   modifiers?: Modifier[];
diff --git a/packages/typescript-estree/tests/lib/semanticInfo.ts b/packages/typescript-estree/tests/lib/semanticInfo.ts
index a164288ceb0f..531ab1a34d54 100644
--- a/packages/typescript-estree/tests/lib/semanticInfo.ts
+++ b/packages/typescript-estree/tests/lib/semanticInfo.ts
@@ -123,10 +123,10 @@ describe('semanticInfo', () => {
       arrayBoundName
     );
     expect(tsArrayBoundName).toBeDefined();
-    checkNumberArrayType(checker, tsArrayBoundName);
+    checkNumberArrayType(checker, tsArrayBoundName!);
 
     expect(
-      parseResult.services.tsNodeToESTreeNodeMap!.get(tsArrayBoundName)
+      parseResult.services.tsNodeToESTreeNodeMap!.get(tsArrayBoundName!)
     ).toBe(arrayBoundName);
   });
 
@@ -149,9 +149,9 @@ describe('semanticInfo', () => {
     );
     expect(tsBoundName).toBeDefined();
 
-    checkNumberArrayType(checker, tsBoundName);
+    checkNumberArrayType(checker, tsBoundName!);
 
-    expect(parseResult.services.tsNodeToESTreeNodeMap!.get(tsBoundName)).toBe(
+    expect(parseResult.services.tsNodeToESTreeNodeMap!.get(tsBoundName!)).toBe(
       boundName
     );
   });
diff --git a/yarn.lock b/yarn.lock
index 00804abee1f8..95f575e0097c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -816,7 +816,7 @@
     "@types/estree" "*"
     "@types/json-schema" "*"
 
-"@types/estree@*", "@types/estree@^0.0.39":
+"@types/estree@*":
   version "0.0.39"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==