ast-types 0.12.4 → 0.13.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. package/.travis.yml +1 -0
  2. package/README.md +219 -201
  3. package/def/core.js +4 -7
  4. package/def/es2020.d.ts +2 -0
  5. package/def/es2020.js +18 -0
  6. package/def/esNext.d.ts +2 -0
  7. package/def/esNext.js +57 -0
  8. package/def/flow.js +4 -0
  9. package/def/typescript.js +4 -4
  10. package/fork.d.ts +3 -7
  11. package/fork.js +1 -2
  12. package/gen/builders.d.ts +508 -496
  13. package/gen/kinds.d.ts +263 -262
  14. package/gen/namedTypes.d.ts +1797 -262
  15. package/gen/namedTypes.js +3 -0
  16. package/gen/nodes.d.ts +15 -15
  17. package/gen/visitor.d.ts +263 -262
  18. package/lib/node-path.js +8 -6
  19. package/lib/path-visitor.d.ts +1 -1
  20. package/lib/scope.js +3 -1
  21. package/lib/types.d.ts +2 -6
  22. package/main.d.ts +25 -13
  23. package/main.js +27 -6
  24. package/package.json +10 -10
package/gen/builders.d.ts CHANGED
@@ -1,139 +1,139 @@
1
1
  import * as K from "./kinds";
2
- import * as N from "./nodes";
2
+ import { namedTypes } from "./namedTypes";
3
3
  export interface FileBuilder {
4
- (program: K.ProgramKind, name?: string | null): N.File;
4
+ (program: K.ProgramKind, name?: string | null): namedTypes.File;
5
5
  from(params: {
6
6
  comments?: K.CommentKind[] | null;
7
7
  loc?: K.SourceLocationKind | null;
8
8
  name?: string | null;
9
9
  program: K.ProgramKind;
10
- }): N.File;
10
+ }): namedTypes.File;
11
11
  }
12
12
  export interface ProgramBuilder {
13
- (body: K.StatementKind[]): N.Program;
13
+ (body: K.StatementKind[]): namedTypes.Program;
14
14
  from(params: {
15
15
  body: K.StatementKind[];
16
16
  comments?: K.CommentKind[] | null;
17
17
  directives?: K.DirectiveKind[];
18
18
  interpreter?: K.InterpreterDirectiveKind | null;
19
19
  loc?: K.SourceLocationKind | null;
20
- }): N.Program;
20
+ }): namedTypes.Program;
21
21
  }
22
22
  export interface IdentifierBuilder {
23
- (name: string): N.Identifier;
23
+ (name: string): namedTypes.Identifier;
24
24
  from(params: {
25
25
  comments?: K.CommentKind[] | null;
26
26
  loc?: K.SourceLocationKind | null;
27
27
  name: string;
28
28
  optional?: boolean;
29
29
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
30
- }): N.Identifier;
30
+ }): namedTypes.Identifier;
31
31
  }
32
32
  export interface BlockStatementBuilder {
33
- (body: K.StatementKind[]): N.BlockStatement;
33
+ (body: K.StatementKind[]): namedTypes.BlockStatement;
34
34
  from(params: {
35
35
  body: K.StatementKind[];
36
36
  comments?: K.CommentKind[] | null;
37
37
  directives?: K.DirectiveKind[];
38
38
  loc?: K.SourceLocationKind | null;
39
- }): N.BlockStatement;
39
+ }): namedTypes.BlockStatement;
40
40
  }
41
41
  export interface EmptyStatementBuilder {
42
- (): N.EmptyStatement;
42
+ (): namedTypes.EmptyStatement;
43
43
  from(params: {
44
44
  comments?: K.CommentKind[] | null;
45
45
  loc?: K.SourceLocationKind | null;
46
- }): N.EmptyStatement;
46
+ }): namedTypes.EmptyStatement;
47
47
  }
48
48
  export interface ExpressionStatementBuilder {
49
- (expression: K.ExpressionKind): N.ExpressionStatement;
49
+ (expression: K.ExpressionKind): namedTypes.ExpressionStatement;
50
50
  from(params: {
51
51
  comments?: K.CommentKind[] | null;
52
52
  expression: K.ExpressionKind;
53
53
  loc?: K.SourceLocationKind | null;
54
- }): N.ExpressionStatement;
54
+ }): namedTypes.ExpressionStatement;
55
55
  }
56
56
  export interface IfStatementBuilder {
57
- (test: K.ExpressionKind, consequent: K.StatementKind, alternate?: K.StatementKind | null): N.IfStatement;
57
+ (test: K.ExpressionKind, consequent: K.StatementKind, alternate?: K.StatementKind | null): namedTypes.IfStatement;
58
58
  from(params: {
59
59
  alternate?: K.StatementKind | null;
60
60
  comments?: K.CommentKind[] | null;
61
61
  consequent: K.StatementKind;
62
62
  loc?: K.SourceLocationKind | null;
63
63
  test: K.ExpressionKind;
64
- }): N.IfStatement;
64
+ }): namedTypes.IfStatement;
65
65
  }
66
66
  export interface LabeledStatementBuilder {
67
- (label: K.IdentifierKind, body: K.StatementKind): N.LabeledStatement;
67
+ (label: K.IdentifierKind, body: K.StatementKind): namedTypes.LabeledStatement;
68
68
  from(params: {
69
69
  body: K.StatementKind;
70
70
  comments?: K.CommentKind[] | null;
71
71
  label: K.IdentifierKind;
72
72
  loc?: K.SourceLocationKind | null;
73
- }): N.LabeledStatement;
73
+ }): namedTypes.LabeledStatement;
74
74
  }
75
75
  export interface BreakStatementBuilder {
76
- (label?: K.IdentifierKind | null): N.BreakStatement;
76
+ (label?: K.IdentifierKind | null): namedTypes.BreakStatement;
77
77
  from(params: {
78
78
  comments?: K.CommentKind[] | null;
79
79
  label?: K.IdentifierKind | null;
80
80
  loc?: K.SourceLocationKind | null;
81
- }): N.BreakStatement;
81
+ }): namedTypes.BreakStatement;
82
82
  }
83
83
  export interface ContinueStatementBuilder {
84
- (label?: K.IdentifierKind | null): N.ContinueStatement;
84
+ (label?: K.IdentifierKind | null): namedTypes.ContinueStatement;
85
85
  from(params: {
86
86
  comments?: K.CommentKind[] | null;
87
87
  label?: K.IdentifierKind | null;
88
88
  loc?: K.SourceLocationKind | null;
89
- }): N.ContinueStatement;
89
+ }): namedTypes.ContinueStatement;
90
90
  }
91
91
  export interface WithStatementBuilder {
92
- (object: K.ExpressionKind, body: K.StatementKind): N.WithStatement;
92
+ (object: K.ExpressionKind, body: K.StatementKind): namedTypes.WithStatement;
93
93
  from(params: {
94
94
  body: K.StatementKind;
95
95
  comments?: K.CommentKind[] | null;
96
96
  loc?: K.SourceLocationKind | null;
97
97
  object: K.ExpressionKind;
98
- }): N.WithStatement;
98
+ }): namedTypes.WithStatement;
99
99
  }
100
100
  export interface SwitchStatementBuilder {
101
- (discriminant: K.ExpressionKind, cases: K.SwitchCaseKind[], lexical?: boolean): N.SwitchStatement;
101
+ (discriminant: K.ExpressionKind, cases: K.SwitchCaseKind[], lexical?: boolean): namedTypes.SwitchStatement;
102
102
  from(params: {
103
103
  cases: K.SwitchCaseKind[];
104
104
  comments?: K.CommentKind[] | null;
105
105
  discriminant: K.ExpressionKind;
106
106
  lexical?: boolean;
107
107
  loc?: K.SourceLocationKind | null;
108
- }): N.SwitchStatement;
108
+ }): namedTypes.SwitchStatement;
109
109
  }
110
110
  export interface SwitchCaseBuilder {
111
- (test: K.ExpressionKind | null, consequent: K.StatementKind[]): N.SwitchCase;
111
+ (test: K.ExpressionKind | null, consequent: K.StatementKind[]): namedTypes.SwitchCase;
112
112
  from(params: {
113
113
  comments?: K.CommentKind[] | null;
114
114
  consequent: K.StatementKind[];
115
115
  loc?: K.SourceLocationKind | null;
116
116
  test: K.ExpressionKind | null;
117
- }): N.SwitchCase;
117
+ }): namedTypes.SwitchCase;
118
118
  }
119
119
  export interface ReturnStatementBuilder {
120
- (argument: K.ExpressionKind | null): N.ReturnStatement;
120
+ (argument: K.ExpressionKind | null): namedTypes.ReturnStatement;
121
121
  from(params: {
122
122
  argument: K.ExpressionKind | null;
123
123
  comments?: K.CommentKind[] | null;
124
124
  loc?: K.SourceLocationKind | null;
125
- }): N.ReturnStatement;
125
+ }): namedTypes.ReturnStatement;
126
126
  }
127
127
  export interface ThrowStatementBuilder {
128
- (argument: K.ExpressionKind): N.ThrowStatement;
128
+ (argument: K.ExpressionKind): namedTypes.ThrowStatement;
129
129
  from(params: {
130
130
  argument: K.ExpressionKind;
131
131
  comments?: K.CommentKind[] | null;
132
132
  loc?: K.SourceLocationKind | null;
133
- }): N.ThrowStatement;
133
+ }): namedTypes.ThrowStatement;
134
134
  }
135
135
  export interface TryStatementBuilder {
136
- (block: K.BlockStatementKind, handler?: K.CatchClauseKind | null, finalizer?: K.BlockStatementKind | null): N.TryStatement;
136
+ (block: K.BlockStatementKind, handler?: K.CatchClauseKind | null, finalizer?: K.BlockStatementKind | null): namedTypes.TryStatement;
137
137
  from(params: {
138
138
  block: K.BlockStatementKind;
139
139
  comments?: K.CommentKind[] | null;
@@ -142,38 +142,38 @@ export interface TryStatementBuilder {
142
142
  handler?: K.CatchClauseKind | null;
143
143
  handlers?: K.CatchClauseKind[];
144
144
  loc?: K.SourceLocationKind | null;
145
- }): N.TryStatement;
145
+ }): namedTypes.TryStatement;
146
146
  }
147
147
  export interface CatchClauseBuilder {
148
- (param: K.PatternKind | null | undefined, guard: K.ExpressionKind | null | undefined, body: K.BlockStatementKind): N.CatchClause;
148
+ (param: K.PatternKind | null | undefined, guard: K.ExpressionKind | null | undefined, body: K.BlockStatementKind): namedTypes.CatchClause;
149
149
  from(params: {
150
150
  body: K.BlockStatementKind;
151
151
  comments?: K.CommentKind[] | null;
152
152
  guard?: K.ExpressionKind | null;
153
153
  loc?: K.SourceLocationKind | null;
154
154
  param?: K.PatternKind | null;
155
- }): N.CatchClause;
155
+ }): namedTypes.CatchClause;
156
156
  }
157
157
  export interface WhileStatementBuilder {
158
- (test: K.ExpressionKind, body: K.StatementKind): N.WhileStatement;
158
+ (test: K.ExpressionKind, body: K.StatementKind): namedTypes.WhileStatement;
159
159
  from(params: {
160
160
  body: K.StatementKind;
161
161
  comments?: K.CommentKind[] | null;
162
162
  loc?: K.SourceLocationKind | null;
163
163
  test: K.ExpressionKind;
164
- }): N.WhileStatement;
164
+ }): namedTypes.WhileStatement;
165
165
  }
166
166
  export interface DoWhileStatementBuilder {
167
- (body: K.StatementKind, test: K.ExpressionKind): N.DoWhileStatement;
167
+ (body: K.StatementKind, test: K.ExpressionKind): namedTypes.DoWhileStatement;
168
168
  from(params: {
169
169
  body: K.StatementKind;
170
170
  comments?: K.CommentKind[] | null;
171
171
  loc?: K.SourceLocationKind | null;
172
172
  test: K.ExpressionKind;
173
- }): N.DoWhileStatement;
173
+ }): namedTypes.DoWhileStatement;
174
174
  }
175
175
  export interface ForStatementBuilder {
176
- (init: K.VariableDeclarationKind | K.ExpressionKind | null, test: K.ExpressionKind | null, update: K.ExpressionKind | null, body: K.StatementKind): N.ForStatement;
176
+ (init: K.VariableDeclarationKind | K.ExpressionKind | null, test: K.ExpressionKind | null, update: K.ExpressionKind | null, body: K.StatementKind): namedTypes.ForStatement;
177
177
  from(params: {
178
178
  body: K.StatementKind;
179
179
  comments?: K.CommentKind[] | null;
@@ -181,36 +181,36 @@ export interface ForStatementBuilder {
181
181
  loc?: K.SourceLocationKind | null;
182
182
  test: K.ExpressionKind | null;
183
183
  update: K.ExpressionKind | null;
184
- }): N.ForStatement;
184
+ }): namedTypes.ForStatement;
185
185
  }
186
186
  export interface VariableDeclarationBuilder {
187
- (kind: "var" | "let" | "const", declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[]): N.VariableDeclaration;
187
+ (kind: "var" | "let" | "const", declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[]): namedTypes.VariableDeclaration;
188
188
  from(params: {
189
189
  comments?: K.CommentKind[] | null;
190
190
  declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[];
191
191
  kind: "var" | "let" | "const";
192
192
  loc?: K.SourceLocationKind | null;
193
- }): N.VariableDeclaration;
193
+ }): namedTypes.VariableDeclaration;
194
194
  }
195
195
  export interface ForInStatementBuilder {
196
- (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): N.ForInStatement;
196
+ (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForInStatement;
197
197
  from(params: {
198
198
  body: K.StatementKind;
199
199
  comments?: K.CommentKind[] | null;
200
200
  left: K.VariableDeclarationKind | K.ExpressionKind;
201
201
  loc?: K.SourceLocationKind | null;
202
202
  right: K.ExpressionKind;
203
- }): N.ForInStatement;
203
+ }): namedTypes.ForInStatement;
204
204
  }
205
205
  export interface DebuggerStatementBuilder {
206
- (): N.DebuggerStatement;
206
+ (): namedTypes.DebuggerStatement;
207
207
  from(params: {
208
208
  comments?: K.CommentKind[] | null;
209
209
  loc?: K.SourceLocationKind | null;
210
- }): N.DebuggerStatement;
210
+ }): namedTypes.DebuggerStatement;
211
211
  }
212
212
  export interface FunctionDeclarationBuilder {
213
- (id: K.IdentifierKind, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): N.FunctionDeclaration;
213
+ (id: K.IdentifierKind, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionDeclaration;
214
214
  from(params: {
215
215
  async?: boolean;
216
216
  body: K.BlockStatementKind;
@@ -224,10 +224,10 @@ export interface FunctionDeclarationBuilder {
224
224
  rest?: K.IdentifierKind | null;
225
225
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
226
226
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
227
- }): N.FunctionDeclaration;
227
+ }): namedTypes.FunctionDeclaration;
228
228
  }
229
229
  export interface FunctionExpressionBuilder {
230
- (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): N.FunctionExpression;
230
+ (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], body: K.BlockStatementKind, generator?: boolean, expression?: boolean): namedTypes.FunctionExpression;
231
231
  from(params: {
232
232
  async?: boolean;
233
233
  body: K.BlockStatementKind;
@@ -241,42 +241,42 @@ export interface FunctionExpressionBuilder {
241
241
  rest?: K.IdentifierKind | null;
242
242
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
243
243
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
244
- }): N.FunctionExpression;
244
+ }): namedTypes.FunctionExpression;
245
245
  }
246
246
  export interface VariableDeclaratorBuilder {
247
- (id: K.PatternKind, init?: K.ExpressionKind | null): N.VariableDeclarator;
247
+ (id: K.PatternKind, init?: K.ExpressionKind | null): namedTypes.VariableDeclarator;
248
248
  from(params: {
249
249
  comments?: K.CommentKind[] | null;
250
250
  id: K.PatternKind;
251
251
  init?: K.ExpressionKind | null;
252
252
  loc?: K.SourceLocationKind | null;
253
- }): N.VariableDeclarator;
253
+ }): namedTypes.VariableDeclarator;
254
254
  }
255
255
  export interface ThisExpressionBuilder {
256
- (): N.ThisExpression;
256
+ (): namedTypes.ThisExpression;
257
257
  from(params: {
258
258
  comments?: K.CommentKind[] | null;
259
259
  loc?: K.SourceLocationKind | null;
260
- }): N.ThisExpression;
260
+ }): namedTypes.ThisExpression;
261
261
  }
262
262
  export interface ArrayExpressionBuilder {
263
- (elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[]): N.ArrayExpression;
263
+ (elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[]): namedTypes.ArrayExpression;
264
264
  from(params: {
265
265
  comments?: K.CommentKind[] | null;
266
266
  elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[];
267
267
  loc?: K.SourceLocationKind | null;
268
- }): N.ArrayExpression;
268
+ }): namedTypes.ArrayExpression;
269
269
  }
270
270
  export interface ObjectExpressionBuilder {
271
- (properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[]): N.ObjectExpression;
271
+ (properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[]): namedTypes.ObjectExpression;
272
272
  from(params: {
273
273
  comments?: K.CommentKind[] | null;
274
274
  loc?: K.SourceLocationKind | null;
275
275
  properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[];
276
- }): N.ObjectExpression;
276
+ }): namedTypes.ObjectExpression;
277
277
  }
