ast-types 0.12.3 → 0.13.2

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 (20) hide show
  1. package/.travis.yml +1 -0
  2. package/README.md +218 -201
  3. package/def/core.js +4 -7
  4. package/def/flow.js +4 -0
  5. package/def/typescript.js +5 -5
  6. package/fork.d.ts +3 -7
  7. package/fork.js +1 -2
  8. package/gen/builders.d.ts +500 -497
  9. package/gen/kinds.d.ts +262 -262
  10. package/gen/namedTypes.d.ts +1791 -262
  11. package/gen/namedTypes.js +3 -0
  12. package/gen/nodes.d.ts +16 -16
  13. package/gen/visitor.d.ts +262 -262
  14. package/lib/node-path.js +8 -6
  15. package/lib/path-visitor.d.ts +1 -1
  16. package/lib/scope.js +7 -2
  17. package/lib/types.d.ts +2 -6
  18. package/main.d.ts +25 -13
  19. package/main.js +25 -6
  20. package/package.json +19 -19
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,89 @@ 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;
723
725
  }
724
726
  export interface JSXAttributeBuilder {
725
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): N.JSXAttribute;
727
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind, value?: K.LiteralKind | K.JSXExpressionContainerKind | null): namedTypes.JSXAttribute;
726
728
  from(params: {
727
729
  comments?: K.CommentKind[] | null;
728
730
  loc?: K.SourceLocationKind | null;
729
731
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;
730
732
  value?: K.LiteralKind | K.JSXExpressionContainerKind | null;
731
- }): N.JSXAttribute;
733
+ }): namedTypes.JSXAttribute;
732
734
  }
733
735
  export interface JSXIdentifierBuilder {
734
- (name: string): N.JSXIdentifier;
736
+ (name: string): namedTypes.JSXIdentifier;
735
737
  from(params: {
736
738
  comments?: K.CommentKind[] | null;
737
739
  loc?: K.SourceLocationKind | null;
738
740
  name: string;
739
741
  optional?: boolean;
740
742
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
741
- }): N.JSXIdentifier;
743
+ }): namedTypes.JSXIdentifier;
742
744
  }
743
745
  export interface JSXNamespacedNameBuilder {
744
- (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): N.JSXNamespacedName;
746
+ (namespace: K.JSXIdentifierKind, name: K.JSXIdentifierKind): namedTypes.JSXNamespacedName;
745
747
  from(params: {
746
748
  comments?: K.CommentKind[] | null;
747
749
  loc?: K.SourceLocationKind | null;
748
750
  name: K.JSXIdentifierKind;
749
751
  namespace: K.JSXIdentifierKind;
750
- }): N.JSXNamespacedName;
752
+ }): namedTypes.JSXNamespacedName;
751
753
  }
752
754
  export interface JSXExpressionContainerBuilder {
753
- (expression: K.ExpressionKind): N.JSXExpressionContainer;
755
+ (expression: K.ExpressionKind): namedTypes.JSXExpressionContainer;
754
756
  from(params: {
755
757
  comments?: K.CommentKind[] | null;
756
758
  expression: K.ExpressionKind;
757
759
  loc?: K.SourceLocationKind | null;
758
- }): N.JSXExpressionContainer;
760
+ }): namedTypes.JSXExpressionContainer;
759
761
  }
760
762
  export interface JSXMemberExpressionBuilder {
761
- (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): N.JSXMemberExpression;
763
+ (object: K.JSXIdentifierKind | K.JSXMemberExpressionKind, property: K.JSXIdentifierKind): namedTypes.JSXMemberExpression;
762
764
  from(params: {
763
765
  comments?: K.CommentKind[] | null;
764
766
  computed?: boolean;
765
767
  loc?: K.SourceLocationKind | null;
766
768
  object: K.JSXIdentifierKind | K.JSXMemberExpressionKind;
767
769
  property: K.JSXIdentifierKind;
768
- }): N.JSXMemberExpression;
770
+ }): namedTypes.JSXMemberExpression;
769
771
  }
770
772
  export interface JSXSpreadAttributeBuilder {
771
- (argument: K.ExpressionKind): N.JSXSpreadAttribute;
773
+ (argument: K.ExpressionKind): namedTypes.JSXSpreadAttribute;
772
774
  from(params: {
773
775
  argument: K.ExpressionKind;
774
776
  comments?: K.CommentKind[] | null;
775
777
  loc?: K.SourceLocationKind | null;
776
- }): N.JSXSpreadAttribute;
778
+ }): namedTypes.JSXSpreadAttribute;
777
779
  }
778
780
  export interface JSXElementBuilder {
779
- (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXElement;
781
+ (openingElement: K.JSXOpeningElementKind, closingElement?: K.JSXClosingElementKind | null, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXElement;
780
782
  from(params: {
781
783
  attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
782
784
  children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
@@ -786,38 +788,38 @@ export interface JSXElementBuilder {
786
788
  name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
787
789
  openingElement: K.JSXOpeningElementKind;
788
790
  selfClosing?: boolean;
789
- }): N.JSXElement;
791
+ }): namedTypes.JSXElement;
790
792
  }
791
793
  export interface JSXOpeningElementBuilder {
792
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): N.JSXOpeningElement;
794
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind, attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[], selfClosing?: boolean): namedTypes.JSXOpeningElement;
793
795
  from(params: {
794
796
  attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];
795
797
  comments?: K.CommentKind[] | null;
796
798
  loc?: K.SourceLocationKind | null;
797
799
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
798
800
  selfClosing?: boolean;
799
- }): N.JSXOpeningElement;
801
+ }): namedTypes.JSXOpeningElement;
800
802
  }
801
803
  export interface JSXClosingElementBuilder {
802
- (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): N.JSXClosingElement;
804
+ (name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind): namedTypes.JSXClosingElement;
803
805
  from(params: {
804
806
  comments?: K.CommentKind[] | null;
805
807
  loc?: K.SourceLocationKind | null;
806
808
  name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;
807
- }): N.JSXClosingElement;
809
+ }): namedTypes.JSXClosingElement;
808
810
  }
809
811
  export interface JSXFragmentBuilder {
810
- (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): N.JSXFragment;
812
+ (openingElement: K.JSXOpeningFragmentKind, closingElement: K.JSXClosingFragmentKind, children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]): namedTypes.JSXFragment;
811
813
  from(params: {
812
814
  children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[];
813
815
  closingElement: K.JSXClosingFragmentKind;
814
816
  comments?: K.CommentKind[] | null;
815
817
  loc?: K.SourceLocationKind | null;
816
818
  openingElement: K.JSXOpeningFragmentKind;
817
- }): N.JSXFragment;
819
+ }): namedTypes.JSXFragment;
818
820
  }
819
821
  export interface JSXTextBuilder {
820
- (value: string): N.JSXText;
822
+ (value: string): namedTypes.JSXText;
821
823
  from(params: {
822
824
  comments?: K.CommentKind[] | null;
823
825
  loc?: K.SourceLocationKind | null;
@@ -826,218 +828,218 @@ export interface JSXTextBuilder {
826
828
  flags: string;
827
829
  } | null;
828
830
  value: string;
829
- }): N.JSXText;
831
+ }): namedTypes.JSXText;
830
832
  }
831
833
  export interface JSXOpeningFragmentBuilder {
832
- (): N.JSXOpeningFragment;
834
+ (): namedTypes.JSXOpeningFragment;
833
835
  from(params: {
834
836
  comments?: K.CommentKind[] | null;
835
837
  loc?: K.SourceLocationKind | null;
836
- }): N.JSXOpeningFragment;
838
+ }): namedTypes.JSXOpeningFragment;
837
839
  }
838
840
  export interface JSXClosingFragmentBuilder {
839
- (): N.JSXClosingFragment;
841
+ (): namedTypes.JSXClosingFragment;
840
842
  from(params: {
841
843
  comments?: K.CommentKind[] | null;
842
844
  loc?: K.SourceLocationKind | null;
843
- }): N.JSXClosingFragment;
845
+ }): namedTypes.JSXClosingFragment;
844
846
  }
845
847
  export interface JSXEmptyExpressionBuilder {
846
- (): N.JSXEmptyExpression;
848
+ (): namedTypes.JSXEmptyExpression;
847
849
  from(params: {
848
850
  comments?: K.CommentKind[] | null;
849
851
  loc?: K.SourceLocationKind | null;
850
- }): N.JSXEmptyExpression;
852
+ }): namedTypes.JSXEmptyExpression;
851
853
  }
852
854
  export interface JSXSpreadChildBuilder {
853
- (expression: K.ExpressionKind): N.JSXSpreadChild;
855
+ (expression: K.ExpressionKind): namedTypes.JSXSpreadChild;
854
856
  from(params: {
855
857
  comments?: K.CommentKind[] | null;
856
858
  expression: K.ExpressionKind;
857
859
  loc?: K.SourceLocationKind | null;
858
- }): N.JSXSpreadChild;
860
+ }): namedTypes.JSXSpreadChild;
859
861
  }
860
862
  export interface TypeParameterDeclarationBuilder {
861
- (params: K.TypeParameterKind[]): N.TypeParameterDeclaration;
863
+ (params: K.TypeParameterKind[]): namedTypes.TypeParameterDeclaration;
862
864
  from(params: {
863
865
  comments?: K.CommentKind[] | null;
864
866
  loc?: K.SourceLocationKind | null;
865
867
  params: K.TypeParameterKind[];
866
- }): N.TypeParameterDeclaration;
868
+ }): namedTypes.TypeParameterDeclaration;
867
869
  }
868
870
  export interface TSTypeParameterDeclarationBuilder {
869
- (params: K.TSTypeParameterKind[]): N.TSTypeParameterDeclaration;
871
+ (params: K.TSTypeParameterKind[]): namedTypes.TSTypeParameterDeclaration;
870
872
  from(params: {
871
873
  comments?: K.CommentKind[] | null;
872
874
  loc?: K.SourceLocationKind | null;
873
875
  params: K.TSTypeParameterKind[];
874
- }): N.TSTypeParameterDeclaration;
876
+ }): namedTypes.TSTypeParameterDeclaration;
875
877
  }
876
878
  export interface TypeParameterInstantiationBuilder {
877
- (params: K.FlowTypeKind[]): N.TypeParameterInstantiation;
879
+ (params: K.FlowTypeKind[]): namedTypes.TypeParameterInstantiation;
878
880
  from(params: {
879
881
  comments?: K.CommentKind[] | null;
880
882
  loc?: K.SourceLocationKind | null;
881
883
  params: K.FlowTypeKind[];
882
- }): N.TypeParameterInstantiation;
884
+ }): namedTypes.TypeParameterInstantiation;
883
885
  }
884
886
  export interface TSTypeParameterInstantiationBuilder {
885
- (params: K.TSTypeKind[]): N.TSTypeParameterInstantiation;
887
+ (params: K.TSTypeKind[]): namedTypes.TSTypeParameterInstantiation;
886
888
  from(params: {
887
889
  comments?: K.CommentKind[] | null;
888
890
  loc?: K.SourceLocationKind | null;
889
891
  params: K.TSTypeKind[];
890
- }): N.TSTypeParameterInstantiation;
892
+ }): namedTypes.TSTypeParameterInstantiation;
891
893
  }
892
894
  export interface ClassImplementsBuilder {
893
- (id: K.IdentifierKind): N.ClassImplements;
895
+ (id: K.IdentifierKind): namedTypes.ClassImplements;
894
896
  from(params: {
895
897
  comments?: K.CommentKind[] | null;
896
898
  id: K.IdentifierKind;
897
899
  loc?: K.SourceLocationKind | null;
898
900
  superClass?: K.ExpressionKind | null;
899
901
  typeParameters?: K.TypeParameterInstantiationKind | null;
900
- }): N.ClassImplements;
902
+ }): namedTypes.ClassImplements;
901
903
  }
902
904
  export interface TSExpressionWithTypeArgumentsBuilder {
903
- (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSExpressionWithTypeArguments;
905
+ (expression: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSExpressionWithTypeArguments;
904
906
  from(params: {
905
907
  comments?: K.CommentKind[] | null;
906
908
  expression: K.IdentifierKind | K.TSQualifiedNameKind;
907
909
  loc?: K.SourceLocationKind | null;
908
910
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
909
- }): N.TSExpressionWithTypeArguments;
911
+ }): namedTypes.TSExpressionWithTypeArguments;
910
912
  }
911
913
  export interface AnyTypeAnnotationBuilder {
912
- (): N.AnyTypeAnnotation;
914
+ (): namedTypes.AnyTypeAnnotation;
913
915
  from(params: {
914
916
  comments?: K.CommentKind[] | null;
915
917
  loc?: K.SourceLocationKind | null;
916
- }): N.AnyTypeAnnotation;
918
+ }): namedTypes.AnyTypeAnnotation;
917
919
  }
