0
# @typescript-eslint/types
1

2
@typescript-eslint/types provides comprehensive TypeScript type definitions for the TypeScript-ESTree Abstract Syntax Tree (AST) specification. As an internal utility package within the typescript-eslint ecosystem, it serves as the foundation for type-safe parsing, analysis, and linting of TypeScript code across all related tools.
3

4
## Package Information
5

6
- **Package Name**: @typescript-eslint/types
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install @typescript-eslint/types`
10

11
## Core Imports
12

13
```typescript
14
import { AST_NODE_TYPES, AST_TOKEN_TYPES, ParserOptions, TSESTree, Lib } from "@typescript-eslint/types";
15
```
16

17
For CommonJS:
18

19
```javascript
20
const { AST_NODE_TYPES, AST_TOKEN_TYPES, ParserOptions, TSESTree, Lib } = require("@typescript-eslint/types");
21
```
22

23
## Basic Usage
24

25
```typescript
26
import { AST_NODE_TYPES, ParserOptions, TSESTree } from "@typescript-eslint/types";
27

28
// Check AST node types
29
if (node.type === AST_NODE_TYPES.FunctionDeclaration) {
30
  // TypeScript now knows this is a function declaration node
31
  console.log(node.id?.name);
32
}
33

34
// Configure parser options
35
const parserOptions: ParserOptions = {
36
  ecmaVersion: 2022,
37
  sourceType: "module",
38
  project: "./tsconfig.json",
39
  lib: ["es2022", "dom"]
40
};
41

42
// Work with strongly-typed AST nodes
43
function processNode(node: TSESTree.Node): void {
44
  switch (node.type) {
45
    case AST_NODE_TYPES.VariableDeclaration:
46
      // TypeScript provides full type safety
47
      node.declarations.forEach(declarator => {
48
        if (declarator.id.type === AST_NODE_TYPES.Identifier) {
49
          console.log(`Variable: ${declarator.id.name}`);
50
        }
51
      });
52
      break;
53
  }
54
}
55
```
56

57
## Architecture
58

59
@typescript-eslint/types is built around several key components:
60

61
- **AST Node Types**: Enum constants for all JavaScript and TypeScript AST node types
62
- **Token Types**: Enum constants for lexical token classification
63
- **Parser Configuration**: Comprehensive interfaces for configuring the TypeScript parser
64
- **Type System**: Complete TypeScript definitions for all AST node structures
65
- **Parent Relationships**: Augmented type definitions that include parent node references
66

67
## Capabilities
68

69
### AST Node Type Constants
70

71
Comprehensive enumeration of all AST node types for JavaScript and TypeScript, enabling type-safe node identification and processing.
72

73
```typescript { .api }
74
enum AST_NODE_TYPES {
75
  // Standard JavaScript nodes
76
  Program = 'Program',
77
  Identifier = 'Identifier',
78
  Literal = 'Literal',
79
  FunctionDeclaration = 'FunctionDeclaration',
80
  // ... 172 total node types
81
  
82
  // TypeScript-specific nodes
83
  TSInterfaceDeclaration = 'TSInterfaceDeclaration',
84
  TSTypeAnnotation = 'TSTypeAnnotation',
85
  TSAsExpression = 'TSAsExpression',
86
  // ... and many more
87
}
88
```
89

90
[AST Node Types](./ast-node-types.md)
91

92
### Token Type Constants
93

94
Enumeration of lexical token types for parsing and syntax highlighting.
95

96
```typescript { .api }
97
enum AST_TOKEN_TYPES {
98
  Boolean = 'Boolean',
99
  Identifier = 'Identifier',
100
  Keyword = 'Keyword',
101
  Null = 'Null',
102
  Numeric = 'Numeric',
103
  Punctuator = 'Punctuator',
104
  RegularExpression = 'RegularExpression',
105
  String = 'String',
106
  Template = 'Template',
107
  Block = 'Block',      // Block comment
108
  Line = 'Line',        // Line comment
109
  // ... 18 total token types
110
}
111
```
112

113
[Token Types](./token-types.md)
114

115
### Parser Configuration
116

117
Comprehensive configuration interfaces for the TypeScript parser, including ECMAScript version settings, project configuration, and TypeScript-specific options.
118

119
```typescript { .api }
120
interface ParserOptions {
121
  // ECMAScript configuration
122
  ecmaVersion?: EcmaVersion;
123
  sourceType?: SourceType;
124
  
125
  // TypeScript project configuration
126
  project?: boolean | string | string[] | null;
127
  projectService?: boolean | ProjectServiceOptions;
128
  tsconfigRootDir?: string;
129
  
130
  // Parser features
131
  jsxPragma?: string | null;
132
  jsxFragmentName?: string | null;
133
  lib?: Lib[];
134
  
135
  // Debug and optimization
136
  debugLevel?: DebugLevel;
137
  errorOnUnknownASTType?: boolean;
138
  
139
  // ... 25+ additional options
140
}
141
```
142

143
[Parser Configuration](./parser-configuration.md)
144

145
### TypeScript Library Targets
146

147
Union type defining all available TypeScript library targets for compilation and type checking.
148

149
```typescript { .api }
150
type Lib = 
151
  | 'es5' | 'es6' | 'es2015' | 'es2016' | 'es2017' | 'es2018' 
152
  | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'es2023' | 'es2024'
153
  | 'esnext' | 'dom' | 'webworker' | 'scripthost'
154
  | 'decorators' | 'decorators.legacy'
155
  // ... 114 total library targets
156
```
157

158
[TypeScript Libraries](./typescript-libraries.md)
159

160
### TypeScript ESTree Types
161

162
Complete type definitions for all AST node structures with parent relationship augmentations, providing strongly-typed access to the entire syntax tree.
163

164
```typescript { .api }
165
declare namespace TSESTree {
166
  interface NodeOrTokenData {
167
    type: string;
168
    loc: SourceLocation;
169
    range: Range;
170
  }
171
  
172
  interface BaseNode extends NodeOrTokenData {
173
    type: AST_NODE_TYPES;
174
    parent: Node; // Added by @typescript-eslint/types package
175
  }
176
  
177
  interface Program extends NodeOrTokenData {
178
    type: AST_NODE_TYPES.Program;
179
    body: ProgramStatement[];
180
    comments: Comment[] | undefined;
181
    sourceType: 'module' | 'script';
182
    tokens: Token[] | undefined;
183
    parent?: never; // Program has no parent
184
  }
185
  
186
  interface FunctionDeclaration extends BaseNode {
187
    type: AST_NODE_TYPES.FunctionDeclaration;
188
    id: Identifier | null;
189
    params: Parameter[];
190
    body: BlockStatement;
191
    // ... complete interface definitions
192
  }
193
  
194
  // ... interfaces for all 172 node types
195
}
196
```
197

198
[TypeScript ESTree](./typescript-estree.md)