278
278
  export interface PropertyBuilder {
279
- (kind: "init" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): N.Property;
279
+ (kind: "init" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): namedTypes.Property;
280
280
  from(params: {
281
281
  comments?: K.CommentKind[] | null;
282
282
  computed?: boolean;
@@ -287,10 +287,10 @@ export interface PropertyBuilder {
287
287
  method?: boolean;
288
288
  shorthand?: boolean;
289
289
  value: K.ExpressionKind | K.PatternKind;
290
- }): N.Property;
290
+ }): namedTypes.Property;
291
291
  }
292
292
  export interface LiteralBuilder {
293
- (value: string | boolean | null | number | RegExp): N.Literal;
293
+ (value: string | boolean | null | number | RegExp): namedTypes.Literal;
294
294
  from(params: {
295
295
  comments?: K.CommentKind[] | null;
296
296
  loc?: K.SourceLocationKind | null;
@@ -299,139 +299,141 @@ export interface LiteralBuilder {
299
299
  flags: string;
300
300
  } | null;
301
301
  value: string | boolean | null | number | RegExp;
302
- }): N.Literal;
302
+ }): namedTypes.Literal;
303
303
  }
304
304
  export interface SequenceExpressionBuilder {
305
- (expressions: K.ExpressionKind[]): N.SequenceExpression;
305
+ (expressions: K.ExpressionKind[]): namedTypes.SequenceExpression;
306
306
  from(params: {
307
307
  comments?: K.CommentKind[] | null;
308
308
  expressions: K.ExpressionKind[];
309
309
  loc?: K.SourceLocationKind | null;
310
- }): N.SequenceExpression;
310
+ }): namedTypes.SequenceExpression;
311
311
  }
312
312
  export interface UnaryExpressionBuilder {
313
- (operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete", argument: K.ExpressionKind, prefix?: boolean): N.UnaryExpression;
313
+ (operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete", argument: K.ExpressionKind, prefix?: boolean): namedTypes.UnaryExpression;
314
314
  from(params: {
315
315
  argument: K.ExpressionKind;
316
316
  comments?: K.CommentKind[] | null;
317
317
  loc?: K.SourceLocationKind | null;
318
318
  operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
319
319
  prefix?: boolean;
320
- }): N.UnaryExpression;
320
+ }): namedTypes.UnaryExpression;
321
321
  }
322
322
  export interface BinaryExpressionBuilder {
323
- (operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof", left: K.ExpressionKind, right: K.ExpressionKind): N.BinaryExpression;
323
+ (operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof", left: K.ExpressionKind, right: K.ExpressionKind): namedTypes.BinaryExpression;
324
324
  from(params: {
325
325
  comments?: K.CommentKind[] | null;
326
326
  left: K.ExpressionKind;
327
327
  loc?: K.SourceLocationKind | null;
328
328
  operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof";
329
329
  right: K.ExpressionKind;
330
- }): N.BinaryExpression;
330
+ }): namedTypes.BinaryExpression;
331
331
  }
332
332
  export interface AssignmentExpressionBuilder {
333
- (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=", left: K.PatternKind, right: K.ExpressionKind): N.AssignmentExpression;
333
+ (operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=", left: K.PatternKind | K.MemberExpressionKind, right: K.ExpressionKind): namedTypes.AssignmentExpression;
334
334
  from(params: {
335
335
  comments?: K.CommentKind[] | null;
336
- left: K.PatternKind;
336
+ left: K.PatternKind | K.MemberExpressionKind;
337
337
  loc?: K.SourceLocationKind | null;
338
338
  operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
339
339
  right: K.ExpressionKind;
340
- }): N.AssignmentExpression;
340
+ }): namedTypes.AssignmentExpression;
341
+ }
342
+ export interface MemberExpressionBuilder {
343
+ (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean): namedTypes.MemberExpression;
344
+ from(params: {
345
+ comments?: K.CommentKind[] | null;
346
+ computed?: boolean;
347
+ loc?: K.SourceLocationKind | null;
348
+ object: K.ExpressionKind;
349
+ property: K.IdentifierKind | K.ExpressionKind;
350
+ }): namedTypes.MemberExpression;
341
351
  }
342
352
  export interface UpdateExpressionBuilder {
343
- (operator: "++" | "--", argument: K.ExpressionKind, prefix: boolean): N.UpdateExpression;
353
+ (operator: "++" | "--", argument: K.ExpressionKind, prefix: boolean): namedTypes.UpdateExpression;
344
354
  from(params: {
345
355
  argument: K.ExpressionKind;
346
356
  comments?: K.CommentKind[] | null;
347
357
  loc?: K.SourceLocationKind | null;
348
358
  operator: "++" | "--";
349
359
  prefix: boolean;
350
- }): N.UpdateExpression;
360
+ }): namedTypes.UpdateExpression;
351
361
  }
352
362
  export interface LogicalExpressionBuilder {
353
- (operator: "||" | "&&" | "??", left: K.ExpressionKind, right: K.ExpressionKind): N.LogicalExpression;
363
+ (operator: "||" | "&&" | "??", left: K.ExpressionKind, right: K.ExpressionKind): namedTypes.LogicalExpression;
354
364
  from(params: {
355
365
  comments?: K.CommentKind[] | null;
356
366
  left: K.ExpressionKind;
357
367
  loc?: K.SourceLocationKind | null;
358
368
  operator: "||" | "&&" | "??";
359
369
  right: K.ExpressionKind;
360
- }): N.LogicalExpression;
370
+ }): namedTypes.LogicalExpression;
361
371
  }
362
372
  export interface ConditionalExpressionBuilder {
363
- (test: K.ExpressionKind, consequent: K.ExpressionKind, alternate: K.ExpressionKind): N.ConditionalExpression;
373
+ (test: K.ExpressionKind, consequent: K.ExpressionKind, alternate: K.ExpressionKind): namedTypes.ConditionalExpression;
364
374
  from(params: {
365
375
  alternate: K.ExpressionKind;
366
376
  comments?: K.CommentKind[] | null;
367
377
  consequent: K.ExpressionKind;
368
378
  loc?: K.SourceLocationKind | null;
369
379
  test: K.ExpressionKind;
370
- }): N.ConditionalExpression;
380
+ }): namedTypes.ConditionalExpression;
371
381
  }
372
382
  export interface NewExpressionBuilder {
373
- (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): N.NewExpression;
383
+ (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): namedTypes.NewExpression;
374
384
  from(params: {
375
385
  arguments: (K.ExpressionKind | K.SpreadElementKind)[];
376
386
  callee: K.ExpressionKind;
377
387
  comments?: K.CommentKind[] | null;
378
388
  loc?: K.SourceLocationKind | null;
379
- }): N.NewExpression;
389
+ typeArguments?: null | K.TypeParameterInstantiationKind;
390
+ }): namedTypes.NewExpression;
380
391
  }
381
392
  export interface CallExpressionBuilder {
382
- (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): N.CallExpression;
393
+ (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[]): namedTypes.CallExpression;
383
394
  from(params: {
384
395
  arguments: (K.ExpressionKind | K.SpreadElementKind)[];
385
396
  callee: K.ExpressionKind;
386
397
  comments?: K.CommentKind[] | null;
387
398
  loc?: K.SourceLocationKind | null;
388
- }): N.CallExpression;
389
- }
390
- export interface MemberExpressionBuilder {
391
- (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean): N.MemberExpression;
392
- from(params: {
393
- comments?: K.CommentKind[] | null;
394
- computed?: boolean;
395
- loc?: K.SourceLocationKind | null;
396
- object: K.ExpressionKind;
397
- property: K.IdentifierKind | K.ExpressionKind;
398
- }): N.MemberExpression;
399
+ typeArguments?: null | K.TypeParameterInstantiationKind;
400
+ }): namedTypes.CallExpression;
399
401
  }
400
402
  export interface RestElementBuilder {
401
- (argument: K.PatternKind): N.RestElement;
403
+ (argument: K.PatternKind): namedTypes.RestElement;
402
404
  from(params: {
403
405
  argument: K.PatternKind;
404
406
  comments?: K.CommentKind[] | null;
405
407
  loc?: K.SourceLocationKind | null;
406
408
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
407
- }): N.RestElement;
409
+ }): namedTypes.RestElement;
408
410
  }
409
411
  export interface TypeAnnotationBuilder {
410
- (typeAnnotation: K.FlowTypeKind): N.TypeAnnotation;
412
+ (typeAnnotation: K.FlowTypeKind): namedTypes.TypeAnnotation;
411
413
  from(params: {
412
414
  comments?: K.CommentKind[] | null;
413
415
  loc?: K.SourceLocationKind | null;
414
416
  typeAnnotation: K.FlowTypeKind;
415
- }): N.TypeAnnotation;
417
+ }): namedTypes.TypeAnnotation;
416
418
  }
417
419
  export interface TSTypeAnnotationBuilder {
418
- (typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind): N.TSTypeAnnotation;
420
+ (typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind): namedTypes.TSTypeAnnotation;
419
421
  from(params: {
420
422
  comments?: K.CommentKind[] | null;
421
423
  loc?: K.SourceLocationKind | null;
422
424
  typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind;
423
- }): N.TSTypeAnnotation;
425
+ }): namedTypes.TSTypeAnnotation;
424
426
  }
425
427
  export interface SpreadElementPatternBuilder {
426
- (argument: K.PatternKind): N.SpreadElementPattern;
428
+ (argument: K.PatternKind): namedTypes.SpreadElementPattern;
427
429
  from(params: {
428
430
  argument: K.PatternKind;
429
431
  comments?: K.CommentKind[] | null;
430
432
  loc?: K.SourceLocationKind | null;
431
- }): N.SpreadElementPattern;
433
+ }): namedTypes.SpreadElementPattern;
432
434
  }
433
435
  export interface ArrowFunctionExpressionBuilder {
434
- (params: K.PatternKind[], body: K.BlockStatementKind | K.ExpressionKind, expression?: boolean): N.ArrowFunctionExpression;
436
+ (params: K.PatternKind[], body: K.BlockStatementKind | K.ExpressionKind, expression?: boolean): namedTypes.ArrowFunctionExpression;
435
437
  from(params: {
436
438
  async?: boolean;
437
439
  body: K.BlockStatementKind | K.ExpressionKind;
@@ -445,59 +447,59 @@ export interface ArrowFunctionExpressionBuilder {
445
447
  rest?: K.IdentifierKind | null;
446
448
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
447
449
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
448
- }): N.ArrowFunctionExpression;
450
+ }): namedTypes.ArrowFunctionExpression;
449
451
  }
450
452
  export interface ForOfStatementBuilder {
451
- (left: K.VariableDeclarationKind | K.PatternKind, right: K.ExpressionKind, body: K.StatementKind): N.ForOfStatement;
453
+ (left: K.VariableDeclarationKind | K.PatternKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForOfStatement;
452
454
  from(params: {
453
455
  body: K.StatementKind;
454
456
  comments?: K.CommentKind[] | null;
455
457
  left: K.VariableDeclarationKind | K.PatternKind;
456
458
  loc?: K.SourceLocationKind | null;
457
459
  right: K.ExpressionKind;
458
- }): N.ForOfStatement;
460
+ }): namedTypes.ForOfStatement;
459
461
  }
460
462
  export interface YieldExpressionBuilder {
461
- (argument: K.ExpressionKind | null, delegate?: boolean): N.YieldExpression;
463
+ (argument: K.ExpressionKind | null, delegate?: boolean): namedTypes.YieldExpression;
462
464
  from(params: {
463
465
  argument: K.ExpressionKind | null;
464
466
  comments?: K.CommentKind[] | null;
465
467
  delegate?: boolean;
466
468
  loc?: K.SourceLocationKind | null;
467
- }): N.YieldExpression;
469
+ }): namedTypes.YieldExpression;
468
470
  }
469
471
  export interface GeneratorExpressionBuilder {
470
- (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): N.GeneratorExpression;
472
+ (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): namedTypes.GeneratorExpression;
471
473
  from(params: {
472
474
  blocks: K.ComprehensionBlockKind[];
473
475
  body: K.ExpressionKind;
474
476
  comments?: K.CommentKind[] | null;
475
477
  filter: K.ExpressionKind | null;
476
478
  loc?: K.SourceLocationKind | null;
477
- }): N.GeneratorExpression;
479
+ }): namedTypes.GeneratorExpression;
478
480
  }
479
481
  export interface ComprehensionBlockBuilder {
480
- (left: K.PatternKind, right: K.ExpressionKind, each: boolean): N.ComprehensionBlock;
482
+ (left: K.PatternKind, right: K.ExpressionKind, each: boolean): namedTypes.ComprehensionBlock;
481
483
  from(params: {
482
484
  comments?: K.CommentKind[] | null;
483
485
  each: boolean;
484
486
  left: K.PatternKind;
485
487
  loc?: K.SourceLocationKind | null;
486
488
  right: K.ExpressionKind;
487
- }): N.ComprehensionBlock;
489
+ }): namedTypes.ComprehensionBlock;
488
490
  }
489
491
  export interface ComprehensionExpressionBuilder {
490
- (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): N.ComprehensionExpression;
492
+ (body: K.ExpressionKind, blocks: K.ComprehensionBlockKind[], filter: K.ExpressionKind | null): namedTypes.ComprehensionExpression;
491
493
  from(params: {
492
494
  blocks: K.ComprehensionBlockKind[];
493
495
  body: K.ExpressionKind;
494
496
  comments?: K.CommentKind[] | null;
495
497
  filter: K.ExpressionKind | null;
496
498
  loc?: K.SourceLocationKind | null;
497
- }): N.ComprehensionExpression;
499
+ }): namedTypes.ComprehensionExpression;
498
500
  }
499
501
  export interface ObjectPropertyBuilder {
500
- (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): N.ObjectProperty;
502
+ (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | K.PatternKind): namedTypes.ObjectProperty;
501
503
  from(params: {
502
504
  accessibility?: K.LiteralKind | null;
503
505
  comments?: K.CommentKind[] | null;
@@ -506,38 +508,38 @@ export interface ObjectPropertyBuilder {
506
508
  loc?: K.SourceLocationKind | null;
507
509
  shorthand?: boolean;
508
510
  value: K.ExpressionKind | K.PatternKind;
509
- }): N.ObjectProperty;
511
+ }): namedTypes.ObjectProperty;
510
512
  }
511
513
  export interface PropertyPatternBuilder {
512
- (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, pattern: K.PatternKind): N.PropertyPattern;
514
+ (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, pattern: K.PatternKind): namedTypes.PropertyPattern;
513
515
  from(params: {
514
516
  comments?: K.CommentKind[] | null;
515
517
  computed?: boolean;
516
518
  key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;
517
519
  loc?: K.SourceLocationKind | null;
518
520
  pattern: K.PatternKind;
519
- }): N.PropertyPattern;
521
+ }): namedTypes.PropertyPattern;
520
522
  }
521
523
  export interface ObjectPatternBuilder {
522
- (properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[]): N.ObjectPattern;
524
+ (properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[]): namedTypes.ObjectPattern;
523
525
  from(params: {
524
526
  comments?: K.CommentKind[] | null;
525
527
  decorators?: K.DecoratorKind[] | null;
526
528
  loc?: K.SourceLocationKind | null;
527
529
  properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[];
528
530
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
529
- }): N.ObjectPattern;
531
+ }): namedTypes.ObjectPattern;
530
532
  }
531
533
  export interface ArrayPatternBuilder {
532
- (elements: (K.PatternKind | K.SpreadElementKind | null)[]): N.ArrayPattern;
534
+ (elements: (K.PatternKind | K.SpreadElementKind | null)[]): namedTypes.ArrayPattern;
533
535
  from(params: {
534
536
  comments?: K.CommentKind[] | null;
535
537
  elements: (K.PatternKind | K.SpreadElementKind | null)[];
536
538
  loc?: K.SourceLocationKind | null;
537
- }): N.ArrayPattern;
539
+ }): namedTypes.ArrayPattern;
538
540
  }
539
541
  export interface MethodDefinitionBuilder {
540
- (kind: "constructor" | "method" | "get" | "set", key: K.ExpressionKind, value: K.FunctionKind, staticParam?: boolean): N.MethodDefinition;
542
+ (kind: "constructor" | "method" | "get" | "set", key: K.ExpressionKind, value: K.FunctionKind, staticParam?: boolean): namedTypes.MethodDefinition;
541
543
  from(params: {
542
544
  comments?: K.CommentKind[] | null;
543
545
  computed?: boolean;
@@ -547,35 +549,35 @@ export interface MethodDefinitionBuilder {
547
549
  loc?: K.SourceLocationKind | null;
548
550
  static?: boolean;
549
551
  value: K.FunctionKind;
550
- }): N.MethodDefinition;
552
+ }): namedTypes.MethodDefinition;
551
553
  }
552
554
  export interface SpreadElementBuilder {
553
- (argument: K.ExpressionKind): N.SpreadElement;
555
+ (argument: K.ExpressionKind): namedTypes.SpreadElement;
554
556
  from(params: {
555
557
  argument: K.ExpressionKind;
556
558
  comments?: K.CommentKind[] | null;
557
559
  loc?: K.SourceLocationKind | null;
558
- }): N.SpreadElement;
560
+ }): namedTypes.SpreadElement;
559
561
  }
560
562
  export interface AssignmentPatternBuilder {
561
- (left: K.PatternKind, right: K.ExpressionKind): N.AssignmentPattern;
563
+ (left: K.PatternKind, right: K.ExpressionKind): namedTypes.AssignmentPattern;
562
564
  from(params: {
563
565
  comments?: K.CommentKind[] | null;
564
566
  left: K.PatternKind;
565
567
  loc?: K.SourceLocationKind | null;
566
568
  right: K.ExpressionKind;
567
- }): N.AssignmentPattern;
569
+ }): namedTypes.AssignmentPattern;
568
570
  }