918
920
  export interface EmptyTypeAnnotationBuilder {
919
- (): N.EmptyTypeAnnotation;
921
+ (): namedTypes.EmptyTypeAnnotation;
920
922
  from(params: {
921
923
  comments?: K.CommentKind[] | null;
922
924
  loc?: K.SourceLocationKind | null;
923
- }): N.EmptyTypeAnnotation;
925
+ }): namedTypes.EmptyTypeAnnotation;
924
926
  }
925
927
  export interface MixedTypeAnnotationBuilder {
926
- (): N.MixedTypeAnnotation;
928
+ (): namedTypes.MixedTypeAnnotation;
927
929
  from(params: {
928
930
  comments?: K.CommentKind[] | null;
929
931
  loc?: K.SourceLocationKind | null;
930
- }): N.MixedTypeAnnotation;
932
+ }): namedTypes.MixedTypeAnnotation;
931
933
  }
932
934
  export interface VoidTypeAnnotationBuilder {
933
- (): N.VoidTypeAnnotation;
935
+ (): namedTypes.VoidTypeAnnotation;
934
936
  from(params: {
935
937
  comments?: K.CommentKind[] | null;
936
938
  loc?: K.SourceLocationKind | null;
937
- }): N.VoidTypeAnnotation;
939
+ }): namedTypes.VoidTypeAnnotation;
938
940
  }
939
941
  export interface NumberTypeAnnotationBuilder {
940
- (): N.NumberTypeAnnotation;
942
+ (): namedTypes.NumberTypeAnnotation;
941
943
  from(params: {
942
944
  comments?: K.CommentKind[] | null;
943
945
  loc?: K.SourceLocationKind | null;
944
- }): N.NumberTypeAnnotation;
946
+ }): namedTypes.NumberTypeAnnotation;
945
947
  }
946
948
  export interface NumberLiteralTypeAnnotationBuilder {
947
- (value: number, raw: string): N.NumberLiteralTypeAnnotation;
949
+ (value: number, raw: string): namedTypes.NumberLiteralTypeAnnotation;
948
950
  from(params: {
949
951
  comments?: K.CommentKind[] | null;
950
952
  loc?: K.SourceLocationKind | null;
951
953
  raw: string;
952
954
  value: number;
953
- }): N.NumberLiteralTypeAnnotation;
955
+ }): namedTypes.NumberLiteralTypeAnnotation;
954
956
  }
955
957
  export interface NumericLiteralTypeAnnotationBuilder {
956
- (value: number, raw: string): N.NumericLiteralTypeAnnotation;
958
+ (value: number, raw: string): namedTypes.NumericLiteralTypeAnnotation;
957
959
  from(params: {
958
960
  comments?: K.CommentKind[] | null;
959
961
  loc?: K.SourceLocationKind | null;
960
962
  raw: string;
961
963
  value: number;
962
- }): N.NumericLiteralTypeAnnotation;
964
+ }): namedTypes.NumericLiteralTypeAnnotation;
963
965
  }
964
966
  export interface StringTypeAnnotationBuilder {
965
- (): N.StringTypeAnnotation;
967
+ (): namedTypes.StringTypeAnnotation;
966
968
  from(params: {
967
969
  comments?: K.CommentKind[] | null;
968
970
  loc?: K.SourceLocationKind | null;
969
- }): N.StringTypeAnnotation;
971
+ }): namedTypes.StringTypeAnnotation;
970
972
  }
971
973
  export interface StringLiteralTypeAnnotationBuilder {
972
- (value: string, raw: string): N.StringLiteralTypeAnnotation;
974
+ (value: string, raw: string): namedTypes.StringLiteralTypeAnnotation;
973
975
  from(params: {
974
976
  comments?: K.CommentKind[] | null;
975
977
  loc?: K.SourceLocationKind | null;
976
978
  raw: string;
977
979
  value: string;
978
- }): N.StringLiteralTypeAnnotation;
980
+ }): namedTypes.StringLiteralTypeAnnotation;
979
981
  }
980
982
  export interface BooleanTypeAnnotationBuilder {
981
- (): N.BooleanTypeAnnotation;
983
+ (): namedTypes.BooleanTypeAnnotation;
982
984
  from(params: {
983
985
  comments?: K.CommentKind[] | null;
984
986
  loc?: K.SourceLocationKind | null;
985
- }): N.BooleanTypeAnnotation;
987
+ }): namedTypes.BooleanTypeAnnotation;
986
988
  }
987
989
  export interface BooleanLiteralTypeAnnotationBuilder {
988
- (value: boolean, raw: string): N.BooleanLiteralTypeAnnotation;
990
+ (value: boolean, raw: string): namedTypes.BooleanLiteralTypeAnnotation;
989
991
  from(params: {
990
992
  comments?: K.CommentKind[] | null;
991
993
  loc?: K.SourceLocationKind | null;
992
994
  raw: string;
993
995
  value: boolean;
994
- }): N.BooleanLiteralTypeAnnotation;
996
+ }): namedTypes.BooleanLiteralTypeAnnotation;
995
997
  }
996
998
  export interface NullableTypeAnnotationBuilder {
997
- (typeAnnotation: K.FlowTypeKind): N.NullableTypeAnnotation;
999
+ (typeAnnotation: K.FlowTypeKind): namedTypes.NullableTypeAnnotation;
998
1000
  from(params: {
999
1001
  comments?: K.CommentKind[] | null;
1000
1002
  loc?: K.SourceLocationKind | null;
1001
1003
  typeAnnotation: K.FlowTypeKind;
1002
- }): N.NullableTypeAnnotation;
1004
+ }): namedTypes.NullableTypeAnnotation;
1003
1005
  }
1004
1006
  export interface NullLiteralTypeAnnotationBuilder {
1005
- (): N.NullLiteralTypeAnnotation;
1007
+ (): namedTypes.NullLiteralTypeAnnotation;
1006
1008
  from(params: {
1007
1009
  comments?: K.CommentKind[] | null;
1008
1010
  loc?: K.SourceLocationKind | null;
1009
- }): N.NullLiteralTypeAnnotation;
1011
+ }): namedTypes.NullLiteralTypeAnnotation;
1010
1012
  }
1011
1013
  export interface NullTypeAnnotationBuilder {
1012
- (): N.NullTypeAnnotation;
1014
+ (): namedTypes.NullTypeAnnotation;
1013
1015
  from(params: {
1014
1016
  comments?: K.CommentKind[] | null;
1015
1017
  loc?: K.SourceLocationKind | null;
1016
- }): N.NullTypeAnnotation;
1018
+ }): namedTypes.NullTypeAnnotation;
1017
1019
  }
1018
1020
  export interface ThisTypeAnnotationBuilder {
1019
- (): N.ThisTypeAnnotation;
1021
+ (): namedTypes.ThisTypeAnnotation;
1020
1022
  from(params: {
1021
1023
  comments?: K.CommentKind[] | null;
1022
1024
  loc?: K.SourceLocationKind | null;
1023
- }): N.ThisTypeAnnotation;
1025
+ }): namedTypes.ThisTypeAnnotation;
1024
1026
  }
1025
1027
  export interface ExistsTypeAnnotationBuilder {
1026
- (): N.ExistsTypeAnnotation;
1028
+ (): namedTypes.ExistsTypeAnnotation;
1027
1029
  from(params: {
1028
1030
  comments?: K.CommentKind[] | null;
1029
1031
  loc?: K.SourceLocationKind | null;
1030
- }): N.ExistsTypeAnnotation;
1032
+ }): namedTypes.ExistsTypeAnnotation;
1031
1033
  }
1032
1034
  export interface ExistentialTypeParamBuilder {
1033
- (): N.ExistentialTypeParam;
1035
+ (): namedTypes.ExistentialTypeParam;
1034
1036
  from(params: {
1035
1037
  comments?: K.CommentKind[] | null;
1036
1038
  loc?: K.SourceLocationKind | null;
1037
- }): N.ExistentialTypeParam;
1039
+ }): namedTypes.ExistentialTypeParam;
1038
1040
  }
1039
1041
  export interface FunctionTypeAnnotationBuilder {
1040
- (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): N.FunctionTypeAnnotation;
1042
+ (params: K.FunctionTypeParamKind[], returnType: K.FlowTypeKind, rest: K.FunctionTypeParamKind | null, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.FunctionTypeAnnotation;
1041
1043
  from(params: {
1042
1044
  comments?: K.CommentKind[] | null;
1043
1045
  loc?: K.SourceLocationKind | null;
@@ -1045,28 +1047,28 @@ export interface FunctionTypeAnnotationBuilder {
1045
1047
  rest: K.FunctionTypeParamKind | null;
1046
1048
  returnType: K.FlowTypeKind;
1047
1049
  typeParameters: K.TypeParameterDeclarationKind | null;
1048
- }): N.FunctionTypeAnnotation;
1050
+ }): namedTypes.FunctionTypeAnnotation;
1049
1051
  }
1050
1052
  export interface FunctionTypeParamBuilder {
1051
- (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): N.FunctionTypeParam;
1053
+ (name: K.IdentifierKind, typeAnnotation: K.FlowTypeKind, optional: boolean): namedTypes.FunctionTypeParam;
1052
1054
  from(params: {
1053
1055
  comments?: K.CommentKind[] | null;
1054
1056
  loc?: K.SourceLocationKind | null;
1055
1057
  name: K.IdentifierKind;
1056
1058
  optional: boolean;
1057
1059
  typeAnnotation: K.FlowTypeKind;
1058
- }): N.FunctionTypeParam;
1060
+ }): namedTypes.FunctionTypeParam;
1059
1061
  }
1060
1062
  export interface ArrayTypeAnnotationBuilder {
1061
- (elementType: K.FlowTypeKind): N.ArrayTypeAnnotation;
1063
+ (elementType: K.FlowTypeKind): namedTypes.ArrayTypeAnnotation;
1062
1064
  from(params: {
1063
1065
  comments?: K.CommentKind[] | null;
1064
1066
  elementType: K.FlowTypeKind;
1065
1067
  loc?: K.SourceLocationKind | null;
1066
- }): N.ArrayTypeAnnotation;
1068
+ }): namedTypes.ArrayTypeAnnotation;
1067
1069
  }
1068
1070
  export interface ObjectTypeAnnotationBuilder {
1069
- (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): N.ObjectTypeAnnotation;
1071
+ (properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[], indexers?: K.ObjectTypeIndexerKind[], callProperties?: K.ObjectTypeCallPropertyKind[]): namedTypes.ObjectTypeAnnotation;
1070
1072
  from(params: {
1071
1073
  callProperties?: K.ObjectTypeCallPropertyKind[];
1072
1074
  comments?: K.CommentKind[] | null;
@@ -1076,10 +1078,10 @@ export interface ObjectTypeAnnotationBuilder {
1076
1078
  internalSlots?: K.ObjectTypeInternalSlotKind[];
1077
1079
  loc?: K.SourceLocationKind | null;
1078
1080
  properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[];
1079
- }): N.ObjectTypeAnnotation;
1081
+ }): namedTypes.ObjectTypeAnnotation;
1080
1082
  }
1081
1083
  export interface ObjectTypePropertyBuilder {
1082
- (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): N.ObjectTypeProperty;
1084
+ (key: K.LiteralKind | K.IdentifierKind, value: K.FlowTypeKind, optional: boolean): namedTypes.ObjectTypeProperty;
1083
1085
  from(params: {
1084
1086
  comments?: K.CommentKind[] | null;
1085
1087
  key: K.LiteralKind | K.IdentifierKind;
@@ -1087,18 +1089,18 @@ export interface ObjectTypePropertyBuilder {
1087
1089
  optional: boolean;
1088
1090
  value: K.FlowTypeKind;
1089
1091
  variance?: K.VarianceKind | "plus" | "minus" | null;
1090
- }): N.ObjectTypeProperty;
1092
+ }): namedTypes.ObjectTypeProperty;
1091
1093
  }
1092
1094
  export interface ObjectTypeSpreadPropertyBuilder {
1093
- (argument: K.FlowTypeKind): N.ObjectTypeSpreadProperty;
1095
+ (argument: K.FlowTypeKind): namedTypes.ObjectTypeSpreadProperty;
1094
1096
  from(params: {
1095
1097
  argument: K.FlowTypeKind;
1096
1098
  comments?: K.CommentKind[] | null;
1097
1099
  loc?: K.SourceLocationKind | null;
1098
- }): N.ObjectTypeSpreadProperty;
1100
+ }): namedTypes.ObjectTypeSpreadProperty;
1099
1101
  }