569
571
  export interface ClassPropertyDefinitionBuilder {
570
- (definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind): N.ClassPropertyDefinition;
572
+ (definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind): namedTypes.ClassPropertyDefinition;
571
573
  from(params: {
572
574
  comments?: K.CommentKind[] | null;
573
575
  definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind;
574
576
  loc?: K.SourceLocationKind | null;
575
- }): N.ClassPropertyDefinition;
577
+ }): namedTypes.ClassPropertyDefinition;
576
578
  }
577
579
  export interface ClassPropertyBuilder {
578
- (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | null, typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null, staticParam?: boolean): N.ClassProperty;
580
+ (key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, value: K.ExpressionKind | null, typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null, staticParam?: boolean): namedTypes.ClassProperty;
579
581
  from(params: {
580
582
  access?: "public" | "private" | "protected" | undefined;
581
583
  comments?: K.CommentKind[] | null;
@@ -586,18 +588,18 @@ export interface ClassPropertyBuilder {
586
588
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
587
589
  value: K.ExpressionKind | null;
588
590
  variance?: K.VarianceKind | "plus" | "minus" | null;
589
- }): N.ClassProperty;
591
+ }): namedTypes.ClassProperty;
590
592
  }
591
593
  export interface ClassBodyBuilder {
592
- (body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.ClassBody;
594
+ (body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.ClassBody;
593
595
  from(params: {
594
596
  body: (K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind | K.ClassPrivatePropertyKind | K.ClassMethodKind | K.ClassPrivateMethodKind | K.TSDeclareMethodKind | K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
595
597
  comments?: K.CommentKind[] | null;
596
598
  loc?: K.SourceLocationKind | null;
597
- }): N.ClassBody;
599
+ }): namedTypes.ClassBody;
598
600
  }
599
601
  export interface ClassDeclarationBuilder {
600
- (id: K.IdentifierKind | null, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): N.ClassDeclaration;
602
+ (id: K.IdentifierKind | null, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassDeclaration;
601
603
  from(params: {
602
604
  body: K.ClassBodyKind;
603
605
  comments?: K.CommentKind[] | null;
@@ -607,10 +609,10 @@ export interface ClassDeclarationBuilder {
607
609
  superClass?: K.ExpressionKind | null;
608
610
  superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
609
611
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
610
- }): N.ClassDeclaration;
612
+ }): namedTypes.ClassDeclaration;
611
613
  }
612
614
  export interface ClassExpressionBuilder {
613
- (id: K.IdentifierKind | null | undefined, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): N.ClassExpression;
615
+ (id: K.IdentifierKind | null | undefined, body: K.ClassBodyKind, superClass?: K.ExpressionKind | null): namedTypes.ClassExpression;
614
616
  from(params: {
615
617
  body: K.ClassBodyKind;
616
618
  comments?: K.CommentKind[] | null;
@@ -620,10 +622,10 @@ export interface ClassExpressionBuilder {
620
622
  superClass?: K.ExpressionKind | null;
621
623
  superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null;
622
624
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
623
- }): N.ClassExpression;
625
+ }): namedTypes.ClassExpression;
624
626
  }
625
627
  export interface ImportSpecifierBuilder {
626
- (imported: K.IdentifierKind, local?: K.IdentifierKind | null): N.ImportSpecifier;
628
+ (imported: K.IdentifierKind, local?: K.IdentifierKind | null): namedTypes.ImportSpecifier;
627
629
  from(params: {
628
630
  comments?: K.CommentKind[] | null;
629
631
  id?: K.IdentifierKind | null;
@@ -631,61 +633,61 @@ export interface ImportSpecifierBuilder {
631
633
  loc?: K.SourceLocationKind | null;
632
634
  local?: K.IdentifierKind | null;
633
635
  name?: K.IdentifierKind | null;
634
- }): N.ImportSpecifier;
636
+ }): namedTypes.ImportSpecifier;
635
637
  }
636
638
  export interface ImportNamespaceSpecifierBuilder {
637
- (local?: K.IdentifierKind | null): N.ImportNamespaceSpecifier;
639
+ (local?: K.IdentifierKind | null): namedTypes.ImportNamespaceSpecifier;
638
640
  from(params: {
639
641
  comments?: K.CommentKind[] | null;
640
642
  id?: K.IdentifierKind | null;
641
643
  loc?: K.SourceLocationKind | null;
642
644
  local?: K.IdentifierKind | null;
643
645
  name?: K.IdentifierKind | null;
644
- }): N.ImportNamespaceSpecifier;
646
+ }): namedTypes.ImportNamespaceSpecifier;
645
647
  }
646
648
  export interface ImportDefaultSpecifierBuilder {
647
- (local?: K.IdentifierKind | null): N.ImportDefaultSpecifier;
649
+ (local?: K.IdentifierKind | null): namedTypes.ImportDefaultSpecifier;
648
650
  from(params: {
649
651
  comments?: K.CommentKind[] | null;
650
652
  id?: K.IdentifierKind | null;
651
653
  loc?: K.SourceLocationKind | null;
652
654
  local?: K.IdentifierKind | null;
653
655
  name?: K.IdentifierKind | null;
654
- }): N.ImportDefaultSpecifier;
656
+ }): namedTypes.ImportDefaultSpecifier;
655
657
  }
656
658
  export interface ImportDeclarationBuilder {
657
- (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type"): N.ImportDeclaration;
659
+ (specifiers: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[] | undefined, source: K.LiteralKind, importKind?: "value" | "type"): namedTypes.ImportDeclaration;
658
660
  from(params: {
659
661
  comments?: K.CommentKind[] | null;
660
662
  importKind?: "value" | "type";
661
663
  loc?: K.SourceLocationKind | null;
662
664
  source: K.LiteralKind;
663
665
  specifiers?: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[];
664
- }): N.ImportDeclaration;
666
+ }): namedTypes.ImportDeclaration;
665
667
  }
666
668
  export interface TaggedTemplateExpressionBuilder {
667
- (tag: K.ExpressionKind, quasi: K.TemplateLiteralKind): N.TaggedTemplateExpression;
669
+ (tag: K.ExpressionKind, quasi: K.TemplateLiteralKind): namedTypes.TaggedTemplateExpression;
668
670
  from(params: {
669
671
  comments?: K.CommentKind[] | null;
670
672
  loc?: K.SourceLocationKind | null;
671
673
  quasi: K.TemplateLiteralKind;
672
674
  tag: K.ExpressionKind;
673
- }): N.TaggedTemplateExpression;
675
+ }): namedTypes.TaggedTemplateExpression;
674
676
  }
675
677
  export interface TemplateLiteralBuilder {
676
- (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[]): N.TemplateLiteral;
678
+ (quasis: K.TemplateElementKind[], expressions: K.ExpressionKind[]): namedTypes.TemplateLiteral;
677
679
  from(params: {
678
680
  comments?: K.CommentKind[] | null;
679
681
  expressions: K.ExpressionKind[];
680
682
  loc?: K.SourceLocationKind | null;
681
683
  quasis: K.TemplateElementKind[];
682
- }): N.TemplateLiteral;
684
+ }): namedTypes.TemplateLiteral;
683
685
  }
684
686
  export interface TemplateElementBuilder {
685
687
  (value: {
686
688
  cooked: string;
687
689
  raw: string;
688
- }, tail: boolean): N.TemplateElement;
690
+ }, tail: boolean): namedTypes.TemplateElement;
689
691
  from(params: {
690
692
  comments?: K.CommentKind[] | null;
691
693
  loc?: K.SourceLocationKind | null;
@@ -694,89 +696,97 @@ export interface TemplateElementBuilder {
694
696
  cooked: string;
695
697
  raw: string;
696
698
  };
697
- }): N.TemplateElement;
699
+ }): namedTypes.TemplateElement;
698
700
  }
699
701
  export interface SpreadPropertyBuilder {
700
- (argument: K.ExpressionKind): N.SpreadProperty;
702
+ (argument: K.ExpressionKind): namedTypes.SpreadProperty;
701
703
  from(params: {
702
704
  argument: K.ExpressionKind;
703
705
  comments?: K.CommentKind[] | null;
704
706
  loc?: K.SourceLocationKind | null;
705
- }): N.SpreadProperty;
707
+ }): namedTypes.SpreadProperty;
706
708
  }
707
709
  export interface SpreadPropertyPatternBuilder {
708
- (argument: K.PatternKind): N.SpreadPropertyPattern;
710
+ (argument: K.PatternKind): namedTypes.SpreadPropertyPattern;
709
711
  from(params: {
710
712
  argument: K.PatternKind;
711
713
  comments?: K.CommentKind[] | null;
712
714
  loc?: K.SourceLocationKind | null;
713
- }): N.SpreadPropertyPattern;
715
+ }): namedTypes.SpreadPropertyPattern;
714
716
  }
715
717
  export interface AwaitExpressionBuilder {
716
- (argument: K.ExpressionKind | null, all?: boolean): N.AwaitExpression;
718
+ (argument: K.ExpressionKind | null, all?: boolean): namedTypes.AwaitExpression;
717
719
  from(params: {
718
720
  all?: boolean;
719
721
  argument: K.ExpressionKind | null;
720
722
  comments?: K.CommentKind[] | null;
721
723
  loc?: K.SourceLocationKind | null;
722
- }): N.AwaitExpression;
724
+ }): namedTypes.AwaitExpression;
725
+ }
726
+ export interface ImportExpressionBuilder {
727
+ (source: K.ExpressionKind): namedTypes.ImportExpression;
728
+ from(params: {
729
+ comments?: K.CommentKind[] | null;
730
+ loc?: K.SourceLocationKind | null;
731
+ source: K.ExpressionKind;
732
+ }): namedTypes.ImportExpression;
723
733
  }
724
734
  export interface JSXAttributeBuilder {
725
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): N.JSXAttribute;
735
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): namedTypes.JSXAttribute;
726
736
  from(params: {
727
737
  comments?: K.CommentKind[] | null;
728
738
  loc?: K.SourceLocationKind | null;
729
739
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;
730
740
  value?: K.LiteralKind | K.JSXExpressionContainerKind | null;
731
- }): N.JSXAttribute;
741
+ }): namedTypes.JSXAttribute;
732
742
  }
733
743
  export interface JSXIdentifierBuilder {
734
- (name: string): N.JSXIdentifier;
744
+ (name: string): namedTypes.JSXIdentifier;
735
745
  from(params: {
736
746
  comments?: K.CommentKind[] | null;
737
747
  loc?: K.SourceLocationKind | null;
738
748
  name: string;
739
749
  optional?: boolean;
740
750
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
741
- }): N.JSXIdentifier;
751
+ }): namedTypes.JSXIdentifier;
742
752
  }
743
753
  export interface JSXNamespacedNameBuilder {
744
- (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): N.JSXNamespacedName;
754
+ (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): namedTypes.JSXNamespacedName;
745
755
  from(params: {
746
756
  comments?: K.CommentKind[] | null;
747
757
  loc?: K.SourceLocationKind | null;
748
758
  name: K.JSXIdentifierKind;
749
759
  namespace: K.JSXIdentifierKind;
750
- }): N.JSXNamespacedName;
760
+ }): namedTypes.JSXNamespacedName;
751
761
  }
752
762
  export interface JSXExpressionContainerBuilder {
753
- (expression: K.ExpressionKind): N.JSXExpressionContainer;
763
+ (expression: K.ExpressionKind): namedTypes.JSXExpressionContainer;
754
764
  from(params: {
755
765
  comments?: K.CommentKind[] | null;
756
766
  expression: K.ExpressionKind;
757
767
  loc?: K.SourceLocationKind | null;
758
- }): N.JSXExpressionContainer;
768
+ }): namedTypes.JSXExpressionContainer;
759
769
  }
760
770
  export interface JSXMemberExpressionBuilder {
761
- (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): N.JSXMemberExpression;
771
+ (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): namedTypes.JSXMemberExpression;
762
772
  from(params: {
763
773
  comments?: K.CommentKind[] | null;
764
774
  computed?: boolean;
765
775
  loc?: K.SourceLocationKind | null;
766
776
  object: K.JSXIdentifierKind | K.JSXMemberExpressionKind;
767
777
  property: K.JSXIdentifierKind;
768
- }): N.JSXMemberExpression;
778
+ }): namedTypes.JSXMemberExpression;
769
779
  }
770
780
  export interface JSXSpreadAttributeBuilder {
771
- (argument: K.ExpressionKind): N.JSXSpreadAttribute;
781
+ (argument: K.ExpressionKind): namedTypes.JSXSpreadAttribute;
772
782
  from(params: {
773
783
  argument: K.ExpressionKind;
774
784
  comments?: K.CommentKind[] | null;
775
785
  loc?: K.SourceLocationKind | null;
776
- }): N.JSXSpreadAttribute;
786
+ }): namedTypes.JSXSpreadAttribute;
777
787
  }
778
788
  export interface JSXElementBuilder {
779
- (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXElement;
789
+ (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXElement;
780
790
  from(params: {
781
791
  attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
782
792
  children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
@@ -786,38 +796,38 @@ export interface JSXElementBuilder {
786
796
  name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
787
797
  openingElement: K.JSXOpeningElementKind;
788
798
  selfClosing?: boolean;
789
- }): N.JSXElement;
799
+ }): namedTypes.JSXElement;
790
800
  }
791
801
  export interface JSXOpeningElementBuilder {
792
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): N.JSXOpeningElement;
802
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): namedTypes.JSXOpeningElement;
793
803
  from(params: {
794
804
  attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
795
805
  comments?: K.CommentKind[] | null;
796
806
  loc?: K.SourceLocationKind | null;
797
807
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
798
808
  selfClosing?: boolean;
799
- }): N.JSXOpeningElement;
809
+ }): namedTypes.JSXOpeningElement;
800
810
  }
801
811
  export interface JSXClosingElementBuilder {
802
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): N.JSXClosingElement;
812
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): namedTypes.JSXClosingElement;
803
813
  from(params: {
804
814
  comments?: K.CommentKind[] | null;
805
815
  loc?: K.SourceLocationKind | null;
806
816
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
807
- }): N.JSXClosingElement;
817
+ }): namedTypes.JSXClosingElement;
808
818
  }
809
819
  export interface JSXFragmentBuilder {
810
- (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXFragment;
820
+ (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXFragment;
811
821
  from(params: {
812
822
  children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
813
823
  closingElement: K.JSXClosingFragmentKind;
814
824
  comments?: K.CommentKind[] | null;
815
825
  loc?: K.SourceLocationKind | null;
816
826
  openingElement: K.JSXOpeningFragmentKind;
817
- }): N.JSXFragment;
827
+ }): namedTypes.JSXFragment;
818
828
  }
819
829
  export interface JSXTextBuilder {
820
- (value: string): N.JSXText;
830
+ (value: string): namedTypes.JSXText;
821
831
  from(params: {
822
832
  comments?: K.CommentKind[] | null;
823
833
  loc?: K.SourceLocationKind | null;
@@ -826,218 +836,218 @@ export interface JSXTextBuilder {
826
836
  flags: string;
827
837
  } | null;
828
838
  value: string;
829
- }): N.JSXText;
839
+ }): namedTypes.JSXText;
830
840
  }
831
841
  export interface JSXOpeningFragmentBuilder {
832
- (): N.JSXOpeningFragment;
842
+ (): namedTypes.JSXOpeningFragment;
833
843
  from(params: {
834
844
  comments?: K.CommentKind[] | null;
835
845
  loc?: K.SourceLocationKind | null;
836
- }): N.JSXOpeningFragment;
846
+ }): namedTypes.JSXOpeningFragment;
837
847
  }
838
848
  export interface JSXClosingFragmentBuilder {
839
- (): N.JSXClosingFragment;
849
+ (): namedTypes.JSXClosingFragment;
840
850
  from(params: {
841
851
  comments?: K.CommentKind[] | null;
842
852
  loc?: K.SourceLocationKind | null;
843
- }): N.JSXClosingFragment;
853
+ }): namedTypes.JSXClosingFragment;
844
854
  }
845
855
  export interface JSXEmptyExpressionBuilder {
846
- (): N.JSXEmptyExpression;
856
+ (): namedTypes.JSXEmptyExpression;
847
857
  from(params: {
848
858
  comments?: K.CommentKind[] | null;
849
859
  loc?: K.SourceLocationKind | null;
850
- }): N.JSXEmptyExpression;
860
+ }): namedTypes.JSXEmptyExpression;
851
861
  }
852
862
  export interface JSXSpreadChildBuilder {
853
- (expression: K.ExpressionKind): N.JSXSpreadChild;
863
+ (expression: K.ExpressionKind): namedTypes.JSXSpreadChild;
854
864
  from(params: {
855
865
  comments?: K.CommentKind[] | null;
856
866
  expression: K.ExpressionKind;
857
867
  loc?: K.SourceLocationKind | null;
858
- }): N.JSXSpreadChild;
868
+ }): namedTypes.JSXSpreadChild;
859
869
  }
860
870
  export interface TypeParameterDeclarationBuilder {
861
- (params: K.TypeParameterKind[]): N.TypeParameterDeclaration;
871
+ (params: K.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
862
872
  from(params: {
863
873
  comments?: K.CommentKind[] | null;
864
874
  loc?: K.SourceLocationKind | null;
865
875
  params: K.TypeParameterKind[];
866
- }): N.TypeParameterDeclaration;
876
+ }): namedTypes.TypeParameterDeclaration;
867
877
  }
868
878
  export interface TSTypeParameterDeclarationBuilder {
869
- (params: K.TSTypeParameterKind[]): N.TSTypeParameterDeclaration;
879
+ (params: K.TSTypeParameterKind[]): namedTypes.TSTypeParameterDeclaration;
870
880
  from(params: {
871
881
  comments?: K.CommentKind[] | null;
872
882
  loc?: K.SourceLocationKind | null;
873
883
  params: K.TSTypeParameterKind[];
874
- }): N.TSTypeParameterDeclaration;
884
+ }): namedTypes.TSTypeParameterDeclaration;
875
885
  }
876
886
  export interface TypeParameterInstantiationBuilder {
877
- (params: K.FlowTypeKind[]): N.TypeParameterInstantiation;
887
+ (params: K.FlowTypeKind[]): namedTypes.TypeParameterInstantiation;
878
888
  from(params: {
879
889
  comments?: K.CommentKind[] | null;
880
890
  loc?: K.SourceLocationKind | null;
881
891
  params: K.FlowTypeKind[];
882
- }): N.TypeParameterInstantiation;
892
+ }): namedTypes.TypeParameterInstantiation;
883
893
  }
884
894
  export interface TSTypeParameterInstantiationBuilder {
885
- (params: K.TSTypeKind[]): N.TSTypeParameterInstantiation;
895
+ (params: K.TSTypeKind[]): namedTypes.TSTypeParameterInstantiation;
886
896
  from(params: {
887
897
  comments?: K.CommentKind[] | null;
888
898
  loc?: K.SourceLocationKind | null;
889
899
  params: K.TSTypeKind[];
890
- }): N.TSTypeParameterInstantiation;
900
+ }): namedTypes.TSTypeParameterInstantiation;
891
901
  }
892
902
  export interface ClassImplementsBuilder {
893
- (id: K.IdentifierKind): N.ClassImplements;
903
+ (id: K.IdentifierKind): namedTypes.ClassImplements;
894
904
  from(params: {
895
905
  comments?: K.CommentKind[] | null;
896
906
  id: K.IdentifierKind;
897
907
  loc?: K.SourceLocationKind | null;
898
908
  superClass?: K.ExpressionKind | null;
899
909
  typeParameters?: K.TypeParameterInstantiationKind | null;
900
- }): N.ClassImplements;
910
+ }): namedTypes.ClassImplements;
901
911
  }
902
912
  export interface TSExpressionWithTypeArgumentsBuilder {
903
- (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSExpressionWithTypeArguments;
913
+ (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSExpressionWithTypeArguments;
904
914
  from(params: {
905
915
  comments?: K.CommentKind[] | null;
906
916
  expression: K.IdentifierKind | K.TSQualifiedNameKind;
907
917
  loc?: K.SourceLocationKind | null;
908
918
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
909
- }): N.TSExpressionWithTypeArguments;
919
+ }): namedTypes.TSExpressionWithTypeArguments;
910
920
  }
911
921
  export interface AnyTypeAnnotationBuilder {
912
- (): N.AnyTypeAnnotation;
922
+ (): namedTypes.AnyTypeAnnotation;
913
923
  from(params: {
914
924
  comments?: K.CommentKind[] | null;
915
925
  loc?: K.SourceLocationKind | null;
916
- }): N.AnyTypeAnnotation;
926
+ }): namedTypes.AnyTypeAnnotation;
917
927
  }
918
928
  export interface EmptyTypeAnnotationBuilder {
919
- (): N.EmptyTypeAnnotation;
929
+ (): namedTypes.EmptyTypeAnnotation;
920
930
  from(params: {
921
931
  comments?: K.CommentKind[] | null;
922
932
  loc?: K.SourceLocationKind | null;
923
- }): N.EmptyTypeAnnotation;
933
+ }): namedTypes.EmptyTypeAnnotation;
924
934
  }
925
935
  export interface MixedTypeAnnotationBuilder {
926
- (): N.MixedTypeAnnotation;
936
+ (): namedTypes.MixedTypeAnnotation;
927
937
  from(params: {
928
938
  comments?: K.CommentKind[] | null;
929
939
  loc?: K.SourceLocationKind | null;
930
- }): N.MixedTypeAnnotation;
940
+ }): namedTypes.MixedTypeAnnotation;
931
941
  }
932
942
  export interface VoidTypeAnnotationBuilder {
933
- (): N.VoidTypeAnnotation;
943
+ (): namedTypes.VoidTypeAnnotation;
934
944
  from(params: {
935
945
  comments?: K.CommentKind[] | null;
936
946
  loc?: K.SourceLocationKind | null;
937
- }): N.VoidTypeAnnotation;
947
+ }): namedTypes.VoidTypeAnnotation;
938
948
  }
939
949
  export interface NumberTypeAnnotationBuilder {
940
- (): N.NumberTypeAnnotation;
950
+ (): namedTypes.NumberTypeAnnotation;
941
951
  from(params: {
942
952
  comments?: K.CommentKind[] | null;
943
953
  loc?: K.SourceLocationKind | null;
944
- }): N.NumberTypeAnnotation;
954
+ }): namedTypes.NumberTypeAnnotation;
945
955
  }
946
956
  export interface NumberLiteralTypeAnnotationBuilder {
947
- (value: number, raw: string): N.NumberLiteralTypeAnnotation;
957
+ (value: number, raw: string): namedTypes.NumberLiteralTypeAnnotation;
948
958
  from(params: {
949
959
  comments?: K.CommentKind[] | null;
950
960
  loc?: K.SourceLocationKind | null;
951
961
  raw: string;
952
962
  value: number;
953
- }): N.NumberLiteralTypeAnnotation;
963
+ }): namedTypes.NumberLiteralTypeAnnotation;
954
964
  }
955
965
  export interface NumericLiteralTypeAnnotationBuilder {
956
- (value: number, raw: string): N.NumericLiteralTypeAnnotation;
966
+ (value: number, raw: string): namedTypes.NumericLiteralTypeAnnotation;
957
967
  from(params: {
958
968
  comments?: K.CommentKind[] | null;
959
969
  loc?: K.SourceLocationKind | null;
960
970
  raw: string;
961
971
  value: number;
962
- }): N.NumericLiteralTypeAnnotation;
972
+ }): namedTypes.NumericLiteralTypeAnnotation;
963
973
  }
964
974
  export interface StringTypeAnnotationBuilder {
965
- (): N.StringTypeAnnotation;
975
+ (): namedTypes.StringTypeAnnotation;
966
976
  from(params: {
967
977
  comments?: K.CommentKind[] | null;
968
978
  loc?: K.SourceLocationKind | null;
969
- }): N.StringTypeAnnotation;
979
+ }): namedTypes.StringTypeAnnotation;
970
980
  }
971
981
  export interface StringLiteralTypeAnnotationBuilder {
972
- (value: string, raw: string): N.StringLiteralTypeAnnotation;
982
+ (value: string, raw: string): namedTypes.StringLiteralTypeAnnotation;
973
983
  from(params: {
974
984
  comments?: K.CommentKind[] | null;
975
985
  loc?: K.SourceLocationKind | null;
976
986
  raw: string;
977
987
  value: string;
978
- }): N.StringLiteralTypeAnnotation;
988
+ }): namedTypes.StringLiteralTypeAnnotation;
979
989
  }
980
990
  export interface BooleanTypeAnnotationBuilder {
981
- (): N.BooleanTypeAnnotation;
991
+ (): namedTypes.BooleanTypeAnnotation;
982
992
  from(params: {
983
993
  comments?: K.CommentKind[] | null;
984
994
  loc?: K.SourceLocationKind | null;
985
- }): N.BooleanTypeAnnotation;
995
+ }): namedTypes.BooleanTypeAnnotation;
986
996
  }
987
997
  export interface BooleanLiteralTypeAnnotationBuilder {
988
- (value: boolean, raw: string): N.BooleanLiteralTypeAnnotation;
998
+ (value: boolean, raw: string): namedTypes.BooleanLiteralTypeAnnotation;
989
999
  from(params: {
990
1000
  comments?: K.CommentKind[] | null;
991
1001
  loc?: K.SourceLocationKind | null;
992
1002
  raw: string;
993
1003
  value: boolean;
994
- }): N.BooleanLiteralTypeAnnotation;
1004
+ }): namedTypes.BooleanLiteralTypeAnnotation;
995
1005
  }
996
1006
  export interface NullableTypeAnnotationBuilder {
997
- (typeAnnotation: K.FlowTypeKind): N.NullableTypeAnnotation;
1007
+ (typeAnnotation: K.FlowTypeKind): namedTypes.NullableTypeAnnotation;
998
1008
  from(params: {
999
1009
  comments?: K.CommentKind[] | null;
1000
1010
  loc?: K.SourceLocationKind | null;
1001
1011
  typeAnnotation: K.FlowTypeKind;
1002
- }): N.NullableTypeAnnotation;
1012
+ }): namedTypes.NullableTypeAnnotation;
1003
1013
  }
1004
1014
  export interface NullLiteralTypeAnnotationBuilder {
1005
- (): N.NullLiteralTypeAnnotation;
1015
+ (): namedTypes.NullLiteralTypeAnnotation;
1006
1016
  from(params: {
1007
1017
  comments?: K.CommentKind[] | null;
1008
1018
  loc?: K.SourceLocationKind | null;
1009
- }): N.NullLiteralTypeAnnotation;
1019
+ }): namedTypes.NullLiteralTypeAnnotation;
1010
1020
  }
1011
1021
  export interface NullTypeAnnotationBuilder {
1012
- (): N.NullTypeAnnotation;
1022
+ (): namedTypes.NullTypeAnnotation;
1013
1023
  from(params: {
1014
1024
  comments?: K.CommentKind[] | null;
1015
1025
  loc?: K.SourceLocationKind | null;
1016
- }): N.NullTypeAnnotation;
1026
+ }): namedTypes.NullTypeAnnotation;
1017
1027
  }
1018
1028
  export interface ThisTypeAnnotationBuilder {
1019
- (): N.ThisTypeAnnotation;
1029
+ (): namedTypes.ThisTypeAnnotation;
1020
1030
  from(params: {
1021
1031
  comments?: K.CommentKind[] | null;
1022
1032
  loc?: K.SourceLocationKind | null;
1023
- }): N.ThisTypeAnnotation;
1033
+ }): namedTypes.ThisTypeAnnotation;
1024
1034
  }
1025
1035
  export interface ExistsTypeAnnotationBuilder {
1026
- (): N.ExistsTypeAnnotation;
1036
+ (): namedTypes.ExistsTypeAnnotation;
1027
1037
  from(params: {
1028
1038
  comments?: K.CommentKind[] | null;
1029
1039
  loc?: K.SourceLocationKind | null;
1030
- }): N.ExistsTypeAnnotation;
1040
+ }): namedTypes.ExistsTypeAnnotation;
1031
1041
  }
1032
1042
  export interface ExistentialTypeParamBuilder {
1033
- (): N.ExistentialTypeParam;
1043
+ (): namedTypes.ExistentialTypeParam;
1034
1044
  from(params: {
1035
1045
  comments?: K.CommentKind[] | null;
1036
1046
  loc?: K.SourceLocationKind | null;
1037
- }): N.ExistentialTypeParam;
1047
+ }): namedTypes.ExistentialTypeParam;
1038
1048
  }
1039
1049
  export interface FunctionTypeAnnotationBuilder {
1040
- (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): N.FunctionTypeAnnotation;
1050
+ (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.FunctionTypeAnnotation;
1041
1051
  from(params: {
1042
1052
  comments?: K.CommentKind[] | null;
1043
1053
  loc?: K.SourceLocationKind | null;
@@ -1045,28 +1055,28 @@ export interface FunctionTypeAnnotationBuilder {
1045
1055
  rest: K.FunctionTypeParamKind | null;
1046
1056
  returnType: K.FlowTypeKind;
1047
1057
  typeParameters: K.TypeParameterDeclarationKind | null;
1048
- }): N.FunctionTypeAnnotation;
1058
+ }): namedTypes.FunctionTypeAnnotation;
1049
1059
  }
1050
1060
  export interface FunctionTypeParamBuilder {
1051
- (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): N.FunctionTypeParam;
1061
+ (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): namedTypes.FunctionTypeParam;
1052
1062
  from(params: {
1053
1063
  comments?: K.CommentKind[] | null;
1054
1064
  loc?: K.SourceLocationKind | null;
1055
1065
  name: K.IdentifierKind;
1056
1066
  optional: boolean;
1057
1067
  typeAnnotation: K.FlowTypeKind;
1058
- }): N.FunctionTypeParam;
1068
+ }): namedTypes.FunctionTypeParam;
1059
1069
  }
1060
1070
  export interface ArrayTypeAnnotationBuilder {
1061
- (elementType: K.FlowTypeKind): N.ArrayTypeAnnotation;
1071
+ (elementType: K.FlowTypeKind): namedTypes.ArrayTypeAnnotation;
1062
1072
  from(params: {
1063
1073
  comments?: K.CommentKind[] | null;
1064
1074
  elementType: K.FlowTypeKind;
1065
1075
  loc?: K.SourceLocationKind | null;
1066
- }): N.ArrayTypeAnnotation;
1076
+ }): namedTypes.ArrayTypeAnnotation;
1067
1077
  }
1068
1078
  export interface ObjectTypeAnnotationBuilder {
1069
- (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): N.ObjectTypeAnnotation;
1079
+ (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): namedTypes.ObjectTypeAnnotation;
1070
1080
  from(params: {
1071
1081
  callProperties?: K.ObjectTypeCallPropertyKind[];
1072
1082
  comments?: K.CommentKind[] | null;
@@ -1076,10 +1086,10 @@ export interface ObjectTypeAnnotationBuilder {
1076
1086
  internalSlots?: K.ObjectTypeInternalSlotKind[];
1077
1087
  loc?: K.SourceLocationKind | null;
1078
1088
  properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[];
1079
- }): N.ObjectTypeAnnotation;
1089
+ }): namedTypes.ObjectTypeAnnotation;
1080
1090
  }
1081
1091
  export interface ObjectTypePropertyBuilder {
1082
- (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): N.ObjectTypeProperty;
1092
+ (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): namedTypes.ObjectTypeProperty;
1083
1093
  from(params: {
1084
1094
  comments?: K.CommentKind[] | null;
1085
1095
  key: K.LiteralKind | K.IdentifierKind;
@@ -1087,18 +1097,18 @@ export interface ObjectTypePropertyBuilder {
1087
1097
  optional: boolean;
1088
1098
  value: K.FlowTypeKind;
1089
1099
  variance?: K.VarianceKind | "plus" | "minus" | null;
1090
- }): N.ObjectTypeProperty;
1100
+ }): namedTypes.ObjectTypeProperty;
1091
1101
  }
1092
1102
  export interface ObjectTypeSpreadPropertyBuilder {
1093
- (argument: K.FlowTypeKind): N.ObjectTypeSpreadProperty;
1103
+ (argument: K.FlowTypeKind): namedTypes.ObjectTypeSpreadProperty;
1094
1104
  from(params: {
1095
1105
  argument: K.FlowTypeKind;
1096
1106
  comments?: K.CommentKind[] | null;
1097
1107
  loc?: K.SourceLocationKind | null;
1098
- }): N.ObjectTypeSpreadProperty;
1108
+ }): namedTypes.ObjectTypeSpreadProperty;
1099
1109
  }
1100
1110
  export interface ObjectTypeIndexerBuilder {
1101
- (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): N.ObjectTypeIndexer;
1111
+ (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): namedTypes.ObjectTypeIndexer;
1102
1112
  from(params: {
1103
1113
  comments?: K.CommentKind[] | null;
1104
1114
  id: K.IdentifierKind;
@@ -1106,19 +1116,19 @@ export interface ObjectTypeIndexerBuilder {
1106
1116
  loc?: K.SourceLocationKind | null;
1107
1117
  value: K.FlowTypeKind;
1108
1118
  variance?: K.VarianceKind | "plus" | "minus" | null;
1109
- }): N.ObjectTypeIndexer;
1119
+ }): namedTypes.ObjectTypeIndexer;
1110
1120
  }
1111
1121
  export interface ObjectTypeCallPropertyBuilder {
1112
- (value: K.FunctionTypeAnnotationKind): N.ObjectTypeCallProperty;
1122
+ (value: K.FunctionTypeAnnotationKind): namedTypes.ObjectTypeCallProperty;
1113
1123
  from(params: {
1114
1124
  comments?: K.CommentKind[] | null;
1115
1125
  loc?: K.SourceLocationKind | null;
1116
1126
  static?: boolean;
1117
1127
  value: K.FunctionTypeAnnotationKind;
1118
- }): N.ObjectTypeCallProperty;
1128
+ }): namedTypes.ObjectTypeCallProperty;
1119
1129
  }
1120
1130
  export interface ObjectTypeInternalSlotBuilder {
1121
- (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): N.ObjectTypeInternalSlot;
1131
+ (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): namedTypes.ObjectTypeInternalSlot;
1122
1132
  from(params: {
1123
1133
  comments?: K.CommentKind[] | null;
1124
1134
  id: K.IdentifierKind;
@@ -1127,97 +1137,97 @@ export interface ObjectTypeInternalSlotBuilder {
1127
1137
  optional: boolean;
1128
1138
  static: boolean;
1129
1139
  value: K.FlowTypeKind;
1130
- }): N.ObjectTypeInternalSlot;
1140
+ }): namedTypes.ObjectTypeInternalSlot;
1131
1141
  }