1100
1102
  export interface ObjectTypeIndexerBuilder {
1101
- (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): N.ObjectTypeIndexer;
1103
+ (id: K.IdentifierKind, key: K.FlowTypeKind, value: K.FlowTypeKind): namedTypes.ObjectTypeIndexer;
1102
1104
  from(params: {
1103
1105
  comments?: K.CommentKind[] | null;
1104
1106
  id: K.IdentifierKind;
@@ -1106,19 +1108,19 @@ export interface ObjectTypeIndexerBuilder {
1106
1108
  loc?: K.SourceLocationKind | null;
1107
1109
  value: K.FlowTypeKind;
1108
1110
  variance?: K.VarianceKind | "plus" | "minus" | null;
1109
- }): N.ObjectTypeIndexer;
1111
+ }): namedTypes.ObjectTypeIndexer;
1110
1112
  }
1111
1113
  export interface ObjectTypeCallPropertyBuilder {
1112
- (value: K.FunctionTypeAnnotationKind): N.ObjectTypeCallProperty;
1114
+ (value: K.FunctionTypeAnnotationKind): namedTypes.ObjectTypeCallProperty;
1113
1115
  from(params: {
1114
1116
  comments?: K.CommentKind[] | null;
1115
1117
  loc?: K.SourceLocationKind | null;
1116
1118
  static?: boolean;
1117
1119
  value: K.FunctionTypeAnnotationKind;
1118
- }): N.ObjectTypeCallProperty;
1120
+ }): namedTypes.ObjectTypeCallProperty;
1119
1121
  }
1120
1122
  export interface ObjectTypeInternalSlotBuilder {
1121
- (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): N.ObjectTypeInternalSlot;
1123
+ (id: K.IdentifierKind, value: K.FlowTypeKind, optional: boolean, staticParam: boolean, method: boolean): namedTypes.ObjectTypeInternalSlot;
1122
1124
  from(params: {
1123
1125
  comments?: K.CommentKind[] | null;
1124
1126
  id: K.IdentifierKind;
@@ -1127,97 +1129,97 @@ export interface ObjectTypeInternalSlotBuilder {
1127
1129
  optional: boolean;
1128
1130
  static: boolean;
1129
1131
  value: K.FlowTypeKind;
1130
- }): N.ObjectTypeInternalSlot;
1132
+ }): namedTypes.ObjectTypeInternalSlot;
1131
1133
  }
1132
1134
  export interface VarianceBuilder {
1133
- (kind: "plus" | "minus"): N.Variance;
1135
+ (kind: "plus" | "minus"): namedTypes.Variance;
1134
1136
  from(params: {
1135
1137
  comments?: K.CommentKind[] | null;
1136
1138
  kind: "plus" | "minus";
1137
1139
  loc?: K.SourceLocationKind | null;
1138
- }): N.Variance;
1140
+ }): namedTypes.Variance;
1139
1141
  }
1140
1142
  export interface QualifiedTypeIdentifierBuilder {
1141
- (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): N.QualifiedTypeIdentifier;
1143
+ (qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind, id: K.IdentifierKind): namedTypes.QualifiedTypeIdentifier;
1142
1144
  from(params: {
1143
1145
  comments?: K.CommentKind[] | null;
1144
1146
  id: K.IdentifierKind;
1145
1147
  loc?: K.SourceLocationKind | null;
1146
1148
  qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
1147
- }): N.QualifiedTypeIdentifier;
1149
+ }): namedTypes.QualifiedTypeIdentifier;
1148
1150
  }
1149
1151
  export interface GenericTypeAnnotationBuilder {
1150
- (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): N.GenericTypeAnnotation;
1152
+ (id: K.IdentifierKind | K.QualifiedTypeIdentifierKind, typeParameters: K.TypeParameterInstantiationKind | null): namedTypes.GenericTypeAnnotation;
1151
1153
  from(params: {
1152
1154
  comments?: K.CommentKind[] | null;
1153
1155
  id: K.IdentifierKind | K.QualifiedTypeIdentifierKind;
1154
1156
  loc?: K.SourceLocationKind | null;
1155
1157
  typeParameters: K.TypeParameterInstantiationKind | null;
1156
- }): N.GenericTypeAnnotation;
1158
+ }): namedTypes.GenericTypeAnnotation;
1157
1159
  }
1158
1160
  export interface MemberTypeAnnotationBuilder {
1159
- (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): N.MemberTypeAnnotation;
1161
+ (object: K.IdentifierKind, property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind): namedTypes.MemberTypeAnnotation;
1160
1162
  from(params: {
1161
1163
  comments?: K.CommentKind[] | null;
1162
1164
  loc?: K.SourceLocationKind | null;
1163
1165
  object: K.IdentifierKind;
1164
1166
  property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;
1165
- }): N.MemberTypeAnnotation;
1167
+ }): namedTypes.MemberTypeAnnotation;
1166
1168
  }
1167
1169
  export interface UnionTypeAnnotationBuilder {
1168
- (types: K.FlowTypeKind[]): N.UnionTypeAnnotation;
1170
+ (types: K.FlowTypeKind[]): namedTypes.UnionTypeAnnotation;
1169
1171
  from(params: {
1170
1172
  comments?: K.CommentKind[] | null;
1171
1173
  loc?: K.SourceLocationKind | null;
1172
1174
  types: K.FlowTypeKind[];
1173
- }): N.UnionTypeAnnotation;
1175
+ }): namedTypes.UnionTypeAnnotation;
1174
1176
  }
1175
1177
  export interface IntersectionTypeAnnotationBuilder {
1176
- (types: K.FlowTypeKind[]): N.IntersectionTypeAnnotation;
1178
+ (types: K.FlowTypeKind[]): namedTypes.IntersectionTypeAnnotation;
1177
1179
  from(params: {
1178
1180
  comments?: K.CommentKind[] | null;
1179
1181
  loc?: K.SourceLocationKind | null;
1180
1182
  types: K.FlowTypeKind[];
1181
- }): N.IntersectionTypeAnnotation;
1183
+ }): namedTypes.IntersectionTypeAnnotation;
1182
1184
  }
1183
1185
  export interface TypeofTypeAnnotationBuilder {
1184
- (argument: K.FlowTypeKind): N.TypeofTypeAnnotation;
1186
+ (argument: K.FlowTypeKind): namedTypes.TypeofTypeAnnotation;
1185
1187
  from(params: {
1186
1188
  argument: K.FlowTypeKind;
1187
1189
  comments?: K.CommentKind[] | null;
1188
1190
  loc?: K.SourceLocationKind | null;
1189
- }): N.TypeofTypeAnnotation;
1191
+ }): namedTypes.TypeofTypeAnnotation;
1190
1192
  }
1191
1193
  export interface TypeParameterBuilder {
1192
- (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): N.TypeParameter;
1194
+ (name: string, variance?: K.VarianceKind | "plus" | "minus" | null, bound?: K.TypeAnnotationKind | null): namedTypes.TypeParameter;
1193
1195
  from(params: {
1194
1196
  bound?: K.TypeAnnotationKind | null;
1195
1197
  comments?: K.CommentKind[] | null;
1196
1198
  loc?: K.SourceLocationKind | null;
1197
1199
  name: string;
1198
1200
  variance?: K.VarianceKind | "plus" | "minus" | null;
1199
- }): N.TypeParameter;
1201
+ }): namedTypes.TypeParameter;
1200
1202
  }
1201
1203
  export interface InterfaceTypeAnnotationBuilder {
1202
- (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): N.InterfaceTypeAnnotation;
1204
+ (body: K.ObjectTypeAnnotationKind, extendsParam?: K.InterfaceExtendsKind[] | null): namedTypes.InterfaceTypeAnnotation;
1203
1205
  from(params: {
1204
1206
  body: K.ObjectTypeAnnotationKind;
1205
1207
  comments?: K.CommentKind[] | null;
1206
1208
  extends?: K.InterfaceExtendsKind[] | null;
1207
1209
  loc?: K.SourceLocationKind | null;
1208
- }): N.InterfaceTypeAnnotation;
1210
+ }): namedTypes.InterfaceTypeAnnotation;
1209
1211
  }
1210
1212
  export interface InterfaceExtendsBuilder {
1211
- (id: K.IdentifierKind): N.InterfaceExtends;
1213
+ (id: K.IdentifierKind): namedTypes.InterfaceExtends;
1212
1214
  from(params: {
1213
1215
  comments?: K.CommentKind[] | null;
1214
1216
  id: K.IdentifierKind;
1215
1217
  loc?: K.SourceLocationKind | null;
1216
1218
  typeParameters?: K.TypeParameterInstantiationKind | null;
1217
- }): N.InterfaceExtends;
1219
+ }): namedTypes.InterfaceExtends;
1218
1220
  }
1219
1221
  export interface InterfaceDeclarationBuilder {
1220
- (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.InterfaceDeclaration;
1222
+ (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.InterfaceDeclaration;
1221
1223
  from(params: {
1222
1224
  body: K.ObjectTypeAnnotationKind;
1223
1225
  comments?: K.CommentKind[] | null;
@@ -1225,10 +1227,10 @@ export interface InterfaceDeclarationBuilder {
1225
1227
  id: K.IdentifierKind;
1226
1228
  loc?: K.SourceLocationKind | null;
1227
1229
  typeParameters?: K.TypeParameterDeclarationKind | null;
1228
- }): N.InterfaceDeclaration;
1230
+ }): namedTypes.InterfaceDeclaration;
1229
1231
  }
1230
1232
  export interface DeclareInterfaceBuilder {
1231
- (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): N.DeclareInterface;
1233
+ (id: K.IdentifierKind, body: K.ObjectTypeAnnotationKind, extendsParam: K.InterfaceExtendsKind[]): namedTypes.DeclareInterface;
1232
1234
  from(params: {
1233
1235
  body: K.ObjectTypeAnnotationKind;
1234
1236
  comments?: K.CommentKind[] | null;
@@ -1236,20 +1238,20 @@ export interface DeclareInterfaceBuilder {
1236
1238
  id: K.IdentifierKind;
1237
1239
  loc?: K.SourceLocationKind | null;
1238
1240
  typeParameters?: K.TypeParameterDeclarationKind | null;
1239
- }): N.DeclareInterface;
1241
+ }): namedTypes.DeclareInterface;
1240
1242
  }
1241
1243
  export interface TypeAliasBuilder {
1242
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.TypeAlias;
1244
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.TypeAlias;
1243
1245
  from(params: {
1244
1246
  comments?: K.CommentKind[] | null;
1245
1247
  id: K.IdentifierKind;
1246
1248
  loc?: K.SourceLocationKind | null;
1247
1249
  right: K.FlowTypeKind;
1248
1250
  typeParameters: K.TypeParameterDeclarationKind | null;
1249
- }): N.TypeAlias;
1251
+ }): namedTypes.TypeAlias;
1250
1252
  }
1251
1253
  export interface OpaqueTypeBuilder {
1252
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): N.OpaqueType;
1254
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, impltype: K.FlowTypeKind, supertype: K.FlowTypeKind): namedTypes.OpaqueType;
1253
1255
  from(params: {
1254
1256
  comments?: K.CommentKind[] | null;
1255
1257
  id: K.IdentifierKind;
@@ -1257,63 +1259,63 @@ export interface OpaqueTypeBuilder {
1257
1259
  loc?: K.SourceLocationKind | null;
1258
1260
  supertype: K.FlowTypeKind;
1259
1261
  typeParameters: K.TypeParameterDeclarationKind | null;
1260
- }): N.OpaqueType;
1262
+ }): namedTypes.OpaqueType;
1261
1263
  }
1262
1264
  export interface DeclareTypeAliasBuilder {
1263
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): N.DeclareTypeAlias;
1265
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null, right: K.FlowTypeKind): namedTypes.DeclareTypeAlias;
1264
1266
  from(params: {
1265
1267
  comments?: K.CommentKind[] | null;
1266
1268
  id: K.IdentifierKind;
1267
1269
  loc?: K.SourceLocationKind | null;
1268
1270
  right: K.FlowTypeKind;
1269
1271
  typeParameters: K.TypeParameterDeclarationKind | null;
1270
- }): N.DeclareTypeAlias;
1272
+ }): namedTypes.DeclareTypeAlias;
1271
1273
  }
1272
1274
  export interface DeclareOpaqueTypeBuilder {
1273
- (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): N.DeclareOpaqueType;
1275
+ (id: K.IdentifierKind, typeParameters: K.TypeParameterDeclarationKind | null): namedTypes.DeclareOpaqueType;
1274
1276
  from(params: {
1275
1277
  comments?: K.CommentKind[] | null;
1276
1278
  id: K.IdentifierKind;
1277
1279
  loc?: K.SourceLocationKind | null;
1278
1280
  right: K.FlowTypeKind;
1279
1281
  typeParameters: K.TypeParameterDeclarationKind | null;
1280
- }): N.DeclareOpaqueType;
1282
+ }): namedTypes.DeclareOpaqueType;
1281
1283
  }