1132
1142
  export interface VarianceBuilder {
1133
- (kind: "plus" | "minus"): N.Variance;
1143
+ (kind: "plus" | "minus"): namedTypes.Variance;
1134
1144
  from(params: {
1135
1145
  comments?: K.CommentKind[] | null;
1136
1146
  kind: "plus" | "minus";
1137
1147
  loc?: K.SourceLocationKind | null;
1138
- }): N.Variance;
1148
+ }): namedTypes.Variance;
1139
1149
  }
1140
1150
  export interface QualifiedTypeIdentifierBuilder {
1141
- (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): N.QualifiedTypeIdentifier;
1151
+ (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): namedTypes.QualifiedTypeIdentifier;
1142
1152
  from(params: {
1143
1153
  comments?: K.CommentKind[] | null;
1144
1154
  id: K.IdentifierKind;
1145
1155
  loc?: K.SourceLocationKind | null;
1146
1156
  qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
1147
- }): N.QualifiedTypeIdentifier;
1157
+ }): namedTypes.QualifiedTypeIdentifier;
1148
1158
  }
1149
1159
  export interface GenericTypeAnnotationBuilder {
1150
- (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): N.GenericTypeAnnotation;
1160
+ (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): namedTypes.GenericTypeAnnotation;
1151
1161
  from(params: {
1152
1162
  comments?: K.CommentKind[] | null;
1153
1163
  id: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
1154
1164
  loc?: K.SourceLocationKind | null;
1155
1165
  typeParameters: K.TypeParameterInstantiationKind | null;
1156
- }): N.GenericTypeAnnotation;
1166
+ }): namedTypes.GenericTypeAnnotation;
1157
1167
  }
1158
1168
  export interface MemberTypeAnnotationBuilder {
1159
- (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): N.MemberTypeAnnotation;
1169
+ (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): namedTypes.MemberTypeAnnotation;
1160
1170
  from(params: {
1161
1171
  comments?: K.CommentKind[] | null;
1162
1172
  loc?: K.SourceLocationKind | null;
1163
1173
  object: K.IdentifierKind;
1164
1174
  property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;
1165
- }): N.MemberTypeAnnotation;
1175
+ }): namedTypes.MemberTypeAnnotation;
1166
1176
  }
1167
1177
  export interface UnionTypeAnnotationBuilder {
1168
- (types: K.FlowTypeKind[]): N.UnionTypeAnnotation;
1178
+ (types: K.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
1169
1179
  from(params: {
1170
1180
  comments?: K.CommentKind[] | null;
1171
1181
  loc?: K.SourceLocationKind | null;
1172
1182
  types: K.FlowTypeKind[];
1173
- }): N.UnionTypeAnnotation;
1183
+ }): namedTypes.UnionTypeAnnotation;
1174
1184
  }
1175
1185
  export interface IntersectionTypeAnnotationBuilder {
1176
- (types: K.FlowTypeKind[]): N.IntersectionTypeAnnotation;
1186
+ (types: K.FlowTypeKind[]): namedTypes.IntersectionTypeAnnotation;
1177
1187
  from(params: {
1178
1188
  comments?: K.CommentKind[] | null;
1179
1189
  loc?: K.SourceLocationKind | null;
1180
1190
  types: K.FlowTypeKind[];
1181
- }): N.IntersectionTypeAnnotation;
1191
+ }): namedTypes.IntersectionTypeAnnotation;
1182
1192
  }
1183
1193
  export interface TypeofTypeAnnotationBuilder {
1184
- (argument: K.FlowTypeKind): N.TypeofTypeAnnotation;
1194
+ (argument: K.FlowTypeKind): namedTypes.TypeofTypeAnnotation;
1185
1195
  from(params: {
1186
1196
  argument: K.FlowTypeKind;
1187
1197
  comments?: K.CommentKind[] | null;
1188
1198
  loc?: K.SourceLocationKind | null;
1189
- }): N.TypeofTypeAnnotation;
1199
+ }): namedTypes.TypeofTypeAnnotation;
1190
1200
  }
1191
1201
  export interface TypeParameterBuilder {
1192
- (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): N.TypeParameter;
1202
+ (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): namedTypes.TypeParameter;
1193
1203
  from(params: {
1194
1204
  bound?: K.TypeAnnotationKind | null;
1195
1205
  comments?: K.CommentKind[] | null;
1196
1206
  loc?: K.SourceLocationKind | null;
1197
1207
  name: string;
1198
1208
  variance?: K.VarianceKind | "plus" | "minus" | null;
1199
- }): N.TypeParameter;
1209
+ }): namedTypes.TypeParameter;
1200
1210
  }
1201
1211
  export interface InterfaceTypeAnnotationBuilder {
1202
- (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): N.InterfaceTypeAnnotation;
1212
+ (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): namedTypes.InterfaceTypeAnnotation;
1203
1213
  from(params: {
1204
1214
  body: K.ObjectTypeAnnotationKind;
1205
1215
  comments?: K.CommentKind[] | null;
1206
1216
  extends?: K.InterfaceExtendsKind[] | null;
1207
1217
  loc?: K.SourceLocationKind | null;
1208
- }): N.InterfaceTypeAnnotation;
1218
+ }): namedTypes.InterfaceTypeAnnotation;
1209
1219
  }
1210
1220
  export interface InterfaceExtendsBuilder {
1211
- (id: K.IdentifierKind): N.InterfaceExtends;
1221
+ (id: K.IdentifierKind): namedTypes.InterfaceExtends;
1212
1222
  from(params: {
1213
1223
  comments?: K.CommentKind[] | null;
1214
1224
  id: K.IdentifierKind;
1215
1225
  loc?: K.SourceLocationKind | null;
1216
1226
  typeParameters?: K.TypeParameterInstantiationKind | null;
1217
- }): N.InterfaceExtends;
1227
+ }): namedTypes.InterfaceExtends;
1218
1228
  }
1219
1229
  export interface InterfaceDeclarationBuilder {
1220
- (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.InterfaceDeclaration;
1230
+ (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.InterfaceDeclaration;
1221
1231
  from(params: {
1222
1232
  body: K.ObjectTypeAnnotationKind;
1223
1233
  comments?: K.CommentKind[] | null;
@@ -1225,10 +1235,10 @@ export interface InterfaceDeclarationBuilder {
1225
1235
  id: K.IdentifierKind;
1226
1236
  loc?: K.SourceLocationKind | null;
1227
1237
  typeParameters?: K.TypeParameterDeclarationKind | null;
1228
- }): N.InterfaceDeclaration;
1238
+ }): namedTypes.InterfaceDeclaration;
1229
1239
  }
1230
1240
  export interface DeclareInterfaceBuilder {
1231
- (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.DeclareInterface;
1241
+ (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.DeclareInterface;
1232
1242
  from(params: {
1233
1243
  body: K.ObjectTypeAnnotationKind;
1234
1244
  comments?: K.CommentKind[] | null;
@@ -1236,20 +1246,20 @@ export interface DeclareInterfaceBuilder {
1236
1246
  id: K.IdentifierKind;
1237
1247
  loc?: K.SourceLocationKind | null;
1238
1248
  typeParameters?: K.TypeParameterDeclarationKind | null;
1239
- }): N.DeclareInterface;
1249
+ }): namedTypes.DeclareInterface;
1240
1250
  }
1241
1251
  export interface TypeAliasBuilder {
1242
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.TypeAlias;
1252
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.TypeAlias;
1243
1253
  from(params: {
1244
1254
  comments?: K.CommentKind[] | null;
1245
1255
  id: K.IdentifierKind;
1246
1256
  loc?: K.SourceLocationKind | null;
1247
1257
  right: K.FlowTypeKind;
1248
1258
  typeParameters: K.TypeParameterDeclarationKind | null;
1249
- }): N.TypeAlias;
1259
+ }): namedTypes.TypeAlias;
1250
1260
  }
1251
1261
  export interface OpaqueTypeBuilder {
1252
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): N.OpaqueType;
1262
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): namedTypes.OpaqueType;
1253
1263
  from(params: {
1254
1264
  comments?: K.CommentKind[] | null;
1255
1265
  id: K.IdentifierKind;
@@ -1257,63 +1267,63 @@ export interface OpaqueTypeBuilder {
1257
1267
  loc?: K.SourceLocationKind | null;
1258
1268
  supertype: K.FlowTypeKind;
1259
1269
  typeParameters: K.TypeParameterDeclarationKind | null;
1260
- }): N.OpaqueType;
1270
+ }): namedTypes.OpaqueType;
1261
1271
  }
1262
1272
  export interface DeclareTypeAliasBuilder {
1263
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.DeclareTypeAlias;
1273
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.DeclareTypeAlias;
1264
1274
  from(params: {
1265
1275
  comments?: K.CommentKind[] | null;
1266
1276
  id: K.IdentifierKind;
1267
1277
  loc?: K.SourceLocationKind | null;
1268
1278
  right: K.FlowTypeKind;
1269
1279
  typeParameters: K.TypeParameterDeclarationKind | null;
1270
- }): N.DeclareTypeAlias;
1280
+ }): namedTypes.DeclareTypeAlias;
1271
1281
  }
1272
1282
  export interface DeclareOpaqueTypeBuilder {
1273
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): N.DeclareOpaqueType;
1283
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.DeclareOpaqueType;
1274
1284
  from(params: {
1275
1285
  comments?: K.CommentKind[] | null;
1276
1286
  id: K.IdentifierKind;
1277
1287
  loc?: K.SourceLocationKind | null;
1278
1288
  right: K.FlowTypeKind;
1279
1289
  typeParameters: K.TypeParameterDeclarationKind | null;
1280
- }): N.DeclareOpaqueType;
1290
+ }): namedTypes.DeclareOpaqueType;
1281
1291
  }
1282
1292
  export interface TypeCastExpressionBuilder {
1283
- (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): N.TypeCastExpression;
1293
+ (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): namedTypes.TypeCastExpression;
1284
1294
  from(params: {
1285
1295
  comments?: K.CommentKind[] | null;
1286
1296
  expression: K.ExpressionKind;
1287
1297
  loc?: K.SourceLocationKind | null;
1288
1298
  typeAnnotation: K.TypeAnnotationKind;
1289
- }): N.TypeCastExpression;
1299
+ }): namedTypes.TypeCastExpression;
1290
1300
  }
1291
1301
  export interface TupleTypeAnnotationBuilder {
1292
- (types: K.FlowTypeKind[]): N.TupleTypeAnnotation;
1302
+ (types: K.FlowTypeKind[]): namedTypes.TupleTypeAnnotation;
1293
1303
  from(params: {
1294
1304
  comments?: K.CommentKind[] | null;
1295
1305
  loc?: K.SourceLocationKind | null;
1296
1306
  types: K.FlowTypeKind[];
1297
- }): N.TupleTypeAnnotation;
1307
+ }): namedTypes.TupleTypeAnnotation;
1298
1308
  }
1299
1309
  export interface DeclareVariableBuilder {
1300
- (id: K.IdentifierKind): N.DeclareVariable;
1310
+ (id: K.IdentifierKind): namedTypes.DeclareVariable;
1301
1311
  from(params: {
1302
1312
  comments?: K.CommentKind[] | null;
1303
1313
  id: K.IdentifierKind;
1304
1314
  loc?: K.SourceLocationKind | null;
1305
- }): N.DeclareVariable;
1315
+ }): namedTypes.DeclareVariable;
1306
1316
  }
1307
1317
  export interface DeclareFunctionBuilder {
1308
- (id: K.IdentifierKind): N.DeclareFunction;
1318
+ (id: K.IdentifierKind): namedTypes.DeclareFunction;
1309
1319
  from(params: {
1310
1320
  comments?: K.CommentKind[] | null;
1311
1321
  id: K.IdentifierKind;
1312
1322
  loc?: K.SourceLocationKind | null;
1313
- }): N.DeclareFunction;
1323
+ }): namedTypes.DeclareFunction;
1314
1324
  }
1315
1325
  export interface DeclareClassBuilder {
1316
- (id: K.IdentifierKind): N.DeclareClass;
1326
+ (id: K.IdentifierKind): namedTypes.DeclareClass;
1317
1327
  from(params: {
1318
1328
  body: K.ObjectTypeAnnotationKind;
1319
1329
  comments?: K.CommentKind[] | null;
@@ -1321,27 +1331,27 @@ export interface DeclareClassBuilder {
1321
1331
  id: K.IdentifierKind;
1322
1332
  loc?: K.SourceLocationKind | null;
1323
1333
  typeParameters?: K.TypeParameterDeclarationKind | null;
1324
- }): N.DeclareClass;
1334
+ }): namedTypes.DeclareClass;
1325
1335
  }
1326
1336
  export interface DeclareModuleBuilder {
1327
- (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): N.DeclareModule;
1337
+ (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): namedTypes.DeclareModule;
1328
1338
  from(params: {
1329
1339
  body: K.BlockStatementKind;
1330
1340
  comments?: K.CommentKind[] | null;
1331
1341
  id: K.IdentifierKind | K.LiteralKind;
1332
1342
  loc?: K.SourceLocationKind | null;
1333
- }): N.DeclareModule;
1343
+ }): namedTypes.DeclareModule;
1334
1344
  }
1335
1345
  export interface DeclareModuleExportsBuilder {
1336
- (typeAnnotation: K.TypeAnnotationKind): N.DeclareModuleExports;
1346
+ (typeAnnotation: K.TypeAnnotationKind): namedTypes.DeclareModuleExports;
1337
1347
  from(params: {
1338
1348
  comments?: K.CommentKind[] | null;
1339
1349
  loc?: K.SourceLocationKind | null;
1340
1350
  typeAnnotation: K.TypeAnnotationKind;
1341
- }): N.DeclareModuleExports;
1351
+ }): namedTypes.DeclareModuleExports;
1342
1352
  }
1343
1353
  export interface DeclareExportDeclarationBuilder {
1344
- (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): N.DeclareExportDeclaration;
1354
+ (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.DeclareExportDeclaration;
1345
1355
  from(params: {
1346
1356
  comments?: K.CommentKind[] | null;
1347
1357
  declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null;
@@ -1349,10 +1359,10 @@ export interface DeclareExportDeclarationBuilder {
1349
1359
  loc?: K.SourceLocationKind | null;
1350
1360
  source?: K.LiteralKind | null;
1351
1361
  specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
1352
- }): N.DeclareExportDeclaration;
1362
+ }): namedTypes.DeclareExportDeclaration;
1353
1363
  }
1354
1364
  export interface ExportSpecifierBuilder {
1355
- (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): N.ExportSpecifier;
1365
+ (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): namedTypes.ExportSpecifier;
1356
1366
  from(params: {
1357
1367
  comments?: K.CommentKind[] | null;
1358
1368
  exported: K.IdentifierKind;
@@ -1360,40 +1370,40 @@ export interface ExportSpecifierBuilder {
1360
1370
  loc?: K.SourceLocationKind | null;
1361
1371
  local?: K.IdentifierKind | null;
1362
1372
  name?: K.IdentifierKind | null;
1363
- }): N.ExportSpecifier;
1373
+ }): namedTypes.ExportSpecifier;
1364
1374
  }
1365
1375
  export interface ExportBatchSpecifierBuilder {
1366
- (): N.ExportBatchSpecifier;
1376
+ (): namedTypes.ExportBatchSpecifier;
1367
1377
  from(params: {
1368
1378
  comments?: K.CommentKind[] | null;
1369
1379
  loc?: K.SourceLocationKind | null;
1370
- }): N.ExportBatchSpecifier;
1380
+ }): namedTypes.ExportBatchSpecifier;
1371
1381
  }
1372
1382
  export interface DeclareExportAllDeclarationBuilder {
1373
- (source?: K.LiteralKind | null): N.DeclareExportAllDeclaration;
1383
+ (source?: K.LiteralKind | null): namedTypes.DeclareExportAllDeclaration;
1374
1384
  from(params: {
1375
1385
  comments?: K.CommentKind[] | null;
1376
1386
  loc?: K.SourceLocationKind | null;
1377
1387
  source?: K.LiteralKind | null;
1378
- }): N.DeclareExportAllDeclaration;
1388
+ }): namedTypes.DeclareExportAllDeclaration;
1379
1389
  }
1380
1390
  export interface InferredPredicateBuilder {
1381
- (): N.InferredPredicate;
1391
+ (): namedTypes.InferredPredicate;
1382
1392
  from(params: {
1383
1393
  comments?: K.CommentKind[] | null;
1384
1394
  loc?: K.SourceLocationKind | null;
1385
- }): N.InferredPredicate;
1395
+ }): namedTypes.InferredPredicate;
1386
1396
  }
1387
1397
  export interface DeclaredPredicateBuilder {
1388
- (value: K.ExpressionKind): N.DeclaredPredicate;
1398
+ (value: K.ExpressionKind): namedTypes.DeclaredPredicate;
1389
1399
  from(params: {
1390
1400
  comments?: K.CommentKind[] | null;
1391
1401
  loc?: K.SourceLocationKind | null;
1392
1402
  value: K.ExpressionKind;
1393
- }): N.DeclaredPredicate;
1403
+ }): namedTypes.DeclaredPredicate;
1394
1404
  }
1395
1405
  export interface ExportDeclarationBuilder {
1396
- (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): N.ExportDeclaration;
1406
+ (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.ExportDeclaration;
1397
1407
  from(params: {
1398
1408
  comments?: K.CommentKind[] | null;
1399
1409
  declaration: K.DeclarationKind | K.ExpressionKind | null;
@@ -1401,169 +1411,169 @@ export interface ExportDeclarationBuilder {
1401
1411
  loc?: K.SourceLocationKind | null;
1402
1412
  source?: K.LiteralKind | null;
1403
1413
  specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
1404
- }): N.ExportDeclaration;
1414
+ }): namedTypes.ExportDeclaration;
1405
1415
  }