1282
1284
  export interface TypeCastExpressionBuilder {
1283
- (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): N.TypeCastExpression;
1285
+ (expression: K.ExpressionKind, typeAnnotation: K.TypeAnnotationKind): namedTypes.TypeCastExpression;
1284
1286
  from(params: {
1285
1287
  comments?: K.CommentKind[] | null;
1286
1288
  expression: K.ExpressionKind;
1287
1289
  loc?: K.SourceLocationKind | null;
1288
1290
  typeAnnotation: K.TypeAnnotationKind;
1289
- }): N.TypeCastExpression;
1291
+ }): namedTypes.TypeCastExpression;
1290
1292
  }
1291
1293
  export interface TupleTypeAnnotationBuilder {
1292
- (types: K.FlowTypeKind[]): N.TupleTypeAnnotation;
1294
+ (types: K.FlowTypeKind[]): namedTypes.TupleTypeAnnotation;
1293
1295
  from(params: {
1294
1296
  comments?: K.CommentKind[] | null;
1295
1297
  loc?: K.SourceLocationKind | null;
1296
1298
  types: K.FlowTypeKind[];
1297
- }): N.TupleTypeAnnotation;
1299
+ }): namedTypes.TupleTypeAnnotation;
1298
1300
  }
1299
1301
  export interface DeclareVariableBuilder {
1300
- (id: K.IdentifierKind): N.DeclareVariable;
1302
+ (id: K.IdentifierKind): namedTypes.DeclareVariable;
1301
1303
  from(params: {
1302
1304
  comments?: K.CommentKind[] | null;
1303
1305
  id: K.IdentifierKind;
1304
1306
  loc?: K.SourceLocationKind | null;
1305
- }): N.DeclareVariable;
1307
+ }): namedTypes.DeclareVariable;
1306
1308
  }
1307
1309
  export interface DeclareFunctionBuilder {
1308
- (id: K.IdentifierKind): N.DeclareFunction;
1310
+ (id: K.IdentifierKind): namedTypes.DeclareFunction;
1309
1311
  from(params: {
1310
1312
  comments?: K.CommentKind[] | null;
1311
1313
  id: K.IdentifierKind;
1312
1314
  loc?: K.SourceLocationKind | null;
1313
- }): N.DeclareFunction;
1315
+ }): namedTypes.DeclareFunction;
1314
1316
  }
1315
1317
  export interface DeclareClassBuilder {
1316
- (id: K.IdentifierKind): N.DeclareClass;
1318
+ (id: K.IdentifierKind): namedTypes.DeclareClass;
1317
1319
  from(params: {
1318
1320
  body: K.ObjectTypeAnnotationKind;
1319
1321
  comments?: K.CommentKind[] | null;
@@ -1321,27 +1323,27 @@ export interface DeclareClassBuilder {
1321
1323
  id: K.IdentifierKind;
1322
1324
  loc?: K.SourceLocationKind | null;
1323
1325
  typeParameters?: K.TypeParameterDeclarationKind | null;
1324
- }): N.DeclareClass;
1326
+ }): namedTypes.DeclareClass;
1325
1327
  }
1326
1328
  export interface DeclareModuleBuilder {
1327
- (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): N.DeclareModule;
1329
+ (id: K.IdentifierKind | K.LiteralKind, body: K.BlockStatementKind): namedTypes.DeclareModule;
1328
1330
  from(params: {
1329
1331
  body: K.BlockStatementKind;
1330
1332
  comments?: K.CommentKind[] | null;
1331
1333
  id: K.IdentifierKind | K.LiteralKind;
1332
1334
  loc?: K.SourceLocationKind | null;
1333
- }): N.DeclareModule;
1335
+ }): namedTypes.DeclareModule;
1334
1336
  }
1335
1337
  export interface DeclareModuleExportsBuilder {
1336
- (typeAnnotation: K.TypeAnnotationKind): N.DeclareModuleExports;
1338
+ (typeAnnotation: K.TypeAnnotationKind): namedTypes.DeclareModuleExports;
1337
1339
  from(params: {
1338
1340
  comments?: K.CommentKind[] | null;
1339
1341
  loc?: K.SourceLocationKind | null;
1340
1342
  typeAnnotation: K.TypeAnnotationKind;
1341
- }): N.DeclareModuleExports;
1343
+ }): namedTypes.DeclareModuleExports;
1342
1344
  }
1343
1345
  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;
1346
+ (defaultParam: boolean, declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.DeclareExportDeclaration;
1345
1347
  from(params: {
1346
1348
  comments?: K.CommentKind[] | null;
1347
1349
  declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null;
@@ -1349,10 +1351,10 @@ export interface DeclareExportDeclarationBuilder {
1349
1351
  loc?: K.SourceLocationKind | null;
1350
1352
  source?: K.LiteralKind | null;
1351
1353
  specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
1352
- }): N.DeclareExportDeclaration;
1354
+ }): namedTypes.DeclareExportDeclaration;
1353
1355
  }
1354
1356
  export interface ExportSpecifierBuilder {
1355
- (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): N.ExportSpecifier;
1357
+ (local: K.IdentifierKind | null | undefined, exported: K.IdentifierKind): namedTypes.ExportSpecifier;
1356
1358
  from(params: {
1357
1359
  comments?: K.CommentKind[] | null;
1358
1360
  exported: K.IdentifierKind;
@@ -1360,40 +1362,40 @@ export interface ExportSpecifierBuilder {
1360
1362
  loc?: K.SourceLocationKind | null;
1361
1363
  local?: K.IdentifierKind | null;
1362
1364
  name?: K.IdentifierKind | null;
1363
- }): N.ExportSpecifier;
1365
+ }): namedTypes.ExportSpecifier;
1364
1366
  }
1365
1367
  export interface ExportBatchSpecifierBuilder {
1366
- (): N.ExportBatchSpecifier;
1368
+ (): namedTypes.ExportBatchSpecifier;
1367
1369
  from(params: {
1368
1370
  comments?: K.CommentKind[] | null;
1369
1371
  loc?: K.SourceLocationKind | null;
1370
- }): N.ExportBatchSpecifier;
1372
+ }): namedTypes.ExportBatchSpecifier;
1371
1373
  }
1372
1374
  export interface DeclareExportAllDeclarationBuilder {
1373
- (source?: K.LiteralKind | null): N.DeclareExportAllDeclaration;
1375
+ (source?: K.LiteralKind | null): namedTypes.DeclareExportAllDeclaration;
1374
1376
  from(params: {
1375
1377
  comments?: K.CommentKind[] | null;
1376
1378
  loc?: K.SourceLocationKind | null;
1377
1379
  source?: K.LiteralKind | null;
1378
- }): N.DeclareExportAllDeclaration;
1380
+ }): namedTypes.DeclareExportAllDeclaration;
1379
1381
  }
1380
1382
  export interface InferredPredicateBuilder {
1381
- (): N.InferredPredicate;
1383
+ (): namedTypes.InferredPredicate;
1382
1384
  from(params: {
1383
1385
  comments?: K.CommentKind[] | null;
1384
1386
  loc?: K.SourceLocationKind | null;
1385
- }): N.InferredPredicate;
1387
+ }): namedTypes.InferredPredicate;
1386
1388
  }
1387
1389
  export interface DeclaredPredicateBuilder {
1388
- (value: K.ExpressionKind): N.DeclaredPredicate;
1390
+ (value: K.ExpressionKind): namedTypes.DeclaredPredicate;
1389
1391
  from(params: {
1390
1392
  comments?: K.CommentKind[] | null;
1391
1393
  loc?: K.SourceLocationKind | null;
1392
1394
  value: K.ExpressionKind;
1393
- }): N.DeclaredPredicate;
1395
+ }): namedTypes.DeclaredPredicate;
1394
1396
  }
1395
1397
  export interface ExportDeclarationBuilder {
1396
- (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): N.ExportDeclaration;
1398
+ (defaultParam: boolean, declaration: K.DeclarationKind | K.ExpressionKind | null, specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[], source?: K.LiteralKind | null): namedTypes.ExportDeclaration;
1397
1399
  from(params: {
1398
1400
  comments?: K.CommentKind[] | null;
1399
1401
  declaration: K.DeclarationKind | K.ExpressionKind | null;
@@ -1401,169 +1403,169 @@ export interface ExportDeclarationBuilder {
1401
1403
  loc?: K.SourceLocationKind | null;
1402
1404
  source?: K.LiteralKind | null;
1403
1405
  specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];
1404
- }): N.ExportDeclaration;
1406
+ }): namedTypes.ExportDeclaration;
1405
1407
  }
1406
1408
  export interface BlockBuilder {
1407
- (value: string, leading?: boolean, trailing?: boolean): N.Block;
1409
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.Block;
1408
1410
  from(params: {
1409
1411
  leading?: boolean;
1410
1412
  loc?: K.SourceLocationKind | null;
1411
1413
  trailing?: boolean;
1412
1414
  value: string;
1413
- }): N.Block;
1415
+ }): namedTypes.Block;
1414
1416
  }
1415
1417
  export interface LineBuilder {
1416
- (value: string, leading?: boolean, trailing?: boolean): N.Line;
1418
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.Line;
1417
1419
  from(params: {
1418
1420
  leading?: boolean;
1419
1421
  loc?: K.SourceLocationKind | null;
1420
1422
  trailing?: boolean;
1421
1423
  value: string;
1422
- }): N.Line;
1424
+ }): namedTypes.Line;
1423
1425
  }
1424
1426
  export interface NoopBuilder {
1425
- (): N.Noop;
1427
+ (): namedTypes.Noop;
1426
1428
  from(params: {
1427
1429
  comments?: K.CommentKind[] | null;
1428
1430
  loc?: K.SourceLocationKind | null;
1429
- }): N.Noop;
1431
+ }): namedTypes.Noop;
1430
1432
  }
1431
1433
  export interface DoExpressionBuilder {
1432
- (body: K.StatementKind[]): N.DoExpression;
1434
+ (body: K.StatementKind[]): namedTypes.DoExpression;
1433
1435
  from(params: {
1434
1436
  body: K.StatementKind[];
1435
1437
  comments?: K.CommentKind[] | null;
1436
1438
  loc?: K.SourceLocationKind | null;
1437
- }): N.DoExpression;
1439
+ }): namedTypes.DoExpression;
1438
1440
  }
1439
1441
  export interface SuperBuilder {
1440
- (): N.Super;
1442
+ (): namedTypes.Super;
1441
1443
  from(params: {
1442
1444
  comments?: K.CommentKind[] | null;
1443
1445
  loc?: K.SourceLocationKind | null;
1444
- }): N.Super;
1446
+ }): namedTypes.Super;
1445
1447
  }
1446
1448
  export interface BindExpressionBuilder {
1447
- (object: K.ExpressionKind | null, callee: K.ExpressionKind): N.BindExpression;
1449
+ (object: K.ExpressionKind | null, callee: K.ExpressionKind): namedTypes.BindExpression;
1448
1450
  from(params: {
1449
1451
  callee: K.ExpressionKind;
1450
1452
  comments?: K.CommentKind[] | null;
1451
1453
  loc?: K.SourceLocationKind | null;
1452
1454
  object: K.ExpressionKind | null;
1453
- }): N.BindExpression;
1455
+ }): namedTypes.BindExpression;
1454
1456
  }
1455
1457
  export interface DecoratorBuilder {
1456
- (expression: K.ExpressionKind): N.Decorator;
1458
+ (expression: K.ExpressionKind): namedTypes.Decorator;
1457
1459
  from(params: {
1458
1460
  comments?: K.CommentKind[] | null;
1459
1461
  expression: K.ExpressionKind;
1460
1462
  loc?: K.SourceLocationKind | null;
1461
- }): N.Decorator;
1463
+ }): namedTypes.Decorator;
1462
1464
  }
1463
1465
  export interface MetaPropertyBuilder {
1464
- (meta: K.IdentifierKind, property: K.IdentifierKind): N.MetaProperty;
1466
+ (meta: K.IdentifierKind, property: K.IdentifierKind): namedTypes.MetaProperty;
1465
1467
  from(params: {
1466
1468
  comments?: K.CommentKind[] | null;
1467
1469
  loc?: K.SourceLocationKind | null;
1468
1470
  meta: K.IdentifierKind;
1469
1471
  property: K.IdentifierKind;
1470
- }): N.MetaProperty;
1472
+ }): namedTypes.MetaProperty;
1471
1473
  }
1472
1474
  export interface ParenthesizedExpressionBuilder {
1473
- (expression: K.ExpressionKind): N.ParenthesizedExpression;
1475
+ (expression: K.ExpressionKind): namedTypes.ParenthesizedExpression;
1474
1476
  from(params: {
1475
1477
  comments?: K.CommentKind[] | null;
1476
1478
  expression: K.ExpressionKind;
1477
1479
  loc?: K.SourceLocationKind | null;
1478
- }): N.ParenthesizedExpression;
1480
+ }): namedTypes.ParenthesizedExpression;
1479
1481
  }
1480
1482
  export interface ExportDefaultDeclarationBuilder {
1481
- (declaration: K.DeclarationKind | K.ExpressionKind): N.ExportDefaultDeclaration;
1483
+ (declaration: K.DeclarationKind | K.ExpressionKind): namedTypes.ExportDefaultDeclaration;
1482
1484
  from(params: {
1483
1485
  comments?: K.CommentKind[] | null;
1484
1486
  declaration: K.DeclarationKind | K.ExpressionKind;
1485
1487
  loc?: K.SourceLocationKind | null;
1486
- }): N.ExportDefaultDeclaration;
1488
+ }): namedTypes.ExportDefaultDeclaration;
1487
1489
  }
1488
1490
  export interface ExportNamedDeclarationBuilder {
1489
- (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): N.ExportNamedDeclaration;
1491
+ (declaration: K.DeclarationKind | null, specifiers?: K.ExportSpecifierKind[], source?: K.LiteralKind | null): namedTypes.ExportNamedDeclaration;
1490
1492
  from(params: {
1491
1493
  comments?: K.CommentKind[] | null;
1492
1494
  declaration: K.DeclarationKind | null;
1493
1495
  loc?: K.SourceLocationKind | null;
1494
1496
  source?: K.LiteralKind | null;
1495
1497
  specifiers?: K.ExportSpecifierKind[];
1496
- }): N.ExportNamedDeclaration;
1498
+ }): namedTypes.ExportNamedDeclaration;
1497
1499
  }
1498
1500
  export interface ExportNamespaceSpecifierBuilder {
1499
- (exported: K.IdentifierKind): N.ExportNamespaceSpecifier;
1501
+ (exported: K.IdentifierKind): namedTypes.ExportNamespaceSpecifier;
1500
1502
  from(params: {
1501
1503
  comments?: K.CommentKind[] | null;
1502
1504
  exported: K.IdentifierKind;
1503
1505
  loc?: K.SourceLocationKind | null;
1504
- }): N.ExportNamespaceSpecifier;
1506
+ }): namedTypes.ExportNamespaceSpecifier;
1505
1507
  }
1506
1508
  export interface ExportDefaultSpecifierBuilder {
1507
- (exported: K.IdentifierKind): N.ExportDefaultSpecifier;
1509
+ (exported: K.IdentifierKind): namedTypes.ExportDefaultSpecifier;
1508
1510
  from(params: {
1509
1511
  comments?: K.CommentKind[] | null;
1510
1512
  exported: K.IdentifierKind;
1511
1513
  loc?: K.SourceLocationKind | null;
1512
- }): N.ExportDefaultSpecifier;
1514
+ }): namedTypes.ExportDefaultSpecifier;
1513
1515
  }
1514
1516
  export interface ExportAllDeclarationBuilder {
1515
- (exported: K.IdentifierKind | null, source: K.LiteralKind): N.ExportAllDeclaration;
1517
+ (exported: K.IdentifierKind | null, source: K.LiteralKind): namedTypes.ExportAllDeclaration;
1516
1518
  from(params: {
1517
1519
  comments?: K.CommentKind[] | null;
1518
1520
  exported: K.IdentifierKind | null;
1519
1521
  loc?: K.SourceLocationKind | null;
1520
1522
  source: K.LiteralKind;
1521
- }): N.ExportAllDeclaration;
1523
+ }): namedTypes.ExportAllDeclaration;
1522
1524
  }
1523
1525
  export interface CommentBlockBuilder {
1524
- (value: string, leading?: boolean, trailing?: boolean): N.CommentBlock;
1526
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentBlock;
1525
1527
  from(params: {
1526
1528
  leading?: boolean;
1527
1529
  loc?: K.SourceLocationKind | null;
1528
1530
  trailing?: boolean;
1529
1531
  value: string;
1530
- }): N.CommentBlock;
1532
+ }): namedTypes.CommentBlock;
1531
1533
  }
1532
1534
  export interface CommentLineBuilder {
1533
- (value: string, leading?: boolean, trailing?: boolean): N.CommentLine;
1535
+ (value: string, leading?: boolean, trailing?: boolean): namedTypes.CommentLine;
1534
1536
  from(params: {
1535
1537
  leading?: boolean;
1536
1538
  loc?: K.SourceLocationKind | null;
1537
1539
  trailing?: boolean;
1538
1540
  value: string;
1539
- }): N.CommentLine;
1541
+ }): namedTypes.CommentLine;
1540
1542
  }
1541
1543
  export interface DirectiveBuilder {
1542
- (value: K.DirectiveLiteralKind): N.Directive;
1544
+ (value: K.DirectiveLiteralKind): namedTypes.Directive;
1543
1545
  from(params: {
1544
1546
  comments?: K.CommentKind[] | null;
1545
1547
  loc?: K.SourceLocationKind | null;
1546
1548
  value: K.DirectiveLiteralKind;
1547
- }): N.Directive;
1549
+ }): namedTypes.Directive;
1548
1550
  }
1549
1551
  export interface DirectiveLiteralBuilder {
1550
- (value?: string): N.DirectiveLiteral;
1552
+ (value?: string): namedTypes.DirectiveLiteral;
1551
1553
  from(params: {
1552
1554
  comments?: K.CommentKind[] | null;
1553
1555
  loc?: K.SourceLocationKind | null;
1554
1556
  value?: string;
1555
- }): N.DirectiveLiteral;
1557
+ }): namedTypes.DirectiveLiteral;
1556
1558
  }
1557
1559
  export interface InterpreterDirectiveBuilder {
1558
- (value: string): N.InterpreterDirective;
1560
+ (value: string): namedTypes.InterpreterDirective;
1559
1561
  from(params: {
1560
1562
  comments?: K.CommentKind[] | null;
1561
1563
  loc?: K.SourceLocationKind | null;
1562
1564
  value: string;
1563
- }): N.InterpreterDirective;
1565
+ }): namedTypes.InterpreterDirective;
1564
1566
  }
1565
1567
  export interface StringLiteralBuilder {
1566
- (value: string): N.StringLiteral;
1568
+ (value: string): namedTypes.StringLiteral;
1567
1569
  from(params: {
1568
1570
  comments?: K.CommentKind[] | null;
1569
1571
  loc?: K.SourceLocationKind | null;
@@ -1572,10 +1574,10 @@ export interface StringLiteralBuilder {
1572
1574
  flags: string;
1573
1575
  } | null;
1574
1576
  value: string;
1575
- }): N.StringLiteral;
1577
+ }): namedTypes.StringLiteral;
1576
1578
  }
1577
1579
  export interface NumericLiteralBuilder {
1578
- (value: number): N.NumericLiteral;
1580
+ (value: number): namedTypes.NumericLiteral;
1579
1581
  from(params: {
1580
1582
  comments?: K.CommentKind[] | null;
1581
1583
  extra?: {
@@ -1589,10 +1591,10 @@ export interface NumericLiteralBuilder {
1589
1591
  flags: string;
1590
1592
  } | null;
1591
1593
  value: number;
1592
- }): N.NumericLiteral;
1594
+ }): namedTypes.NumericLiteral;
1593
1595
  }
1594
1596
  export interface BigIntLiteralBuilder {
1595
- (value: string | number): N.BigIntLiteral;
1597
+ (value: string | number): namedTypes.BigIntLiteral;
1596
1598
  from(params: {
1597
1599
  comments?: K.CommentKind[] | null;
1598
1600
  extra?: {
@@ -1605,10 +1607,10 @@ export interface BigIntLiteralBuilder {
1605
1607
  flags: string;
1606
1608
  } | null;
1607
1609
  value: string | number;
1608
- }): N.BigIntLiteral;
1610
+ }): namedTypes.BigIntLiteral;
1609
1611
  }
1610
1612
  export interface NullLiteralBuilder {
1611
- (): N.NullLiteral;
1613
+ (): namedTypes.NullLiteral;
1612
1614
  from(params: {
1613
1615
  comments?: K.CommentKind[] | null;
1614
1616
  loc?: K.SourceLocationKind | null;
@@ -1617,10 +1619,10 @@ export interface NullLiteralBuilder {
1617
1619
  flags: string;
1618
1620
  } | null;
1619
1621
  value?: null;
1620
- }): N.NullLiteral;
1622
+ }): namedTypes.NullLiteral;
1621
1623
  }
1622
1624
  export interface BooleanLiteralBuilder {
1623
- (value: boolean): N.BooleanLiteral;
1625
+ (value: boolean): namedTypes.BooleanLiteral;
1624
1626
  from(params: {
1625
1627
  comments?: K.CommentKind[] | null;
1626
1628
  loc?: K.SourceLocationKind | null;
@@ -1629,10 +1631,10 @@ export interface BooleanLiteralBuilder {
1629
1631
  flags: string;
1630
1632
  } | null;
1631
1633
  value: boolean;
1632
- }): N.BooleanLiteral;
1634
+ }): namedTypes.BooleanLiteral;
1633
1635
  }
1634
1636
  export interface RegExpLiteralBuilder {
1635
- (pattern: string, flags: string): N.RegExpLiteral;
1637
+ (pattern: string, flags: string): namedTypes.RegExpLiteral;
1636
1638
  from(params: {
1637
1639
  comments?: K.CommentKind[] | null;
1638
1640
  flags: string;
@@ -1643,10 +1645,10 @@ export interface RegExpLiteralBuilder {
1643
1645
  flags: string;
1644
1646
  } | null;
1645
1647
  value?: RegExp;
1646
- }): N.RegExpLiteral;
1648
+ }): namedTypes.RegExpLiteral;
1647
1649
  }
1648
1650
  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;
1651
+ (kind: "method" | "get" | "set", key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind, params: K.PatternKind[], body: K.BlockStatementKind, computed?: boolean): namedTypes.ObjectMethod;
1650
1652
  from(params: {
1651
1653
  accessibility?: K.LiteralKind | null;
1652
1654
  async?: boolean;
@@ -1665,10 +1667,10 @@ export interface ObjectMethodBuilder {
1665
1667
  rest?: K.IdentifierKind | null;
1666
1668
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1667
1669
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1668
- }): N.ObjectMethod;
1670
+ }): namedTypes.ObjectMethod;
1669
1671
  }
1670
1672
  export interface ClassPrivatePropertyBuilder {
1671
- (key: K.PrivateNameKind, value?: K.ExpressionKind | null): N.ClassPrivateProperty;
1673
+ (key: K.PrivateNameKind, value?: K.ExpressionKind | null): namedTypes.ClassPrivateProperty;
1672
1674
  from(params: {
1673
1675
  access?: "public" | "private" | "protected" | undefined;
1674
1676
  comments?: K.CommentKind[] | null;
@@ -1679,10 +1681,10 @@ export interface ClassPrivatePropertyBuilder {
1679
1681
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1680
1682
  value?: K.ExpressionKind | null;
1681
1683
  variance?: K.VarianceKind | "plus" | "minus" | null;
1682
- }): N.ClassPrivateProperty;
1684
+ }): namedTypes.ClassPrivateProperty;
1683
1685
  }
1684
1686
  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;
1687
+ (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
1688
  from(params: {
1687
1689
  abstract?: boolean | null;
1688
1690
  access?: "public" | "private" | "protected" | null;
@@ -1705,10 +1707,10 @@ export interface ClassMethodBuilder {
1705
1707
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1706
1708
  static?: boolean | null;
1707
1709
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1708
- }): N.ClassMethod;
1710
+ }): namedTypes.ClassMethod;
1709
1711
  }
1710
1712
  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;
1713
+ (key: K.PrivateNameKind, params: K.PatternKind[], body: K.BlockStatementKind, kind?: "get" | "set" | "method" | "constructor", computed?: boolean, staticParam?: boolean | null): namedTypes.ClassPrivateMethod;
1712
1714
  from(params: {
1713
1715
  abstract?: boolean | null;
1714
1716
  access?: "public" | "private" | "protected" | null;
@@ -1731,61 +1733,61 @@ export interface ClassPrivateMethodBuilder {
1731
1733
  returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1732
1734
  static?: boolean | null;
1733
1735
  typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null;
1734
- }): N.ClassPrivateMethod;
1736
+ }): namedTypes.ClassPrivateMethod;
1735
1737
  }