1406
1416
  export interface BlockBuilder {
1407
- (value: string, leading?: boolean, trailing?: boolean): N.Block;
1417
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.Block;
1408
1418
  from(params: {
1409
1419
  leading?: boolean;
1410
1420
  loc?: K.SourceLocationKind | null;
1411
1421
  trailing?: boolean;
1412
1422
  value: string;
1413
- }): N.Block;
1423
+ }): namedTypes.Block;
1414
1424
  }
1415
1425
  export interface LineBuilder {
1416
- (value: string, leading?: boolean, trailing?: boolean): N.Line;
1426
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.Line;
1417
1427
  from(params: {
1418
1428
  leading?: boolean;
1419
1429
  loc?: K.SourceLocationKind | null;
1420
1430
  trailing?: boolean;
1421
1431
  value: string;
1422
- }): N.Line;
1432
+ }): namedTypes.Line;
1423
1433
  }
1424
1434
  export interface NoopBuilder {
1425
- (): N.Noop;
1435
+ (): namedTypes.Noop;
1426
1436
  from(params: {
1427
1437
  comments?: K.CommentKind[] | null;
1428
1438
  loc?: K.SourceLocationKind | null;
1429
- }): N.Noop;
1439
+ }): namedTypes.Noop;
1430
1440
  }
1431
1441
  export interface DoExpressionBuilder {
1432
- (body: K.StatementKind[]): N.DoExpression;
1442
+ (body: K.StatementKind[]): namedTypes.DoExpression;
1433
1443
  from(params: {
1434
1444
  body: K.StatementKind[];
1435
1445
  comments?: K.CommentKind[] | null;
1436
1446
  loc?: K.SourceLocationKind | null;
1437
- }): N.DoExpression;
1447
+ }): namedTypes.DoExpression;
1438
1448
  }
1439
1449
  export interface SuperBuilder {
1440
- (): N.Super;
1450
+ (): namedTypes.Super;
1441
1451
  from(params: {
1442
1452
  comments?: K.CommentKind[] | null;
1443
1453
  loc?: K.SourceLocationKind | null;
1444
- }): N.Super;
1454
+ }): namedTypes.Super;
1445
1455
  }
1446
1456
  export interface BindExpressionBuilder {
1447
- (object: K.ExpressionKind | null, callee: K.ExpressionKind): N.BindExpression;
1457
+ (object: K.ExpressionKind | null, callee: K.ExpressionKind): namedTypes.BindExpression;
1448
1458
  from(params: {
1449
1459
  callee: K.ExpressionKind;
1450
1460
  comments?: K.CommentKind[] | null;
1451
1461
  loc?: K.SourceLocationKind | null;
1452
1462
  object: K.ExpressionKind | null;
1453
- }): N.BindExpression;
1463
+ }): namedTypes.BindExpression;
1454
1464
  }
1455
1465
  export interface DecoratorBuilder {
1456
- (expression: K.ExpressionKind): N.Decorator;
1466
+ (expression: K.ExpressionKind): namedTypes.Decorator;
1457
1467
  from(params: {
1458
1468
  comments?: K.CommentKind[] | null;
1459
1469
  expression: K.ExpressionKind;
1460
1470
  loc?: K.SourceLocationKind | null;
1461
- }): N.Decorator;
1471
+ }): namedTypes.Decorator;
1462
1472
  }
1463
1473
  export interface MetaPropertyBuilder {
1464
- (meta: K.IdentifierKind, property: K.IdentifierKind): N.MetaProperty;
1474
+ (meta: K.IdentifierKind, property: K.IdentifierKind): namedTypes.MetaProperty;
1465
1475
  from(params: {
1466
1476
  comments?: K.CommentKind[] | null;
1467
1477
  loc?: K.SourceLocationKind | null;
1468
1478
  meta: K.IdentifierKind;
1469
1479
  property: K.IdentifierKind;
1470
- }): N.MetaProperty;
1480
+ }): namedTypes.MetaProperty;
1471
1481
  }
1472
1482
  export interface ParenthesizedExpressionBuilder {
1473
- (expression: K.ExpressionKind): N.ParenthesizedExpression;
1483
+ (expression: K.ExpressionKind): namedTypes.ParenthesizedExpression;
1474
1484
  from(params: {
1475
1485
  comments?: K.CommentKind[] | null;
1476
1486
  expression: K.ExpressionKind;
1477
1487
  loc?: K.SourceLocationKind | null;
1478
- }): N.ParenthesizedExpression;
1488
+ }): namedTypes.ParenthesizedExpression;
1479
1489
  }
1480
1490
  export interface ExportDefaultDeclarationBuilder {
1481
- (declaration: K.DeclarationKind | K.ExpressionKind): N.ExportDefaultDeclaration;
1491
+ (declaration: K.DeclarationKind | K.ExpressionKind): namedTypes.ExportDefaultDeclaration;
1482
1492
  from(params: {
1483
1493
  comments?: K.CommentKind[] | null;
1484
1494
  declaration: K.DeclarationKind | K.ExpressionKind;
1485
1495
  loc?: K.SourceLocationKind | null;
1486
- }): N.ExportDefaultDeclaration;
1496
+ }): namedTypes.ExportDefaultDeclaration;
1487
1497
  }
1488
1498
  export interface ExportNamedDeclarationBuilder {
1489
- (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): N.ExportNamedDeclaration;
1499
+ (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): namedTypes.ExportNamedDeclaration;
1490
1500
  from(params: {
1491
1501
  comments?: K.CommentKind[] | null;
1492
1502
  declaration: K.DeclarationKind | null;
1493
1503
  loc?: K.SourceLocationKind | null;
1494
1504
  source?: K.LiteralKind | null;
1495
1505
  specifiers?: K.ExportSpecifierKind[];
1496
- }): N.ExportNamedDeclaration;
1506
+ }): namedTypes.ExportNamedDeclaration;
1497
1507
  }
1498
1508
  export interface ExportNamespaceSpecifierBuilder {
1499
- (exported: K.IdentifierKind): N.ExportNamespaceSpecifier;
1509
+ (exported: K.IdentifierKind): namedTypes.ExportNamespaceSpecifier;
1500
1510
  from(params: {
1501
1511
  comments?: K.CommentKind[] | null;
1502
1512
  exported: K.IdentifierKind;
1503
1513
  loc?: K.SourceLocationKind | null;
1504
- }): N.ExportNamespaceSpecifier;
1514
+ }): namedTypes.ExportNamespaceSpecifier;
1505
1515
  }
1506
1516
  export interface ExportDefaultSpecifierBuilder {
1507
- (exported: K.IdentifierKind): N.ExportDefaultSpecifier;
1517
+ (exported: K.IdentifierKind): namedTypes.ExportDefaultSpecifier;
1508
1518
  from(params: {
1509
1519
  comments?: K.CommentKind[] | null;
1510
1520
  exported: K.IdentifierKind;
1511
1521
  loc?: K.SourceLocationKind | null;
1512
- }): N.ExportDefaultSpecifier;
1522
+ }): namedTypes.ExportDefaultSpecifier;
1513
1523
  }
1514
1524
  export interface ExportAllDeclarationBuilder {
1515
- (exported: K.IdentifierKind | null, source: K.LiteralKind): N.ExportAllDeclaration;
1525
+ (exported: K.IdentifierKind | null, source: K.LiteralKind): namedTypes.ExportAllDeclaration;
1516
1526
  from(params: {
1517
1527
  comments?: K.CommentKind[] | null;
1518
1528
  exported: K.IdentifierKind | null;
1519
1529
  loc?: K.SourceLocationKind | null;
1520
1530
  source: K.LiteralKind;
1521
- }): N.ExportAllDeclaration;
1531
+ }): namedTypes.ExportAllDeclaration;
1522
1532
  }
1523
1533
  export interface CommentBlockBuilder {
1524
- (value: string, leading?: boolean, trailing?: boolean): N.CommentBlock;
1534
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentBlock;
1525
1535
  from(params: {
1526
1536
  leading?: boolean;
1527
1537
  loc?: K.SourceLocationKind | null;
1528
1538
  trailing?: boolean;
1529
1539
  value: string;
1530
- }): N.CommentBlock;
1540
+ }): namedTypes.CommentBlock;
1531
1541
  }
1532
1542
  export interface CommentLineBuilder {
1533
- (value: string, leading?: boolean, trailing?: boolean): N.CommentLine;
1543
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentLine;
1534
1544
  from(params: {
1535
1545
  leading?: boolean;
1536
1546
  loc?: K.SourceLocationKind | null;
1537
1547
  trailing?: boolean;
1538
1548
  value: string;
1539
- }): N.CommentLine;
1549
+ }): namedTypes.CommentLine;
1540
1550
  }
1541
1551
  export interface DirectiveBuilder {
1542
- (value: K.DirectiveLiteralKind): N.Directive;
1552
+ (value: K.DirectiveLiteralKind): namedTypes.Directive;
1543
1553
  from(params: {
1544
1554
  comments?: K.CommentKind[] | null;
1545
1555
  loc?: K.SourceLocationKind | null;
1546
1556
  value: K.DirectiveLiteralKind;
1547
- }): N.Directive;
1557
+ }): namedTypes.Directive;
1548
1558
  }
1549
1559
  export interface DirectiveLiteralBuilder {
1550
- (value?: string): N.DirectiveLiteral;
1560
+ (value?: string): namedTypes.DirectiveLiteral;
1551
1561
  from(params: {
1552
1562
  comments?: K.CommentKind[] | null;
1553
1563
  loc?: K.SourceLocationKind | null;
1554
1564
  value?: string;
1555
- }): N.DirectiveLiteral;
1565
+ }): namedTypes.DirectiveLiteral;
1556
1566
  }
1557
1567
  export interface InterpreterDirectiveBuilder {
1558
- (value: string): N.InterpreterDirective;
1568
+ (value: string): namedTypes.InterpreterDirective;
1559
1569
  from(params: {
1560
1570
  comments?: K.CommentKind[] | null;
1561
1571
  loc?: K.SourceLocationKind | null;
1562
1572
  value: string;
1563
- }): N.InterpreterDirective;
1573
+ }): namedTypes.InterpreterDirective;
1564
1574
  }
1565
1575
  export interface StringLiteralBuilder {
1566
- (value: string): N.StringLiteral;
1576
+ (value: string): namedTypes.StringLiteral;
1567
1577
  from(params: {
1568
1578
  comments?: K.CommentKind[] | null;
1569
1579
  loc?: K.SourceLocationKind | null;
@@ -1572,10 +1582,10 @@ export interface StringLiteralBuilder {
1572
1582
  flags: string;
1573
1583
  } | null;
1574
1584
  value: string;
1575
- }): N.StringLiteral;
1585
+ }): namedTypes.StringLiteral;
1576
1586
  }
1577
1587
  export interface NumericLiteralBuilder {
1578
- (value: number): N.NumericLiteral;
1588
+ (value: number): namedTypes.NumericLiteral;
1579
1589
  from(params: {
1580
1590
  comments?: K.CommentKind[] | null;
1581
1591
  extra?: {
@@ -1589,10 +1599,10 @@ export interface NumericLiteralBuilder {
1589
1599
  flags: string;
1590
1600
  } | null;
1591
1601
  value: number;
1592
- }): N.NumericLiteral;
1602
+ }): namedTypes.NumericLiteral;
1593
1603
  }
1594
1604
  export interface BigIntLiteralBuilder {
1595
- (value: string | number): N.BigIntLiteral;
1605
+ (value: string | number): namedTypes.BigIntLiteral;
1596
1606
  from(params: {
1597
1607
  comments?: K.CommentKind[] | null;
1598
1608
  extra?: {
@@ -1605,10 +1615,10 @@ export interface BigIntLiteralBuilder {
1605
1615
  flags: string;
1606
1616
  } | null;
1607
1617
  value: string | number;
1608
- }): N.BigIntLiteral;
1618
+ }): namedTypes.BigIntLiteral;
1609
1619
  }
1610
1620
  export interface NullLiteralBuilder {
1611
- (): N.NullLiteral;
1621
+ (): namedTypes.NullLiteral;
1612
1622
  from(params: {
1613
1623
  comments?: K.CommentKind[] | null;
1614
1624
  loc?: K.SourceLocationKind | null;
@@ -1617,10 +1627,10 @@ export interface NullLiteralBuilder {
1617
1627
  flags: string;
1618
1628
  } | null;
1619
1629
  value?: null;
1620
- }): N.NullLiteral;
1630
+ }): namedTypes.NullLiteral;
1621
1631
  }
1622
1632
  export interface BooleanLiteralBuilder {
1623
- (value: boolean): N.BooleanLiteral;
1633
+ (value: boolean): namedTypes.BooleanLiteral;
1624
1634
  from(params: {
1625
1635
  comments?: K.CommentKind[] | null;
1626
1636
  loc?: K.SourceLocationKind | null;
@@ -1629,10 +1639,10 @@ export interface BooleanLiteralBuilder {
1629
1639
  flags: string;
1630
1640
  } | null;
1631
1641
  value: boolean;
1632
- }): N.BooleanLiteral;
1642
+ }): namedTypes.BooleanLiteral;
1633
1643
  }
1634
1644
  export interface RegExpLiteralBuilder {
1635
- (pattern: string, flags: string): N.RegExpLiteral;
1645
+ (pattern: string, flags: string): namedTypes.RegExpLiteral;
1636
1646
  from(params: {
1637
1647
  comments?: K.CommentKind[] | null;
1638
1648
  flags: string;
@@ -1643,10 +1653,10 @@ export interface RegExpLiteralBuilder {
1643
1653
  flags: string;
1644
1654
  } | null;
1645
1655
  value?: RegExp;
1646
- }): N.RegExpLiteral;
1656
+ }): namedTypes.RegExpLiteral;
1647
1657
  }
1648
1658
  export interface ObjectMethodBuilder {
1649
- (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): N.ObjectMethod;
1659
+ (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
1650
1660
  from(params: {
1651
1661
  accessibility?: K.LiteralKind | null;
1652
1662
  async?: boolean;
@@ -1665,10 +1675,10 @@ export interface ObjectMethodBuilder {
1665
1675
  rest?: K.IdentifierKind | null;
1666
1676
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1667
1677
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1668
- }): N.ObjectMethod;
1678
+ }): namedTypes.ObjectMethod;
1669
1679
  }
1670
1680
  export interface ClassPrivatePropertyBuilder {
1671
- (key: K.PrivateNameKind, value?: K.ExpressionKind | null): N.ClassPrivateProperty;
1681
+ (key: K.PrivateNameKind, value?: K.ExpressionKind | null): namedTypes.ClassPrivateProperty;
1672
1682
  from(params: {
1673
1683
  access?: "public" | "private" | "protected" | undefined;
1674
1684
  comments?: K.CommentKind[] | null;
@@ -1679,10 +1689,10 @@ export interface ClassPrivatePropertyBuilder {
1679
1689
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1680
1690
  value?: K.ExpressionKind | null;
1681
1691
  variance?: K.VarianceKind | "plus" | "minus" | null;
1682
- }): N.ClassPrivateProperty;
1692
+ }): namedTypes.ClassPrivateProperty;
1683
1693
  }
1684
1694
  export interface ClassMethodBuilder {
1685
- (kind: "get" | "set" | "method" | "constructor" | undefined, key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean, staticParam?: boolean | null): N.ClassMethod;
1695
+ (kind: "get" | "set" | "method" | "constructor" | undefined, key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean, staticParam?: boolean | null): namedTypes.ClassMethod;
1686
1696
  from(params: {
1687
1697
  abstract?: boolean | null;
1688
1698
  access?: "public" | "private" | "protected" | null;
@@ -1705,10 +1715,10 @@ export interface ClassMethodBuilder {
1705
1715
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1706
1716
  static?: boolean | null;
1707
1717
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1708
- }): N.ClassMethod;
1718
+ }): namedTypes.ClassMethod;
1709
1719
  }
1710
1720
  export interface ClassPrivateMethodBuilder {
1711
- (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean | null): N.ClassPrivateMethod;
1721
+ (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean | null): namedTypes.ClassPrivateMethod;
1712
1722
  from(params: {
1713
1723
  abstract?: boolean | null;
1714
1724
  access?: "public" | "private" | "protected" | null;
@@ -1731,61 +1741,61 @@ export interface ClassPrivateMethodBuilder {
1731
1741
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1732
1742
  static?: boolean | null;
1733
1743
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1734
- }): N.ClassPrivateMethod;
1744
+ }): namedTypes.ClassPrivateMethod;
1735
1745
  }
1736
1746
  export interface PrivateNameBuilder {
1737
- (id: K.IdentifierKind): N.PrivateName;
1747
+ (id: K.IdentifierKind): namedTypes.PrivateName;
1738
1748
  from(params: {
1739
1749
  comments?: K.CommentKind[] | null;
1740
1750
  id: K.IdentifierKind;
1741
1751
  loc?: K.SourceLocationKind | null;
1742
- }): N.PrivateName;
1752
+ }): namedTypes.PrivateName;
1743
1753
  }
1744
1754
  export interface RestPropertyBuilder {
1745
- (argument: K.ExpressionKind): N.RestProperty;
1755
+ (argument: K.ExpressionKind): namedTypes.RestProperty;
1746
1756
  from(params: {
1747
1757
  argument: K.ExpressionKind;
1748
1758
  comments?: K.CommentKind[] | null;
1749
1759
  loc?: K.SourceLocationKind | null;
1750
- }): N.RestProperty;
1760
+ }): namedTypes.RestProperty;
1751
1761
  }
1752
1762
  export interface ForAwaitStatementBuilder {
1753
- (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): N.ForAwaitStatement;
1763
+ (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForAwaitStatement;
1754
1764
  from(params: {
1755
1765
  body: K.StatementKind;
1756
1766
  comments?: K.CommentKind[] | null;
1757
1767
  left: K.VariableDeclarationKind | K.ExpressionKind;
1758
1768
  loc?: K.SourceLocationKind | null;
1759
1769
  right: K.ExpressionKind;
1760
- }): N.ForAwaitStatement;
1770
+ }): namedTypes.ForAwaitStatement;
1761
1771
  }
1762
1772
  export interface ImportBuilder {
1763
- (): N.Import;
1773
+ (): namedTypes.Import;
1764
1774
  from(params: {
1765
1775
  comments?: K.CommentKind[] | null;
1766
1776
  loc?: K.SourceLocationKind | null;
1767
- }): N.Import;
1777
+ }): namedTypes.Import;
1768
1778
  }
1769
1779
  export interface TSQualifiedNameBuilder {
1770
- (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): N.TSQualifiedName;
1780
+ (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): namedTypes.TSQualifiedName;
1771
1781
  from(params: {
1772
1782
  comments?: K.CommentKind[] | null;
1773
1783
  left: K.IdentifierKind | K.TSQualifiedNameKind;
1774
1784
  loc?: K.SourceLocationKind | null;
1775
1785
  right: K.IdentifierKind | K.TSQualifiedNameKind;
1776
- }): N.TSQualifiedName;
1786
+ }): namedTypes.TSQualifiedName;
1777
1787
  }
1778
1788
  export interface TSTypeReferenceBuilder {
1779
- (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSTypeReference;
1789
+ (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSTypeReference;
1780
1790
  from(params: {
1781
1791
  comments?: K.CommentKind[] | null;
1782
1792
  loc?: K.SourceLocationKind | null;
1783
1793
  typeName: K.IdentifierKind | K.TSQualifiedNameKind;
1784
1794
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
1785
- }): N.TSTypeReference;
1795
+ }): namedTypes.TSTypeReference;
1786
1796
  }
1787
1797
  export interface TSAsExpressionBuilder {
1788
- (expression: K.ExpressionKind): N.TSAsExpression;
1798
+ (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSAsExpression;
1789
1799
  from(params: {
1790
1800
  comments?: K.CommentKind[] | null;
1791
1801
  expression: K.ExpressionKind;
@@ -1794,141 +1804,141 @@ export interface TSAsExpressionBuilder {
1794
1804
  } | null;
1795
1805
  loc?: K.SourceLocationKind | null;
1796
1806
  typeAnnotation: K.TSTypeKind;
1797
- }): N.TSAsExpression;
1807
+ }): namedTypes.TSAsExpression;
1798
1808
  }
1799
1809
  export interface TSNonNullExpressionBuilder {
1800
- (expression: K.ExpressionKind): N.TSNonNullExpression;
1810
+ (expression: K.ExpressionKind): namedTypes.TSNonNullExpression;
1801
1811
  from(params: {
1802
1812
  comments?: K.CommentKind[] | null;
1803
1813
  expression: K.ExpressionKind;
1804
1814
  loc?: K.SourceLocationKind | null;
1805
- }): N.TSNonNullExpression;
1815
+ }): namedTypes.TSNonNullExpression;
1806
1816
  }
1807
1817
  export interface TSAnyKeywordBuilder {
1808
- (): N.TSAnyKeyword;
1818
+ (): namedTypes.TSAnyKeyword;
1809
1819
  from(params: {
1810
1820
  comments?: K.CommentKind[] | null;
1811
1821
  loc?: K.SourceLocationKind | null;
1812
- }): N.TSAnyKeyword;
1822
+ }): namedTypes.TSAnyKeyword;
1813
1823
  }
1814
1824
  export interface TSBigIntKeywordBuilder {
1815
- (): N.TSBigIntKeyword;
1825
+ (): namedTypes.TSBigIntKeyword;
1816
1826
  from(params: {
1817
1827
  comments?: K.CommentKind[] | null;
1818
1828
  loc?: K.SourceLocationKind | null;
1819
- }): N.TSBigIntKeyword;
1829
+ }): namedTypes.TSBigIntKeyword;
1820
1830
  }
1821
1831
  export interface TSBooleanKeywordBuilder {
1822
- (): N.TSBooleanKeyword;
1832
+ (): namedTypes.TSBooleanKeyword;
1823
1833
  from(params: {
1824
1834
  comments?: K.CommentKind[] | null;
1825
1835
  loc?: K.SourceLocationKind | null;
1826
- }): N.TSBooleanKeyword;
1836
+ }): namedTypes.TSBooleanKeyword;
1827
1837
  }
1828
1838
  export interface TSNeverKeywordBuilder {
1829
- (): N.TSNeverKeyword;
1839
+ (): namedTypes.TSNeverKeyword;
1830
1840
  from(params: {
1831
1841
  comments?: K.CommentKind[] | null;
1832
1842
  loc?: K.SourceLocationKind | null;
1833
- }): N.TSNeverKeyword;
1843
+ }): namedTypes.TSNeverKeyword;
1834
1844
  }
1835
1845
  export interface TSNullKeywordBuilder {
1836
- (): N.TSNullKeyword;
1846
+ (): namedTypes.TSNullKeyword;
1837
1847
  from(params: {
1838
1848
  comments?: K.CommentKind[] | null;
1839
1849
  loc?: K.SourceLocationKind | null;
1840
- }): N.TSNullKeyword;
1850
+ }): namedTypes.TSNullKeyword;
1841
1851
  }
1842
1852
  export interface TSNumberKeywordBuilder {
1843
- (): N.TSNumberKeyword;
1853
+ (): namedTypes.TSNumberKeyword;
1844
1854
  from(params: {
1845
1855
  comments?: K.CommentKind[] | null;
1846
1856
  loc?: K.SourceLocationKind | null;
1847
- }): N.TSNumberKeyword;
1857
+ }): namedTypes.TSNumberKeyword;
1848
1858
  }
1849
1859
  export interface TSObjectKeywordBuilder {
1850
- (): N.TSObjectKeyword;
1860
+ (): namedTypes.TSObjectKeyword;
1851
1861
  from(params: {
1852
1862
  comments?: K.CommentKind[] | null;
1853
1863
  loc?: K.SourceLocationKind | null;
1854
- }): N.TSObjectKeyword;
1864
+ }): namedTypes.TSObjectKeyword;
1855
1865
  }
1856
1866
  export interface TSStringKeywordBuilder {
1857
- (): N.TSStringKeyword;
1867
+ (): namedTypes.TSStringKeyword;
1858
1868
  from(params: {
1859
1869
  comments?: K.CommentKind[] | null;
1860
1870
  loc?: K.SourceLocationKind | null;
1861
- }): N.TSStringKeyword;
1871
+ }): namedTypes.TSStringKeyword;
1862
1872
  }
1863
1873
  export interface TSSymbolKeywordBuilder {
1864
- (): N.TSSymbolKeyword;
1874
+ (): namedTypes.TSSymbolKeyword;
1865
1875
  from(params: {
1866
1876
  comments?: K.CommentKind[] | null;
1867
1877
  loc?: K.SourceLocationKind | null;
1868
- }): N.TSSymbolKeyword;
1878
+ }): namedTypes.TSSymbolKeyword;
1869
1879
  }
1870
1880
  export interface TSUndefinedKeywordBuilder {
1871
- (): N.TSUndefinedKeyword;
1881
+ (): namedTypes.TSUndefinedKeyword;
1872
1882
  from(params: {
1873
1883
  comments?: K.CommentKind[] | null;
1874
1884
  loc?: K.SourceLocationKind | null;
1875
- }): N.TSUndefinedKeyword;
1885
+ }): namedTypes.TSUndefinedKeyword;
1876
1886
  }
1877
1887
  export interface TSUnknownKeywordBuilder {
1878
- (): N.TSUnknownKeyword;
1888
+ (): namedTypes.TSUnknownKeyword;
1879
1889
  from(params: {
1880
1890
  comments?: K.CommentKind[] | null;
1881
1891
  loc?: K.SourceLocationKind | null;
1882
- }): N.TSUnknownKeyword;
1892
+ }): namedTypes.TSUnknownKeyword;
1883
1893
  }
1884
1894
  export interface TSVoidKeywordBuilder {
1885
- (): N.TSVoidKeyword;
1895
+ (): namedTypes.TSVoidKeyword;
1886
1896
  from(params: {
1887
1897
  comments?: K.CommentKind[] | null;
1888
1898
  loc?: K.SourceLocationKind | null;
1889
- }): N.TSVoidKeyword;
1899
+ }): namedTypes.TSVoidKeyword;
1890
1900
  }
1891
1901
  export interface TSThisTypeBuilder {
1892
- (): N.TSThisType;
1902
+ (): namedTypes.TSThisType;
1893
1903
  from(params: {
1894
1904
  comments?: K.CommentKind[] | null;
1895
1905
  loc?: K.SourceLocationKind | null;
1896
- }): N.TSThisType;
1906
+ }): namedTypes.TSThisType;
1897
1907
  }
1898
1908
  export interface TSArrayTypeBuilder {
1899
- (elementType: K.TSTypeKind): N.TSArrayType;
1909
+ (elementType: K.TSTypeKind): namedTypes.TSArrayType;
1900
1910
  from(params: {
1901
1911
  comments?: K.CommentKind[] | null;
1902
1912
  elementType: K.TSTypeKind;
1903
1913
  loc?: K.SourceLocationKind | null;
1904
- }): N.TSArrayType;
1914
+ }): namedTypes.TSArrayType;
1905
1915
  }
1906
1916
  export interface TSLiteralTypeBuilder {
1907
- (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind): N.TSLiteralType;
1917
+ (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind): namedTypes.TSLiteralType;
1908
1918
  from(params: {
1909
1919
  comments?: K.CommentKind[] | null;
1910
1920
  literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind;
1911
1921
  loc?: K.SourceLocationKind | null;
1912
- }): N.TSLiteralType;
1922
+ }): namedTypes.TSLiteralType;
1913
1923
  }
1914
1924
  export interface TSUnionTypeBuilder {
1915
- (types: K.TSTypeKind[]): N.TSUnionType;
1925
+ (types: K.TSTypeKind[]): namedTypes.TSUnionType;
1916
1926
  from(params: {
1917
1927
  comments?: K.CommentKind[] | null;
1918
1928
  loc?: K.SourceLocationKind | null;
1919
1929
  types: K.TSTypeKind[];
1920
- }): N.TSUnionType;
1930
+ }): namedTypes.TSUnionType;
1921
1931
  }
1922
1932
  export interface TSIntersectionTypeBuilder {
1923
- (types: K.TSTypeKind[]): N.TSIntersectionType;
1933
+ (types: K.TSTypeKind[]): namedTypes.TSIntersectionType;
1924
1934
  from(params: {
1925
1935
  comments?: K.CommentKind[] | null;
1926
1936
  loc?: K.SourceLocationKind | null;
1927
1937
  types: K.TSTypeKind[];
1928
- }): N.TSIntersectionType;
1938
+ }): namedTypes.TSIntersectionType;
1929
1939
  }
1930
1940
  export interface TSConditionalTypeBuilder {
1931
- (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): N.TSConditionalType;
1941
+ (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): namedTypes.TSConditionalType;
1932
1942
  from(params: {
1933
1943
  checkType: K.TSTypeKind;
1934
1944
  comments?: K.CommentKind[] | null;
@@ -1936,18 +1946,18 @@ export interface TSConditionalTypeBuilder {
1936
1946
  falseType: K.TSTypeKind;
1937
1947
  loc?: K.SourceLocationKind | null;
1938
1948
  trueType: K.TSTypeKind;
1939
- }): N.TSConditionalType;
1949
+ }): namedTypes.TSConditionalType;
1940
1950
  }
1941
1951
  export interface TSInferTypeBuilder {
1942
- (typeParameter: K.TSTypeParameterKind): N.TSInferType;
1952
+ (typeParameter: K.TSTypeParameterKind): namedTypes.TSInferType;
1943
1953
  from(params: {
1944
1954
  comments?: K.CommentKind[] | null;
1945
1955
  loc?: K.SourceLocationKind | null;
1946
1956
  typeParameter: K.TSTypeParameterKind;
1947
- }): N.TSInferType;
1957
+ }): namedTypes.TSInferType;
1948
1958
  }
1949
1959
  export interface TSTypeParameterBuilder {
1950
- (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): N.TSTypeParameter;
1960
+ (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): namedTypes.TSTypeParameter;
1951
1961
  from(params: {
1952
1962
  comments?: K.CommentKind[] | null;
1953
1963
  constraint?: K.TSTypeKind | undefined;
@@ -1956,38 +1966,38 @@ export interface TSTypeParameterBuilder {
1956
1966
  name: string;
1957
1967
  optional?: boolean;
1958
1968
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1959
- }): N.TSTypeParameter;
1969
+ }): namedTypes.TSTypeParameter;
1960
1970
  }
1961
1971
  export interface TSParenthesizedTypeBuilder {
1962
- (typeAnnotation: K.TSTypeKind): N.TSParenthesizedType;
1972
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSParenthesizedType;
1963
1973
  from(params: {
1964
1974
  comments?: K.CommentKind[] | null;
1965
1975
  loc?: K.SourceLocationKind | null;
1966
1976
  typeAnnotation: K.TSTypeKind;
1967
- }): N.TSParenthesizedType;
1977
+ }): namedTypes.TSParenthesizedType;
1968
1978
  }
1969
1979
  export interface TSFunctionTypeBuilder {
1970
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): N.TSFunctionType;
1980
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSFunctionType;
1971
1981
  from(params: {
1972
1982
  comments?: K.CommentKind[] | null;
1973
1983
  loc?: K.SourceLocationKind | null;
1974
1984
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
1975
1985
  typeAnnotation?: K.TSTypeAnnotationKind | null;
1976
1986
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
1977
- }): N.TSFunctionType;
1987
+ }): namedTypes.TSFunctionType;
1978
1988
  }
1979
1989
  export interface TSConstructorTypeBuilder {
1980
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): N.TSConstructorType;
1990
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSConstructorType;
1981
1991
  from(params: {
1982
1992
  comments?: K.CommentKind[] | null;
1983
1993
  loc?: K.SourceLocationKind | null;
1984
1994
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
1985
1995
  typeAnnotation?: K.TSTypeAnnotationKind | null;
1986
1996
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
1987
- }): N.TSConstructorType;
1997
+ }): namedTypes.TSConstructorType;
1988
1998
  }
1989
1999
  export interface TSDeclareFunctionBuilder {
1990
- (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareFunction;
2000
+ (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareFunction;
1991
2001
  from(params: {
1992
2002
  async?: boolean;
1993
2003
  comments?: K.CommentKind[] | null;
@@ -1998,10 +2008,10 @@ export interface TSDeclareFunctionBuilder {
1998
2008
  params: K.PatternKind[];
1999
2009
  returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
2000
2010
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2001
- }): N.TSDeclareFunction;
2011
+ }): namedTypes.TSDeclareFunction;
2002
2012
  }
2003
2013
  export interface TSDeclareMethodBuilder {
2004
- (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareMethod;
2014
+ (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareMethod;
2005
2015
  from(params: {
2006
2016
  abstract?: boolean;
2007
2017
  access?: "public" | "private" | "protected" | undefined;
@@ -2019,10 +2029,10 @@ export interface TSDeclareMethodBuilder {
2019
2029
  returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
2020
2030
  static?: boolean;
2021
2031
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2022
- }): N.TSDeclareMethod;
2032
+ }): namedTypes.TSDeclareMethod;
2023
2033
  }
2024
2034
  export interface TSMappedTypeBuilder {
2025
- (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): N.TSMappedType;
2035
+ (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): namedTypes.TSMappedType;
2026
2036
  from(params: {
2027
2037
  comments?: K.CommentKind[] | null;
2028
2038
  loc?: K.SourceLocationKind | null;
@@ -2030,62 +2040,62 @@ export interface TSMappedTypeBuilder {
2030
2040
  readonly?: boolean | "+" | "-";
2031
2041
  typeAnnotation?: K.TSTypeKind | null;
2032
2042
  typeParameter: K.TSTypeParameterKind;
2033
- }): N.TSMappedType;
2043
+ }): namedTypes.TSMappedType;
2034
2044
  }
2035
2045
  export interface TSTupleTypeBuilder {
2036
- (elementTypes: K.TSTypeKind[]): N.TSTupleType;
2046
+ (elementTypes: K.TSTypeKind[]): namedTypes.TSTupleType;
2037
2047
  from(params: {
2038
2048
  comments?: K.CommentKind[] | null;
2039
2049
  elementTypes: K.TSTypeKind[];
2040
2050
  loc?: K.SourceLocationKind | null;
2041
- }): N.TSTupleType;
2051
+ }): namedTypes.TSTupleType;
2042
2052
  }
2043
2053
  export interface TSRestTypeBuilder {
2044
- (typeAnnotation: K.TSTypeKind): N.TSRestType;
2054
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSRestType;
2045
2055
  from(params: {
2046
2056
  comments?: K.CommentKind[] | null;
2047
2057
  loc?: K.SourceLocationKind | null;
2048
2058
  typeAnnotation: K.TSTypeKind;
2049
- }): N.TSRestType;
2059
+ }): namedTypes.TSRestType;
2050
2060
  }