1736
1738
  export interface PrivateNameBuilder {
1737
- (id: K.IdentifierKind): N.PrivateName;
1739
+ (id: K.IdentifierKind): namedTypes.PrivateName;
1738
1740
  from(params: {
1739
1741
  comments?: K.CommentKind[] | null;
1740
1742
  id: K.IdentifierKind;
1741
1743
  loc?: K.SourceLocationKind | null;
1742
- }): N.PrivateName;
1744
+ }): namedTypes.PrivateName;
1743
1745
  }
1744
1746
  export interface RestPropertyBuilder {
1745
- (argument: K.ExpressionKind): N.RestProperty;
1747
+ (argument: K.ExpressionKind): namedTypes.RestProperty;
1746
1748
  from(params: {
1747
1749
  argument: K.ExpressionKind;
1748
1750
  comments?: K.CommentKind[] | null;
1749
1751
  loc?: K.SourceLocationKind | null;
1750
- }): N.RestProperty;
1752
+ }): namedTypes.RestProperty;
1751
1753
  }
1752
1754
  export interface ForAwaitStatementBuilder {
1753
- (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): N.ForAwaitStatement;
1755
+ (left: K.VariableDeclarationKind | K.ExpressionKind, right: K.ExpressionKind, body: K.StatementKind): namedTypes.ForAwaitStatement;
1754
1756
  from(params: {
1755
1757
  body: K.StatementKind;
1756
1758
  comments?: K.CommentKind[] | null;
1757
1759
  left: K.VariableDeclarationKind | K.ExpressionKind;
1758
1760
  loc?: K.SourceLocationKind | null;
1759
1761
  right: K.ExpressionKind;
1760
- }): N.ForAwaitStatement;
1762
+ }): namedTypes.ForAwaitStatement;
1761
1763
  }
1762
1764
  export interface ImportBuilder {
1763
- (): N.Import;
1765
+ (): namedTypes.Import;
1764
1766
  from(params: {
1765
1767
  comments?: K.CommentKind[] | null;
1766
1768
  loc?: K.SourceLocationKind | null;
1767
- }): N.Import;
1769
+ }): namedTypes.Import;
1768
1770
  }
1769
1771
  export interface TSQualifiedNameBuilder {
1770
- (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): N.TSQualifiedName;
1772
+ (left: K.IdentifierKind | K.TSQualifiedNameKind, right: K.IdentifierKind | K.TSQualifiedNameKind): namedTypes.TSQualifiedName;
1771
1773
  from(params: {
1772
1774
  comments?: K.CommentKind[] | null;
1773
1775
  left: K.IdentifierKind | K.TSQualifiedNameKind;
1774
1776
  loc?: K.SourceLocationKind | null;
1775
1777
  right: K.IdentifierKind | K.TSQualifiedNameKind;
1776
- }): N.TSQualifiedName;
1778
+ }): namedTypes.TSQualifiedName;
1777
1779
  }
1778
1780
  export interface TSTypeReferenceBuilder {
1779
- (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSTypeReference;
1781
+ (typeName: K.IdentifierKind | K.TSQualifiedNameKind, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSTypeReference;
1780
1782
  from(params: {
1781
1783
  comments?: K.CommentKind[] | null;
1782
1784
  loc?: K.SourceLocationKind | null;
1783
1785
  typeName: K.IdentifierKind | K.TSQualifiedNameKind;
1784
1786
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
1785
- }): N.TSTypeReference;
1787
+ }): namedTypes.TSTypeReference;
1786
1788
  }
1787
1789
  export interface TSAsExpressionBuilder {
1788
- (expression: K.ExpressionKind): N.TSAsExpression;
1790
+ (expression: K.ExpressionKind, typeAnnotation: K.TSTypeKind): namedTypes.TSAsExpression;
1789
1791
  from(params: {
1790
1792
  comments?: K.CommentKind[] | null;
1791
1793
  expression: K.ExpressionKind;
@@ -1794,141 +1796,141 @@ export interface TSAsExpressionBuilder {
1794
1796
  } | null;
1795
1797
  loc?: K.SourceLocationKind | null;
1796
1798
  typeAnnotation: K.TSTypeKind;
1797
- }): N.TSAsExpression;
1799
+ }): namedTypes.TSAsExpression;
1798
1800
  }
1799
1801
  export interface TSNonNullExpressionBuilder {
1800
- (expression: K.ExpressionKind): N.TSNonNullExpression;
1802
+ (expression: K.ExpressionKind): namedTypes.TSNonNullExpression;
1801
1803
  from(params: {
1802
1804
  comments?: K.CommentKind[] | null;
1803
1805
  expression: K.ExpressionKind;
1804
1806
  loc?: K.SourceLocationKind | null;
1805
- }): N.TSNonNullExpression;
1807
+ }): namedTypes.TSNonNullExpression;
1806
1808
  }
1807
1809
  export interface TSAnyKeywordBuilder {
1808
- (): N.TSAnyKeyword;
1810
+ (): namedTypes.TSAnyKeyword;
1809
1811
  from(params: {
1810
1812
  comments?: K.CommentKind[] | null;
1811
1813
  loc?: K.SourceLocationKind | null;
1812
- }): N.TSAnyKeyword;
1814
+ }): namedTypes.TSAnyKeyword;
1813
1815
  }
1814
1816
  export interface TSBigIntKeywordBuilder {
1815
- (): N.TSBigIntKeyword;
1817
+ (): namedTypes.TSBigIntKeyword;
1816
1818
  from(params: {
1817
1819
  comments?: K.CommentKind[] | null;
1818
1820
  loc?: K.SourceLocationKind | null;
1819
- }): N.TSBigIntKeyword;
1821
+ }): namedTypes.TSBigIntKeyword;
1820
1822
  }
1821
1823
  export interface TSBooleanKeywordBuilder {
1822
- (): N.TSBooleanKeyword;
1824
+ (): namedTypes.TSBooleanKeyword;
1823
1825
  from(params: {
1824
1826
  comments?: K.CommentKind[] | null;
1825
1827
  loc?: K.SourceLocationKind | null;
1826
- }): N.TSBooleanKeyword;
1828
+ }): namedTypes.TSBooleanKeyword;
1827
1829
  }
1828
1830
  export interface TSNeverKeywordBuilder {
1829
- (): N.TSNeverKeyword;
1831
+ (): namedTypes.TSNeverKeyword;
1830
1832
  from(params: {
1831
1833
  comments?: K.CommentKind[] | null;
1832
1834
  loc?: K.SourceLocationKind | null;
1833
- }): N.TSNeverKeyword;
1835
+ }): namedTypes.TSNeverKeyword;
1834
1836
  }
1835
1837
  export interface TSNullKeywordBuilder {
1836
- (): N.TSNullKeyword;
1838
+ (): namedTypes.TSNullKeyword;
1837
1839
  from(params: {
1838
1840
  comments?: K.CommentKind[] | null;
1839
1841
  loc?: K.SourceLocationKind | null;
1840
- }): N.TSNullKeyword;
1842
+ }): namedTypes.TSNullKeyword;
1841
1843
  }
1842
1844
  export interface TSNumberKeywordBuilder {
1843
- (): N.TSNumberKeyword;
1845
+ (): namedTypes.TSNumberKeyword;
1844
1846
  from(params: {
1845
1847
  comments?: K.CommentKind[] | null;
1846
1848
  loc?: K.SourceLocationKind | null;
1847
- }): N.TSNumberKeyword;
1849
+ }): namedTypes.TSNumberKeyword;
1848
1850
  }
1849
1851
  export interface TSObjectKeywordBuilder {
1850
- (): N.TSObjectKeyword;
1852
+ (): namedTypes.TSObjectKeyword;
1851
1853
  from(params: {
1852
1854
  comments?: K.CommentKind[] | null;
1853
1855
  loc?: K.SourceLocationKind | null;
1854
- }): N.TSObjectKeyword;
1856
+ }): namedTypes.TSObjectKeyword;
1855
1857
  }
1856
1858
  export interface TSStringKeywordBuilder {
1857
- (): N.TSStringKeyword;
1859
+ (): namedTypes.TSStringKeyword;
1858
1860
  from(params: {
1859
1861
  comments?: K.CommentKind[] | null;
1860
1862
  loc?: K.SourceLocationKind | null;
1861
- }): N.TSStringKeyword;
1863
+ }): namedTypes.TSStringKeyword;
1862
1864
  }
1863
1865
  export interface TSSymbolKeywordBuilder {
1864
- (): N.TSSymbolKeyword;
1866
+ (): namedTypes.TSSymbolKeyword;
1865
1867
  from(params: {
1866
1868
  comments?: K.CommentKind[] | null;
1867
1869
  loc?: K.SourceLocationKind | null;
1868
- }): N.TSSymbolKeyword;
1870
+ }): namedTypes.TSSymbolKeyword;
1869
1871
  }
1870
1872
  export interface TSUndefinedKeywordBuilder {
1871
- (): N.TSUndefinedKeyword;
1873
+ (): namedTypes.TSUndefinedKeyword;
1872
1874
  from(params: {
1873
1875
  comments?: K.CommentKind[] | null;
1874
1876
  loc?: K.SourceLocationKind | null;
1875
- }): N.TSUndefinedKeyword;
1877
+ }): namedTypes.TSUndefinedKeyword;
1876
1878
  }
1877
1879
  export interface TSUnknownKeywordBuilder {
1878
- (): N.TSUnknownKeyword;
1880
+ (): namedTypes.TSUnknownKeyword;
1879
1881
  from(params: {
1880
1882
  comments?: K.CommentKind[] | null;
1881
1883
  loc?: K.SourceLocationKind | null;
1882
- }): N.TSUnknownKeyword;
1884
+ }): namedTypes.TSUnknownKeyword;
1883
1885
  }
1884
1886
  export interface TSVoidKeywordBuilder {
1885
- (): N.TSVoidKeyword;
1887
+ (): namedTypes.TSVoidKeyword;
1886
1888
  from(params: {
1887
1889
  comments?: K.CommentKind[] | null;
1888
1890
  loc?: K.SourceLocationKind | null;
1889
- }): N.TSVoidKeyword;
1891
+ }): namedTypes.TSVoidKeyword;
1890
1892
  }
1891
1893
  export interface TSThisTypeBuilder {
1892
- (): N.TSThisType;
1894
+ (): namedTypes.TSThisType;
1893
1895
  from(params: {
1894
1896
  comments?: K.CommentKind[] | null;
1895
1897
  loc?: K.SourceLocationKind | null;
1896
- }): N.TSThisType;
1898
+ }): namedTypes.TSThisType;
1897
1899
  }
1898
1900
  export interface TSArrayTypeBuilder {
1899
- (elementType: K.TSTypeKind): N.TSArrayType;
1901
+ (elementType: K.TSTypeKind): namedTypes.TSArrayType;
1900
1902
  from(params: {
1901
1903
  comments?: K.CommentKind[] | null;
1902
1904
  elementType: K.TSTypeKind;
1903
1905
  loc?: K.SourceLocationKind | null;
1904
- }): N.TSArrayType;
1906
+ }): namedTypes.TSArrayType;
1905
1907
  }
1906
1908
  export interface TSLiteralTypeBuilder {
1907
- (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind): N.TSLiteralType;
1909
+ (literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind): namedTypes.TSLiteralType;
1908
1910
  from(params: {
1909
1911
  comments?: K.CommentKind[] | null;
1910
- literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind;
1912
+ literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind;
1911
1913
  loc?: K.SourceLocationKind | null;
1912
- }): N.TSLiteralType;
1914
+ }): namedTypes.TSLiteralType;
1913
1915
  }
1914
1916
  export interface TSUnionTypeBuilder {
1915
- (types: K.TSTypeKind[]): N.TSUnionType;
1917
+ (types: K.TSTypeKind[]): namedTypes.TSUnionType;
1916
1918
  from(params: {
1917
1919
  comments?: K.CommentKind[] | null;
1918
1920
  loc?: K.SourceLocationKind | null;
1919
1921
  types: K.TSTypeKind[];
1920
- }): N.TSUnionType;
1922
+ }): namedTypes.TSUnionType;
1921
1923
  }
1922
1924
  export interface TSIntersectionTypeBuilder {
1923
- (types: K.TSTypeKind[]): N.TSIntersectionType;
1925
+ (types: K.TSTypeKind[]): namedTypes.TSIntersectionType;
1924
1926
  from(params: {
1925
1927
  comments?: K.CommentKind[] | null;
1926
1928
  loc?: K.SourceLocationKind | null;
1927
1929
  types: K.TSTypeKind[];
1928
- }): N.TSIntersectionType;
1930
+ }): namedTypes.TSIntersectionType;
1929
1931
  }
1930
1932
  export interface TSConditionalTypeBuilder {
1931
- (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): N.TSConditionalType;
1933
+ (checkType: K.TSTypeKind, extendsType: K.TSTypeKind, trueType: K.TSTypeKind, falseType: K.TSTypeKind): namedTypes.TSConditionalType;
1932
1934
  from(params: {
1933
1935
  checkType: K.TSTypeKind;
1934
1936
  comments?: K.CommentKind[] | null;
@@ -1936,18 +1938,18 @@ export interface TSConditionalTypeBuilder {
1936
1938
  falseType: K.TSTypeKind;
1937
1939
  loc?: K.SourceLocationKind | null;
1938
1940
  trueType: K.TSTypeKind;
1939
- }): N.TSConditionalType;
1941
+ }): namedTypes.TSConditionalType;
1940
1942
  }
1941
1943
  export interface TSInferTypeBuilder {
1942
- (typeParameter: K.TSTypeParameterKind): N.TSInferType;
1944
+ (typeParameter: K.TSTypeParameterKind): namedTypes.TSInferType;
1943
1945
  from(params: {
1944
1946
  comments?: K.CommentKind[] | null;
1945
1947
  loc?: K.SourceLocationKind | null;
1946
1948
  typeParameter: K.TSTypeParameterKind;
1947
- }): N.TSInferType;
1949
+ }): namedTypes.TSInferType;
1948
1950
  }
1949
1951
  export interface TSTypeParameterBuilder {
1950
- (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): N.TSTypeParameter;
1952
+ (name: string, constraint?: K.TSTypeKind | undefined, defaultParam?: K.TSTypeKind | undefined): namedTypes.TSTypeParameter;
1951
1953
  from(params: {
1952
1954
  comments?: K.CommentKind[] | null;
1953
1955
  constraint?: K.TSTypeKind | undefined;
@@ -1956,38 +1958,38 @@ export interface TSTypeParameterBuilder {
1956
1958
  name: string;
1957
1959
  optional?: boolean;
1958
1960
  typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;
1959
- }): N.TSTypeParameter;
1961
+ }): namedTypes.TSTypeParameter;
1960
1962
  }
1961
1963
  export interface TSParenthesizedTypeBuilder {
1962
- (typeAnnotation: K.TSTypeKind): N.TSParenthesizedType;
1964
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSParenthesizedType;
1963
1965
  from(params: {
1964
1966
  comments?: K.CommentKind[] | null;
1965
1967
  loc?: K.SourceLocationKind | null;
1966
1968
  typeAnnotation: K.TSTypeKind;
1967
- }): N.TSParenthesizedType;
1969
+ }): namedTypes.TSParenthesizedType;
1968
1970
  }
1969
1971
  export interface TSFunctionTypeBuilder {
1970
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): N.TSFunctionType;
1972
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSFunctionType;
1971
1973
  from(params: {
1972
1974
  comments?: K.CommentKind[] | null;
1973
1975
  loc?: K.SourceLocationKind | null;
1974
1976
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
1975
1977
  typeAnnotation?: K.TSTypeAnnotationKind | null;
1976
1978
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
1977
- }): N.TSFunctionType;
1979
+ }): namedTypes.TSFunctionType;
1978
1980
  }
1979
1981
  export interface TSConstructorTypeBuilder {
1980
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): N.TSConstructorType;
1982
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]): namedTypes.TSConstructorType;
1981
1983
  from(params: {
1982
1984
  comments?: K.CommentKind[] | null;
1983
1985
  loc?: K.SourceLocationKind | null;
1984
1986
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
1985
1987
  typeAnnotation?: K.TSTypeAnnotationKind | null;
1986
1988
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
1987
- }): N.TSConstructorType;
1989
+ }): namedTypes.TSConstructorType;
1988
1990
  }
1989
1991
  export interface TSDeclareFunctionBuilder {
1990
- (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareFunction;
1992
+ (id: K.IdentifierKind | null | undefined, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareFunction;
1991
1993
  from(params: {
1992
1994
  async?: boolean;
1993
1995
  comments?: K.CommentKind[] | null;
@@ -1998,10 +2000,10 @@ export interface TSDeclareFunctionBuilder {
1998
2000
  params: K.PatternKind[];
1999
2001
  returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
2000
2002
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2001
- }): N.TSDeclareFunction;
2003
+ }): namedTypes.TSDeclareFunction;
2002
2004
  }
2003
2005
  export interface TSDeclareMethodBuilder {
2004
- (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): N.TSDeclareMethod;
2006
+ (key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind, params: K.PatternKind[], returnType?: K.TSTypeAnnotationKind | K.NoopKind | null): namedTypes.TSDeclareMethod;
2005
2007
  from(params: {
2006
2008
  abstract?: boolean;
2007
2009
  access?: "public" | "private" | "protected" | undefined;
@@ -2019,10 +2021,10 @@ export interface TSDeclareMethodBuilder {
2019
2021
  returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;
2020
2022
  static?: boolean;
2021
2023
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2022
- }): N.TSDeclareMethod;
2024
+ }): namedTypes.TSDeclareMethod;
2023
2025
  }
2024
2026
  export interface TSMappedTypeBuilder {
2025
- (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): N.TSMappedType;
2027
+ (typeParameter: K.TSTypeParameterKind, typeAnnotation?: K.TSTypeKind | null): namedTypes.TSMappedType;
2026
2028
  from(params: {
2027
2029
  comments?: K.CommentKind[] | null;
2028
2030
  loc?: K.SourceLocationKind | null;
@@ -2030,62 +2032,62 @@ export interface TSMappedTypeBuilder {
2030
2032
  readonly?: boolean | "+" | "-";
2031
2033
  typeAnnotation?: K.TSTypeKind | null;
2032
2034
  typeParameter: K.TSTypeParameterKind;
2033
- }): N.TSMappedType;
2035
+ }): namedTypes.TSMappedType;
2034
2036
  }
2035
2037
  export interface TSTupleTypeBuilder {
2036
- (elementTypes: K.TSTypeKind[]): N.TSTupleType;
2038
+ (elementTypes: K.TSTypeKind[]): namedTypes.TSTupleType;
2037
2039
  from(params: {
2038
2040
  comments?: K.CommentKind[] | null;
2039
2041
  elementTypes: K.TSTypeKind[];
2040
2042
  loc?: K.SourceLocationKind | null;
2041
- }): N.TSTupleType;
2043
+ }): namedTypes.TSTupleType;
2042
2044
  }
2043
2045
  export interface TSRestTypeBuilder {
2044
- (typeAnnotation: K.TSTypeKind): N.TSRestType;
2046
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSRestType;
2045
2047
  from(params: {
2046
2048
  comments?: K.CommentKind[] | null;
2047
2049
  loc?: K.SourceLocationKind | null;
2048
2050
  typeAnnotation: K.TSTypeKind;
2049
- }): N.TSRestType;
2051
+ }): namedTypes.TSRestType;
2050
2052
  }
2051
2053
  export interface TSOptionalTypeBuilder {
2052
- (typeAnnotation: K.TSTypeKind): N.TSOptionalType;
2054
+ (typeAnnotation: K.TSTypeKind): namedTypes.TSOptionalType;
2053
2055
  from(params: {
2054
2056
  comments?: K.CommentKind[] | null;
2055
2057
  loc?: K.SourceLocationKind | null;
2056
2058
  typeAnnotation: K.TSTypeKind;
2057
- }): N.TSOptionalType;
2059
+ }): namedTypes.TSOptionalType;
2058
2060
  }
2059
2061
  export interface TSIndexedAccessTypeBuilder {
2060
- (objectType: K.TSTypeKind, indexType: K.TSTypeKind): N.TSIndexedAccessType;
2062
+ (objectType: K.TSTypeKind, indexType: K.TSTypeKind): namedTypes.TSIndexedAccessType;
2061
2063
  from(params: {
2062
2064
  comments?: K.CommentKind[] | null;
2063
2065
  indexType: K.TSTypeKind;
2064
2066
  loc?: K.SourceLocationKind | null;
2065
2067
  objectType: K.TSTypeKind;
2066
- }): N.TSIndexedAccessType;
2068
+ }): namedTypes.TSIndexedAccessType;
2067
2069
  }
2068
2070
  export interface TSTypeOperatorBuilder {
2069
- (operator: string): N.TSTypeOperator;
2071
+ (operator: string): namedTypes.TSTypeOperator;
2070
2072
  from(params: {
2071
2073
  comments?: K.CommentKind[] | null;
2072
2074
  loc?: K.SourceLocationKind | null;
2073
2075
  operator: string;
2074
2076
  typeAnnotation: K.TSTypeKind;
2075
- }): N.TSTypeOperator;
2077
+ }): namedTypes.TSTypeOperator;
2076
2078
  }
2077
2079
  export interface TSIndexSignatureBuilder {
2078
- (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSIndexSignature;
2080
+ (parameters: K.IdentifierKind[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSIndexSignature;
2079
2081
  from(params: {
2080
2082
  comments?: K.CommentKind[] | null;
2081
2083
  loc?: K.SourceLocationKind | null;
2082
2084
  parameters: K.IdentifierKind[];
2083
2085
  readonly?: boolean;
2084
2086
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2085
- }): N.TSIndexSignature;
2087
+ }): namedTypes.TSIndexSignature;
2086
2088
  }
2087
2089
  export interface TSPropertySignatureBuilder {
2088
- (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): N.TSPropertySignature;
2090
+ (key: K.ExpressionKind, typeAnnotation?: K.TSTypeAnnotationKind | null, optional?: boolean): namedTypes.TSPropertySignature;
2089
2091
  from(params: {
2090
2092
  comments?: K.CommentKind[] | null;
2091
2093
  computed?: boolean;
@@ -2095,10 +2097,10 @@ export interface TSPropertySignatureBuilder {
2095
2097
  optional?: boolean;
2096
2098
  readonly?: boolean;
2097
2099
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2098
- }): N.TSPropertySignature;
2100
+ }): namedTypes.TSPropertySignature;
2099
2101
  }
2100
2102
  export interface TSMethodSignatureBuilder {
2101
- (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSMethodSignature;
2103
+ (key: K.ExpressionKind, parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSMethodSignature;
2102
2104
  from(params: {
2103
2105
  comments?: K.CommentKind[] | null;
2104
2106
  computed?: boolean;
@@ -2108,74 +2110,74 @@ export interface TSMethodSignatureBuilder {
2108
2110
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2109
2111
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2110
2112
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2111
- }): N.TSMethodSignature;
2113
+ }): namedTypes.TSMethodSignature;
2112
2114
  }
2113
2115
  export interface TSTypePredicateBuilder {
2114
- (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): N.TSTypePredicate;
2116
+ (parameterName: K.IdentifierKind | K.TSThisTypeKind, typeAnnotation: K.TSTypeAnnotationKind): namedTypes.TSTypePredicate;
2115
2117
  from(params: {
2116
2118
  comments?: K.CommentKind[] | null;
2117
2119
  loc?: K.SourceLocationKind | null;
2118
2120
  parameterName: K.IdentifierKind | K.TSThisTypeKind;
2119
2121
  typeAnnotation: K.TSTypeAnnotationKind;
2120
- }): N.TSTypePredicate;
2122
+ }): namedTypes.TSTypePredicate;
2121
2123
  }
2122
2124
  export interface TSCallSignatureDeclarationBuilder {
2123
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSCallSignatureDeclaration;
2125
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSCallSignatureDeclaration;
2124
2126
  from(params: {
2125
2127
  comments?: K.CommentKind[] | null;
2126
2128
  loc?: K.SourceLocationKind | null;
2127
2129
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2128
2130
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2129
2131
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2130
- }): N.TSCallSignatureDeclaration;
2132
+ }): namedTypes.TSCallSignatureDeclaration;
2131
2133
  }
2132
2134
  export interface TSConstructSignatureDeclarationBuilder {
2133
- (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): N.TSConstructSignatureDeclaration;
2135
+ (parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[], typeAnnotation?: K.TSTypeAnnotationKind | null): namedTypes.TSConstructSignatureDeclaration;
2134
2136
  from(params: {
2135
2137
  comments?: K.CommentKind[] | null;
2136
2138
  loc?: K.SourceLocationKind | null;
2137
2139
  parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[];
2138
2140
  typeAnnotation?: K.TSTypeAnnotationKind | null;
2139
2141
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2140
- }): N.TSConstructSignatureDeclaration;
2142
+ }): namedTypes.TSConstructSignatureDeclaration;
2141
2143
  }
2142
2144
  export interface TSEnumMemberBuilder {
2143
- (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): N.TSEnumMember;
2145
+ (id: K.IdentifierKind | K.StringLiteralKind, initializer?: K.ExpressionKind | null): namedTypes.TSEnumMember;
2144
2146
  from(params: {
2145
2147
  comments?: K.CommentKind[] | null;
2146
2148
  id: K.IdentifierKind | K.StringLiteralKind;
2147
2149
  initializer?: K.ExpressionKind | null;
2148
2150
  loc?: K.SourceLocationKind | null;
2149
- }): N.TSEnumMember;
2151
+ }): namedTypes.TSEnumMember;
2150
2152
  }