2051
2061
  export interface TSOptionalTypeBuilder {
2052
- (typeAnnotation: K.TSTypeKind): N.TSOptionalType;
2062
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSOptionalType;
2053
2063
  from(params: {
2054
2064
  comments?: K.CommentKind[] | null;
2055
2065
  loc?: K.SourceLocationKind | null;
2056
2066
  typeAnnotation: K.TSTypeKind;
2057
- }): N.TSOptionalType;
2067
+ }): namedTypes.TSOptionalType;
2058
2068
  }
2059
2069
  export interface TSIndexedAccessTypeBuilder {
2060
- (objectType: K.TSTypeKind, indexType: K.TSTypeKind): N.TSIndexedAccessType;
2070
+ (objectType: K.TSTypeKind, indexType: K.TSTypeKind): namedTypes.TSIndexedAccessType;
2061
2071
  from(params: {
2062
2072
  comments?: K.CommentKind[] | null;
2063
2073
  indexType: K.TSTypeKind;
2064
2074
  loc?: K.SourceLocationKind | null;
2065
2075
  objectType: K.TSTypeKind;
2066
- }): N.TSIndexedAccessType;
2076
+ }): namedTypes.TSIndexedAccessType;
2067
2077
  }
2068
2078
  export interface TSTypeOperatorBuilder {
2069
- (operator: string): N.TSTypeOperator;
2079
+ (operator: string): namedTypes.TSTypeOperator;
2070
2080
  from(params: {
2071
2081
  comments?: K.CommentKind[] | null;
2072
2082
  loc?: K.SourceLocationKind | null;
2073
2083
  operator: string;
2074
2084
  typeAnnotation: K.TSTypeKind;
2075
- }): N.TSTypeOperator;
2085
+ }): namedTypes.TSTypeOperator;
2076
2086
  }
2077
2087
  export interface TSIndexSignatureBuilder {
2078
- (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSIndexSignature;
2088
+ (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSIndexSignature;
2079
2089
  from(params: {
2080
2090
  comments?: K.CommentKind[] | null;
2081
2091
  loc?: K.SourceLocationKind | null;
2082
2092
  parameters: K.IdentifierKind[];
2083
2093
  readonly?: boolean;
2084
2094
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2085
- }): N.TSIndexSignature;
2095
+ }): namedTypes.TSIndexSignature;
2086
2096
  }
2087
2097
  export interface TSPropertySignatureBuilder {
2088
- (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): N.TSPropertySignature;
2098
+ (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): namedTypes.TSPropertySignature;
2089
2099
  from(params: {
2090
2100
  comments?: K.CommentKind[] | null;
2091
2101
  computed?: boolean;
@@ -2095,10 +2105,10 @@ export interface TSPropertySignatureBuilder {
2095
2105
  optional?: boolean;
2096
2106
  readonly?: boolean;
2097
2107
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2098
- }): N.TSPropertySignature;
2108
+ }): namedTypes.TSPropertySignature;
2099
2109
  }
2100
2110
  export interface TSMethodSignatureBuilder {
2101
- (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSMethodSignature;
2111
+ (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSMethodSignature;
2102
2112
  from(params: {
2103
2113
  comments?: K.CommentKind[] | null;
2104
2114
  computed?: boolean;
@@ -2108,74 +2118,74 @@ export interface TSMethodSignatureBuilder {
2108
2118
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2109
2119
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2110
2120
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2111
- }): N.TSMethodSignature;
2121
+ }): namedTypes.TSMethodSignature;
2112
2122
  }
2113
2123
  export interface TSTypePredicateBuilder {
2114
- (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): N.TSTypePredicate;
2124
+ (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): namedTypes.TSTypePredicate;
2115
2125
  from(params: {
2116
2126
  comments?: K.CommentKind[] | null;
2117
2127
  loc?: K.SourceLocationKind | null;
2118
2128
  parameterName: K.IdentifierKind | K.TSThisTypeKind;
2119
2129
  typeAnnotation: K.TSTypeAnnotationKind;
2120
- }): N.TSTypePredicate;
2130
+ }): namedTypes.TSTypePredicate;
2121
2131
  }
2122
2132
  export interface TSCallSignatureDeclarationBuilder {
2123
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSCallSignatureDeclaration;
2133
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSCallSignatureDeclaration;
2124
2134
  from(params: {
2125
2135
  comments?: K.CommentKind[] | null;
2126
2136
  loc?: K.SourceLocationKind | null;
2127
2137
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2128
2138
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2129
2139
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2130
- }): N.TSCallSignatureDeclaration;
2140
+ }): namedTypes.TSCallSignatureDeclaration;
2131
2141
  }
2132
2142
  export interface TSConstructSignatureDeclarationBuilder {
2133
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSConstructSignatureDeclaration;
2143
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSConstructSignatureDeclaration;
2134
2144
  from(params: {
2135
2145
  comments?: K.CommentKind[] | null;
2136
2146
  loc?: K.SourceLocationKind | null;
2137
2147
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2138
2148
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2139
2149
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2140
- }): N.TSConstructSignatureDeclaration;
2150
+ }): namedTypes.TSConstructSignatureDeclaration;
2141
2151
  }
2142
2152
  export interface TSEnumMemberBuilder {
2143
- (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): N.TSEnumMember;
2153
+ (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): namedTypes.TSEnumMember;
2144
2154
  from(params: {
2145
2155
  comments?: K.CommentKind[] | null;
2146
2156
  id: K.IdentifierKind | K.StringLiteralKind;
2147
2157
  initializer?: K.ExpressionKind | null;
2148
2158
  loc?: K.SourceLocationKind | null;
2149
- }): N.TSEnumMember;
2159
+ }): namedTypes.TSEnumMember;
2150
2160
  }
2151
2161
  export interface TSTypeQueryBuilder {
2152
- (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): N.TSTypeQuery;
2162
+ (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): namedTypes.TSTypeQuery;
2153
2163
  from(params: {
2154
2164
  comments?: K.CommentKind[] | null;
2155
2165
  exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind;
2156
2166
  loc?: K.SourceLocationKind | null;
2157
- }): N.TSTypeQuery;
2167
+ }): namedTypes.TSTypeQuery;
2158
2168
  }
2159
2169
  export interface TSImportTypeBuilder {
2160
- (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSImportType;
2170
+ (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSImportType;
2161
2171
  from(params: {
2162
2172
  argument: K.StringLiteralKind;
2163
2173
  comments?: K.CommentKind[] | null;
2164
2174
  loc?: K.SourceLocationKind | null;
2165
2175
  qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined;
2166
2176
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
2167
- }): N.TSImportType;
2177
+ }): namedTypes.TSImportType;
2168
2178
  }
2169
2179
  export interface TSTypeLiteralBuilder {
2170
- (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSTypeLiteral;
2180
+ (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSTypeLiteral;
2171
2181
  from(params: {
2172
2182
  comments?: K.CommentKind[] | null;
2173
2183
  loc?: K.SourceLocationKind | null;
2174
2184
  members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
2175
- }): N.TSTypeLiteral;
2185
+ }): namedTypes.TSTypeLiteral;
2176
2186
  }
2177
2187
  export interface TSTypeAssertionBuilder {
2178
- (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): N.TSTypeAssertion;
2188
+ (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): namedTypes.TSTypeAssertion;
2179
2189
  from(params: {
2180
2190
  comments?: K.CommentKind[] | null;
2181
2191
  expression: K.ExpressionKind;
@@ -2184,10 +2194,10 @@ export interface TSTypeAssertionBuilder {
2184
2194
  } | null;
2185
2195
  loc?: K.SourceLocationKind | null;
2186
2196
  typeAnnotation: K.TSTypeKind;
2187
- }): N.TSTypeAssertion;
2197
+ }): namedTypes.TSTypeAssertion;
2188
2198
  }
2189
2199
  export interface TSEnumDeclarationBuilder {
2190
- (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): N.TSEnumDeclaration;
2200
+ (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): namedTypes.TSEnumDeclaration;
2191
2201
  from(params: {
2192
2202
  comments?: K.CommentKind[] | null;
2193
2203
  const?: boolean;
@@ -2196,10 +2206,10 @@ export interface TSEnumDeclarationBuilder {
2196
2206
  initializer?: K.ExpressionKind | null;
2197
2207
  loc?: K.SourceLocationKind | null;
2198
2208
  members: K.TSEnumMemberKind[];
2199
- }): N.TSEnumDeclaration;
2209
+ }): namedTypes.TSEnumDeclaration;
2200
2210
  }
2201
2211
  export interface TSTypeAliasDeclarationBuilder {
2202
- (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): N.TSTypeAliasDeclaration;
2212
+ (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): namedTypes.TSTypeAliasDeclaration;
2203
2213
  from(params: {
2204
2214
  comments?: K.CommentKind[] | null;
2205
2215
  declare?: boolean;
@@ -2207,18 +2217,18 @@ export interface TSTypeAliasDeclarationBuilder {
2207
2217
  loc?: K.SourceLocationKind | null;
2208
2218
  typeAnnotation: K.TSTypeKind;
2209
2219
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2210
- }): N.TSTypeAliasDeclaration;
2220
+ }): namedTypes.TSTypeAliasDeclaration;
2211
2221
  }
2212
2222
  export interface TSModuleBlockBuilder {
2213
- (body: K.StatementKind[]): N.TSModuleBlock;
2223
+ (body: K.StatementKind[]): namedTypes.TSModuleBlock;
2214
2224
  from(params: {
2215
2225
  body: K.StatementKind[];
2216
2226
  comments?: K.CommentKind[] | null;
2217
2227
  loc?: K.SourceLocationKind | null;
2218
- }): N.TSModuleBlock;
2228
+ }): namedTypes.TSModuleBlock;
2219
2229
  }
2220
2230
  export interface TSModuleDeclarationBuilder {
2221
- (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): N.TSModuleDeclaration;
2231
+ (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): namedTypes.TSModuleDeclaration;
2222
2232
  from(params: {
2223
2233
  body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null;
2224
2234
  comments?: K.CommentKind[] | null;
@@ -2226,52 +2236,52 @@ export interface TSModuleDeclarationBuilder {
2226
2236
  global?: boolean;
2227
2237
  id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind;
2228
2238
  loc?: K.SourceLocationKind | null;
2229
- }): N.TSModuleDeclaration;
2239
+ }): namedTypes.TSModuleDeclaration;
2230
2240
  }
2231
2241
  export interface TSImportEqualsDeclarationBuilder {
2232
- (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): N.TSImportEqualsDeclaration;
2242
+ (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): namedTypes.TSImportEqualsDeclaration;
2233
2243
  from(params: {
2234
2244
  comments?: K.CommentKind[] | null;
2235
2245
  id: K.IdentifierKind;
2236
2246
  isExport?: boolean;
2237
2247
  loc?: K.SourceLocationKind | null;
2238
2248
  moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind;
2239
- }): N.TSImportEqualsDeclaration;
2249
+ }): namedTypes.TSImportEqualsDeclaration;
2240
2250
  }
2241
2251
  export interface TSExternalModuleReferenceBuilder {
2242
- (expression: K.StringLiteralKind): N.TSExternalModuleReference;
2252
+ (expression: K.StringLiteralKind): namedTypes.TSExternalModuleReference;
2243
2253
  from(params: {
2244
2254
  comments?: K.CommentKind[] | null;
2245
2255
  expression: K.StringLiteralKind;
2246
2256
  loc?: K.SourceLocationKind | null;
2247
- }): N.TSExternalModuleReference;
2257
+ }): namedTypes.TSExternalModuleReference;
2248
2258
  }
2249
2259
  export interface TSExportAssignmentBuilder {
2250
- (expression: K.ExpressionKind): N.TSExportAssignment;
2260
+ (expression: K.ExpressionKind): namedTypes.TSExportAssignment;
2251
2261
  from(params: {
2252
2262
  comments?: K.CommentKind[] | null;
2253
2263
  expression: K.ExpressionKind;
2254
2264
  loc?: K.SourceLocationKind | null;
2255
- }): N.TSExportAssignment;
2265
+ }): namedTypes.TSExportAssignment;
2256
2266
  }
2257
2267
  export interface TSNamespaceExportDeclarationBuilder {
2258
- (id: K.IdentifierKind): N.TSNamespaceExportDeclaration;
2268
+ (id: K.IdentifierKind): namedTypes.TSNamespaceExportDeclaration;
2259
2269
  from(params: {
2260
2270
  comments?: K.CommentKind[] | null;
2261
2271
  id: K.IdentifierKind;
2262
2272
  loc?: K.SourceLocationKind | null;
2263
- }): N.TSNamespaceExportDeclaration;
2273
+ }): namedTypes.TSNamespaceExportDeclaration;
2264
2274
  }
2265
2275
  export interface TSInterfaceBodyBuilder {
2266
- (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSInterfaceBody;
2276
+ (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSInterfaceBody;
2267
2277
  from(params: {
2268
2278
  body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
2269
2279
  comments?: K.CommentKind[] | null;
2270
2280
  loc?: K.SourceLocationKind | null;
2271
- }): N.TSInterfaceBody;
2281
+ }): namedTypes.TSInterfaceBody;
2272
2282
  }
2273
2283
  export interface TSInterfaceDeclarationBuilder {
2274
- (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): N.TSInterfaceDeclaration;
2284
+ (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): namedTypes.TSInterfaceDeclaration;
2275
2285
  from(params: {
2276
2286
  body: K.TSInterfaceBodyKind;
2277
2287
  comments?: K.CommentKind[] | null;
@@ -2280,20 +2290,20 @@ export interface TSInterfaceDeclarationBuilder {
2280
2290
  id: K.IdentifierKind | K.TSQualifiedNameKind;
2281
2291
  loc?: K.SourceLocationKind | null;
2282
2292
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2283
- }): N.TSInterfaceDeclaration;
2293
+ }): namedTypes.TSInterfaceDeclaration;
2284
2294
  }
2285
2295
  export interface TSParameterPropertyBuilder {
2286
- (parameter: K.IdentifierKind | K.AssignmentPatternKind): N.TSParameterProperty;
2296
+ (parameter: K.IdentifierKind | K.AssignmentPatternKind): namedTypes.TSParameterProperty;
2287
2297
  from(params: {
2288
2298
  accessibility?: "public" | "private" | "protected" | undefined;
2289
2299
  comments?: K.CommentKind[] | null;
2290
2300
  loc?: K.SourceLocationKind | null;
2291
2301
  parameter: K.IdentifierKind | K.AssignmentPatternKind;
2292
2302
  readonly?: boolean;
2293
- }): N.TSParameterProperty;
2303
+ }): namedTypes.TSParameterProperty;
2294
2304
  }
2295
2305
  export interface OptionalMemberExpressionBuilder {
2296
- (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): N.OptionalMemberExpression;
2306
+ (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
2297
2307
  from(params: {
2298
2308
  comments?: K.CommentKind[] | null;
2299
2309
  computed?: boolean;
@@ -2301,19 +2311,20 @@ export interface OptionalMemberExpressionBuilder {
2301
2311
  object: K.ExpressionKind;
2302
2312
  optional?: boolean;
2303
2313
  property: K.IdentifierKind | K.ExpressionKind;
2304
- }): N.OptionalMemberExpression;
2314
+ }): namedTypes.OptionalMemberExpression;
2305
2315
  }
2306
2316
  export interface OptionalCallExpressionBuilder {
2307
- (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): N.OptionalCallExpression;
2317
+ (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): namedTypes.OptionalCallExpression;
2308
2318
  from(params: {
2309
2319
  arguments: (K.ExpressionKind | K.SpreadElementKind)[];
2310
2320
  callee: K.ExpressionKind;
2311
2321
  comments?: K.CommentKind[] | null;
2312
2322
  loc?: K.SourceLocationKind | null;
2313
2323
  optional?: boolean;
2314
- }): N.OptionalCallExpression;
2324
+ typeArguments?: null | K.TypeParameterInstantiationKind;
2325
+ }): namedTypes.OptionalCallExpression;
2315
2326
  }
2316
- export interface Builders {
2327
+ export interface builders {
2317
2328
  file: FileBuilder;
2318
2329
  program: ProgramBuilder;
2319
2330
  identifier: IdentifierBuilder;
@@ -2349,12 +2360,12 @@ export interface Builders {
2349
2360
  unaryExpression: UnaryExpressionBuilder;
2350
2361
  binaryExpression: BinaryExpressionBuilder;
2351
2362
  assignmentExpression: AssignmentExpressionBuilder;
2363
+ memberExpression: MemberExpressionBuilder;
2352
2364
  updateExpression: UpdateExpressionBuilder;
2353
2365
  logicalExpression: LogicalExpressionBuilder;
2354
2366
  conditionalExpression: ConditionalExpressionBuilder;
2355
2367
  newExpression: NewExpressionBuilder;
2356
2368
  callExpression: CallExpressionBuilder;
2357
- memberExpression: MemberExpressionBuilder;
2358
2369
  restElement: RestElementBuilder;
2359
2370
  typeAnnotation: TypeAnnotationBuilder;
2360
2371
  tsTypeAnnotation: TSTypeAnnotationBuilder;
@@ -2387,6 +2398,7 @@ export interface Builders {
2387
2398
  spreadProperty: SpreadPropertyBuilder;
2388
2399
  spreadPropertyPattern: SpreadPropertyPatternBuilder;
2389
2400
  awaitExpression: AwaitExpressionBuilder;
2401
+ importExpression: ImportExpressionBuilder;
2390
2402
  jsxAttribute: JSXAttributeBuilder;
2391
2403
  jsxIdentifier: JSXIdentifierBuilder;
2392
2404
  jsxNamespacedName: JSXNamespacedNameBuilder;