2151
2153
  export interface TSTypeQueryBuilder {
2152
- (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): N.TSTypeQuery;
2154
+ (exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind): namedTypes.TSTypeQuery;
2153
2155
  from(params: {
2154
2156
  comments?: K.CommentKind[] | null;
2155
2157
  exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind;
2156
2158
  loc?: K.SourceLocationKind | null;
2157
- }): N.TSTypeQuery;
2159
+ }): namedTypes.TSTypeQuery;
2158
2160
  }
2159
2161
  export interface TSImportTypeBuilder {
2160
- (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): N.TSImportType;
2162
+ (argument: K.StringLiteralKind, qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined, typeParameters?: K.TSTypeParameterInstantiationKind | null): namedTypes.TSImportType;
2161
2163
  from(params: {
2162
2164
  argument: K.StringLiteralKind;
2163
2165
  comments?: K.CommentKind[] | null;
2164
2166
  loc?: K.SourceLocationKind | null;
2165
2167
  qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined;
2166
2168
  typeParameters?: K.TSTypeParameterInstantiationKind | null;
2167
- }): N.TSImportType;
2169
+ }): namedTypes.TSImportType;
2168
2170
  }
2169
2171
  export interface TSTypeLiteralBuilder {
2170
- (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSTypeLiteral;
2172
+ (members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSTypeLiteral;
2171
2173
  from(params: {
2172
2174
  comments?: K.CommentKind[] | null;
2173
2175
  loc?: K.SourceLocationKind | null;
2174
2176
  members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
2175
- }): N.TSTypeLiteral;
2177
+ }): namedTypes.TSTypeLiteral;
2176
2178
  }
2177
2179
  export interface TSTypeAssertionBuilder {
2178
- (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): N.TSTypeAssertion;
2180
+ (typeAnnotation: K.TSTypeKind, expression: K.ExpressionKind): namedTypes.TSTypeAssertion;
2179
2181
  from(params: {
2180
2182
  comments?: K.CommentKind[] | null;
2181
2183
  expression: K.ExpressionKind;
@@ -2184,10 +2186,10 @@ export interface TSTypeAssertionBuilder {
2184
2186
  } | null;
2185
2187
  loc?: K.SourceLocationKind | null;
2186
2188
  typeAnnotation: K.TSTypeKind;
2187
- }): N.TSTypeAssertion;
2189
+ }): namedTypes.TSTypeAssertion;
2188
2190
  }
2189
2191
  export interface TSEnumDeclarationBuilder {
2190
- (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): N.TSEnumDeclaration;
2192
+ (id: K.IdentifierKind, members: K.TSEnumMemberKind[]): namedTypes.TSEnumDeclaration;
2191
2193
  from(params: {
2192
2194
  comments?: K.CommentKind[] | null;
2193
2195
  const?: boolean;
@@ -2196,10 +2198,10 @@ export interface TSEnumDeclarationBuilder {
2196
2198
  initializer?: K.ExpressionKind | null;
2197
2199
  loc?: K.SourceLocationKind | null;
2198
2200
  members: K.TSEnumMemberKind[];
2199
- }): N.TSEnumDeclaration;
2201
+ }): namedTypes.TSEnumDeclaration;
2200
2202
  }
2201
2203
  export interface TSTypeAliasDeclarationBuilder {
2202
- (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): N.TSTypeAliasDeclaration;
2204
+ (id: K.IdentifierKind, typeAnnotation: K.TSTypeKind): namedTypes.TSTypeAliasDeclaration;
2203
2205
  from(params: {
2204
2206
  comments?: K.CommentKind[] | null;
2205
2207
  declare?: boolean;
@@ -2207,18 +2209,18 @@ export interface TSTypeAliasDeclarationBuilder {
2207
2209
  loc?: K.SourceLocationKind | null;
2208
2210
  typeAnnotation: K.TSTypeKind;
2209
2211
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2210
- }): N.TSTypeAliasDeclaration;
2212
+ }): namedTypes.TSTypeAliasDeclaration;
2211
2213
  }
2212
2214
  export interface TSModuleBlockBuilder {
2213
- (body: K.StatementKind[]): N.TSModuleBlock;
2215
+ (body: K.StatementKind[]): namedTypes.TSModuleBlock;
2214
2216
  from(params: {
2215
2217
  body: K.StatementKind[];
2216
2218
  comments?: K.CommentKind[] | null;
2217
2219
  loc?: K.SourceLocationKind | null;
2218
- }): N.TSModuleBlock;
2220
+ }): namedTypes.TSModuleBlock;
2219
2221
  }
2220
2222
  export interface TSModuleDeclarationBuilder {
2221
- (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): N.TSModuleDeclaration;
2223
+ (id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind, body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null): namedTypes.TSModuleDeclaration;
2222
2224
  from(params: {
2223
2225
  body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null;
2224
2226
  comments?: K.CommentKind[] | null;
@@ -2226,52 +2228,52 @@ export interface TSModuleDeclarationBuilder {
2226
2228
  global?: boolean;
2227
2229
  id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind;
2228
2230
  loc?: K.SourceLocationKind | null;
2229
- }): N.TSModuleDeclaration;
2231
+ }): namedTypes.TSModuleDeclaration;
2230
2232
  }
2231
2233
  export interface TSImportEqualsDeclarationBuilder {
2232
- (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): N.TSImportEqualsDeclaration;
2234
+ (id: K.IdentifierKind, moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind): namedTypes.TSImportEqualsDeclaration;
2233
2235
  from(params: {
2234
2236
  comments?: K.CommentKind[] | null;
2235
2237
  id: K.IdentifierKind;
2236
2238
  isExport?: boolean;
2237
2239
  loc?: K.SourceLocationKind | null;
2238
2240
  moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind;
2239
- }): N.TSImportEqualsDeclaration;
2241
+ }): namedTypes.TSImportEqualsDeclaration;
2240
2242
  }
2241
2243
  export interface TSExternalModuleReferenceBuilder {
2242
- (expression: K.StringLiteralKind): N.TSExternalModuleReference;
2244
+ (expression: K.StringLiteralKind): namedTypes.TSExternalModuleReference;
2243
2245
  from(params: {
2244
2246
  comments?: K.CommentKind[] | null;
2245
2247
  expression: K.StringLiteralKind;
2246
2248
  loc?: K.SourceLocationKind | null;
2247
- }): N.TSExternalModuleReference;
2249
+ }): namedTypes.TSExternalModuleReference;
2248
2250
  }
2249
2251
  export interface TSExportAssignmentBuilder {
2250
- (expression: K.ExpressionKind): N.TSExportAssignment;
2252
+ (expression: K.ExpressionKind): namedTypes.TSExportAssignment;
2251
2253
  from(params: {
2252
2254
  comments?: K.CommentKind[] | null;
2253
2255
  expression: K.ExpressionKind;
2254
2256
  loc?: K.SourceLocationKind | null;
2255
- }): N.TSExportAssignment;
2257
+ }): namedTypes.TSExportAssignment;
2256
2258
  }
2257
2259
  export interface TSNamespaceExportDeclarationBuilder {
2258
- (id: K.IdentifierKind): N.TSNamespaceExportDeclaration;
2260
+ (id: K.IdentifierKind): namedTypes.TSNamespaceExportDeclaration;
2259
2261
  from(params: {
2260
2262
  comments?: K.CommentKind[] | null;
2261
2263
  id: K.IdentifierKind;
2262
2264
  loc?: K.SourceLocationKind | null;
2263
- }): N.TSNamespaceExportDeclaration;
2265
+ }): namedTypes.TSNamespaceExportDeclaration;
2264
2266
  }
2265
2267
  export interface TSInterfaceBodyBuilder {
2266
- (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): N.TSInterfaceBody;
2268
+ (body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]): namedTypes.TSInterfaceBody;
2267
2269
  from(params: {
2268
2270
  body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[];
2269
2271
  comments?: K.CommentKind[] | null;
2270
2272
  loc?: K.SourceLocationKind | null;
2271
- }): N.TSInterfaceBody;
2273
+ }): namedTypes.TSInterfaceBody;
2272
2274
  }
2273
2275
  export interface TSInterfaceDeclarationBuilder {
2274
- (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): N.TSInterfaceDeclaration;
2276
+ (id: K.IdentifierKind | K.TSQualifiedNameKind, body: K.TSInterfaceBodyKind): namedTypes.TSInterfaceDeclaration;
2275
2277
  from(params: {
2276
2278
  body: K.TSInterfaceBodyKind;
2277
2279
  comments?: K.CommentKind[] | null;
@@ -2280,20 +2282,20 @@ export interface TSInterfaceDeclarationBuilder {
2280
2282
  id: K.IdentifierKind | K.TSQualifiedNameKind;
2281
2283
  loc?: K.SourceLocationKind | null;
2282
2284
  typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;
2283
- }): N.TSInterfaceDeclaration;
2285
+ }): namedTypes.TSInterfaceDeclaration;
2284
2286
  }
2285
2287
  export interface TSParameterPropertyBuilder {
2286
- (parameter: K.IdentifierKind | K.AssignmentPatternKind): N.TSParameterProperty;
2288
+ (parameter: K.IdentifierKind | K.AssignmentPatternKind): namedTypes.TSParameterProperty;
2287
2289
  from(params: {
2288
2290
  accessibility?: "public" | "private" | "protected" | undefined;
2289
2291
  comments?: K.CommentKind[] | null;
2290
2292
  loc?: K.SourceLocationKind | null;
2291
2293
  parameter: K.IdentifierKind | K.AssignmentPatternKind;
2292
2294
  readonly?: boolean;
2293
- }): N.TSParameterProperty;
2295
+ }): namedTypes.TSParameterProperty;
2294
2296
  }
2295
2297
  export interface OptionalMemberExpressionBuilder {
2296
- (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): N.OptionalMemberExpression;
2298
+ (object: K.ExpressionKind, property: K.IdentifierKind | K.ExpressionKind, computed?: boolean, optional?: boolean): namedTypes.OptionalMemberExpression;
2297
2299
  from(params: {
2298
2300
  comments?: K.CommentKind[] | null;
2299
2301
  computed?: boolean;
@@ -2301,19 +2303,20 @@ export interface OptionalMemberExpressionBuilder {
2301
2303
  object: K.ExpressionKind;
2302
2304
  optional?: boolean;
2303
2305
  property: K.IdentifierKind | K.ExpressionKind;
2304
- }): N.OptionalMemberExpression;
2306
+ }): namedTypes.OptionalMemberExpression;
2305
2307
  }
2306
2308
  export interface OptionalCallExpressionBuilder {
2307
- (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): N.OptionalCallExpression;
2309
+ (callee: K.ExpressionKind, argumentsParam: (K.ExpressionKind | K.SpreadElementKind)[], optional?: boolean): namedTypes.OptionalCallExpression;
2308
2310
  from(params: {
2309
2311
  arguments: (K.ExpressionKind | K.SpreadElementKind)[];
2310
2312
  callee: K.ExpressionKind;
2311
2313
  comments?: K.CommentKind[] | null;
2312
2314
  loc?: K.SourceLocationKind | null;
2313
2315
  optional?: boolean;
2314
- }): N.OptionalCallExpression;
2316
+ typeArguments?: null | K.TypeParameterInstantiationKind;
2317
+ }): namedTypes.OptionalCallExpression;
2315
2318
  }
2316
- export interface Builders {
2319
+ export interface builders {
2317
2320
  file: FileBuilder;
2318
2321
  program: ProgramBuilder;
2319
2322
  identifier: IdentifierBuilder;
@@ -2349,12 +2352,12 @@ export interface Builders {
2349
2352
  unaryExpression: UnaryExpressionBuilder;
2350
2353
  binaryExpression: BinaryExpressionBuilder;
2351
2354
  assignmentExpression: AssignmentExpressionBuilder;
2355
+ memberExpression: MemberExpressionBuilder;
2352
2356
  updateExpression: UpdateExpressionBuilder;
2353
2357
  logicalExpression: LogicalExpressionBuilder;
2354
2358
  conditionalExpression: ConditionalExpressionBuilder;
2355
2359
  newExpression: NewExpressionBuilder;
2356
2360
  callExpression: CallExpressionBuilder;
2357
- memberExpression: MemberExpressionBuilder;
2358
2361
  restElement: RestElementBuilder;
2359
2362
  typeAnnotation: TypeAnnotationBuilder;
2360
2363
  tsTypeAnnotation: TSTypeAnnotationBuilder;