source: trip-planner-front/node_modules/@babel/types/lib/index.d.ts@ 59329aa

Last change on this file since 59329aa was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 203.9 KB
Line 
1interface BaseComment {
2 value: string;
3 start: number;
4 end: number;
5 loc: SourceLocation;
6 type: "CommentBlock" | "CommentLine";
7}
8interface CommentBlock extends BaseComment {
9 type: "CommentBlock";
10}
11interface CommentLine extends BaseComment {
12 type: "CommentLine";
13}
14declare type Comment = CommentBlock | CommentLine;
15interface SourceLocation {
16 start: {
17 line: number;
18 column: number;
19 };
20 end: {
21 line: number;
22 column: number;
23 };
24}
25interface BaseNode {
26 leadingComments: ReadonlyArray<Comment> | null;
27 innerComments: ReadonlyArray<Comment> | null;
28 trailingComments: ReadonlyArray<Comment> | null;
29 start: number | null;
30 end: number | null;
31 loc: SourceLocation | null;
32 type: Node["type"];
33 range?: [number, number];
34 extra?: Record<string, unknown>;
35}
36declare type CommentTypeShorthand = "leading" | "inner" | "trailing";
37declare type Node = AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | Binary | BinaryExpression | BindExpression | Block | BlockParent | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | Class | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | CompletionStatement | Conditional | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | Declaration | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBody | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | Expression | ExpressionStatement | ExpressionWrapper | File | Flow | FlowBaseAnnotation | FlowDeclaration | FlowPredicate | FlowType | For | ForInStatement | ForOfStatement | ForStatement | ForXStatement | Function | FunctionDeclaration | FunctionExpression | FunctionParent | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Immutable | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSX | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LVal | LabeledStatement | Literal | LogicalExpression | Loop | MemberExpression | MetaProperty | Method | MixedTypeAnnotation | ModuleDeclaration | ModuleExpression | ModuleSpecifier | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral$1 | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMember | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | Pattern | PatternLike | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | Private | PrivateName | Program | Property | Pureish | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral$1 | RestElement | RestProperty$1 | ReturnStatement | Scopable | SequenceExpression | SpreadElement | SpreadProperty$1 | Statement | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBaseType | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEntityName | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSStringKeyword | TSSymbolKeyword | TSThisType | TSTupleType | TSType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeElement | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | Terminatorless | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnaryLike | UnionTypeAnnotation | UpdateExpression | UserWhitespacable | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidTypeAnnotation | While | WhileStatement | WithStatement | YieldExpression;
38interface ArrayExpression extends BaseNode {
39 type: "ArrayExpression";
40 elements: Array<null | Expression | SpreadElement>;
41}
42interface AssignmentExpression extends BaseNode {
43 type: "AssignmentExpression";
44 operator: string;
45 left: LVal;
46 right: Expression;
47}
48interface BinaryExpression extends BaseNode {
49 type: "BinaryExpression";
50 operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
51 left: Expression | PrivateName;
52 right: Expression;
53}
54interface InterpreterDirective extends BaseNode {
55 type: "InterpreterDirective";
56 value: string;
57}
58interface Directive extends BaseNode {
59 type: "Directive";
60 value: DirectiveLiteral;
61}
62interface DirectiveLiteral extends BaseNode {
63 type: "DirectiveLiteral";
64 value: string;
65}
66interface BlockStatement extends BaseNode {
67 type: "BlockStatement";
68 body: Array<Statement>;
69 directives: Array<Directive>;
70}
71interface BreakStatement extends BaseNode {
72 type: "BreakStatement";
73 label?: Identifier | null;
74}
75interface CallExpression extends BaseNode {
76 type: "CallExpression";
77 callee: Expression | V8IntrinsicIdentifier;
78 arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
79 optional?: true | false | null;
80 typeArguments?: TypeParameterInstantiation | null;
81 typeParameters?: TSTypeParameterInstantiation | null;
82}
83interface CatchClause extends BaseNode {
84 type: "CatchClause";
85 param?: Identifier | ArrayPattern | ObjectPattern | null;
86 body: BlockStatement;
87}
88interface ConditionalExpression extends BaseNode {
89 type: "ConditionalExpression";
90 test: Expression;
91 consequent: Expression;
92 alternate: Expression;
93}
94interface ContinueStatement extends BaseNode {
95 type: "ContinueStatement";
96 label?: Identifier | null;
97}
98interface DebuggerStatement extends BaseNode {
99 type: "DebuggerStatement";
100}
101interface DoWhileStatement extends BaseNode {
102 type: "DoWhileStatement";
103 test: Expression;
104 body: Statement;
105}
106interface EmptyStatement extends BaseNode {
107 type: "EmptyStatement";
108}
109interface ExpressionStatement extends BaseNode {
110 type: "ExpressionStatement";
111 expression: Expression;
112}
113interface File extends BaseNode {
114 type: "File";
115 program: Program;
116 comments?: Array<CommentBlock | CommentLine> | null;
117 tokens?: Array<any> | null;
118}
119interface ForInStatement extends BaseNode {
120 type: "ForInStatement";
121 left: VariableDeclaration | LVal;
122 right: Expression;
123 body: Statement;
124}
125interface ForStatement extends BaseNode {
126 type: "ForStatement";
127 init?: VariableDeclaration | Expression | null;
128 test?: Expression | null;
129 update?: Expression | null;
130 body: Statement;
131}
132interface FunctionDeclaration extends BaseNode {
133 type: "FunctionDeclaration";
134 id?: Identifier | null;
135 params: Array<Identifier | Pattern | RestElement>;
136 body: BlockStatement;
137 generator?: boolean;
138 async?: boolean;
139 declare?: boolean | null;
140 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
141 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
142}
143interface FunctionExpression extends BaseNode {
144 type: "FunctionExpression";
145 id?: Identifier | null;
146 params: Array<Identifier | Pattern | RestElement>;
147 body: BlockStatement;
148 generator?: boolean;
149 async?: boolean;
150 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
151 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
152}
153interface Identifier extends BaseNode {
154 type: "Identifier";
155 name: string;
156 decorators?: Array<Decorator> | null;
157 optional?: boolean | null;
158 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
159}
160interface IfStatement extends BaseNode {
161 type: "IfStatement";
162 test: Expression;
163 consequent: Statement;
164 alternate?: Statement | null;
165}
166interface LabeledStatement extends BaseNode {
167 type: "LabeledStatement";
168 label: Identifier;
169 body: Statement;
170}
171interface StringLiteral extends BaseNode {
172 type: "StringLiteral";
173 value: string;
174}
175interface NumericLiteral extends BaseNode {
176 type: "NumericLiteral";
177 value: number;
178}
179/**
180 * @deprecated Use `NumericLiteral`
181 */
182interface NumberLiteral$1 extends BaseNode {
183 type: "NumberLiteral";
184 value: number;
185}
186interface NullLiteral extends BaseNode {
187 type: "NullLiteral";
188}
189interface BooleanLiteral extends BaseNode {
190 type: "BooleanLiteral";
191 value: boolean;
192}
193interface RegExpLiteral extends BaseNode {
194 type: "RegExpLiteral";
195 pattern: string;
196 flags: string;
197}
198/**
199 * @deprecated Use `RegExpLiteral`
200 */
201interface RegexLiteral$1 extends BaseNode {
202 type: "RegexLiteral";
203 pattern: string;
204 flags: string;
205}
206interface LogicalExpression extends BaseNode {
207 type: "LogicalExpression";
208 operator: "||" | "&&" | "??";
209 left: Expression;
210 right: Expression;
211}
212interface MemberExpression extends BaseNode {
213 type: "MemberExpression";
214 object: Expression;
215 property: Expression | Identifier | PrivateName;
216 computed: boolean;
217 optional?: true | false | null;
218}
219interface NewExpression extends BaseNode {
220 type: "NewExpression";
221 callee: Expression | V8IntrinsicIdentifier;
222 arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
223 optional?: true | false | null;
224 typeArguments?: TypeParameterInstantiation | null;
225 typeParameters?: TSTypeParameterInstantiation | null;
226}
227interface Program extends BaseNode {
228 type: "Program";
229 body: Array<Statement>;
230 directives: Array<Directive>;
231 sourceType: "script" | "module";
232 interpreter?: InterpreterDirective | null;
233 sourceFile: string;
234}
235interface ObjectExpression extends BaseNode {
236 type: "ObjectExpression";
237 properties: Array<ObjectMethod | ObjectProperty | SpreadElement>;
238}
239interface ObjectMethod extends BaseNode {
240 type: "ObjectMethod";
241 kind: "method" | "get" | "set";
242 key: Expression | Identifier | StringLiteral | NumericLiteral;
243 params: Array<Identifier | Pattern | RestElement>;
244 body: BlockStatement;
245 computed: boolean;
246 generator?: boolean;
247 async?: boolean;
248 decorators?: Array<Decorator> | null;
249 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
250 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
251}
252interface ObjectProperty extends BaseNode {
253 type: "ObjectProperty";
254 key: Expression | Identifier | StringLiteral | NumericLiteral;
255 value: Expression | PatternLike;
256 computed: boolean;
257 shorthand: boolean;
258 decorators?: Array<Decorator> | null;
259}
260interface RestElement extends BaseNode {
261 type: "RestElement";
262 argument: LVal;
263 decorators?: Array<Decorator> | null;
264 optional?: boolean | null;
265 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
266}
267/**
268 * @deprecated Use `RestElement`
269 */
270interface RestProperty$1 extends BaseNode {
271 type: "RestProperty";
272 argument: LVal;
273 decorators?: Array<Decorator> | null;
274 optional?: boolean | null;
275 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
276}
277interface ReturnStatement extends BaseNode {
278 type: "ReturnStatement";
279 argument?: Expression | null;
280}
281interface SequenceExpression extends BaseNode {
282 type: "SequenceExpression";
283 expressions: Array<Expression>;
284}
285interface ParenthesizedExpression extends BaseNode {
286 type: "ParenthesizedExpression";
287 expression: Expression;
288}
289interface SwitchCase extends BaseNode {
290 type: "SwitchCase";
291 test?: Expression | null;
292 consequent: Array<Statement>;
293}
294interface SwitchStatement extends BaseNode {
295 type: "SwitchStatement";
296 discriminant: Expression;
297 cases: Array<SwitchCase>;
298}
299interface ThisExpression extends BaseNode {
300 type: "ThisExpression";
301}
302interface ThrowStatement extends BaseNode {
303 type: "ThrowStatement";
304 argument: Expression;
305}
306interface TryStatement extends BaseNode {
307 type: "TryStatement";
308 block: BlockStatement;
309 handler?: CatchClause | null;
310 finalizer?: BlockStatement | null;
311}
312interface UnaryExpression extends BaseNode {
313 type: "UnaryExpression";
314 operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
315 argument: Expression;
316 prefix: boolean;
317}
318interface UpdateExpression extends BaseNode {
319 type: "UpdateExpression";
320 operator: "++" | "--";
321 argument: Expression;
322 prefix: boolean;
323}
324interface VariableDeclaration extends BaseNode {
325 type: "VariableDeclaration";
326 kind: "var" | "let" | "const";
327 declarations: Array<VariableDeclarator>;
328 declare?: boolean | null;
329}
330interface VariableDeclarator extends BaseNode {
331 type: "VariableDeclarator";
332 id: LVal;
333 init?: Expression | null;
334 definite?: boolean | null;
335}
336interface WhileStatement extends BaseNode {
337 type: "WhileStatement";
338 test: Expression;
339 body: Statement;
340}
341interface WithStatement extends BaseNode {
342 type: "WithStatement";
343 object: Expression;
344 body: Statement;
345}
346interface AssignmentPattern extends BaseNode {
347 type: "AssignmentPattern";
348 left: Identifier | ObjectPattern | ArrayPattern | MemberExpression;
349 right: Expression;
350 decorators?: Array<Decorator> | null;
351 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
352}
353interface ArrayPattern extends BaseNode {
354 type: "ArrayPattern";
355 elements: Array<null | PatternLike>;
356 decorators?: Array<Decorator> | null;
357 optional?: boolean | null;
358 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
359}
360interface ArrowFunctionExpression extends BaseNode {
361 type: "ArrowFunctionExpression";
362 params: Array<Identifier | Pattern | RestElement>;
363 body: BlockStatement | Expression;
364 async?: boolean;
365 expression: boolean;
366 generator?: boolean;
367 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
368 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
369}
370interface ClassBody extends BaseNode {
371 type: "ClassBody";
372 body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | TSDeclareMethod | TSIndexSignature>;
373}
374interface ClassExpression extends BaseNode {
375 type: "ClassExpression";
376 id?: Identifier | null;
377 superClass?: Expression | null;
378 body: ClassBody;
379 decorators?: Array<Decorator> | null;
380 implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
381 mixins?: InterfaceExtends | null;
382 superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
383 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
384}
385interface ClassDeclaration extends BaseNode {
386 type: "ClassDeclaration";
387 id: Identifier;
388 superClass?: Expression | null;
389 body: ClassBody;
390 decorators?: Array<Decorator> | null;
391 abstract?: boolean | null;
392 declare?: boolean | null;
393 implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
394 mixins?: InterfaceExtends | null;
395 superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
396 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
397}
398interface ExportAllDeclaration extends BaseNode {
399 type: "ExportAllDeclaration";
400 source: StringLiteral;
401 assertions?: Array<ImportAttribute> | null;
402 exportKind?: "type" | "value" | null;
403}
404interface ExportDefaultDeclaration extends BaseNode {
405 type: "ExportDefaultDeclaration";
406 declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression;
407 exportKind?: "value" | null;
408}
409interface ExportNamedDeclaration extends BaseNode {
410 type: "ExportNamedDeclaration";
411 declaration?: Declaration | null;
412 specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>;
413 source?: StringLiteral | null;
414 assertions?: Array<ImportAttribute> | null;
415 exportKind?: "type" | "value" | null;
416}
417interface ExportSpecifier extends BaseNode {
418 type: "ExportSpecifier";
419 local: Identifier;
420 exported: Identifier | StringLiteral;
421}
422interface ForOfStatement extends BaseNode {
423 type: "ForOfStatement";
424 left: VariableDeclaration | LVal;
425 right: Expression;
426 body: Statement;
427 await: boolean;
428}
429interface ImportDeclaration extends BaseNode {
430 type: "ImportDeclaration";
431 specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
432 source: StringLiteral;
433 assertions?: Array<ImportAttribute> | null;
434 importKind?: "type" | "typeof" | "value" | null;
435}
436interface ImportDefaultSpecifier extends BaseNode {
437 type: "ImportDefaultSpecifier";
438 local: Identifier;
439}
440interface ImportNamespaceSpecifier extends BaseNode {
441 type: "ImportNamespaceSpecifier";
442 local: Identifier;
443}
444interface ImportSpecifier extends BaseNode {
445 type: "ImportSpecifier";
446 local: Identifier;
447 imported: Identifier | StringLiteral;
448 importKind?: "type" | "typeof" | null;
449}
450interface MetaProperty extends BaseNode {
451 type: "MetaProperty";
452 meta: Identifier;
453 property: Identifier;
454}
455interface ClassMethod extends BaseNode {
456 type: "ClassMethod";
457 kind?: "get" | "set" | "method" | "constructor";
458 key: Identifier | StringLiteral | NumericLiteral | Expression;
459 params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
460 body: BlockStatement;
461 computed?: boolean;
462 static?: boolean;
463 generator?: boolean;
464 async?: boolean;
465 abstract?: boolean | null;
466 access?: "public" | "private" | "protected" | null;
467 accessibility?: "public" | "private" | "protected" | null;
468 decorators?: Array<Decorator> | null;
469 optional?: boolean | null;
470 override?: boolean;
471 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
472 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
473}
474interface ObjectPattern extends BaseNode {
475 type: "ObjectPattern";
476 properties: Array<RestElement | ObjectProperty>;
477 decorators?: Array<Decorator> | null;
478 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
479}
480interface SpreadElement extends BaseNode {
481 type: "SpreadElement";
482 argument: Expression;
483}
484/**
485 * @deprecated Use `SpreadElement`
486 */
487interface SpreadProperty$1 extends BaseNode {
488 type: "SpreadProperty";
489 argument: Expression;
490}
491interface Super extends BaseNode {
492 type: "Super";
493}
494interface TaggedTemplateExpression extends BaseNode {
495 type: "TaggedTemplateExpression";
496 tag: Expression;
497 quasi: TemplateLiteral;
498 typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
499}
500interface TemplateElement extends BaseNode {
501 type: "TemplateElement";
502 value: {
503 raw: string;
504 cooked?: string;
505 };
506 tail: boolean;
507}
508interface TemplateLiteral extends BaseNode {
509 type: "TemplateLiteral";
510 quasis: Array<TemplateElement>;
511 expressions: Array<Expression | TSType>;
512}
513interface YieldExpression extends BaseNode {
514 type: "YieldExpression";
515 argument?: Expression | null;
516 delegate: boolean;
517}
518interface AwaitExpression extends BaseNode {
519 type: "AwaitExpression";
520 argument: Expression;
521}
522interface Import extends BaseNode {
523 type: "Import";
524}
525interface BigIntLiteral extends BaseNode {
526 type: "BigIntLiteral";
527 value: string;
528}
529interface ExportNamespaceSpecifier extends BaseNode {
530 type: "ExportNamespaceSpecifier";
531 exported: Identifier;
532}
533interface OptionalMemberExpression extends BaseNode {
534 type: "OptionalMemberExpression";
535 object: Expression;
536 property: Expression | Identifier;
537 computed: boolean;
538 optional: boolean;
539}
540interface OptionalCallExpression extends BaseNode {
541 type: "OptionalCallExpression";
542 callee: Expression;
543 arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
544 optional: boolean;
545 typeArguments?: TypeParameterInstantiation | null;
546 typeParameters?: TSTypeParameterInstantiation | null;
547}
548interface ClassProperty extends BaseNode {
549 type: "ClassProperty";
550 key: Identifier | StringLiteral | NumericLiteral | Expression;
551 value?: Expression | null;
552 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
553 decorators?: Array<Decorator> | null;
554 computed?: boolean;
555 static?: boolean;
556 abstract?: boolean | null;
557 accessibility?: "public" | "private" | "protected" | null;
558 declare?: boolean | null;
559 definite?: boolean | null;
560 optional?: boolean | null;
561 override?: boolean;
562 readonly?: boolean | null;
563 variance?: Variance | null;
564}
565interface ClassPrivateProperty extends BaseNode {
566 type: "ClassPrivateProperty";
567 key: PrivateName;
568 value?: Expression | null;
569 decorators?: Array<Decorator> | null;
570 static: any;
571 definite?: boolean | null;
572 readonly?: boolean | null;
573 typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
574 variance?: Variance | null;
575}
576interface ClassPrivateMethod extends BaseNode {
577 type: "ClassPrivateMethod";
578 kind?: "get" | "set" | "method" | "constructor";
579 key: PrivateName;
580 params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
581 body: BlockStatement;
582 static?: boolean;
583 abstract?: boolean | null;
584 access?: "public" | "private" | "protected" | null;
585 accessibility?: "public" | "private" | "protected" | null;
586 async?: boolean;
587 computed?: boolean;
588 decorators?: Array<Decorator> | null;
589 generator?: boolean;
590 optional?: boolean | null;
591 override?: boolean;
592 returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
593 typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
594}
595interface PrivateName extends BaseNode {
596 type: "PrivateName";
597 id: Identifier;
598}
599interface AnyTypeAnnotation extends BaseNode {
600 type: "AnyTypeAnnotation";
601}
602interface ArrayTypeAnnotation extends BaseNode {
603 type: "ArrayTypeAnnotation";
604 elementType: FlowType;
605}
606interface BooleanTypeAnnotation extends BaseNode {
607 type: "BooleanTypeAnnotation";
608}
609interface BooleanLiteralTypeAnnotation extends BaseNode {
610 type: "BooleanLiteralTypeAnnotation";
611 value: boolean;
612}
613interface NullLiteralTypeAnnotation extends BaseNode {
614 type: "NullLiteralTypeAnnotation";
615}
616interface ClassImplements extends BaseNode {
617 type: "ClassImplements";
618 id: Identifier;
619 typeParameters?: TypeParameterInstantiation | null;
620}
621interface DeclareClass extends BaseNode {
622 type: "DeclareClass";
623 id: Identifier;
624 typeParameters?: TypeParameterDeclaration | null;
625 extends?: Array<InterfaceExtends> | null;
626 body: ObjectTypeAnnotation;
627 implements?: Array<ClassImplements> | null;
628 mixins?: Array<InterfaceExtends> | null;
629}
630interface DeclareFunction extends BaseNode {
631 type: "DeclareFunction";
632 id: Identifier;
633 predicate?: DeclaredPredicate | null;
634}
635interface DeclareInterface extends BaseNode {
636 type: "DeclareInterface";
637 id: Identifier;
638 typeParameters?: TypeParameterDeclaration | null;
639 extends?: Array<InterfaceExtends> | null;
640 body: ObjectTypeAnnotation;
641 implements?: Array<ClassImplements> | null;
642 mixins?: Array<InterfaceExtends> | null;
643}
644interface DeclareModule extends BaseNode {
645 type: "DeclareModule";
646 id: Identifier | StringLiteral;
647 body: BlockStatement;
648 kind?: "CommonJS" | "ES" | null;
649}
650interface DeclareModuleExports extends BaseNode {
651 type: "DeclareModuleExports";
652 typeAnnotation: TypeAnnotation;
653}
654interface DeclareTypeAlias extends BaseNode {
655 type: "DeclareTypeAlias";
656 id: Identifier;
657 typeParameters?: TypeParameterDeclaration | null;
658 right: FlowType;
659}
660interface DeclareOpaqueType extends BaseNode {
661 type: "DeclareOpaqueType";
662 id: Identifier;
663 typeParameters?: TypeParameterDeclaration | null;
664 supertype?: FlowType | null;
665 impltype?: FlowType | null;
666}
667interface DeclareVariable extends BaseNode {
668 type: "DeclareVariable";
669 id: Identifier;
670}
671interface DeclareExportDeclaration extends BaseNode {
672 type: "DeclareExportDeclaration";
673 declaration?: Flow | null;
674 specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null;
675 source?: StringLiteral | null;
676 default?: boolean | null;
677}
678interface DeclareExportAllDeclaration extends BaseNode {
679 type: "DeclareExportAllDeclaration";
680 source: StringLiteral;
681 exportKind?: "type" | "value" | null;
682}
683interface DeclaredPredicate extends BaseNode {
684 type: "DeclaredPredicate";
685 value: Flow;
686}
687interface ExistsTypeAnnotation extends BaseNode {
688 type: "ExistsTypeAnnotation";
689}
690interface FunctionTypeAnnotation extends BaseNode {
691 type: "FunctionTypeAnnotation";
692 typeParameters?: TypeParameterDeclaration | null;
693 params: Array<FunctionTypeParam>;
694 rest?: FunctionTypeParam | null;
695 returnType: FlowType;
696 this?: FunctionTypeParam | null;
697}
698interface FunctionTypeParam extends BaseNode {
699 type: "FunctionTypeParam";
700 name?: Identifier | null;
701 typeAnnotation: FlowType;
702 optional?: boolean | null;
703}
704interface GenericTypeAnnotation extends BaseNode {
705 type: "GenericTypeAnnotation";
706 id: Identifier | QualifiedTypeIdentifier;
707 typeParameters?: TypeParameterInstantiation | null;
708}
709interface InferredPredicate extends BaseNode {
710 type: "InferredPredicate";
711}
712interface InterfaceExtends extends BaseNode {
713 type: "InterfaceExtends";
714 id: Identifier | QualifiedTypeIdentifier;
715 typeParameters?: TypeParameterInstantiation | null;
716}
717interface InterfaceDeclaration extends BaseNode {
718 type: "InterfaceDeclaration";
719 id: Identifier;
720 typeParameters?: TypeParameterDeclaration | null;
721 extends?: Array<InterfaceExtends> | null;
722 body: ObjectTypeAnnotation;
723 implements?: Array<ClassImplements> | null;
724 mixins?: Array<InterfaceExtends> | null;
725}
726interface InterfaceTypeAnnotation extends BaseNode {
727 type: "InterfaceTypeAnnotation";
728 extends?: Array<InterfaceExtends> | null;
729 body: ObjectTypeAnnotation;
730}
731interface IntersectionTypeAnnotation extends BaseNode {
732 type: "IntersectionTypeAnnotation";
733 types: Array<FlowType>;
734}
735interface MixedTypeAnnotation extends BaseNode {
736 type: "MixedTypeAnnotation";
737}
738interface EmptyTypeAnnotation extends BaseNode {
739 type: "EmptyTypeAnnotation";
740}
741interface NullableTypeAnnotation extends BaseNode {
742 type: "NullableTypeAnnotation";
743 typeAnnotation: FlowType;
744}
745interface NumberLiteralTypeAnnotation extends BaseNode {
746 type: "NumberLiteralTypeAnnotation";
747 value: number;
748}
749interface NumberTypeAnnotation extends BaseNode {
750 type: "NumberTypeAnnotation";
751}
752interface ObjectTypeAnnotation extends BaseNode {
753 type: "ObjectTypeAnnotation";
754 properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>;
755 indexers?: Array<ObjectTypeIndexer> | null;
756 callProperties?: Array<ObjectTypeCallProperty> | null;
757 internalSlots?: Array<ObjectTypeInternalSlot> | null;
758 exact: boolean;
759 inexact?: boolean | null;
760}
761interface ObjectTypeInternalSlot extends BaseNode {
762 type: "ObjectTypeInternalSlot";
763 id: Identifier;
764 value: FlowType;
765 optional: boolean;
766 static: boolean;
767 method: boolean;
768}
769interface ObjectTypeCallProperty extends BaseNode {
770 type: "ObjectTypeCallProperty";
771 value: FlowType;
772 static: boolean;
773}
774interface ObjectTypeIndexer extends BaseNode {
775 type: "ObjectTypeIndexer";
776 id?: Identifier | null;
777 key: FlowType;
778 value: FlowType;
779 variance?: Variance | null;
780 static: boolean;
781}
782interface ObjectTypeProperty extends BaseNode {
783 type: "ObjectTypeProperty";
784 key: Identifier | StringLiteral;
785 value: FlowType;
786 variance?: Variance | null;
787 kind: "init" | "get" | "set";
788 method: boolean;
789 optional: boolean;
790 proto: boolean;
791 static: boolean;
792}
793interface ObjectTypeSpreadProperty extends BaseNode {
794 type: "ObjectTypeSpreadProperty";
795 argument: FlowType;
796}
797interface OpaqueType extends BaseNode {
798 type: "OpaqueType";
799 id: Identifier;
800 typeParameters?: TypeParameterDeclaration | null;
801 supertype?: FlowType | null;
802 impltype: FlowType;
803}
804interface QualifiedTypeIdentifier extends BaseNode {
805 type: "QualifiedTypeIdentifier";
806 id: Identifier;
807 qualification: Identifier | QualifiedTypeIdentifier;
808}
809interface StringLiteralTypeAnnotation extends BaseNode {
810 type: "StringLiteralTypeAnnotation";
811 value: string;
812}
813interface StringTypeAnnotation extends BaseNode {
814 type: "StringTypeAnnotation";
815}
816interface SymbolTypeAnnotation extends BaseNode {
817 type: "SymbolTypeAnnotation";
818}
819interface ThisTypeAnnotation extends BaseNode {
820 type: "ThisTypeAnnotation";
821}
822interface TupleTypeAnnotation extends BaseNode {
823 type: "TupleTypeAnnotation";
824 types: Array<FlowType>;
825}
826interface TypeofTypeAnnotation extends BaseNode {
827 type: "TypeofTypeAnnotation";
828 argument: FlowType;
829}
830interface TypeAlias extends BaseNode {
831 type: "TypeAlias";
832 id: Identifier;
833 typeParameters?: TypeParameterDeclaration | null;
834 right: FlowType;
835}
836interface TypeAnnotation extends BaseNode {
837 type: "TypeAnnotation";
838 typeAnnotation: FlowType;
839}
840interface TypeCastExpression extends BaseNode {
841 type: "TypeCastExpression";
842 expression: Expression;
843 typeAnnotation: TypeAnnotation;
844}
845interface TypeParameter extends BaseNode {
846 type: "TypeParameter";
847 bound?: TypeAnnotation | null;
848 default?: FlowType | null;
849 variance?: Variance | null;
850 name: string;
851}
852interface TypeParameterDeclaration extends BaseNode {
853 type: "TypeParameterDeclaration";
854 params: Array<TypeParameter>;
855}
856interface TypeParameterInstantiation extends BaseNode {
857 type: "TypeParameterInstantiation";
858 params: Array<FlowType>;
859}
860interface UnionTypeAnnotation extends BaseNode {
861 type: "UnionTypeAnnotation";
862 types: Array<FlowType>;
863}
864interface Variance extends BaseNode {
865 type: "Variance";
866 kind: "minus" | "plus";
867}
868interface VoidTypeAnnotation extends BaseNode {
869 type: "VoidTypeAnnotation";
870}
871interface EnumDeclaration extends BaseNode {
872 type: "EnumDeclaration";
873 id: Identifier;
874 body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
875}
876interface EnumBooleanBody extends BaseNode {
877 type: "EnumBooleanBody";
878 members: Array<EnumBooleanMember>;
879 explicitType: boolean;
880 hasUnknownMembers: boolean;
881}
882interface EnumNumberBody extends BaseNode {
883 type: "EnumNumberBody";
884 members: Array<EnumNumberMember>;
885 explicitType: boolean;
886 hasUnknownMembers: boolean;
887}
888interface EnumStringBody extends BaseNode {
889 type: "EnumStringBody";
890 members: Array<EnumStringMember | EnumDefaultedMember>;
891 explicitType: boolean;
892 hasUnknownMembers: boolean;
893}
894interface EnumSymbolBody extends BaseNode {
895 type: "EnumSymbolBody";
896 members: Array<EnumDefaultedMember>;
897 hasUnknownMembers: boolean;
898}
899interface EnumBooleanMember extends BaseNode {
900 type: "EnumBooleanMember";
901 id: Identifier;
902 init: BooleanLiteral;
903}
904interface EnumNumberMember extends BaseNode {
905 type: "EnumNumberMember";
906 id: Identifier;
907 init: NumericLiteral;
908}
909interface EnumStringMember extends BaseNode {
910 type: "EnumStringMember";
911 id: Identifier;
912 init: StringLiteral;
913}
914interface EnumDefaultedMember extends BaseNode {
915 type: "EnumDefaultedMember";
916 id: Identifier;
917}
918interface IndexedAccessType extends BaseNode {
919 type: "IndexedAccessType";
920 objectType: FlowType;
921 indexType: FlowType;
922}
923interface OptionalIndexedAccessType extends BaseNode {
924 type: "OptionalIndexedAccessType";
925 objectType: FlowType;
926 indexType: FlowType;
927 optional: boolean;
928}
929interface JSXAttribute extends BaseNode {
930 type: "JSXAttribute";
931 name: JSXIdentifier | JSXNamespacedName;
932 value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null;
933}
934interface JSXClosingElement extends BaseNode {
935 type: "JSXClosingElement";
936 name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
937}
938interface JSXElement extends BaseNode {
939 type: "JSXElement";
940 openingElement: JSXOpeningElement;
941 closingElement?: JSXClosingElement | null;
942 children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
943 selfClosing?: boolean | null;
944}
945interface JSXEmptyExpression extends BaseNode {
946 type: "JSXEmptyExpression";
947}
948interface JSXExpressionContainer extends BaseNode {
949 type: "JSXExpressionContainer";
950 expression: Expression | JSXEmptyExpression;
951}
952interface JSXSpreadChild extends BaseNode {
953 type: "JSXSpreadChild";
954 expression: Expression;
955}
956interface JSXIdentifier extends BaseNode {
957 type: "JSXIdentifier";
958 name: string;
959}
960interface JSXMemberExpression extends BaseNode {
961 type: "JSXMemberExpression";
962 object: JSXMemberExpression | JSXIdentifier;
963 property: JSXIdentifier;
964}
965interface JSXNamespacedName extends BaseNode {
966 type: "JSXNamespacedName";
967 namespace: JSXIdentifier;
968 name: JSXIdentifier;
969}
970interface JSXOpeningElement extends BaseNode {
971 type: "JSXOpeningElement";
972 name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
973 attributes: Array<JSXAttribute | JSXSpreadAttribute>;
974 selfClosing: boolean;
975 typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
976}
977interface JSXSpreadAttribute extends BaseNode {
978 type: "JSXSpreadAttribute";
979 argument: Expression;
980}
981interface JSXText extends BaseNode {
982 type: "JSXText";
983 value: string;
984}
985interface JSXFragment extends BaseNode {
986 type: "JSXFragment";
987 openingFragment: JSXOpeningFragment;
988 closingFragment: JSXClosingFragment;
989 children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
990}
991interface JSXOpeningFragment extends BaseNode {
992 type: "JSXOpeningFragment";
993}
994interface JSXClosingFragment extends BaseNode {
995 type: "JSXClosingFragment";
996}
997interface Noop extends BaseNode {
998 type: "Noop";
999}
1000interface Placeholder extends BaseNode {
1001 type: "Placeholder";
1002 expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
1003 name: Identifier;
1004}
1005interface V8IntrinsicIdentifier extends BaseNode {
1006 type: "V8IntrinsicIdentifier";
1007 name: string;
1008}
1009interface ArgumentPlaceholder extends BaseNode {
1010 type: "ArgumentPlaceholder";
1011}
1012interface BindExpression extends BaseNode {
1013 type: "BindExpression";
1014 object: Expression;
1015 callee: Expression;
1016}
1017interface ImportAttribute extends BaseNode {
1018 type: "ImportAttribute";
1019 key: Identifier | StringLiteral;
1020 value: StringLiteral;
1021}
1022interface Decorator extends BaseNode {
1023 type: "Decorator";
1024 expression: Expression;
1025}
1026interface DoExpression extends BaseNode {
1027 type: "DoExpression";
1028 body: BlockStatement;
1029 async: boolean;
1030}
1031interface ExportDefaultSpecifier extends BaseNode {
1032 type: "ExportDefaultSpecifier";
1033 exported: Identifier;
1034}
1035interface RecordExpression extends BaseNode {
1036 type: "RecordExpression";
1037 properties: Array<ObjectProperty | SpreadElement>;
1038}
1039interface TupleExpression extends BaseNode {
1040 type: "TupleExpression";
1041 elements: Array<Expression | SpreadElement>;
1042}
1043interface DecimalLiteral extends BaseNode {
1044 type: "DecimalLiteral";
1045 value: string;
1046}
1047interface StaticBlock extends BaseNode {
1048 type: "StaticBlock";
1049 body: Array<Statement>;
1050}
1051interface ModuleExpression extends BaseNode {
1052 type: "ModuleExpression";
1053 body: Program;
1054}
1055interface TopicReference extends BaseNode {
1056 type: "TopicReference";
1057}
1058interface PipelineTopicExpression extends BaseNode {
1059 type: "PipelineTopicExpression";
1060 expression: Expression;
1061}
1062interface PipelineBareFunction extends BaseNode {
1063 type: "PipelineBareFunction";
1064 callee: Expression;
1065}
1066interface PipelinePrimaryTopicReference extends BaseNode {
1067 type: "PipelinePrimaryTopicReference";
1068}
1069interface TSParameterProperty extends BaseNode {
1070 type: "TSParameterProperty";
1071 parameter: Identifier | AssignmentPattern;
1072 accessibility?: "public" | "private" | "protected" | null;
1073 decorators?: Array<Decorator> | null;
1074 override?: boolean | null;
1075 readonly?: boolean | null;
1076}
1077interface TSDeclareFunction extends BaseNode {
1078 type: "TSDeclareFunction";
1079 id?: Identifier | null;
1080 typeParameters?: TSTypeParameterDeclaration | Noop | null;
1081 params: Array<Identifier | Pattern | RestElement>;
1082 returnType?: TSTypeAnnotation | Noop | null;
1083 async?: boolean;
1084 declare?: boolean | null;
1085 generator?: boolean;
1086}
1087interface TSDeclareMethod extends BaseNode {
1088 type: "TSDeclareMethod";
1089 decorators?: Array<Decorator> | null;
1090 key: Identifier | StringLiteral | NumericLiteral | Expression;
1091 typeParameters?: TSTypeParameterDeclaration | Noop | null;
1092 params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
1093 returnType?: TSTypeAnnotation | Noop | null;
1094 abstract?: boolean | null;
1095 access?: "public" | "private" | "protected" | null;
1096 accessibility?: "public" | "private" | "protected" | null;
1097 async?: boolean;
1098 computed?: boolean;
1099 generator?: boolean;
1100 kind?: "get" | "set" | "method" | "constructor";
1101 optional?: boolean | null;
1102 override?: boolean;
1103 static?: boolean;
1104}
1105interface TSQualifiedName extends BaseNode {
1106 type: "TSQualifiedName";
1107 left: TSEntityName;
1108 right: Identifier;
1109}
1110interface TSCallSignatureDeclaration extends BaseNode {
1111 type: "TSCallSignatureDeclaration";
1112 typeParameters?: TSTypeParameterDeclaration | null;
1113 parameters: Array<Identifier | RestElement>;
1114 typeAnnotation?: TSTypeAnnotation | null;
1115}
1116interface TSConstructSignatureDeclaration extends BaseNode {
1117 type: "TSConstructSignatureDeclaration";
1118 typeParameters?: TSTypeParameterDeclaration | null;
1119 parameters: Array<Identifier | RestElement>;
1120 typeAnnotation?: TSTypeAnnotation | null;
1121}
1122interface TSPropertySignature extends BaseNode {
1123 type: "TSPropertySignature";
1124 key: Expression;
1125 typeAnnotation?: TSTypeAnnotation | null;
1126 initializer?: Expression | null;
1127 computed?: boolean | null;
1128 kind: "get" | "set";
1129 optional?: boolean | null;
1130 readonly?: boolean | null;
1131}
1132interface TSMethodSignature extends BaseNode {
1133 type: "TSMethodSignature";
1134 key: Expression;
1135 typeParameters?: TSTypeParameterDeclaration | null;
1136 parameters: Array<Identifier | RestElement>;
1137 typeAnnotation?: TSTypeAnnotation | null;
1138 computed?: boolean | null;
1139 kind: "method" | "get" | "set";
1140 optional?: boolean | null;
1141}
1142interface TSIndexSignature extends BaseNode {
1143 type: "TSIndexSignature";
1144 parameters: Array<Identifier>;
1145 typeAnnotation?: TSTypeAnnotation | null;
1146 readonly?: boolean | null;
1147 static?: boolean | null;
1148}
1149interface TSAnyKeyword extends BaseNode {
1150 type: "TSAnyKeyword";
1151}
1152interface TSBooleanKeyword extends BaseNode {
1153 type: "TSBooleanKeyword";
1154}
1155interface TSBigIntKeyword extends BaseNode {
1156 type: "TSBigIntKeyword";
1157}
1158interface TSIntrinsicKeyword extends BaseNode {
1159 type: "TSIntrinsicKeyword";
1160}
1161interface TSNeverKeyword extends BaseNode {
1162 type: "TSNeverKeyword";
1163}
1164interface TSNullKeyword extends BaseNode {
1165 type: "TSNullKeyword";
1166}
1167interface TSNumberKeyword extends BaseNode {
1168 type: "TSNumberKeyword";
1169}
1170interface TSObjectKeyword extends BaseNode {
1171 type: "TSObjectKeyword";
1172}
1173interface TSStringKeyword extends BaseNode {
1174 type: "TSStringKeyword";
1175}
1176interface TSSymbolKeyword extends BaseNode {
1177 type: "TSSymbolKeyword";
1178}
1179interface TSUndefinedKeyword extends BaseNode {
1180 type: "TSUndefinedKeyword";
1181}
1182interface TSUnknownKeyword extends BaseNode {
1183 type: "TSUnknownKeyword";
1184}
1185interface TSVoidKeyword extends BaseNode {
1186 type: "TSVoidKeyword";
1187}
1188interface TSThisType extends BaseNode {
1189 type: "TSThisType";
1190}
1191interface TSFunctionType extends BaseNode {
1192 type: "TSFunctionType";
1193 typeParameters?: TSTypeParameterDeclaration | null;
1194 parameters: Array<Identifier | RestElement>;
1195 typeAnnotation?: TSTypeAnnotation | null;
1196}
1197interface TSConstructorType extends BaseNode {
1198 type: "TSConstructorType";
1199 typeParameters?: TSTypeParameterDeclaration | null;
1200 parameters: Array<Identifier | RestElement>;
1201 typeAnnotation?: TSTypeAnnotation | null;
1202 abstract?: boolean | null;
1203}
1204interface TSTypeReference extends BaseNode {
1205 type: "TSTypeReference";
1206 typeName: TSEntityName;
1207 typeParameters?: TSTypeParameterInstantiation | null;
1208}
1209interface TSTypePredicate extends BaseNode {
1210 type: "TSTypePredicate";
1211 parameterName: Identifier | TSThisType;
1212 typeAnnotation?: TSTypeAnnotation | null;
1213 asserts?: boolean | null;
1214}
1215interface TSTypeQuery extends BaseNode {
1216 type: "TSTypeQuery";
1217 exprName: TSEntityName | TSImportType;
1218}
1219interface TSTypeLiteral extends BaseNode {
1220 type: "TSTypeLiteral";
1221 members: Array<TSTypeElement>;
1222}
1223interface TSArrayType extends BaseNode {
1224 type: "TSArrayType";
1225 elementType: TSType;
1226}
1227interface TSTupleType extends BaseNode {
1228 type: "TSTupleType";
1229 elementTypes: Array<TSType | TSNamedTupleMember>;
1230}
1231interface TSOptionalType extends BaseNode {
1232 type: "TSOptionalType";
1233 typeAnnotation: TSType;
1234}
1235interface TSRestType extends BaseNode {
1236 type: "TSRestType";
1237 typeAnnotation: TSType;
1238}
1239interface TSNamedTupleMember extends BaseNode {
1240 type: "TSNamedTupleMember";
1241 label: Identifier;
1242 elementType: TSType;
1243 optional: boolean;
1244}
1245interface TSUnionType extends BaseNode {
1246 type: "TSUnionType";
1247 types: Array<TSType>;
1248}
1249interface TSIntersectionType extends BaseNode {
1250 type: "TSIntersectionType";
1251 types: Array<TSType>;
1252}
1253interface TSConditionalType extends BaseNode {
1254 type: "TSConditionalType";
1255 checkType: TSType;
1256 extendsType: TSType;
1257 trueType: TSType;
1258 falseType: TSType;
1259}
1260interface TSInferType extends BaseNode {
1261 type: "TSInferType";
1262 typeParameter: TSTypeParameter;
1263}
1264interface TSParenthesizedType extends BaseNode {
1265 type: "TSParenthesizedType";
1266 typeAnnotation: TSType;
1267}
1268interface TSTypeOperator extends BaseNode {
1269 type: "TSTypeOperator";
1270 typeAnnotation: TSType;
1271 operator: string;
1272}
1273interface TSIndexedAccessType extends BaseNode {
1274 type: "TSIndexedAccessType";
1275 objectType: TSType;
1276 indexType: TSType;
1277}
1278interface TSMappedType extends BaseNode {
1279 type: "TSMappedType";
1280 typeParameter: TSTypeParameter;
1281 typeAnnotation?: TSType | null;
1282 nameType?: TSType | null;
1283 optional?: boolean | null;
1284 readonly?: boolean | null;
1285}
1286interface TSLiteralType extends BaseNode {
1287 type: "TSLiteralType";
1288 literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | UnaryExpression;
1289}
1290interface TSExpressionWithTypeArguments extends BaseNode {
1291 type: "TSExpressionWithTypeArguments";
1292 expression: TSEntityName;
1293 typeParameters?: TSTypeParameterInstantiation | null;
1294}
1295interface TSInterfaceDeclaration extends BaseNode {
1296 type: "TSInterfaceDeclaration";
1297 id: Identifier;
1298 typeParameters?: TSTypeParameterDeclaration | null;
1299 extends?: Array<TSExpressionWithTypeArguments> | null;
1300 body: TSInterfaceBody;
1301 declare?: boolean | null;
1302}
1303interface TSInterfaceBody extends BaseNode {
1304 type: "TSInterfaceBody";
1305 body: Array<TSTypeElement>;
1306}
1307interface TSTypeAliasDeclaration extends BaseNode {
1308 type: "TSTypeAliasDeclaration";
1309 id: Identifier;
1310 typeParameters?: TSTypeParameterDeclaration | null;
1311 typeAnnotation: TSType;
1312 declare?: boolean | null;
1313}
1314interface TSAsExpression extends BaseNode {
1315 type: "TSAsExpression";
1316 expression: Expression;
1317 typeAnnotation: TSType;
1318}
1319interface TSTypeAssertion extends BaseNode {
1320 type: "TSTypeAssertion";
1321 typeAnnotation: TSType;
1322 expression: Expression;
1323}
1324interface TSEnumDeclaration extends BaseNode {
1325 type: "TSEnumDeclaration";
1326 id: Identifier;
1327 members: Array<TSEnumMember>;
1328 const?: boolean | null;
1329 declare?: boolean | null;
1330 initializer?: Expression | null;
1331}
1332interface TSEnumMember extends BaseNode {
1333 type: "TSEnumMember";
1334 id: Identifier | StringLiteral;
1335 initializer?: Expression | null;
1336}
1337interface TSModuleDeclaration extends BaseNode {
1338 type: "TSModuleDeclaration";
1339 id: Identifier | StringLiteral;
1340 body: TSModuleBlock | TSModuleDeclaration;
1341 declare?: boolean | null;
1342 global?: boolean | null;
1343}
1344interface TSModuleBlock extends BaseNode {
1345 type: "TSModuleBlock";
1346 body: Array<Statement>;
1347}
1348interface TSImportType extends BaseNode {
1349 type: "TSImportType";
1350 argument: StringLiteral;
1351 qualifier?: TSEntityName | null;
1352 typeParameters?: TSTypeParameterInstantiation | null;
1353}
1354interface TSImportEqualsDeclaration extends BaseNode {
1355 type: "TSImportEqualsDeclaration";
1356 id: Identifier;
1357 moduleReference: TSEntityName | TSExternalModuleReference;
1358 importKind?: "type" | "value" | null;
1359 isExport: boolean;
1360}
1361interface TSExternalModuleReference extends BaseNode {
1362 type: "TSExternalModuleReference";
1363 expression: StringLiteral;
1364}
1365interface TSNonNullExpression extends BaseNode {
1366 type: "TSNonNullExpression";
1367 expression: Expression;
1368}
1369interface TSExportAssignment extends BaseNode {
1370 type: "TSExportAssignment";
1371 expression: Expression;
1372}
1373interface TSNamespaceExportDeclaration extends BaseNode {
1374 type: "TSNamespaceExportDeclaration";
1375 id: Identifier;
1376}
1377interface TSTypeAnnotation extends BaseNode {
1378 type: "TSTypeAnnotation";
1379 typeAnnotation: TSType;
1380}
1381interface TSTypeParameterInstantiation extends BaseNode {
1382 type: "TSTypeParameterInstantiation";
1383 params: Array<TSType>;
1384}
1385interface TSTypeParameterDeclaration extends BaseNode {
1386 type: "TSTypeParameterDeclaration";
1387 params: Array<TSTypeParameter>;
1388}
1389interface TSTypeParameter extends BaseNode {
1390 type: "TSTypeParameter";
1391 constraint?: TSType | null;
1392 default?: TSType | null;
1393 name: string;
1394}
1395declare type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ParenthesizedExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | OptionalMemberExpression | OptionalCallExpression | TypeCastExpression | JSXElement | JSXFragment | BindExpression | DoExpression | RecordExpression | TupleExpression | DecimalLiteral | ModuleExpression | TopicReference | PipelineTopicExpression | PipelineBareFunction | PipelinePrimaryTopicReference | TSAsExpression | TSTypeAssertion | TSNonNullExpression;
1396declare type Binary = BinaryExpression | LogicalExpression;
1397declare type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ClassExpression | ClassDeclaration | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock;
1398declare type BlockParent = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock;
1399declare type Block = BlockStatement | Program | TSModuleBlock;
1400declare type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration;
1401declare type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression;
1402declare type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement;
1403declare type Conditional = ConditionalExpression | IfStatement;
1404declare type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement;
1405declare type While = DoWhileStatement | WhileStatement;
1406declare type ExpressionWrapper = ExpressionStatement | ParenthesizedExpression | TypeCastExpression;
1407declare type For = ForInStatement | ForStatement | ForOfStatement;
1408declare type ForXStatement = ForInStatement | ForOfStatement;
1409declare type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod;
1410declare type FunctionParent = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod;
1411declare type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ArrowFunctionExpression | BigIntLiteral | DecimalLiteral;
1412declare type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration;
1413declare type PatternLike = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern;
1414declare type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | TSParameterProperty;
1415declare type TSEntityName = Identifier | TSQualifiedName;
1416declare type Literal = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | TemplateLiteral | BigIntLiteral | DecimalLiteral;
1417declare type Immutable = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | BigIntLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXSpreadChild | JSXOpeningElement | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment | DecimalLiteral;
1418declare type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty;
1419declare type Method = ObjectMethod | ClassMethod | ClassPrivateMethod;
1420declare type ObjectMember = ObjectMethod | ObjectProperty;
1421declare type Property = ObjectProperty | ClassProperty | ClassPrivateProperty;
1422declare type UnaryLike = UnaryExpression | SpreadElement;
1423declare type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern;
1424declare type Class = ClassExpression | ClassDeclaration;
1425declare type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration;
1426declare type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration;
1427declare type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportNamespaceSpecifier | ExportDefaultSpecifier;
1428declare type Private = ClassPrivateProperty | ClassPrivateMethod | PrivateName;
1429declare type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType;
1430declare type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType;
1431declare type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | NullLiteralTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation;
1432declare type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias;
1433declare type FlowPredicate = DeclaredPredicate | InferredPredicate;
1434declare type EnumBody = EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
1435declare type EnumMember = EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember;
1436declare type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXSpreadChild | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment;
1437declare type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature;
1438declare type TSType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSLiteralType | TSExpressionWithTypeArguments | TSImportType;
1439declare type TSBaseType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSLiteralType;
1440interface Aliases {
1441 Expression: Expression;
1442 Binary: Binary;
1443 Scopable: Scopable;
1444 BlockParent: BlockParent;
1445 Block: Block;
1446 Statement: Statement;
1447 Terminatorless: Terminatorless;
1448 CompletionStatement: CompletionStatement;
1449 Conditional: Conditional;
1450 Loop: Loop;
1451 While: While;
1452 ExpressionWrapper: ExpressionWrapper;
1453 For: For;
1454 ForXStatement: ForXStatement;
1455 Function: Function;
1456 FunctionParent: FunctionParent;
1457 Pureish: Pureish;
1458 Declaration: Declaration;
1459 PatternLike: PatternLike;
1460 LVal: LVal;
1461 TSEntityName: TSEntityName;
1462 Literal: Literal;
1463 Immutable: Immutable;
1464 UserWhitespacable: UserWhitespacable;
1465 Method: Method;
1466 ObjectMember: ObjectMember;
1467 Property: Property;
1468 UnaryLike: UnaryLike;
1469 Pattern: Pattern;
1470 Class: Class;
1471 ModuleDeclaration: ModuleDeclaration;
1472 ExportDeclaration: ExportDeclaration;
1473 ModuleSpecifier: ModuleSpecifier;
1474 Private: Private;
1475 Flow: Flow;
1476 FlowType: FlowType;
1477 FlowBaseAnnotation: FlowBaseAnnotation;
1478 FlowDeclaration: FlowDeclaration;
1479 FlowPredicate: FlowPredicate;
1480 EnumBody: EnumBody;
1481 EnumMember: EnumMember;
1482 JSX: JSX;
1483 TSTypeElement: TSTypeElement;
1484 TSType: TSType;
1485 TSBaseType: TSBaseType;
1486}
1487
1488declare function isCompatTag(tagName?: string): boolean;
1489
1490declare type ReturnedChild = JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment | Expression;
1491declare function buildChildren(node: {
1492 children: ReadonlyArray<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment | JSXEmptyExpression>;
1493}): ReturnedChild[];
1494
1495declare function assertNode(node?: any): asserts node is Node;
1496
1497declare function assertArrayExpression(node: object | null | undefined, opts?: object | null): asserts node is ArrayExpression;
1498declare function assertAssignmentExpression(node: object | null | undefined, opts?: object | null): asserts node is AssignmentExpression;
1499declare function assertBinaryExpression(node: object | null | undefined, opts?: object | null): asserts node is BinaryExpression;
1500declare function assertInterpreterDirective(node: object | null | undefined, opts?: object | null): asserts node is InterpreterDirective;
1501declare function assertDirective(node: object | null | undefined, opts?: object | null): asserts node is Directive;
1502declare function assertDirectiveLiteral(node: object | null | undefined, opts?: object | null): asserts node is DirectiveLiteral;
1503declare function assertBlockStatement(node: object | null | undefined, opts?: object | null): asserts node is BlockStatement;
1504declare function assertBreakStatement(node: object | null | undefined, opts?: object | null): asserts node is BreakStatement;
1505declare function assertCallExpression(node: object | null | undefined, opts?: object | null): asserts node is CallExpression;
1506declare function assertCatchClause(node: object | null | undefined, opts?: object | null): asserts node is CatchClause;
1507declare function assertConditionalExpression(node: object | null | undefined, opts?: object | null): asserts node is ConditionalExpression;
1508declare function assertContinueStatement(node: object | null | undefined, opts?: object | null): asserts node is ContinueStatement;
1509declare function assertDebuggerStatement(node: object | null | undefined, opts?: object | null): asserts node is DebuggerStatement;
1510declare function assertDoWhileStatement(node: object | null | undefined, opts?: object | null): asserts node is DoWhileStatement;
1511declare function assertEmptyStatement(node: object | null | undefined, opts?: object | null): asserts node is EmptyStatement;
1512declare function assertExpressionStatement(node: object | null | undefined, opts?: object | null): asserts node is ExpressionStatement;
1513declare function assertFile(node: object | null | undefined, opts?: object | null): asserts node is File;
1514declare function assertForInStatement(node: object | null | undefined, opts?: object | null): asserts node is ForInStatement;
1515declare function assertForStatement(node: object | null | undefined, opts?: object | null): asserts node is ForStatement;
1516declare function assertFunctionDeclaration(node: object | null | undefined, opts?: object | null): asserts node is FunctionDeclaration;
1517declare function assertFunctionExpression(node: object | null | undefined, opts?: object | null): asserts node is FunctionExpression;
1518declare function assertIdentifier(node: object | null | undefined, opts?: object | null): asserts node is Identifier;
1519declare function assertIfStatement(node: object | null | undefined, opts?: object | null): asserts node is IfStatement;
1520declare function assertLabeledStatement(node: object | null | undefined, opts?: object | null): asserts node is LabeledStatement;
1521declare function assertStringLiteral(node: object | null | undefined, opts?: object | null): asserts node is StringLiteral;
1522declare function assertNumericLiteral(node: object | null | undefined, opts?: object | null): asserts node is NumericLiteral;
1523declare function assertNullLiteral(node: object | null | undefined, opts?: object | null): asserts node is NullLiteral;
1524declare function assertBooleanLiteral(node: object | null | undefined, opts?: object | null): asserts node is BooleanLiteral;
1525declare function assertRegExpLiteral(node: object | null | undefined, opts?: object | null): asserts node is RegExpLiteral;
1526declare function assertLogicalExpression(node: object | null | undefined, opts?: object | null): asserts node is LogicalExpression;
1527declare function assertMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is MemberExpression;
1528declare function assertNewExpression(node: object | null | undefined, opts?: object | null): asserts node is NewExpression;
1529declare function assertProgram(node: object | null | undefined, opts?: object | null): asserts node is Program;
1530declare function assertObjectExpression(node: object | null | undefined, opts?: object | null): asserts node is ObjectExpression;
1531declare function assertObjectMethod(node: object | null | undefined, opts?: object | null): asserts node is ObjectMethod;
1532declare function assertObjectProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectProperty;
1533declare function assertRestElement(node: object | null | undefined, opts?: object | null): asserts node is RestElement;
1534declare function assertReturnStatement(node: object | null | undefined, opts?: object | null): asserts node is ReturnStatement;
1535declare function assertSequenceExpression(node: object | null | undefined, opts?: object | null): asserts node is SequenceExpression;
1536declare function assertParenthesizedExpression(node: object | null | undefined, opts?: object | null): asserts node is ParenthesizedExpression;
1537declare function assertSwitchCase(node: object | null | undefined, opts?: object | null): asserts node is SwitchCase;
1538declare function assertSwitchStatement(node: object | null | undefined, opts?: object | null): asserts node is SwitchStatement;
1539declare function assertThisExpression(node: object | null | undefined, opts?: object | null): asserts node is ThisExpression;
1540declare function assertThrowStatement(node: object | null | undefined, opts?: object | null): asserts node is ThrowStatement;
1541declare function assertTryStatement(node: object | null | undefined, opts?: object | null): asserts node is TryStatement;
1542declare function assertUnaryExpression(node: object | null | undefined, opts?: object | null): asserts node is UnaryExpression;
1543declare function assertUpdateExpression(node: object | null | undefined, opts?: object | null): asserts node is UpdateExpression;
1544declare function assertVariableDeclaration(node: object | null | undefined, opts?: object | null): asserts node is VariableDeclaration;
1545declare function assertVariableDeclarator(node: object | null | undefined, opts?: object | null): asserts node is VariableDeclarator;
1546declare function assertWhileStatement(node: object | null | undefined, opts?: object | null): asserts node is WhileStatement;
1547declare function assertWithStatement(node: object | null | undefined, opts?: object | null): asserts node is WithStatement;
1548declare function assertAssignmentPattern(node: object | null | undefined, opts?: object | null): asserts node is AssignmentPattern;
1549declare function assertArrayPattern(node: object | null | undefined, opts?: object | null): asserts node is ArrayPattern;
1550declare function assertArrowFunctionExpression(node: object | null | undefined, opts?: object | null): asserts node is ArrowFunctionExpression;
1551declare function assertClassBody(node: object | null | undefined, opts?: object | null): asserts node is ClassBody;
1552declare function assertClassExpression(node: object | null | undefined, opts?: object | null): asserts node is ClassExpression;
1553declare function assertClassDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ClassDeclaration;
1554declare function assertExportAllDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportAllDeclaration;
1555declare function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportDefaultDeclaration;
1556declare function assertExportNamedDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportNamedDeclaration;
1557declare function assertExportSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportSpecifier;
1558declare function assertForOfStatement(node: object | null | undefined, opts?: object | null): asserts node is ForOfStatement;
1559declare function assertImportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ImportDeclaration;
1560declare function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportDefaultSpecifier;
1561declare function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportNamespaceSpecifier;
1562declare function assertImportSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ImportSpecifier;
1563declare function assertMetaProperty(node: object | null | undefined, opts?: object | null): asserts node is MetaProperty;
1564declare function assertClassMethod(node: object | null | undefined, opts?: object | null): asserts node is ClassMethod;
1565declare function assertObjectPattern(node: object | null | undefined, opts?: object | null): asserts node is ObjectPattern;
1566declare function assertSpreadElement(node: object | null | undefined, opts?: object | null): asserts node is SpreadElement;
1567declare function assertSuper(node: object | null | undefined, opts?: object | null): asserts node is Super;
1568declare function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): asserts node is TaggedTemplateExpression;
1569declare function assertTemplateElement(node: object | null | undefined, opts?: object | null): asserts node is TemplateElement;
1570declare function assertTemplateLiteral(node: object | null | undefined, opts?: object | null): asserts node is TemplateLiteral;
1571declare function assertYieldExpression(node: object | null | undefined, opts?: object | null): asserts node is YieldExpression;
1572declare function assertAwaitExpression(node: object | null | undefined, opts?: object | null): asserts node is AwaitExpression;
1573declare function assertImport(node: object | null | undefined, opts?: object | null): asserts node is Import;
1574declare function assertBigIntLiteral(node: object | null | undefined, opts?: object | null): asserts node is BigIntLiteral;
1575declare function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportNamespaceSpecifier;
1576declare function assertOptionalMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is OptionalMemberExpression;
1577declare function assertOptionalCallExpression(node: object | null | undefined, opts?: object | null): asserts node is OptionalCallExpression;
1578declare function assertClassProperty(node: object | null | undefined, opts?: object | null): asserts node is ClassProperty;
1579declare function assertClassPrivateProperty(node: object | null | undefined, opts?: object | null): asserts node is ClassPrivateProperty;
1580declare function assertClassPrivateMethod(node: object | null | undefined, opts?: object | null): asserts node is ClassPrivateMethod;
1581declare function assertPrivateName(node: object | null | undefined, opts?: object | null): asserts node is PrivateName;
1582declare function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is AnyTypeAnnotation;
1583declare function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ArrayTypeAnnotation;
1584declare function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is BooleanTypeAnnotation;
1585declare function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is BooleanLiteralTypeAnnotation;
1586declare function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NullLiteralTypeAnnotation;
1587declare function assertClassImplements(node: object | null | undefined, opts?: object | null): asserts node is ClassImplements;
1588declare function assertDeclareClass(node: object | null | undefined, opts?: object | null): asserts node is DeclareClass;
1589declare function assertDeclareFunction(node: object | null | undefined, opts?: object | null): asserts node is DeclareFunction;
1590declare function assertDeclareInterface(node: object | null | undefined, opts?: object | null): asserts node is DeclareInterface;
1591declare function assertDeclareModule(node: object | null | undefined, opts?: object | null): asserts node is DeclareModule;
1592declare function assertDeclareModuleExports(node: object | null | undefined, opts?: object | null): asserts node is DeclareModuleExports;
1593declare function assertDeclareTypeAlias(node: object | null | undefined, opts?: object | null): asserts node is DeclareTypeAlias;
1594declare function assertDeclareOpaqueType(node: object | null | undefined, opts?: object | null): asserts node is DeclareOpaqueType;
1595declare function assertDeclareVariable(node: object | null | undefined, opts?: object | null): asserts node is DeclareVariable;
1596declare function assertDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is DeclareExportDeclaration;
1597declare function assertDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): asserts node is DeclareExportAllDeclaration;
1598declare function assertDeclaredPredicate(node: object | null | undefined, opts?: object | null): asserts node is DeclaredPredicate;
1599declare function assertExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ExistsTypeAnnotation;
1600declare function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is FunctionTypeAnnotation;
1601declare function assertFunctionTypeParam(node: object | null | undefined, opts?: object | null): asserts node is FunctionTypeParam;
1602declare function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is GenericTypeAnnotation;
1603declare function assertInferredPredicate(node: object | null | undefined, opts?: object | null): asserts node is InferredPredicate;
1604declare function assertInterfaceExtends(node: object | null | undefined, opts?: object | null): asserts node is InterfaceExtends;
1605declare function assertInterfaceDeclaration(node: object | null | undefined, opts?: object | null): asserts node is InterfaceDeclaration;
1606declare function assertInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is InterfaceTypeAnnotation;
1607declare function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is IntersectionTypeAnnotation;
1608declare function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is MixedTypeAnnotation;
1609declare function assertEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is EmptyTypeAnnotation;
1610declare function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NullableTypeAnnotation;
1611declare function assertNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NumberLiteralTypeAnnotation;
1612declare function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is NumberTypeAnnotation;
1613declare function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeAnnotation;
1614declare function assertObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeInternalSlot;
1615declare function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeCallProperty;
1616declare function assertObjectTypeIndexer(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeIndexer;
1617declare function assertObjectTypeProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeProperty;
1618declare function assertObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): asserts node is ObjectTypeSpreadProperty;
1619declare function assertOpaqueType(node: object | null | undefined, opts?: object | null): asserts node is OpaqueType;
1620declare function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): asserts node is QualifiedTypeIdentifier;
1621declare function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is StringLiteralTypeAnnotation;
1622declare function assertStringTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is StringTypeAnnotation;
1623declare function assertSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is SymbolTypeAnnotation;
1624declare function assertThisTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is ThisTypeAnnotation;
1625declare function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TupleTypeAnnotation;
1626declare function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TypeofTypeAnnotation;
1627declare function assertTypeAlias(node: object | null | undefined, opts?: object | null): asserts node is TypeAlias;
1628declare function assertTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TypeAnnotation;
1629declare function assertTypeCastExpression(node: object | null | undefined, opts?: object | null): asserts node is TypeCastExpression;
1630declare function assertTypeParameter(node: object | null | undefined, opts?: object | null): asserts node is TypeParameter;
1631declare function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TypeParameterDeclaration;
1632declare function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): asserts node is TypeParameterInstantiation;
1633declare function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is UnionTypeAnnotation;
1634declare function assertVariance(node: object | null | undefined, opts?: object | null): asserts node is Variance;
1635declare function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is VoidTypeAnnotation;
1636declare function assertEnumDeclaration(node: object | null | undefined, opts?: object | null): asserts node is EnumDeclaration;
1637declare function assertEnumBooleanBody(node: object | null | undefined, opts?: object | null): asserts node is EnumBooleanBody;
1638declare function assertEnumNumberBody(node: object | null | undefined, opts?: object | null): asserts node is EnumNumberBody;
1639declare function assertEnumStringBody(node: object | null | undefined, opts?: object | null): asserts node is EnumStringBody;
1640declare function assertEnumSymbolBody(node: object | null | undefined, opts?: object | null): asserts node is EnumSymbolBody;
1641declare function assertEnumBooleanMember(node: object | null | undefined, opts?: object | null): asserts node is EnumBooleanMember;
1642declare function assertEnumNumberMember(node: object | null | undefined, opts?: object | null): asserts node is EnumNumberMember;
1643declare function assertEnumStringMember(node: object | null | undefined, opts?: object | null): asserts node is EnumStringMember;
1644declare function assertEnumDefaultedMember(node: object | null | undefined, opts?: object | null): asserts node is EnumDefaultedMember;
1645declare function assertIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is IndexedAccessType;
1646declare function assertOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is OptionalIndexedAccessType;
1647declare function assertJSXAttribute(node: object | null | undefined, opts?: object | null): asserts node is JSXAttribute;
1648declare function assertJSXClosingElement(node: object | null | undefined, opts?: object | null): asserts node is JSXClosingElement;
1649declare function assertJSXElement(node: object | null | undefined, opts?: object | null): asserts node is JSXElement;
1650declare function assertJSXEmptyExpression(node: object | null | undefined, opts?: object | null): asserts node is JSXEmptyExpression;
1651declare function assertJSXExpressionContainer(node: object | null | undefined, opts?: object | null): asserts node is JSXExpressionContainer;
1652declare function assertJSXSpreadChild(node: object | null | undefined, opts?: object | null): asserts node is JSXSpreadChild;
1653declare function assertJSXIdentifier(node: object | null | undefined, opts?: object | null): asserts node is JSXIdentifier;
1654declare function assertJSXMemberExpression(node: object | null | undefined, opts?: object | null): asserts node is JSXMemberExpression;
1655declare function assertJSXNamespacedName(node: object | null | undefined, opts?: object | null): asserts node is JSXNamespacedName;
1656declare function assertJSXOpeningElement(node: object | null | undefined, opts?: object | null): asserts node is JSXOpeningElement;
1657declare function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): asserts node is JSXSpreadAttribute;
1658declare function assertJSXText(node: object | null | undefined, opts?: object | null): asserts node is JSXText;
1659declare function assertJSXFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXFragment;
1660declare function assertJSXOpeningFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXOpeningFragment;
1661declare function assertJSXClosingFragment(node: object | null | undefined, opts?: object | null): asserts node is JSXClosingFragment;
1662declare function assertNoop(node: object | null | undefined, opts?: object | null): asserts node is Noop;
1663declare function assertPlaceholder(node: object | null | undefined, opts?: object | null): asserts node is Placeholder;
1664declare function assertV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): asserts node is V8IntrinsicIdentifier;
1665declare function assertArgumentPlaceholder(node: object | null | undefined, opts?: object | null): asserts node is ArgumentPlaceholder;
1666declare function assertBindExpression(node: object | null | undefined, opts?: object | null): asserts node is BindExpression;
1667declare function assertImportAttribute(node: object | null | undefined, opts?: object | null): asserts node is ImportAttribute;
1668declare function assertDecorator(node: object | null | undefined, opts?: object | null): asserts node is Decorator;
1669declare function assertDoExpression(node: object | null | undefined, opts?: object | null): asserts node is DoExpression;
1670declare function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ExportDefaultSpecifier;
1671declare function assertRecordExpression(node: object | null | undefined, opts?: object | null): asserts node is RecordExpression;
1672declare function assertTupleExpression(node: object | null | undefined, opts?: object | null): asserts node is TupleExpression;
1673declare function assertDecimalLiteral(node: object | null | undefined, opts?: object | null): asserts node is DecimalLiteral;
1674declare function assertStaticBlock(node: object | null | undefined, opts?: object | null): asserts node is StaticBlock;
1675declare function assertModuleExpression(node: object | null | undefined, opts?: object | null): asserts node is ModuleExpression;
1676declare function assertTopicReference(node: object | null | undefined, opts?: object | null): asserts node is TopicReference;
1677declare function assertPipelineTopicExpression(node: object | null | undefined, opts?: object | null): asserts node is PipelineTopicExpression;
1678declare function assertPipelineBareFunction(node: object | null | undefined, opts?: object | null): asserts node is PipelineBareFunction;
1679declare function assertPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): asserts node is PipelinePrimaryTopicReference;
1680declare function assertTSParameterProperty(node: object | null | undefined, opts?: object | null): asserts node is TSParameterProperty;
1681declare function assertTSDeclareFunction(node: object | null | undefined, opts?: object | null): asserts node is TSDeclareFunction;
1682declare function assertTSDeclareMethod(node: object | null | undefined, opts?: object | null): asserts node is TSDeclareMethod;
1683declare function assertTSQualifiedName(node: object | null | undefined, opts?: object | null): asserts node is TSQualifiedName;
1684declare function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSCallSignatureDeclaration;
1685declare function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSConstructSignatureDeclaration;
1686declare function assertTSPropertySignature(node: object | null | undefined, opts?: object | null): asserts node is TSPropertySignature;
1687declare function assertTSMethodSignature(node: object | null | undefined, opts?: object | null): asserts node is TSMethodSignature;
1688declare function assertTSIndexSignature(node: object | null | undefined, opts?: object | null): asserts node is TSIndexSignature;
1689declare function assertTSAnyKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSAnyKeyword;
1690declare function assertTSBooleanKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSBooleanKeyword;
1691declare function assertTSBigIntKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSBigIntKeyword;
1692declare function assertTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSIntrinsicKeyword;
1693declare function assertTSNeverKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNeverKeyword;
1694declare function assertTSNullKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNullKeyword;
1695declare function assertTSNumberKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSNumberKeyword;
1696declare function assertTSObjectKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSObjectKeyword;
1697declare function assertTSStringKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSStringKeyword;
1698declare function assertTSSymbolKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSSymbolKeyword;
1699declare function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSUndefinedKeyword;
1700declare function assertTSUnknownKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSUnknownKeyword;
1701declare function assertTSVoidKeyword(node: object | null | undefined, opts?: object | null): asserts node is TSVoidKeyword;
1702declare function assertTSThisType(node: object | null | undefined, opts?: object | null): asserts node is TSThisType;
1703declare function assertTSFunctionType(node: object | null | undefined, opts?: object | null): asserts node is TSFunctionType;
1704declare function assertTSConstructorType(node: object | null | undefined, opts?: object | null): asserts node is TSConstructorType;
1705declare function assertTSTypeReference(node: object | null | undefined, opts?: object | null): asserts node is TSTypeReference;
1706declare function assertTSTypePredicate(node: object | null | undefined, opts?: object | null): asserts node is TSTypePredicate;
1707declare function assertTSTypeQuery(node: object | null | undefined, opts?: object | null): asserts node is TSTypeQuery;
1708declare function assertTSTypeLiteral(node: object | null | undefined, opts?: object | null): asserts node is TSTypeLiteral;
1709declare function assertTSArrayType(node: object | null | undefined, opts?: object | null): asserts node is TSArrayType;
1710declare function assertTSTupleType(node: object | null | undefined, opts?: object | null): asserts node is TSTupleType;
1711declare function assertTSOptionalType(node: object | null | undefined, opts?: object | null): asserts node is TSOptionalType;
1712declare function assertTSRestType(node: object | null | undefined, opts?: object | null): asserts node is TSRestType;
1713declare function assertTSNamedTupleMember(node: object | null | undefined, opts?: object | null): asserts node is TSNamedTupleMember;
1714declare function assertTSUnionType(node: object | null | undefined, opts?: object | null): asserts node is TSUnionType;
1715declare function assertTSIntersectionType(node: object | null | undefined, opts?: object | null): asserts node is TSIntersectionType;
1716declare function assertTSConditionalType(node: object | null | undefined, opts?: object | null): asserts node is TSConditionalType;
1717declare function assertTSInferType(node: object | null | undefined, opts?: object | null): asserts node is TSInferType;
1718declare function assertTSParenthesizedType(node: object | null | undefined, opts?: object | null): asserts node is TSParenthesizedType;
1719declare function assertTSTypeOperator(node: object | null | undefined, opts?: object | null): asserts node is TSTypeOperator;
1720declare function assertTSIndexedAccessType(node: object | null | undefined, opts?: object | null): asserts node is TSIndexedAccessType;
1721declare function assertTSMappedType(node: object | null | undefined, opts?: object | null): asserts node is TSMappedType;
1722declare function assertTSLiteralType(node: object | null | undefined, opts?: object | null): asserts node is TSLiteralType;
1723declare function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): asserts node is TSExpressionWithTypeArguments;
1724declare function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSInterfaceDeclaration;
1725declare function assertTSInterfaceBody(node: object | null | undefined, opts?: object | null): asserts node is TSInterfaceBody;
1726declare function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAliasDeclaration;
1727declare function assertTSAsExpression(node: object | null | undefined, opts?: object | null): asserts node is TSAsExpression;
1728declare function assertTSTypeAssertion(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAssertion;
1729declare function assertTSEnumDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSEnumDeclaration;
1730declare function assertTSEnumMember(node: object | null | undefined, opts?: object | null): asserts node is TSEnumMember;
1731declare function assertTSModuleDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSModuleDeclaration;
1732declare function assertTSModuleBlock(node: object | null | undefined, opts?: object | null): asserts node is TSModuleBlock;
1733declare function assertTSImportType(node: object | null | undefined, opts?: object | null): asserts node is TSImportType;
1734declare function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSImportEqualsDeclaration;
1735declare function assertTSExternalModuleReference(node: object | null | undefined, opts?: object | null): asserts node is TSExternalModuleReference;
1736declare function assertTSNonNullExpression(node: object | null | undefined, opts?: object | null): asserts node is TSNonNullExpression;
1737declare function assertTSExportAssignment(node: object | null | undefined, opts?: object | null): asserts node is TSExportAssignment;
1738declare function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSNamespaceExportDeclaration;
1739declare function assertTSTypeAnnotation(node: object | null | undefined, opts?: object | null): asserts node is TSTypeAnnotation;
1740declare function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameterInstantiation;
1741declare function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameterDeclaration;
1742declare function assertTSTypeParameter(node: object | null | undefined, opts?: object | null): asserts node is TSTypeParameter;
1743declare function assertExpression(node: object | null | undefined, opts?: object | null): asserts node is Expression;
1744declare function assertBinary(node: object | null | undefined, opts?: object | null): asserts node is Binary;
1745declare function assertScopable(node: object | null | undefined, opts?: object | null): asserts node is Scopable;
1746declare function assertBlockParent(node: object | null | undefined, opts?: object | null): asserts node is BlockParent;
1747declare function assertBlock(node: object | null | undefined, opts?: object | null): asserts node is Block;
1748declare function assertStatement(node: object | null | undefined, opts?: object | null): asserts node is Statement;
1749declare function assertTerminatorless(node: object | null | undefined, opts?: object | null): asserts node is Terminatorless;
1750declare function assertCompletionStatement(node: object | null | undefined, opts?: object | null): asserts node is CompletionStatement;
1751declare function assertConditional(node: object | null | undefined, opts?: object | null): asserts node is Conditional;
1752declare function assertLoop(node: object | null | undefined, opts?: object | null): asserts node is Loop;
1753declare function assertWhile(node: object | null | undefined, opts?: object | null): asserts node is While;
1754declare function assertExpressionWrapper(node: object | null | undefined, opts?: object | null): asserts node is ExpressionWrapper;
1755declare function assertFor(node: object | null | undefined, opts?: object | null): asserts node is For;
1756declare function assertForXStatement(node: object | null | undefined, opts?: object | null): asserts node is ForXStatement;
1757declare function assertFunction(node: object | null | undefined, opts?: object | null): asserts node is Function;
1758declare function assertFunctionParent(node: object | null | undefined, opts?: object | null): asserts node is FunctionParent;
1759declare function assertPureish(node: object | null | undefined, opts?: object | null): asserts node is Pureish;
1760declare function assertDeclaration(node: object | null | undefined, opts?: object | null): asserts node is Declaration;
1761declare function assertPatternLike(node: object | null | undefined, opts?: object | null): asserts node is PatternLike;
1762declare function assertLVal(node: object | null | undefined, opts?: object | null): asserts node is LVal;
1763declare function assertTSEntityName(node: object | null | undefined, opts?: object | null): asserts node is TSEntityName;
1764declare function assertLiteral(node: object | null | undefined, opts?: object | null): asserts node is Literal;
1765declare function assertImmutable(node: object | null | undefined, opts?: object | null): asserts node is Immutable;
1766declare function assertUserWhitespacable(node: object | null | undefined, opts?: object | null): asserts node is UserWhitespacable;
1767declare function assertMethod(node: object | null | undefined, opts?: object | null): asserts node is Method;
1768declare function assertObjectMember(node: object | null | undefined, opts?: object | null): asserts node is ObjectMember;
1769declare function assertProperty(node: object | null | undefined, opts?: object | null): asserts node is Property;
1770declare function assertUnaryLike(node: object | null | undefined, opts?: object | null): asserts node is UnaryLike;
1771declare function assertPattern(node: object | null | undefined, opts?: object | null): asserts node is Pattern;
1772declare function assertClass(node: object | null | undefined, opts?: object | null): asserts node is Class;
1773declare function assertModuleDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ModuleDeclaration;
1774declare function assertExportDeclaration(node: object | null | undefined, opts?: object | null): asserts node is ExportDeclaration;
1775declare function assertModuleSpecifier(node: object | null | undefined, opts?: object | null): asserts node is ModuleSpecifier;
1776declare function assertPrivate(node: object | null | undefined, opts?: object | null): asserts node is Private;
1777declare function assertFlow(node: object | null | undefined, opts?: object | null): asserts node is Flow;
1778declare function assertFlowType(node: object | null | undefined, opts?: object | null): asserts node is FlowType;
1779declare function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): asserts node is FlowBaseAnnotation;
1780declare function assertFlowDeclaration(node: object | null | undefined, opts?: object | null): asserts node is FlowDeclaration;
1781declare function assertFlowPredicate(node: object | null | undefined, opts?: object | null): asserts node is FlowPredicate;
1782declare function assertEnumBody(node: object | null | undefined, opts?: object | null): asserts node is EnumBody;
1783declare function assertEnumMember(node: object | null | undefined, opts?: object | null): asserts node is EnumMember;
1784declare function assertJSX(node: object | null | undefined, opts?: object | null): asserts node is JSX;
1785declare function assertTSTypeElement(node: object | null | undefined, opts?: object | null): asserts node is TSTypeElement;
1786declare function assertTSType(node: object | null | undefined, opts?: object | null): asserts node is TSType;
1787declare function assertTSBaseType(node: object | null | undefined, opts?: object | null): asserts node is TSBaseType;
1788declare function assertNumberLiteral(node: any, opts: any): void;
1789declare function assertRegexLiteral(node: any, opts: any): void;
1790declare function assertRestProperty(node: any, opts: any): void;
1791declare function assertSpreadProperty(node: any, opts: any): void;
1792
1793/**
1794 * Create a type annotation based on typeof expression.
1795 */
1796declare function createTypeAnnotationBasedOnTypeof(type: "string" | "number" | "undefined" | "boolean" | "function" | "object" | "symbol"): StringTypeAnnotation | VoidTypeAnnotation | NumberTypeAnnotation | BooleanTypeAnnotation | GenericTypeAnnotation | AnyTypeAnnotation;
1797
1798/**
1799 * Takes an array of `types` and flattens them, removing duplicates and
1800 * returns a `UnionTypeAnnotation` node containing them.
1801 */
1802declare function createFlowUnionType<T extends FlowType>(types: [T] | Array<T>): T | UnionTypeAnnotation;
1803
1804/**
1805 * Takes an array of `types` and flattens them, removing duplicates and
1806 * returns a `UnionTypeAnnotation` node containing them.
1807 */
1808declare function createTSUnionType(typeAnnotations: Array<TSTypeAnnotation>): TSType;
1809
1810declare function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
1811declare function assignmentExpression(operator: string, left: LVal, right: Expression): AssignmentExpression;
1812declare function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=", left: Expression | PrivateName, right: Expression): BinaryExpression;
1813declare function interpreterDirective(value: string): InterpreterDirective;
1814declare function directive(value: DirectiveLiteral): Directive;
1815declare function directiveLiteral(value: string): DirectiveLiteral;
1816declare function blockStatement(body: Array<Statement>, directives?: Array<Directive>): BlockStatement;
1817declare function breakStatement(label?: Identifier | null): BreakStatement;
1818declare function callExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): CallExpression;
1819declare function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause;
1820declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;
1821declare function continueStatement(label?: Identifier | null): ContinueStatement;
1822declare function debuggerStatement(): DebuggerStatement;
1823declare function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;
1824declare function emptyStatement(): EmptyStatement;
1825declare function expressionStatement(expression: Expression): ExpressionStatement;
1826declare function file(program: Program, comments?: Array<CommentBlock | CommentLine> | null, tokens?: Array<any> | null): File;
1827declare function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;
1828declare function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;
1829declare function functionDeclaration(id: Identifier | null | undefined, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
1830declare function functionExpression(id: Identifier | null | undefined, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
1831declare function identifier(name: string): Identifier;
1832declare function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;
1833declare function labeledStatement(label: Identifier, body: Statement): LabeledStatement;
1834declare function stringLiteral(value: string): StringLiteral;
1835declare function numericLiteral(value: number): NumericLiteral;
1836declare function nullLiteral(): NullLiteral;
1837declare function booleanLiteral(value: boolean): BooleanLiteral;
1838declare function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;
1839declare function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;
1840declare function memberExpression(object: Expression, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: true | false | null): MemberExpression;
1841declare function newExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): NewExpression;
1842declare function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
1843declare function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
1844declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
1845declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
1846declare function restElement(argument: LVal): RestElement;
1847declare function returnStatement(argument?: Expression | null): ReturnStatement;
1848declare function sequenceExpression(expressions: Array<Expression>): SequenceExpression;
1849declare function parenthesizedExpression(expression: Expression): ParenthesizedExpression;
1850declare function switchCase(test: Expression | null | undefined, consequent: Array<Statement>): SwitchCase;
1851declare function switchStatement(discriminant: Expression, cases: Array<SwitchCase>): SwitchStatement;
1852declare function thisExpression(): ThisExpression;
1853declare function throwStatement(argument: Expression): ThrowStatement;
1854declare function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;
1855declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;
1856declare function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;
1857declare function variableDeclaration(kind: "var" | "let" | "const", declarations: Array<VariableDeclarator>): VariableDeclaration;
1858declare function variableDeclarator(id: LVal, init?: Expression | null): VariableDeclarator;
1859declare function whileStatement(test: Expression, body: Statement): WhileStatement;
1860declare function withStatement(object: Expression, body: Statement): WithStatement;
1861declare function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression, right: Expression): AssignmentPattern;
1862declare function arrayPattern(elements: Array<null | PatternLike>): ArrayPattern;
1863declare function arrowFunctionExpression(params: Array<Identifier | Pattern | RestElement>, body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
1864declare function classBody(body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | TSDeclareMethod | TSIndexSignature>): ClassBody;
1865declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassExpression;
1866declare function classDeclaration(id: Identifier, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassDeclaration;
1867declare function exportAllDeclaration(source: StringLiteral): ExportAllDeclaration;
1868declare function exportDefaultDeclaration(declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression): ExportDefaultDeclaration;
1869declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>, source?: StringLiteral | null): ExportNamedDeclaration;
1870declare function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier;
1871declare function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;
1872declare function importDeclaration(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: StringLiteral): ImportDeclaration;
1873declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;
1874declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
1875declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
1876declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
1877declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
1878declare function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;
1879declare function spreadElement(argument: Expression): SpreadElement;
1880declare function _super(): Super;
1881
1882declare function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression;
1883declare function templateElement(value: {
1884 raw: string;
1885 cooked?: string;
1886}, tail?: boolean): TemplateElement;
1887declare function templateLiteral(quasis: Array<TemplateElement>, expressions: Array<Expression | TSType>): TemplateLiteral;
1888declare function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;
1889declare function awaitExpression(argument: Expression): AwaitExpression;
1890declare function _import(): Import;
1891
1892declare function bigIntLiteral(value: string): BigIntLiteral;
1893declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
1894declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
1895declare function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;
1896declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
1897declare function classPrivateProperty(key: PrivateName, value: Expression | null | undefined, decorators: Array<Decorator> | null | undefined, _static: any): ClassPrivateProperty;
1898declare function classPrivateMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
1899declare function privateName(id: Identifier): PrivateName;
1900declare function anyTypeAnnotation(): AnyTypeAnnotation;
1901declare function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;
1902declare function booleanTypeAnnotation(): BooleanTypeAnnotation;
1903declare function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;
1904declare function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
1905declare function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;
1906declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
1907declare function declareFunction(id: Identifier): DeclareFunction;
1908declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
1909declare function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;
1910declare function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;
1911declare function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;
1912declare function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;
1913declare function declareVariable(id: Identifier): DeclareVariable;
1914declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null, source?: StringLiteral | null): DeclareExportDeclaration;
1915declare function declareExportAllDeclaration(source: StringLiteral): DeclareExportAllDeclaration;
1916declare function declaredPredicate(value: Flow): DeclaredPredicate;
1917declare function existsTypeAnnotation(): ExistsTypeAnnotation;
1918declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: Array<FunctionTypeParam>, rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
1919declare function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam;
1920declare function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;
1921declare function inferredPredicate(): InferredPredicate;
1922declare function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;
1923declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
1924declare function interfaceTypeAnnotation(_extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
1925declare function intersectionTypeAnnotation(types: Array<FlowType>): IntersectionTypeAnnotation;
1926declare function mixedTypeAnnotation(): MixedTypeAnnotation;
1927declare function emptyTypeAnnotation(): EmptyTypeAnnotation;
1928declare function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;
1929declare function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;
1930declare function numberTypeAnnotation(): NumberTypeAnnotation;
1931declare function objectTypeAnnotation(properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>, indexers?: Array<ObjectTypeIndexer> | null, callProperties?: Array<ObjectTypeCallProperty> | null, internalSlots?: Array<ObjectTypeInternalSlot> | null, exact?: boolean): ObjectTypeAnnotation;
1932declare function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot;
1933declare function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty;
1934declare function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer;
1935declare function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null): ObjectTypeProperty;
1936declare function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty;
1937declare function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType;
1938declare function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;
1939declare function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation;
1940declare function stringTypeAnnotation(): StringTypeAnnotation;
1941declare function symbolTypeAnnotation(): SymbolTypeAnnotation;
1942declare function thisTypeAnnotation(): ThisTypeAnnotation;
1943declare function tupleTypeAnnotation(types: Array<FlowType>): TupleTypeAnnotation;
1944declare function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;
1945declare function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;
1946declare function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;
1947declare function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;
1948declare function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter;
1949declare function typeParameterDeclaration(params: Array<TypeParameter>): TypeParameterDeclaration;
1950declare function typeParameterInstantiation(params: Array<FlowType>): TypeParameterInstantiation;
1951declare function unionTypeAnnotation(types: Array<FlowType>): UnionTypeAnnotation;
1952declare function variance(kind: "minus" | "plus"): Variance;
1953declare function voidTypeAnnotation(): VoidTypeAnnotation;
1954declare function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration;
1955declare function enumBooleanBody(members: Array<EnumBooleanMember>): EnumBooleanBody;
1956declare function enumNumberBody(members: Array<EnumNumberMember>): EnumNumberBody;
1957declare function enumStringBody(members: Array<EnumStringMember | EnumDefaultedMember>): EnumStringBody;
1958declare function enumSymbolBody(members: Array<EnumDefaultedMember>): EnumSymbolBody;
1959declare function enumBooleanMember(id: Identifier): EnumBooleanMember;
1960declare function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember;
1961declare function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember;
1962declare function enumDefaultedMember(id: Identifier): EnumDefaultedMember;
1963declare function indexedAccessType(objectType: FlowType, indexType: FlowType): IndexedAccessType;
1964declare function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType;
1965declare function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute;
1966
1967declare function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement;
1968
1969declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>, selfClosing?: boolean | null): JSXElement;
1970
1971declare function jsxEmptyExpression(): JSXEmptyExpression;
1972
1973declare function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer;
1974
1975declare function jsxSpreadChild(expression: Expression): JSXSpreadChild;
1976
1977declare function jsxIdentifier(name: string): JSXIdentifier;
1978
1979declare function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression;
1980
1981declare function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;
1982
1983declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: Array<JSXAttribute | JSXSpreadAttribute>, selfClosing?: boolean): JSXOpeningElement;
1984
1985declare function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;
1986
1987declare function jsxText(value: string): JSXText;
1988
1989declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>): JSXFragment;
1990
1991declare function jsxOpeningFragment(): JSXOpeningFragment;
1992
1993declare function jsxClosingFragment(): JSXClosingFragment;
1994
1995declare function noop(): Noop;
1996declare function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: Identifier): Placeholder;
1997declare function v8IntrinsicIdentifier(name: string): V8IntrinsicIdentifier;
1998declare function argumentPlaceholder(): ArgumentPlaceholder;
1999declare function bindExpression(object: Expression, callee: Expression): BindExpression;
2000declare function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute;
2001declare function decorator(expression: Expression): Decorator;
2002declare function doExpression(body: BlockStatement, async?: boolean): DoExpression;
2003declare function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;
2004declare function recordExpression(properties: Array<ObjectProperty | SpreadElement>): RecordExpression;
2005declare function tupleExpression(elements?: Array<Expression | SpreadElement>): TupleExpression;
2006declare function decimalLiteral(value: string): DecimalLiteral;
2007declare function staticBlock(body: Array<Statement>): StaticBlock;
2008declare function moduleExpression(body: Program): ModuleExpression;
2009declare function topicReference(): TopicReference;
2010declare function pipelineTopicExpression(expression: Expression): PipelineTopicExpression;
2011declare function pipelineBareFunction(callee: Expression): PipelineBareFunction;
2012declare function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;
2013declare function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
2014
2015declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
2016
2017declare function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
2018
2019declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
2020
2021declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
2022
2023declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
2024
2025declare function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null, initializer?: Expression | null): TSPropertySignature;
2026
2027declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
2028
2029declare function tsIndexSignature(parameters: Array<Identifier>, typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
2030
2031declare function tsAnyKeyword(): TSAnyKeyword;
2032
2033declare function tsBooleanKeyword(): TSBooleanKeyword;
2034
2035declare function tsBigIntKeyword(): TSBigIntKeyword;
2036
2037declare function tsIntrinsicKeyword(): TSIntrinsicKeyword;
2038
2039declare function tsNeverKeyword(): TSNeverKeyword;
2040
2041declare function tsNullKeyword(): TSNullKeyword;
2042
2043declare function tsNumberKeyword(): TSNumberKeyword;
2044
2045declare function tsObjectKeyword(): TSObjectKeyword;
2046
2047declare function tsStringKeyword(): TSStringKeyword;
2048
2049declare function tsSymbolKeyword(): TSSymbolKeyword;
2050
2051declare function tsUndefinedKeyword(): TSUndefinedKeyword;
2052
2053declare function tsUnknownKeyword(): TSUnknownKeyword;
2054
2055declare function tsVoidKeyword(): TSVoidKeyword;
2056
2057declare function tsThisType(): TSThisType;
2058
2059declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
2060
2061declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
2062
2063declare function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;
2064
2065declare function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate;
2066
2067declare function tsTypeQuery(exprName: TSEntityName | TSImportType): TSTypeQuery;
2068
2069declare function tsTypeLiteral(members: Array<TSTypeElement>): TSTypeLiteral;
2070
2071declare function tsArrayType(elementType: TSType): TSArrayType;
2072
2073declare function tsTupleType(elementTypes: Array<TSType | TSNamedTupleMember>): TSTupleType;
2074
2075declare function tsOptionalType(typeAnnotation: TSType): TSOptionalType;
2076
2077declare function tsRestType(typeAnnotation: TSType): TSRestType;
2078
2079declare function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember;
2080
2081declare function tsUnionType(types: Array<TSType>): TSUnionType;
2082
2083declare function tsIntersectionType(types: Array<TSType>): TSIntersectionType;
2084
2085declare function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;
2086
2087declare function tsInferType(typeParameter: TSTypeParameter): TSInferType;
2088
2089declare function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
2090
2091declare function tsTypeOperator(typeAnnotation: TSType): TSTypeOperator;
2092
2093declare function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
2094
2095declare function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType;
2096
2097declare function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | UnaryExpression): TSLiteralType;
2098
2099declare function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;
2100
2101declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: Array<TSExpressionWithTypeArguments> | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
2102
2103declare function tsInterfaceBody(body: Array<TSTypeElement>): TSInterfaceBody;
2104
2105declare function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration;
2106
2107declare function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;
2108
2109declare function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
2110
2111declare function tsEnumDeclaration(id: Identifier, members: Array<TSEnumMember>): TSEnumDeclaration;
2112
2113declare function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;
2114
2115declare function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;
2116
2117declare function tsModuleBlock(body: Array<Statement>): TSModuleBlock;
2118
2119declare function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType;
2120
2121declare function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration;
2122
2123declare function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;
2124
2125declare function tsNonNullExpression(expression: Expression): TSNonNullExpression;
2126
2127declare function tsExportAssignment(expression: Expression): TSExportAssignment;
2128
2129declare function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;
2130
2131declare function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
2132
2133declare function tsTypeParameterInstantiation(params: Array<TSType>): TSTypeParameterInstantiation;
2134
2135declare function tsTypeParameterDeclaration(params: Array<TSTypeParameter>): TSTypeParameterDeclaration;
2136
2137declare function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter;
2138
2139/** @deprecated */
2140declare function NumberLiteral(...args: Array<any>): any;
2141
2142/** @deprecated */
2143declare function RegexLiteral(...args: Array<any>): any;
2144
2145/** @deprecated */
2146declare function RestProperty(...args: Array<any>): any;
2147
2148/** @deprecated */
2149declare function SpreadProperty(...args: Array<any>): any;
2150
2151/**
2152 * Create a clone of a `node` including only properties belonging to the node.
2153 * If the second parameter is `false`, cloneNode performs a shallow clone.
2154 * If the third parameter is true, the cloned nodes exclude location properties.
2155 */
2156declare function cloneNode<T extends Node>(node: T, deep?: boolean, withoutLoc?: boolean): T;
2157
2158/**
2159 * Create a shallow clone of a `node`, including only
2160 * properties belonging to the node.
2161 * @deprecated Use t.cloneNode instead.
2162 */
2163declare function clone<T extends Node>(node: T): T;
2164
2165/**
2166 * Create a deep clone of a `node` and all of it's child nodes
2167 * including only properties belonging to the node.
2168 * @deprecated Use t.cloneNode instead.
2169 */
2170declare function cloneDeep<T extends Node>(node: T): T;
2171
2172/**
2173 * Create a deep clone of a `node` and all of it's child nodes
2174 * including only properties belonging to the node.
2175 * excluding `_private` and location properties.
2176 */
2177declare function cloneDeepWithoutLoc<T extends Node>(node: T): T;
2178
2179/**
2180 * Create a shallow clone of a `node` excluding `_private` and location properties.
2181 */
2182declare function cloneWithoutLoc<T extends Node>(node: T): T;
2183
2184/**
2185 * Add comment of certain type to a node.
2186 */
2187declare function addComment<T extends Node>(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T;
2188
2189/**
2190 * Add comments of certain type to a node.
2191 */
2192declare function addComments<T extends Node>(node: T, type: CommentTypeShorthand, comments: ReadonlyArray<Comment>): T;
2193
2194declare function inheritInnerComments(child: Node, parent: Node): void;
2195
2196declare function inheritLeadingComments(child: Node, parent: Node): void;
2197
2198/**
2199 * Inherit all unique comments from `parent` node to `child` node.
2200 */
2201declare function inheritsComments<T extends Node>(child: T, parent: Node): T;
2202
2203declare function inheritTrailingComments(child: Node, parent: Node): void;
2204
2205/**
2206 * Remove comment properties from a node.
2207 */
2208declare function removeComments<T extends Node>(node: T): T;
2209
2210declare const EXPRESSION_TYPES: string[];
2211declare const BINARY_TYPES: string[];
2212declare const SCOPABLE_TYPES: string[];
2213declare const BLOCKPARENT_TYPES: string[];
2214declare const BLOCK_TYPES: string[];
2215declare const STATEMENT_TYPES: string[];
2216declare const TERMINATORLESS_TYPES: string[];
2217declare const COMPLETIONSTATEMENT_TYPES: string[];
2218declare const CONDITIONAL_TYPES: string[];
2219declare const LOOP_TYPES: string[];
2220declare const WHILE_TYPES: string[];
2221declare const EXPRESSIONWRAPPER_TYPES: string[];
2222declare const FOR_TYPES: string[];
2223declare const FORXSTATEMENT_TYPES: string[];
2224declare const FUNCTION_TYPES: string[];
2225declare const FUNCTIONPARENT_TYPES: string[];
2226declare const PUREISH_TYPES: string[];
2227declare const DECLARATION_TYPES: string[];
2228declare const PATTERNLIKE_TYPES: string[];
2229declare const LVAL_TYPES: string[];
2230declare const TSENTITYNAME_TYPES: string[];
2231declare const LITERAL_TYPES: string[];
2232declare const IMMUTABLE_TYPES: string[];
2233declare const USERWHITESPACABLE_TYPES: string[];
2234declare const METHOD_TYPES: string[];
2235declare const OBJECTMEMBER_TYPES: string[];
2236declare const PROPERTY_TYPES: string[];
2237declare const UNARYLIKE_TYPES: string[];
2238declare const PATTERN_TYPES: string[];
2239declare const CLASS_TYPES: string[];
2240declare const MODULEDECLARATION_TYPES: string[];
2241declare const EXPORTDECLARATION_TYPES: string[];
2242declare const MODULESPECIFIER_TYPES: string[];
2243declare const PRIVATE_TYPES: string[];
2244declare const FLOW_TYPES: string[];
2245declare const FLOWTYPE_TYPES: string[];
2246declare const FLOWBASEANNOTATION_TYPES: string[];
2247declare const FLOWDECLARATION_TYPES: string[];
2248declare const FLOWPREDICATE_TYPES: string[];
2249declare const ENUMBODY_TYPES: string[];
2250declare const ENUMMEMBER_TYPES: string[];
2251declare const JSX_TYPES: string[];
2252declare const TSTYPEELEMENT_TYPES: string[];
2253declare const TSTYPE_TYPES: string[];
2254declare const TSBASETYPE_TYPES: string[];
2255
2256declare const STATEMENT_OR_BLOCK_KEYS: string[];
2257declare const FLATTENABLE_KEYS: string[];
2258declare const FOR_INIT_KEYS: string[];
2259declare const COMMENT_KEYS: string[];
2260declare const LOGICAL_OPERATORS: string[];
2261declare const UPDATE_OPERATORS: string[];
2262declare const BOOLEAN_NUMBER_BINARY_OPERATORS: string[];
2263declare const EQUALITY_BINARY_OPERATORS: string[];
2264declare const COMPARISON_BINARY_OPERATORS: string[];
2265declare const BOOLEAN_BINARY_OPERATORS: string[];
2266declare const NUMBER_BINARY_OPERATORS: string[];
2267declare const BINARY_OPERATORS: string[];
2268declare const ASSIGNMENT_OPERATORS: string[];
2269declare const BOOLEAN_UNARY_OPERATORS: string[];
2270declare const NUMBER_UNARY_OPERATORS: string[];
2271declare const STRING_UNARY_OPERATORS: string[];
2272declare const UNARY_OPERATORS: string[];
2273declare const INHERIT_KEYS: {
2274 optional: string[];
2275 force: string[];
2276};
2277declare const BLOCK_SCOPED_SYMBOL: unique symbol;
2278declare const NOT_LOCAL_BINDING: unique symbol;
2279
2280/**
2281 * Ensure the `key` (defaults to "body") of a `node` is a block.
2282 * Casting it to a block if it is not.
2283 *
2284 * Returns the BlockStatement
2285 */
2286declare function ensureBlock(node: Node, key?: string): BlockStatement;
2287
2288declare function toBindingIdentifierName(name: string): string;
2289
2290declare function toBlock(node: Statement | Expression, parent?: Node): BlockStatement;
2291
2292declare function toComputedKey(node: ObjectMember | ObjectProperty | ClassMethod | ClassProperty | MemberExpression | OptionalMemberExpression, key?: Expression): Expression;
2293
2294declare const _default$3: {
2295 (node: Function): FunctionExpression;
2296 (node: Class): ClassExpression;
2297 (node: ExpressionStatement | Expression | Class | Function): Expression;
2298};
2299//# sourceMappingURL=toExpression.d.ts.map
2300
2301declare function toIdentifier(input: string): string;
2302
2303declare function toKeyAlias(node: Method | Property, key?: Node): string;
2304declare namespace toKeyAlias {
2305 var uid: number;
2306 var increment: () => number;
2307}
2308//# sourceMappingURL=toKeyAlias.d.ts.map
2309
2310declare type Scope = {
2311 push(value: {
2312 id: LVal;
2313 kind: "var";
2314 init?: Expression;
2315 }): void;
2316 buildUndefinedNode(): Node;
2317};
2318
2319/**
2320 * Turn an array of statement `nodes` into a `SequenceExpression`.
2321 *
2322 * Variable declarations are turned into simple assignments and their
2323 * declarations hoisted to the top of the current scope.
2324 *
2325 * Expression statements are just resolved to their expression.
2326 */
2327declare function toSequenceExpression(nodes: ReadonlyArray<Node>, scope: Scope): SequenceExpression | undefined;
2328
2329declare const _default$2: {
2330 (node: AssignmentExpression, ignore?: boolean): ExpressionStatement;
2331 <T extends Statement>(node: T, ignore: false): T;
2332 <T_1 extends Statement>(node: T_1, ignore?: boolean): false | T_1;
2333 (node: Class, ignore: false): ClassDeclaration;
2334 (node: Class, ignore?: boolean): ClassDeclaration | false;
2335 (node: Function, ignore: false): FunctionDeclaration;
2336 (node: Function, ignore?: boolean): FunctionDeclaration | false;
2337 (node: Node, ignore: false): Statement;
2338 (node: Node, ignore?: boolean): Statement | false;
2339};
2340//# sourceMappingURL=toStatement.d.ts.map
2341
2342declare const _default$1: {
2343 (value: undefined): Identifier;
2344 (value: boolean): BooleanLiteral;
2345 (value: null): NullLiteral;
2346 (value: string): StringLiteral;
2347 (value: number): NumericLiteral | BinaryExpression | UnaryExpression;
2348 (value: RegExp): RegExpLiteral;
2349 (value: ReadonlyArray<unknown>): ArrayExpression;
2350 (value: object): ObjectExpression;
2351 (value: unknown): Expression;
2352};
2353//# sourceMappingURL=valueToNode.d.ts.map
2354
2355declare const VISITOR_KEYS: Record<string, string[]>;
2356declare const ALIAS_KEYS: Record<string, string[]>;
2357declare const FLIPPED_ALIAS_KEYS: Record<string, string[]>;
2358declare const NODE_FIELDS: Record<string, {}>;
2359declare const BUILDER_KEYS: Record<string, string[]>;
2360declare const DEPRECATED_KEYS: Record<string, string>;
2361declare const NODE_PARENT_VALIDATIONS: {};
2362
2363declare const PLACEHOLDERS: string[];
2364declare const PLACEHOLDERS_ALIAS: Record<string, string[]>;
2365declare const PLACEHOLDERS_FLIPPED_ALIAS: Record<string, string[]>;
2366
2367declare const TYPES: Array<string>;
2368//# sourceMappingURL=index.d.ts.map
2369
2370/**
2371 * Append a node to a member expression.
2372 */
2373declare function appendToMemberExpression(member: MemberExpression, append: MemberExpression["property"], computed?: boolean): MemberExpression;
2374
2375/**
2376 * Inherit all contextual properties from `parent` node to `child` node.
2377 */
2378declare function inherits<T extends Node | null | undefined>(child: T, parent: Node | null | undefined): T;
2379
2380/**
2381 * Prepend a node to a member expression.
2382 */
2383declare function prependToMemberExpression<T extends Pick<MemberExpression, "object" | "property">>(member: T, prepend: MemberExpression["object"]): T;
2384
2385/**
2386 * Remove all of the _* properties from a node along with the additional metadata
2387 * properties like location data and raw token data.
2388 */
2389declare function removeProperties(node: Node, opts?: {
2390 preserveComments?: boolean;
2391}): void;
2392
2393declare function removePropertiesDeep<T extends Node>(tree: T, opts?: {
2394 preserveComments: boolean;
2395} | null): T;
2396
2397/**
2398 * Dedupe type annotations.
2399 */
2400declare function removeTypeDuplicates(nodes: ReadonlyArray<FlowType | false | null | undefined>): FlowType[];
2401
2402declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean): Record<string, Array<Identifier>>;
2403declare namespace getBindingIdentifiers {
2404 var keys: {
2405 DeclareClass: string[];
2406 DeclareFunction: string[];
2407 DeclareModule: string[];
2408 DeclareVariable: string[];
2409 DeclareInterface: string[];
2410 DeclareTypeAlias: string[];
2411 DeclareOpaqueType: string[];
2412 InterfaceDeclaration: string[];
2413 TypeAlias: string[];
2414 OpaqueType: string[];
2415 CatchClause: string[];
2416 LabeledStatement: string[];
2417 UnaryExpression: string[];
2418 AssignmentExpression: string[];
2419 ImportSpecifier: string[];
2420 ImportNamespaceSpecifier: string[];
2421 ImportDefaultSpecifier: string[];
2422 ImportDeclaration: string[];
2423 ExportSpecifier: string[];
2424 ExportNamespaceSpecifier: string[];
2425 ExportDefaultSpecifier: string[];
2426 FunctionDeclaration: string[];
2427 FunctionExpression: string[];
2428 ArrowFunctionExpression: string[];
2429 ObjectMethod: string[];
2430 ClassMethod: string[];
2431 ClassPrivateMethod: string[];
2432 ForInStatement: string[];
2433 ForOfStatement: string[];
2434 ClassDeclaration: string[];
2435 ClassExpression: string[];
2436 RestElement: string[];
2437 UpdateExpression: string[];
2438 ObjectProperty: string[];
2439 AssignmentPattern: string[];
2440 ArrayPattern: string[];
2441 ObjectPattern: string[];
2442 VariableDeclaration: string[];
2443 VariableDeclarator: string[];
2444 };
2445}
2446declare function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean): Record<string, Identifier>;
2447declare namespace getBindingIdentifiers {
2448 var keys: {
2449 DeclareClass: string[];
2450 DeclareFunction: string[];
2451 DeclareModule: string[];
2452 DeclareVariable: string[];
2453 DeclareInterface: string[];
2454 DeclareTypeAlias: string[];
2455 DeclareOpaqueType: string[];
2456 InterfaceDeclaration: string[];
2457 TypeAlias: string[];
2458 OpaqueType: string[];
2459 CatchClause: string[];
2460 LabeledStatement: string[];
2461 UnaryExpression: string[];
2462 AssignmentExpression: string[];
2463 ImportSpecifier: string[];
2464 ImportNamespaceSpecifier: string[];
2465 ImportDefaultSpecifier: string[];
2466 ImportDeclaration: string[];
2467 ExportSpecifier: string[];
2468 ExportNamespaceSpecifier: string[];
2469 ExportDefaultSpecifier: string[];
2470 FunctionDeclaration: string[];
2471 FunctionExpression: string[];
2472 ArrowFunctionExpression: string[];
2473 ObjectMethod: string[];
2474 ClassMethod: string[];
2475 ClassPrivateMethod: string[];
2476 ForInStatement: string[];
2477 ForOfStatement: string[];
2478 ClassDeclaration: string[];
2479 ClassExpression: string[];
2480 RestElement: string[];
2481 UpdateExpression: string[];
2482 ObjectProperty: string[];
2483 AssignmentPattern: string[];
2484 ArrayPattern: string[];
2485 ObjectPattern: string[];
2486 VariableDeclaration: string[];
2487 VariableDeclarator: string[];
2488 };
2489}
2490declare function getBindingIdentifiers(node: Node, duplicates?: boolean, outerOnly?: boolean): Record<string, Identifier> | Record<string, Array<Identifier>>;
2491declare namespace getBindingIdentifiers {
2492 var keys: {
2493 DeclareClass: string[];
2494 DeclareFunction: string[];
2495 DeclareModule: string[];
2496 DeclareVariable: string[];
2497 DeclareInterface: string[];
2498 DeclareTypeAlias: string[];
2499 DeclareOpaqueType: string[];
2500 InterfaceDeclaration: string[];
2501 TypeAlias: string[];
2502 OpaqueType: string[];
2503 CatchClause: string[];
2504 LabeledStatement: string[];
2505 UnaryExpression: string[];
2506 AssignmentExpression: string[];
2507 ImportSpecifier: string[];
2508 ImportNamespaceSpecifier: string[];
2509 ImportDefaultSpecifier: string[];
2510 ImportDeclaration: string[];
2511 ExportSpecifier: string[];
2512 ExportNamespaceSpecifier: string[];
2513 ExportDefaultSpecifier: string[];
2514 FunctionDeclaration: string[];
2515 FunctionExpression: string[];
2516 ArrowFunctionExpression: string[];
2517 ObjectMethod: string[];
2518 ClassMethod: string[];
2519 ClassPrivateMethod: string[];
2520 ForInStatement: string[];
2521 ForOfStatement: string[];
2522 ClassDeclaration: string[];
2523 ClassExpression: string[];
2524 RestElement: string[];
2525 UpdateExpression: string[];
2526 ObjectProperty: string[];
2527 AssignmentPattern: string[];
2528 ArrayPattern: string[];
2529 ObjectPattern: string[];
2530 VariableDeclaration: string[];
2531 VariableDeclarator: string[];
2532 };
2533}
2534//# sourceMappingURL=getBindingIdentifiers.d.ts.map
2535
2536declare const _default: {
2537 (node: Node, duplicates: true): Record<string, Array<Identifier>>;
2538 (node: Node, duplicates?: false): Record<string, Identifier>;
2539 (node: Node, duplicates?: boolean): Record<string, Identifier> | Record<string, Array<Identifier>>;
2540};
2541//# sourceMappingURL=getOuterBindingIdentifiers.d.ts.map
2542
2543declare type TraversalAncestors = Array<{
2544 node: Node;
2545 key: string;
2546 index?: number;
2547}>;
2548declare type TraversalHandler<T> = (this: undefined, node: Node, parent: TraversalAncestors, state: T) => void;
2549declare type TraversalHandlers<T> = {
2550 enter?: TraversalHandler<T>;
2551 exit?: TraversalHandler<T>;
2552};
2553/**
2554 * A general AST traversal with both prefix and postfix handlers, and a
2555 * state object. Exposes ancestry data to each handler so that more complex
2556 * AST data can be taken into account.
2557 */
2558declare function traverse<T>(node: Node, handlers: TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
2559
2560/**
2561 * A prefix AST traversal implementation meant for simple searching
2562 * and processing.
2563 */
2564declare function traverseFast(node: Node | null | undefined, enter: (node: Node, opts?: any) => void, opts?: any): void;
2565
2566declare function shallowEqual<T extends object>(actual: object, expected: T): actual is T;
2567
2568declare function is<T extends Node["type"]>(type: T, node: Node | null | undefined, opts?: undefined): node is Extract<Node, {
2569 type: T;
2570}>;
2571declare function is<T extends Node["type"], P extends Extract<Node, {
2572 type: T;
2573}>>(type: T, n: Node | null | undefined, required: Partial<P>): n is P;
2574declare function is<P extends Node>(type: string, node: Node | null | undefined, opts: Partial<P>): node is P;
2575declare function is(type: string, node: Node | null | undefined, opts?: Partial<Node>): node is Node;
2576
2577/**
2578 * Check if the input `node` is a binding identifier.
2579 */
2580declare function isBinding(node: Node, parent: Node, grandparent?: Node): boolean;
2581
2582/**
2583 * Check if the input `node` is block scoped.
2584 */
2585declare function isBlockScoped(node: Node): boolean;
2586
2587/**
2588 * Check if the input `node` is definitely immutable.
2589 */
2590declare function isImmutable(node: Node): boolean;
2591
2592/**
2593 * Check if the input `node` is a `let` variable declaration.
2594 */
2595declare function isLet(node: Node): boolean;
2596
2597declare function isNode(node: any): node is Node;
2598
2599/**
2600 * Check if two nodes are equivalent
2601 */
2602declare function isNodesEquivalent<T extends Partial<Node>>(a: T, b: any): b is T;
2603
2604/**
2605 * Test if a `placeholderType` is a `targetType` or if `targetType` is an alias of `placeholderType`.
2606 */
2607declare function isPlaceholderType(placeholderType: string, targetType: string): boolean;
2608
2609/**
2610 * Check if the input `node` is a reference to a bound variable.
2611 */
2612declare function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean;
2613
2614/**
2615 * Check if the input `node` is a scope.
2616 */
2617declare function isScope(node: Node, parent: Node): boolean;
2618
2619/**
2620 * Check if the input `specifier` is a `default` import or export.
2621 */
2622declare function isSpecifierDefault(specifier: ModuleSpecifier): boolean;
2623
2624declare function isType<T extends Node["type"]>(nodeType: string, targetType: T): nodeType is T;
2625declare function isType(nodeType: string | null | undefined, targetType: string): boolean;
2626
2627/**
2628 * Check if the input `name` is a valid identifier name according to the ES3 specification.
2629 *
2630 * Additional ES3 reserved words are
2631 */
2632declare function isValidES3Identifier(name: string): boolean;
2633
2634/**
2635 * Check if the input `name` is a valid identifier name
2636 * and isn't a reserved word.
2637 */
2638declare function isValidIdentifier(name: string, reserved?: boolean): boolean;
2639
2640/**
2641 * Check if the input `node` is a variable declaration.
2642 */
2643declare function isVar(node: Node): boolean;
2644
2645/**
2646 * Determines whether or not the input node `member` matches the
2647 * input `match`.
2648 *
2649 * For example, given the match `React.createClass` it would match the
2650 * parsed nodes of `React.createClass` and `React["createClass"]`.
2651 */
2652declare function matchesPattern(member: Node | null | undefined, match: string | string[], allowPartial?: boolean): boolean;
2653
2654declare function validate(node: Node | undefined | null, key: string, val: any): void;
2655
2656/**
2657 * Build a function that when called will return whether or not the
2658 * input `node` `MemberExpression` matches the input `match`.
2659 *
2660 * For example, given the match `React.createClass` it would match the
2661 * parsed nodes of `React.createClass` and `React["createClass"]`.
2662 */
2663declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (member: Node) => boolean;
2664
2665declare function isArrayExpression(node: object | null | undefined, opts?: object | null): node is ArrayExpression;
2666declare function isAssignmentExpression(node: object | null | undefined, opts?: object | null): node is AssignmentExpression;
2667declare function isBinaryExpression(node: object | null | undefined, opts?: object | null): node is BinaryExpression;
2668declare function isInterpreterDirective(node: object | null | undefined, opts?: object | null): node is InterpreterDirective;
2669declare function isDirective(node: object | null | undefined, opts?: object | null): node is Directive;
2670declare function isDirectiveLiteral(node: object | null | undefined, opts?: object | null): node is DirectiveLiteral;
2671declare function isBlockStatement(node: object | null | undefined, opts?: object | null): node is BlockStatement;
2672declare function isBreakStatement(node: object | null | undefined, opts?: object | null): node is BreakStatement;
2673declare function isCallExpression(node: object | null | undefined, opts?: object | null): node is CallExpression;
2674declare function isCatchClause(node: object | null | undefined, opts?: object | null): node is CatchClause;
2675declare function isConditionalExpression(node: object | null | undefined, opts?: object | null): node is ConditionalExpression;
2676declare function isContinueStatement(node: object | null | undefined, opts?: object | null): node is ContinueStatement;
2677declare function isDebuggerStatement(node: object | null | undefined, opts?: object | null): node is DebuggerStatement;
2678declare function isDoWhileStatement(node: object | null | undefined, opts?: object | null): node is DoWhileStatement;
2679declare function isEmptyStatement(node: object | null | undefined, opts?: object | null): node is EmptyStatement;
2680declare function isExpressionStatement(node: object | null | undefined, opts?: object | null): node is ExpressionStatement;
2681declare function isFile(node: object | null | undefined, opts?: object | null): node is File;
2682declare function isForInStatement(node: object | null | undefined, opts?: object | null): node is ForInStatement;
2683declare function isForStatement(node: object | null | undefined, opts?: object | null): node is ForStatement;
2684declare function isFunctionDeclaration(node: object | null | undefined, opts?: object | null): node is FunctionDeclaration;
2685declare function isFunctionExpression(node: object | null | undefined, opts?: object | null): node is FunctionExpression;
2686declare function isIdentifier(node: object | null | undefined, opts?: object | null): node is Identifier;
2687declare function isIfStatement(node: object | null | undefined, opts?: object | null): node is IfStatement;
2688declare function isLabeledStatement(node: object | null | undefined, opts?: object | null): node is LabeledStatement;
2689declare function isStringLiteral(node: object | null | undefined, opts?: object | null): node is StringLiteral;
2690declare function isNumericLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral;
2691declare function isNullLiteral(node: object | null | undefined, opts?: object | null): node is NullLiteral;
2692declare function isBooleanLiteral(node: object | null | undefined, opts?: object | null): node is BooleanLiteral;
2693declare function isRegExpLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral;
2694declare function isLogicalExpression(node: object | null | undefined, opts?: object | null): node is LogicalExpression;
2695declare function isMemberExpression(node: object | null | undefined, opts?: object | null): node is MemberExpression;
2696declare function isNewExpression(node: object | null | undefined, opts?: object | null): node is NewExpression;
2697declare function isProgram(node: object | null | undefined, opts?: object | null): node is Program;
2698declare function isObjectExpression(node: object | null | undefined, opts?: object | null): node is ObjectExpression;
2699declare function isObjectMethod(node: object | null | undefined, opts?: object | null): node is ObjectMethod;
2700declare function isObjectProperty(node: object | null | undefined, opts?: object | null): node is ObjectProperty;
2701declare function isRestElement(node: object | null | undefined, opts?: object | null): node is RestElement;
2702declare function isReturnStatement(node: object | null | undefined, opts?: object | null): node is ReturnStatement;
2703declare function isSequenceExpression(node: object | null | undefined, opts?: object | null): node is SequenceExpression;
2704declare function isParenthesizedExpression(node: object | null | undefined, opts?: object | null): node is ParenthesizedExpression;
2705declare function isSwitchCase(node: object | null | undefined, opts?: object | null): node is SwitchCase;
2706declare function isSwitchStatement(node: object | null | undefined, opts?: object | null): node is SwitchStatement;
2707declare function isThisExpression(node: object | null | undefined, opts?: object | null): node is ThisExpression;
2708declare function isThrowStatement(node: object | null | undefined, opts?: object | null): node is ThrowStatement;
2709declare function isTryStatement(node: object | null | undefined, opts?: object | null): node is TryStatement;
2710declare function isUnaryExpression(node: object | null | undefined, opts?: object | null): node is UnaryExpression;
2711declare function isUpdateExpression(node: object | null | undefined, opts?: object | null): node is UpdateExpression;
2712declare function isVariableDeclaration(node: object | null | undefined, opts?: object | null): node is VariableDeclaration;
2713declare function isVariableDeclarator(node: object | null | undefined, opts?: object | null): node is VariableDeclarator;
2714declare function isWhileStatement(node: object | null | undefined, opts?: object | null): node is WhileStatement;
2715declare function isWithStatement(node: object | null | undefined, opts?: object | null): node is WithStatement;
2716declare function isAssignmentPattern(node: object | null | undefined, opts?: object | null): node is AssignmentPattern;
2717declare function isArrayPattern(node: object | null | undefined, opts?: object | null): node is ArrayPattern;
2718declare function isArrowFunctionExpression(node: object | null | undefined, opts?: object | null): node is ArrowFunctionExpression;
2719declare function isClassBody(node: object | null | undefined, opts?: object | null): node is ClassBody;
2720declare function isClassExpression(node: object | null | undefined, opts?: object | null): node is ClassExpression;
2721declare function isClassDeclaration(node: object | null | undefined, opts?: object | null): node is ClassDeclaration;
2722declare function isExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is ExportAllDeclaration;
2723declare function isExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDefaultDeclaration;
2724declare function isExportNamedDeclaration(node: object | null | undefined, opts?: object | null): node is ExportNamedDeclaration;
2725declare function isExportSpecifier(node: object | null | undefined, opts?: object | null): node is ExportSpecifier;
2726declare function isForOfStatement(node: object | null | undefined, opts?: object | null): node is ForOfStatement;
2727declare function isImportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportDeclaration;
2728declare function isImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ImportDefaultSpecifier;
2729declare function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ImportNamespaceSpecifier;
2730declare function isImportSpecifier(node: object | null | undefined, opts?: object | null): node is ImportSpecifier;
2731declare function isMetaProperty(node: object | null | undefined, opts?: object | null): node is MetaProperty;
2732declare function isClassMethod(node: object | null | undefined, opts?: object | null): node is ClassMethod;
2733declare function isObjectPattern(node: object | null | undefined, opts?: object | null): node is ObjectPattern;
2734declare function isSpreadElement(node: object | null | undefined, opts?: object | null): node is SpreadElement;
2735declare function isSuper(node: object | null | undefined, opts?: object | null): node is Super;
2736declare function isTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): node is TaggedTemplateExpression;
2737declare function isTemplateElement(node: object | null | undefined, opts?: object | null): node is TemplateElement;
2738declare function isTemplateLiteral(node: object | null | undefined, opts?: object | null): node is TemplateLiteral;
2739declare function isYieldExpression(node: object | null | undefined, opts?: object | null): node is YieldExpression;
2740declare function isAwaitExpression(node: object | null | undefined, opts?: object | null): node is AwaitExpression;
2741declare function isImport(node: object | null | undefined, opts?: object | null): node is Import;
2742declare function isBigIntLiteral(node: object | null | undefined, opts?: object | null): node is BigIntLiteral;
2743declare function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ExportNamespaceSpecifier;
2744declare function isOptionalMemberExpression(node: object | null | undefined, opts?: object | null): node is OptionalMemberExpression;
2745declare function isOptionalCallExpression(node: object | null | undefined, opts?: object | null): node is OptionalCallExpression;
2746declare function isClassProperty(node: object | null | undefined, opts?: object | null): node is ClassProperty;
2747declare function isClassPrivateProperty(node: object | null | undefined, opts?: object | null): node is ClassPrivateProperty;
2748declare function isClassPrivateMethod(node: object | null | undefined, opts?: object | null): node is ClassPrivateMethod;
2749declare function isPrivateName(node: object | null | undefined, opts?: object | null): node is PrivateName;
2750declare function isAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is AnyTypeAnnotation;
2751declare function isArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ArrayTypeAnnotation;
2752declare function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanTypeAnnotation;
2753declare function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanLiteralTypeAnnotation;
2754declare function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullLiteralTypeAnnotation;
2755declare function isClassImplements(node: object | null | undefined, opts?: object | null): node is ClassImplements;
2756declare function isDeclareClass(node: object | null | undefined, opts?: object | null): node is DeclareClass;
2757declare function isDeclareFunction(node: object | null | undefined, opts?: object | null): node is DeclareFunction;
2758declare function isDeclareInterface(node: object | null | undefined, opts?: object | null): node is DeclareInterface;
2759declare function isDeclareModule(node: object | null | undefined, opts?: object | null): node is DeclareModule;
2760declare function isDeclareModuleExports(node: object | null | undefined, opts?: object | null): node is DeclareModuleExports;
2761declare function isDeclareTypeAlias(node: object | null | undefined, opts?: object | null): node is DeclareTypeAlias;
2762declare function isDeclareOpaqueType(node: object | null | undefined, opts?: object | null): node is DeclareOpaqueType;
2763declare function isDeclareVariable(node: object | null | undefined, opts?: object | null): node is DeclareVariable;
2764declare function isDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportDeclaration;
2765declare function isDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportAllDeclaration;
2766declare function isDeclaredPredicate(node: object | null | undefined, opts?: object | null): node is DeclaredPredicate;
2767declare function isExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ExistsTypeAnnotation;
2768declare function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is FunctionTypeAnnotation;
2769declare function isFunctionTypeParam(node: object | null | undefined, opts?: object | null): node is FunctionTypeParam;
2770declare function isGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): node is GenericTypeAnnotation;
2771declare function isInferredPredicate(node: object | null | undefined, opts?: object | null): node is InferredPredicate;
2772declare function isInterfaceExtends(node: object | null | undefined, opts?: object | null): node is InterfaceExtends;
2773declare function isInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is InterfaceDeclaration;
2774declare function isInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): node is InterfaceTypeAnnotation;
2775declare function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is IntersectionTypeAnnotation;
2776declare function isMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): node is MixedTypeAnnotation;
2777declare function isEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is EmptyTypeAnnotation;
2778declare function isNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullableTypeAnnotation;
2779declare function isNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberLiteralTypeAnnotation;
2780declare function isNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberTypeAnnotation;
2781declare function isObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ObjectTypeAnnotation;
2782declare function isObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): node is ObjectTypeInternalSlot;
2783declare function isObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeCallProperty;
2784declare function isObjectTypeIndexer(node: object | null | undefined, opts?: object | null): node is ObjectTypeIndexer;
2785declare function isObjectTypeProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeProperty;
2786declare function isObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeSpreadProperty;
2787declare function isOpaqueType(node: object | null | undefined, opts?: object | null): node is OpaqueType;
2788declare function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): node is QualifiedTypeIdentifier;
2789declare function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringLiteralTypeAnnotation;
2790declare function isStringTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringTypeAnnotation;
2791declare function isSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): node is SymbolTypeAnnotation;
2792declare function isThisTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ThisTypeAnnotation;
2793declare function isTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TupleTypeAnnotation;
2794declare function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeofTypeAnnotation;
2795declare function isTypeAlias(node: object | null | undefined, opts?: object | null): node is TypeAlias;
2796declare function isTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeAnnotation;
2797declare function isTypeCastExpression(node: object | null | undefined, opts?: object | null): node is TypeCastExpression;
2798declare function isTypeParameter(node: object | null | undefined, opts?: object | null): node is TypeParameter;
2799declare function isTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TypeParameterDeclaration;
2800declare function isTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TypeParameterInstantiation;
2801declare function isUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is UnionTypeAnnotation;
2802declare function isVariance(node: object | null | undefined, opts?: object | null): node is Variance;
2803declare function isVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): node is VoidTypeAnnotation;
2804declare function isEnumDeclaration(node: object | null | undefined, opts?: object | null): node is EnumDeclaration;
2805declare function isEnumBooleanBody(node: object | null | undefined, opts?: object | null): node is EnumBooleanBody;
2806declare function isEnumNumberBody(node: object | null | undefined, opts?: object | null): node is EnumNumberBody;
2807declare function isEnumStringBody(node: object | null | undefined, opts?: object | null): node is EnumStringBody;
2808declare function isEnumSymbolBody(node: object | null | undefined, opts?: object | null): node is EnumSymbolBody;
2809declare function isEnumBooleanMember(node: object | null | undefined, opts?: object | null): node is EnumBooleanMember;
2810declare function isEnumNumberMember(node: object | null | undefined, opts?: object | null): node is EnumNumberMember;
2811declare function isEnumStringMember(node: object | null | undefined, opts?: object | null): node is EnumStringMember;
2812declare function isEnumDefaultedMember(node: object | null | undefined, opts?: object | null): node is EnumDefaultedMember;
2813declare function isIndexedAccessType(node: object | null | undefined, opts?: object | null): node is IndexedAccessType;
2814declare function isOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): node is OptionalIndexedAccessType;
2815declare function isJSXAttribute(node: object | null | undefined, opts?: object | null): node is JSXAttribute;
2816declare function isJSXClosingElement(node: object | null | undefined, opts?: object | null): node is JSXClosingElement;
2817declare function isJSXElement(node: object | null | undefined, opts?: object | null): node is JSXElement;
2818declare function isJSXEmptyExpression(node: object | null | undefined, opts?: object | null): node is JSXEmptyExpression;
2819declare function isJSXExpressionContainer(node: object | null | undefined, opts?: object | null): node is JSXExpressionContainer;
2820declare function isJSXSpreadChild(node: object | null | undefined, opts?: object | null): node is JSXSpreadChild;
2821declare function isJSXIdentifier(node: object | null | undefined, opts?: object | null): node is JSXIdentifier;
2822declare function isJSXMemberExpression(node: object | null | undefined, opts?: object | null): node is JSXMemberExpression;
2823declare function isJSXNamespacedName(node: object | null | undefined, opts?: object | null): node is JSXNamespacedName;
2824declare function isJSXOpeningElement(node: object | null | undefined, opts?: object | null): node is JSXOpeningElement;
2825declare function isJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): node is JSXSpreadAttribute;
2826declare function isJSXText(node: object | null | undefined, opts?: object | null): node is JSXText;
2827declare function isJSXFragment(node: object | null | undefined, opts?: object | null): node is JSXFragment;
2828declare function isJSXOpeningFragment(node: object | null | undefined, opts?: object | null): node is JSXOpeningFragment;
2829declare function isJSXClosingFragment(node: object | null | undefined, opts?: object | null): node is JSXClosingFragment;
2830declare function isNoop(node: object | null | undefined, opts?: object | null): node is Noop;
2831declare function isPlaceholder(node: object | null | undefined, opts?: object | null): node is Placeholder;
2832declare function isV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): node is V8IntrinsicIdentifier;
2833declare function isArgumentPlaceholder(node: object | null | undefined, opts?: object | null): node is ArgumentPlaceholder;
2834declare function isBindExpression(node: object | null | undefined, opts?: object | null): node is BindExpression;
2835declare function isImportAttribute(node: object | null | undefined, opts?: object | null): node is ImportAttribute;
2836declare function isDecorator(node: object | null | undefined, opts?: object | null): node is Decorator;
2837declare function isDoExpression(node: object | null | undefined, opts?: object | null): node is DoExpression;
2838declare function isExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ExportDefaultSpecifier;
2839declare function isRecordExpression(node: object | null | undefined, opts?: object | null): node is RecordExpression;
2840declare function isTupleExpression(node: object | null | undefined, opts?: object | null): node is TupleExpression;
2841declare function isDecimalLiteral(node: object | null | undefined, opts?: object | null): node is DecimalLiteral;
2842declare function isStaticBlock(node: object | null | undefined, opts?: object | null): node is StaticBlock;
2843declare function isModuleExpression(node: object | null | undefined, opts?: object | null): node is ModuleExpression;
2844declare function isTopicReference(node: object | null | undefined, opts?: object | null): node is TopicReference;
2845declare function isPipelineTopicExpression(node: object | null | undefined, opts?: object | null): node is PipelineTopicExpression;
2846declare function isPipelineBareFunction(node: object | null | undefined, opts?: object | null): node is PipelineBareFunction;
2847declare function isPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): node is PipelinePrimaryTopicReference;
2848declare function isTSParameterProperty(node: object | null | undefined, opts?: object | null): node is TSParameterProperty;
2849declare function isTSDeclareFunction(node: object | null | undefined, opts?: object | null): node is TSDeclareFunction;
2850declare function isTSDeclareMethod(node: object | null | undefined, opts?: object | null): node is TSDeclareMethod;
2851declare function isTSQualifiedName(node: object | null | undefined, opts?: object | null): node is TSQualifiedName;
2852declare function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSCallSignatureDeclaration;
2853declare function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSConstructSignatureDeclaration;
2854declare function isTSPropertySignature(node: object | null | undefined, opts?: object | null): node is TSPropertySignature;
2855declare function isTSMethodSignature(node: object | null | undefined, opts?: object | null): node is TSMethodSignature;
2856declare function isTSIndexSignature(node: object | null | undefined, opts?: object | null): node is TSIndexSignature;
2857declare function isTSAnyKeyword(node: object | null | undefined, opts?: object | null): node is TSAnyKeyword;
2858declare function isTSBooleanKeyword(node: object | null | undefined, opts?: object | null): node is TSBooleanKeyword;
2859declare function isTSBigIntKeyword(node: object | null | undefined, opts?: object | null): node is TSBigIntKeyword;
2860declare function isTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): node is TSIntrinsicKeyword;
2861declare function isTSNeverKeyword(node: object | null | undefined, opts?: object | null): node is TSNeverKeyword;
2862declare function isTSNullKeyword(node: object | null | undefined, opts?: object | null): node is TSNullKeyword;
2863declare function isTSNumberKeyword(node: object | null | undefined, opts?: object | null): node is TSNumberKeyword;
2864declare function isTSObjectKeyword(node: object | null | undefined, opts?: object | null): node is TSObjectKeyword;
2865declare function isTSStringKeyword(node: object | null | undefined, opts?: object | null): node is TSStringKeyword;
2866declare function isTSSymbolKeyword(node: object | null | undefined, opts?: object | null): node is TSSymbolKeyword;
2867declare function isTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): node is TSUndefinedKeyword;
2868declare function isTSUnknownKeyword(node: object | null | undefined, opts?: object | null): node is TSUnknownKeyword;
2869declare function isTSVoidKeyword(node: object | null | undefined, opts?: object | null): node is TSVoidKeyword;
2870declare function isTSThisType(node: object | null | undefined, opts?: object | null): node is TSThisType;
2871declare function isTSFunctionType(node: object | null | undefined, opts?: object | null): node is TSFunctionType;
2872declare function isTSConstructorType(node: object | null | undefined, opts?: object | null): node is TSConstructorType;
2873declare function isTSTypeReference(node: object | null | undefined, opts?: object | null): node is TSTypeReference;
2874declare function isTSTypePredicate(node: object | null | undefined, opts?: object | null): node is TSTypePredicate;
2875declare function isTSTypeQuery(node: object | null | undefined, opts?: object | null): node is TSTypeQuery;
2876declare function isTSTypeLiteral(node: object | null | undefined, opts?: object | null): node is TSTypeLiteral;
2877declare function isTSArrayType(node: object | null | undefined, opts?: object | null): node is TSArrayType;
2878declare function isTSTupleType(node: object | null | undefined, opts?: object | null): node is TSTupleType;
2879declare function isTSOptionalType(node: object | null | undefined, opts?: object | null): node is TSOptionalType;
2880declare function isTSRestType(node: object | null | undefined, opts?: object | null): node is TSRestType;
2881declare function isTSNamedTupleMember(node: object | null | undefined, opts?: object | null): node is TSNamedTupleMember;
2882declare function isTSUnionType(node: object | null | undefined, opts?: object | null): node is TSUnionType;
2883declare function isTSIntersectionType(node: object | null | undefined, opts?: object | null): node is TSIntersectionType;
2884declare function isTSConditionalType(node: object | null | undefined, opts?: object | null): node is TSConditionalType;
2885declare function isTSInferType(node: object | null | undefined, opts?: object | null): node is TSInferType;
2886declare function isTSParenthesizedType(node: object | null | undefined, opts?: object | null): node is TSParenthesizedType;
2887declare function isTSTypeOperator(node: object | null | undefined, opts?: object | null): node is TSTypeOperator;
2888declare function isTSIndexedAccessType(node: object | null | undefined, opts?: object | null): node is TSIndexedAccessType;
2889declare function isTSMappedType(node: object | null | undefined, opts?: object | null): node is TSMappedType;
2890declare function isTSLiteralType(node: object | null | undefined, opts?: object | null): node is TSLiteralType;
2891declare function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): node is TSExpressionWithTypeArguments;
2892declare function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is TSInterfaceDeclaration;
2893declare function isTSInterfaceBody(node: object | null | undefined, opts?: object | null): node is TSInterfaceBody;
2894declare function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeAliasDeclaration;
2895declare function isTSAsExpression(node: object | null | undefined, opts?: object | null): node is TSAsExpression;
2896declare function isTSTypeAssertion(node: object | null | undefined, opts?: object | null): node is TSTypeAssertion;
2897declare function isTSEnumDeclaration(node: object | null | undefined, opts?: object | null): node is TSEnumDeclaration;
2898declare function isTSEnumMember(node: object | null | undefined, opts?: object | null): node is TSEnumMember;
2899declare function isTSModuleDeclaration(node: object | null | undefined, opts?: object | null): node is TSModuleDeclaration;
2900declare function isTSModuleBlock(node: object | null | undefined, opts?: object | null): node is TSModuleBlock;
2901declare function isTSImportType(node: object | null | undefined, opts?: object | null): node is TSImportType;
2902declare function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): node is TSImportEqualsDeclaration;
2903declare function isTSExternalModuleReference(node: object | null | undefined, opts?: object | null): node is TSExternalModuleReference;
2904declare function isTSNonNullExpression(node: object | null | undefined, opts?: object | null): node is TSNonNullExpression;
2905declare function isTSExportAssignment(node: object | null | undefined, opts?: object | null): node is TSExportAssignment;
2906declare function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): node is TSNamespaceExportDeclaration;
2907declare function isTSTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TSTypeAnnotation;
2908declare function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TSTypeParameterInstantiation;
2909declare function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeParameterDeclaration;
2910declare function isTSTypeParameter(node: object | null | undefined, opts?: object | null): node is TSTypeParameter;
2911declare function isExpression(node: object | null | undefined, opts?: object | null): node is Expression;
2912declare function isBinary(node: object | null | undefined, opts?: object | null): node is Binary;
2913declare function isScopable(node: object | null | undefined, opts?: object | null): node is Scopable;
2914declare function isBlockParent(node: object | null | undefined, opts?: object | null): node is BlockParent;
2915declare function isBlock(node: object | null | undefined, opts?: object | null): node is Block;
2916declare function isStatement(node: object | null | undefined, opts?: object | null): node is Statement;
2917declare function isTerminatorless(node: object | null | undefined, opts?: object | null): node is Terminatorless;
2918declare function isCompletionStatement(node: object | null | undefined, opts?: object | null): node is CompletionStatement;
2919declare function isConditional(node: object | null | undefined, opts?: object | null): node is Conditional;
2920declare function isLoop(node: object | null | undefined, opts?: object | null): node is Loop;
2921declare function isWhile(node: object | null | undefined, opts?: object | null): node is While;
2922declare function isExpressionWrapper(node: object | null | undefined, opts?: object | null): node is ExpressionWrapper;
2923declare function isFor(node: object | null | undefined, opts?: object | null): node is For;
2924declare function isForXStatement(node: object | null | undefined, opts?: object | null): node is ForXStatement;
2925declare function isFunction(node: object | null | undefined, opts?: object | null): node is Function;
2926declare function isFunctionParent(node: object | null | undefined, opts?: object | null): node is FunctionParent;
2927declare function isPureish(node: object | null | undefined, opts?: object | null): node is Pureish;
2928declare function isDeclaration(node: object | null | undefined, opts?: object | null): node is Declaration;
2929declare function isPatternLike(node: object | null | undefined, opts?: object | null): node is PatternLike;
2930declare function isLVal(node: object | null | undefined, opts?: object | null): node is LVal;
2931declare function isTSEntityName(node: object | null | undefined, opts?: object | null): node is TSEntityName;
2932declare function isLiteral(node: object | null | undefined, opts?: object | null): node is Literal;
2933declare function isUserWhitespacable(node: object | null | undefined, opts?: object | null): node is UserWhitespacable;
2934declare function isMethod(node: object | null | undefined, opts?: object | null): node is Method;
2935declare function isObjectMember(node: object | null | undefined, opts?: object | null): node is ObjectMember;
2936declare function isProperty(node: object | null | undefined, opts?: object | null): node is Property;
2937declare function isUnaryLike(node: object | null | undefined, opts?: object | null): node is UnaryLike;
2938declare function isPattern(node: object | null | undefined, opts?: object | null): node is Pattern;
2939declare function isClass(node: object | null | undefined, opts?: object | null): node is Class;
2940declare function isModuleDeclaration(node: object | null | undefined, opts?: object | null): node is ModuleDeclaration;
2941declare function isExportDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDeclaration;
2942declare function isModuleSpecifier(node: object | null | undefined, opts?: object | null): node is ModuleSpecifier;
2943declare function isPrivate(node: object | null | undefined, opts?: object | null): node is Private;
2944declare function isFlow(node: object | null | undefined, opts?: object | null): node is Flow;
2945declare function isFlowType(node: object | null | undefined, opts?: object | null): node is FlowType;
2946declare function isFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): node is FlowBaseAnnotation;
2947declare function isFlowDeclaration(node: object | null | undefined, opts?: object | null): node is FlowDeclaration;
2948declare function isFlowPredicate(node: object | null | undefined, opts?: object | null): node is FlowPredicate;
2949declare function isEnumBody(node: object | null | undefined, opts?: object | null): node is EnumBody;
2950declare function isEnumMember(node: object | null | undefined, opts?: object | null): node is EnumMember;
2951declare function isJSX(node: object | null | undefined, opts?: object | null): node is JSX;
2952declare function isTSTypeElement(node: object | null | undefined, opts?: object | null): node is TSTypeElement;
2953declare function isTSType(node: object | null | undefined, opts?: object | null): node is TSType;
2954declare function isTSBaseType(node: object | null | undefined, opts?: object | null): node is TSBaseType;
2955declare function isNumberLiteral(node: object | null | undefined, opts?: object | null): boolean;
2956declare function isRegexLiteral(node: object | null | undefined, opts?: object | null): boolean;
2957declare function isRestProperty(node: object | null | undefined, opts?: object | null): boolean;
2958declare function isSpreadProperty(node: object | null | undefined, opts?: object | null): boolean;
2959
2960declare const react: {
2961 isReactComponent: (member: Node) => boolean;
2962 isCompatTag: typeof isCompatTag;
2963 buildChildren: typeof buildChildren;
2964};
2965
2966export { ALIAS_KEYS, ASSIGNMENT_OPERATORS, Aliases, AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BINARY_OPERATORS, BINARY_TYPES, BLOCKPARENT_TYPES, BLOCK_SCOPED_SYMBOL, BLOCK_TYPES, BOOLEAN_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS, BOOLEAN_UNARY_OPERATORS, BUILDER_KEYS, BigIntLiteral, Binary, BinaryExpression, BindExpression, Block, BlockParent, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CLASS_TYPES, COMMENT_KEYS, COMPARISON_BINARY_OPERATORS, COMPLETIONSTATEMENT_TYPES, CONDITIONAL_TYPES, CallExpression, CatchClause, Class, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, Comment, CommentBlock, CommentLine, CommentTypeShorthand, CompletionStatement, Conditional, ConditionalExpression, ContinueStatement, DECLARATION_TYPES, DEPRECATED_KEYS, DebuggerStatement, DecimalLiteral, Declaration, DeclareClass, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DeclaredPredicate, Decorator, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, ENUMBODY_TYPES, ENUMMEMBER_TYPES, EQUALITY_BINARY_OPERATORS, EXPORTDECLARATION_TYPES, EXPRESSIONWRAPPER_TYPES, EXPRESSION_TYPES, EmptyStatement, EmptyTypeAnnotation, EnumBody, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, ExpressionWrapper, FLATTENABLE_KEYS, FLIPPED_ALIAS_KEYS, FLOWBASEANNOTATION_TYPES, FLOWDECLARATION_TYPES, FLOWPREDICATE_TYPES, FLOWTYPE_TYPES, FLOW_TYPES, FORXSTATEMENT_TYPES, FOR_INIT_KEYS, FOR_TYPES, FUNCTIONPARENT_TYPES, FUNCTION_TYPES, File, Flow, FlowBaseAnnotation, FlowDeclaration, FlowPredicate, FlowType, For, ForInStatement, ForOfStatement, ForStatement, ForXStatement, Function, FunctionDeclaration, FunctionExpression, FunctionParent, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, IMMUTABLE_TYPES, INHERIT_KEYS, Identifier, IfStatement, Immutable, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSX, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, JSX_TYPES, LITERAL_TYPES, LOGICAL_OPERATORS, LOOP_TYPES, LVAL_TYPES, LVal, LabeledStatement, Literal, LogicalExpression, Loop, METHOD_TYPES, MODULEDECLARATION_TYPES, MODULESPECIFIER_TYPES, MemberExpression, MetaProperty, Method, MixedTypeAnnotation, ModuleDeclaration, ModuleExpression, ModuleSpecifier, NODE_FIELDS, NODE_PARENT_VALIDATIONS, NOT_LOCAL_BINDING, NUMBER_BINARY_OPERATORS, NUMBER_UNARY_OPERATORS, NewExpression, Node, Noop, NullLiteral, NullLiteralTypeAnnotation, NullableTypeAnnotation, NumberLiteral$1 as NumberLiteral, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, OBJECTMEMBER_TYPES, ObjectExpression, ObjectMember, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, PATTERNLIKE_TYPES, PATTERN_TYPES, PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS, PRIVATE_TYPES, PROPERTY_TYPES, PUREISH_TYPES, ParenthesizedExpression, Pattern, PatternLike, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, Private, PrivateName, Program, Property, Pureish, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RegexLiteral$1 as RegexLiteral, RestElement, RestProperty$1 as RestProperty, ReturnStatement, SCOPABLE_TYPES, STATEMENT_OR_BLOCK_KEYS, STATEMENT_TYPES, STRING_UNARY_OPERATORS, Scopable, SequenceExpression, SourceLocation, SpreadElement, SpreadProperty$1 as SpreadProperty, Statement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TERMINATORLESS_TYPES, TSAnyKeyword, TSArrayType, TSAsExpression, TSBASETYPE_TYPES, TSBaseType, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSDeclareMethod, TSENTITYNAME_TYPES, TSEntityName, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexSignature, TSIndexedAccessType, TSInferType, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSStringKeyword, TSSymbolKeyword, TSTYPEELEMENT_TYPES, TSTYPE_TYPES, TSThisType, TSTupleType, TSType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeElement, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TYPES, TaggedTemplateExpression, TemplateElement, TemplateLiteral, Terminatorless, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TraversalAncestors, TraversalHandler, TraversalHandlers, TryStatement, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypeofTypeAnnotation, UNARYLIKE_TYPES, UNARY_OPERATORS, UPDATE_OPERATORS, USERWHITESPACABLE_TYPES, UnaryExpression, UnaryLike, UnionTypeAnnotation, UpdateExpression, UserWhitespacable, V8IntrinsicIdentifier, VISITOR_KEYS, VariableDeclaration, VariableDeclarator, Variance, VoidTypeAnnotation, WHILE_TYPES, While, WhileStatement, WithStatement, YieldExpression, addComment, addComments, anyTypeAnnotation, appendToMemberExpression, argumentPlaceholder, arrayExpression, arrayPattern, arrayTypeAnnotation, arrowFunctionExpression, assertAnyTypeAnnotation, assertArgumentPlaceholder, assertArrayExpression, assertArrayPattern, assertArrayTypeAnnotation, assertArrowFunctionExpression, assertAssignmentExpression, assertAssignmentPattern, assertAwaitExpression, assertBigIntLiteral, assertBinary, assertBinaryExpression, assertBindExpression, assertBlock, assertBlockParent, assertBlockStatement, assertBooleanLiteral, assertBooleanLiteralTypeAnnotation, assertBooleanTypeAnnotation, assertBreakStatement, assertCallExpression, assertCatchClause, assertClass, assertClassBody, assertClassDeclaration, assertClassExpression, assertClassImplements, assertClassMethod, assertClassPrivateMethod, assertClassPrivateProperty, assertClassProperty, assertCompletionStatement, assertConditional, assertConditionalExpression, assertContinueStatement, assertDebuggerStatement, assertDecimalLiteral, assertDeclaration, assertDeclareClass, assertDeclareExportAllDeclaration, assertDeclareExportDeclaration, assertDeclareFunction, assertDeclareInterface, assertDeclareModule, assertDeclareModuleExports, assertDeclareOpaqueType, assertDeclareTypeAlias, assertDeclareVariable, assertDeclaredPredicate, assertDecorator, assertDirective, assertDirectiveLiteral, assertDoExpression, assertDoWhileStatement, assertEmptyStatement, assertEmptyTypeAnnotation, assertEnumBody, assertEnumBooleanBody, assertEnumBooleanMember, assertEnumDeclaration, assertEnumDefaultedMember, assertEnumMember, assertEnumNumberBody, assertEnumNumberMember, assertEnumStringBody, assertEnumStringMember, assertEnumSymbolBody, assertExistsTypeAnnotation, assertExportAllDeclaration, assertExportDeclaration, assertExportDefaultDeclaration, assertExportDefaultSpecifier, assertExportNamedDeclaration, assertExportNamespaceSpecifier, assertExportSpecifier, assertExpression, assertExpressionStatement, assertExpressionWrapper, assertFile, assertFlow, assertFlowBaseAnnotation, assertFlowDeclaration, assertFlowPredicate, assertFlowType, assertFor, assertForInStatement, assertForOfStatement, assertForStatement, assertForXStatement, assertFunction, assertFunctionDeclaration, assertFunctionExpression, assertFunctionParent, assertFunctionTypeAnnotation, assertFunctionTypeParam, assertGenericTypeAnnotation, assertIdentifier, assertIfStatement, assertImmutable, assertImport, assertImportAttribute, assertImportDeclaration, assertImportDefaultSpecifier, assertImportNamespaceSpecifier, assertImportSpecifier, assertIndexedAccessType, assertInferredPredicate, assertInterfaceDeclaration, assertInterfaceExtends, assertInterfaceTypeAnnotation, assertInterpreterDirective, assertIntersectionTypeAnnotation, assertJSX, assertJSXAttribute, assertJSXClosingElement, assertJSXClosingFragment, assertJSXElement, assertJSXEmptyExpression, assertJSXExpressionContainer, assertJSXFragment, assertJSXIdentifier, assertJSXMemberExpression, assertJSXNamespacedName, assertJSXOpeningElement, assertJSXOpeningFragment, assertJSXSpreadAttribute, assertJSXSpreadChild, assertJSXText, assertLVal, assertLabeledStatement, assertLiteral, assertLogicalExpression, assertLoop, assertMemberExpression, assertMetaProperty, assertMethod, assertMixedTypeAnnotation, assertModuleDeclaration, assertModuleExpression, assertModuleSpecifier, assertNewExpression, assertNode, assertNoop, assertNullLiteral, assertNullLiteralTypeAnnotation, assertNullableTypeAnnotation, assertNumberLiteral, assertNumberLiteralTypeAnnotation, assertNumberTypeAnnotation, assertNumericLiteral, assertObjectExpression, assertObjectMember, assertObjectMethod, assertObjectPattern, assertObjectProperty, assertObjectTypeAnnotation, assertObjectTypeCallProperty, assertObjectTypeIndexer, assertObjectTypeInternalSlot, assertObjectTypeProperty, assertObjectTypeSpreadProperty, assertOpaqueType, assertOptionalCallExpression, assertOptionalIndexedAccessType, assertOptionalMemberExpression, assertParenthesizedExpression, assertPattern, assertPatternLike, assertPipelineBareFunction, assertPipelinePrimaryTopicReference, assertPipelineTopicExpression, assertPlaceholder, assertPrivate, assertPrivateName, assertProgram, assertProperty, assertPureish, assertQualifiedTypeIdentifier, assertRecordExpression, assertRegExpLiteral, assertRegexLiteral, assertRestElement, assertRestProperty, assertReturnStatement, assertScopable, assertSequenceExpression, assertSpreadElement, assertSpreadProperty, assertStatement, assertStaticBlock, assertStringLiteral, assertStringLiteralTypeAnnotation, assertStringTypeAnnotation, assertSuper, assertSwitchCase, assertSwitchStatement, assertSymbolTypeAnnotation, assertTSAnyKeyword, assertTSArrayType, assertTSAsExpression, assertTSBaseType, assertTSBigIntKeyword, assertTSBooleanKeyword, assertTSCallSignatureDeclaration, assertTSConditionalType, assertTSConstructSignatureDeclaration, assertTSConstructorType, assertTSDeclareFunction, assertTSDeclareMethod, assertTSEntityName, assertTSEnumDeclaration, assertTSEnumMember, assertTSExportAssignment, assertTSExpressionWithTypeArguments, assertTSExternalModuleReference, assertTSFunctionType, assertTSImportEqualsDeclaration, assertTSImportType, assertTSIndexSignature, assertTSIndexedAccessType, assertTSInferType, assertTSInterfaceBody, assertTSInterfaceDeclaration, assertTSIntersectionType, assertTSIntrinsicKeyword, assertTSLiteralType, assertTSMappedType, assertTSMethodSignature, assertTSModuleBlock, assertTSModuleDeclaration, assertTSNamedTupleMember, assertTSNamespaceExportDeclaration, assertTSNeverKeyword, assertTSNonNullExpression, assertTSNullKeyword, assertTSNumberKeyword, assertTSObjectKeyword, assertTSOptionalType, assertTSParameterProperty, assertTSParenthesizedType, assertTSPropertySignature, assertTSQualifiedName, assertTSRestType, assertTSStringKeyword, assertTSSymbolKeyword, assertTSThisType, assertTSTupleType, assertTSType, assertTSTypeAliasDeclaration, assertTSTypeAnnotation, assertTSTypeAssertion, assertTSTypeElement, assertTSTypeLiteral, assertTSTypeOperator, assertTSTypeParameter, assertTSTypeParameterDeclaration, assertTSTypeParameterInstantiation, assertTSTypePredicate, assertTSTypeQuery, assertTSTypeReference, assertTSUndefinedKeyword, assertTSUnionType, assertTSUnknownKeyword, assertTSVoidKeyword, assertTaggedTemplateExpression, assertTemplateElement, assertTemplateLiteral, assertTerminatorless, assertThisExpression, assertThisTypeAnnotation, assertThrowStatement, assertTopicReference, assertTryStatement, assertTupleExpression, assertTupleTypeAnnotation, assertTypeAlias, assertTypeAnnotation, assertTypeCastExpression, assertTypeParameter, assertTypeParameterDeclaration, assertTypeParameterInstantiation, assertTypeofTypeAnnotation, assertUnaryExpression, assertUnaryLike, assertUnionTypeAnnotation, assertUpdateExpression, assertUserWhitespacable, assertV8IntrinsicIdentifier, assertVariableDeclaration, assertVariableDeclarator, assertVariance, assertVoidTypeAnnotation, assertWhile, assertWhileStatement, assertWithStatement, assertYieldExpression, assignmentExpression, assignmentPattern, awaitExpression, bigIntLiteral, binaryExpression, bindExpression, blockStatement, booleanLiteral, booleanLiteralTypeAnnotation, booleanTypeAnnotation, breakStatement, buildMatchMemberExpression, callExpression, catchClause, classBody, classDeclaration, classExpression, classImplements, classMethod, classPrivateMethod, classPrivateProperty, classProperty, clone, cloneDeep, cloneDeepWithoutLoc, cloneNode, cloneWithoutLoc, conditionalExpression, continueStatement, createFlowUnionType, createTSUnionType, createTypeAnnotationBasedOnTypeof, createFlowUnionType as createUnionTypeAnnotation, debuggerStatement, decimalLiteral, declareClass, declareExportAllDeclaration, declareExportDeclaration, declareFunction, declareInterface, declareModule, declareModuleExports, declareOpaqueType, declareTypeAlias, declareVariable, declaredPredicate, decorator, directive, directiveLiteral, doExpression, doWhileStatement, emptyStatement, emptyTypeAnnotation, ensureBlock, enumBooleanBody, enumBooleanMember, enumDeclaration, enumDefaultedMember, enumNumberBody, enumNumberMember, enumStringBody, enumStringMember, enumSymbolBody, existsTypeAnnotation, exportAllDeclaration, exportDefaultDeclaration, exportDefaultSpecifier, exportNamedDeclaration, exportNamespaceSpecifier, exportSpecifier, expressionStatement, file, forInStatement, forOfStatement, forStatement, functionDeclaration, functionExpression, functionTypeAnnotation, functionTypeParam, genericTypeAnnotation, getBindingIdentifiers, _default as getOuterBindingIdentifiers, identifier, ifStatement, _import as import, importAttribute, importDeclaration, importDefaultSpecifier, importNamespaceSpecifier, importSpecifier, indexedAccessType, inferredPredicate, inheritInnerComments, inheritLeadingComments, inheritTrailingComments, inherits, inheritsComments, interfaceDeclaration, interfaceExtends, interfaceTypeAnnotation, interpreterDirective, intersectionTypeAnnotation, is, isAnyTypeAnnotation, isArgumentPlaceholder, isArrayExpression, isArrayPattern, isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAssignmentPattern, isAwaitExpression, isBigIntLiteral, isBinary, isBinaryExpression, isBindExpression, isBinding, isBlock, isBlockParent, isBlockScoped, isBlockStatement, isBooleanLiteral, isBooleanLiteralTypeAnnotation, isBooleanTypeAnnotation, isBreakStatement, isCallExpression, isCatchClause, isClass, isClassBody, isClassDeclaration, isClassExpression, isClassImplements, isClassMethod, isClassPrivateMethod, isClassPrivateProperty, isClassProperty, isCompletionStatement, isConditional, isConditionalExpression, isContinueStatement, isDebuggerStatement, isDecimalLiteral, isDeclaration, isDeclareClass, isDeclareExportAllDeclaration, isDeclareExportDeclaration, isDeclareFunction, isDeclareInterface, isDeclareModule, isDeclareModuleExports, isDeclareOpaqueType, isDeclareTypeAlias, isDeclareVariable, isDeclaredPredicate, isDecorator, isDirective, isDirectiveLiteral, isDoExpression, isDoWhileStatement, isEmptyStatement, isEmptyTypeAnnotation, isEnumBody, isEnumBooleanBody, isEnumBooleanMember, isEnumDeclaration, isEnumDefaultedMember, isEnumMember, isEnumNumberBody, isEnumNumberMember, isEnumStringBody, isEnumStringMember, isEnumSymbolBody, isExistsTypeAnnotation, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportDefaultSpecifier, isExportNamedDeclaration, isExportNamespaceSpecifier, isExportSpecifier, isExpression, isExpressionStatement, isExpressionWrapper, isFile, isFlow, isFlowBaseAnnotation, isFlowDeclaration, isFlowPredicate, isFlowType, isFor, isForInStatement, isForOfStatement, isForStatement, isForXStatement, isFunction, isFunctionDeclaration, isFunctionExpression, isFunctionParent, isFunctionTypeAnnotation, isFunctionTypeParam, isGenericTypeAnnotation, isIdentifier, isIfStatement, isImmutable, isImport, isImportAttribute, isImportDeclaration, isImportDefaultSpecifier, isImportNamespaceSpecifier, isImportSpecifier, isIndexedAccessType, isInferredPredicate, isInterfaceDeclaration, isInterfaceExtends, isInterfaceTypeAnnotation, isInterpreterDirective, isIntersectionTypeAnnotation, isJSX, isJSXAttribute, isJSXClosingElement, isJSXClosingFragment, isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXFragment, isJSXIdentifier, isJSXMemberExpression, isJSXNamespacedName, isJSXOpeningElement, isJSXOpeningFragment, isJSXSpreadAttribute, isJSXSpreadChild, isJSXText, isLVal, isLabeledStatement, isLet, isLiteral, isLogicalExpression, isLoop, isMemberExpression, isMetaProperty, isMethod, isMixedTypeAnnotation, isModuleDeclaration, isModuleExpression, isModuleSpecifier, isNewExpression, isNode, isNodesEquivalent, isNoop, isNullLiteral, isNullLiteralTypeAnnotation, isNullableTypeAnnotation, isNumberLiteral, isNumberLiteralTypeAnnotation, isNumberTypeAnnotation, isNumericLiteral, isObjectExpression, isObjectMember, isObjectMethod, isObjectPattern, isObjectProperty, isObjectTypeAnnotation, isObjectTypeCallProperty, isObjectTypeIndexer, isObjectTypeInternalSlot, isObjectTypeProperty, isObjectTypeSpreadProperty, isOpaqueType, isOptionalCallExpression, isOptionalIndexedAccessType, isOptionalMemberExpression, isParenthesizedExpression, isPattern, isPatternLike, isPipelineBareFunction, isPipelinePrimaryTopicReference, isPipelineTopicExpression, isPlaceholder, isPlaceholderType, isPrivate, isPrivateName, isProgram, isProperty, isPureish, isQualifiedTypeIdentifier, isRecordExpression, isReferenced, isRegExpLiteral, isRegexLiteral, isRestElement, isRestProperty, isReturnStatement, isScopable, isScope, isSequenceExpression, isSpecifierDefault, isSpreadElement, isSpreadProperty, isStatement, isStaticBlock, isStringLiteral, isStringLiteralTypeAnnotation, isStringTypeAnnotation, isSuper, isSwitchCase, isSwitchStatement, isSymbolTypeAnnotation, isTSAnyKeyword, isTSArrayType, isTSAsExpression, isTSBaseType, isTSBigIntKeyword, isTSBooleanKeyword, isTSCallSignatureDeclaration, isTSConditionalType, isTSConstructSignatureDeclaration, isTSConstructorType, isTSDeclareFunction, isTSDeclareMethod, isTSEntityName, isTSEnumDeclaration, isTSEnumMember, isTSExportAssignment, isTSExpressionWithTypeArguments, isTSExternalModuleReference, isTSFunctionType, isTSImportEqualsDeclaration, isTSImportType, isTSIndexSignature, isTSIndexedAccessType, isTSInferType, isTSInterfaceBody, isTSInterfaceDeclaration, isTSIntersectionType, isTSIntrinsicKeyword, isTSLiteralType, isTSMappedType, isTSMethodSignature, isTSModuleBlock, isTSModuleDeclaration, isTSNamedTupleMember, isTSNamespaceExportDeclaration, isTSNeverKeyword, isTSNonNullExpression, isTSNullKeyword, isTSNumberKeyword, isTSObjectKeyword, isTSOptionalType, isTSParameterProperty, isTSParenthesizedType, isTSPropertySignature, isTSQualifiedName, isTSRestType, isTSStringKeyword, isTSSymbolKeyword, isTSThisType, isTSTupleType, isTSType, isTSTypeAliasDeclaration, isTSTypeAnnotation, isTSTypeAssertion, isTSTypeElement, isTSTypeLiteral, isTSTypeOperator, isTSTypeParameter, isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isTSTypePredicate, isTSTypeQuery, isTSTypeReference, isTSUndefinedKeyword, isTSUnionType, isTSUnknownKeyword, isTSVoidKeyword, isTaggedTemplateExpression, isTemplateElement, isTemplateLiteral, isTerminatorless, isThisExpression, isThisTypeAnnotation, isThrowStatement, isTopicReference, isTryStatement, isTupleExpression, isTupleTypeAnnotation, isType, isTypeAlias, isTypeAnnotation, isTypeCastExpression, isTypeParameter, isTypeParameterDeclaration, isTypeParameterInstantiation, isTypeofTypeAnnotation, isUnaryExpression, isUnaryLike, isUnionTypeAnnotation, isUpdateExpression, isUserWhitespacable, isV8IntrinsicIdentifier, isValidES3Identifier, isValidIdentifier, isVar, isVariableDeclaration, isVariableDeclarator, isVariance, isVoidTypeAnnotation, isWhile, isWhileStatement, isWithStatement, isYieldExpression, jsxAttribute as jSXAttribute, jsxClosingElement as jSXClosingElement, jsxClosingFragment as jSXClosingFragment, jsxElement as jSXElement, jsxEmptyExpression as jSXEmptyExpression, jsxExpressionContainer as jSXExpressionContainer, jsxFragment as jSXFragment, jsxIdentifier as jSXIdentifier, jsxMemberExpression as jSXMemberExpression, jsxNamespacedName as jSXNamespacedName, jsxOpeningElement as jSXOpeningElement, jsxOpeningFragment as jSXOpeningFragment, jsxSpreadAttribute as jSXSpreadAttribute, jsxSpreadChild as jSXSpreadChild, jsxText as jSXText, jsxAttribute, jsxClosingElement, jsxClosingFragment, jsxElement, jsxEmptyExpression, jsxExpressionContainer, jsxFragment, jsxIdentifier, jsxMemberExpression, jsxNamespacedName, jsxOpeningElement, jsxOpeningFragment, jsxSpreadAttribute, jsxSpreadChild, jsxText, labeledStatement, logicalExpression, matchesPattern, memberExpression, metaProperty, mixedTypeAnnotation, moduleExpression, newExpression, noop, nullLiteral, nullLiteralTypeAnnotation, nullableTypeAnnotation, NumberLiteral as numberLiteral, numberLiteralTypeAnnotation, numberTypeAnnotation, numericLiteral, objectExpression, objectMethod, objectPattern, objectProperty, objectTypeAnnotation, objectTypeCallProperty, objectTypeIndexer, objectTypeInternalSlot, objectTypeProperty, objectTypeSpreadProperty, opaqueType, optionalCallExpression, optionalIndexedAccessType, optionalMemberExpression, parenthesizedExpression, pipelineBareFunction, pipelinePrimaryTopicReference, pipelineTopicExpression, placeholder, prependToMemberExpression, privateName, program, qualifiedTypeIdentifier, react, recordExpression, regExpLiteral, RegexLiteral as regexLiteral, removeComments, removeProperties, removePropertiesDeep, removeTypeDuplicates, restElement, RestProperty as restProperty, returnStatement, sequenceExpression, shallowEqual, spreadElement, SpreadProperty as spreadProperty, staticBlock, stringLiteral, stringLiteralTypeAnnotation, stringTypeAnnotation, _super as super, switchCase, switchStatement, symbolTypeAnnotation, tsAnyKeyword as tSAnyKeyword, tsArrayType as tSArrayType, tsAsExpression as tSAsExpression, tsBigIntKeyword as tSBigIntKeyword, tsBooleanKeyword as tSBooleanKeyword, tsCallSignatureDeclaration as tSCallSignatureDeclaration, tsConditionalType as tSConditionalType, tsConstructSignatureDeclaration as tSConstructSignatureDeclaration, tsConstructorType as tSConstructorType, tsDeclareFunction as tSDeclareFunction, tsDeclareMethod as tSDeclareMethod, tsEnumDeclaration as tSEnumDeclaration, tsEnumMember as tSEnumMember, tsExportAssignment as tSExportAssignment, tsExpressionWithTypeArguments as tSExpressionWithTypeArguments, tsExternalModuleReference as tSExternalModuleReference, tsFunctionType as tSFunctionType, tsImportEqualsDeclaration as tSImportEqualsDeclaration, tsImportType as tSImportType, tsIndexSignature as tSIndexSignature, tsIndexedAccessType as tSIndexedAccessType, tsInferType as tSInferType, tsInterfaceBody as tSInterfaceBody, tsInterfaceDeclaration as tSInterfaceDeclaration, tsIntersectionType as tSIntersectionType, tsIntrinsicKeyword as tSIntrinsicKeyword, tsLiteralType as tSLiteralType, tsMappedType as tSMappedType, tsMethodSignature as tSMethodSignature, tsModuleBlock as tSModuleBlock, tsModuleDeclaration as tSModuleDeclaration, tsNamedTupleMember as tSNamedTupleMember, tsNamespaceExportDeclaration as tSNamespaceExportDeclaration, tsNeverKeyword as tSNeverKeyword, tsNonNullExpression as tSNonNullExpression, tsNullKeyword as tSNullKeyword, tsNumberKeyword as tSNumberKeyword, tsObjectKeyword as tSObjectKeyword, tsOptionalType as tSOptionalType, tsParameterProperty as tSParameterProperty, tsParenthesizedType as tSParenthesizedType, tsPropertySignature as tSPropertySignature, tsQualifiedName as tSQualifiedName, tsRestType as tSRestType, tsStringKeyword as tSStringKeyword, tsSymbolKeyword as tSSymbolKeyword, tsThisType as tSThisType, tsTupleType as tSTupleType, tsTypeAliasDeclaration as tSTypeAliasDeclaration, tsTypeAnnotation as tSTypeAnnotation, tsTypeAssertion as tSTypeAssertion, tsTypeLiteral as tSTypeLiteral, tsTypeOperator as tSTypeOperator, tsTypeParameter as tSTypeParameter, tsTypeParameterDeclaration as tSTypeParameterDeclaration, tsTypeParameterInstantiation as tSTypeParameterInstantiation, tsTypePredicate as tSTypePredicate, tsTypeQuery as tSTypeQuery, tsTypeReference as tSTypeReference, tsUndefinedKeyword as tSUndefinedKeyword, tsUnionType as tSUnionType, tsUnknownKeyword as tSUnknownKeyword, tsVoidKeyword as tSVoidKeyword, taggedTemplateExpression, templateElement, templateLiteral, thisExpression, thisTypeAnnotation, throwStatement, toBindingIdentifierName, toBlock, toComputedKey, _default$3 as toExpression, toIdentifier, toKeyAlias, toSequenceExpression, _default$2 as toStatement, topicReference, traverse, traverseFast, tryStatement, tsAnyKeyword, tsArrayType, tsAsExpression, tsBigIntKeyword, tsBooleanKeyword, tsCallSignatureDeclaration, tsConditionalType, tsConstructSignatureDeclaration, tsConstructorType, tsDeclareFunction, tsDeclareMethod, tsEnumDeclaration, tsEnumMember, tsExportAssignment, tsExpressionWithTypeArguments, tsExternalModuleReference, tsFunctionType, tsImportEqualsDeclaration, tsImportType, tsIndexSignature, tsIndexedAccessType, tsInferType, tsInterfaceBody, tsInterfaceDeclaration, tsIntersectionType, tsIntrinsicKeyword, tsLiteralType, tsMappedType, tsMethodSignature, tsModuleBlock, tsModuleDeclaration, tsNamedTupleMember, tsNamespaceExportDeclaration, tsNeverKeyword, tsNonNullExpression, tsNullKeyword, tsNumberKeyword, tsObjectKeyword, tsOptionalType, tsParameterProperty, tsParenthesizedType, tsPropertySignature, tsQualifiedName, tsRestType, tsStringKeyword, tsSymbolKeyword, tsThisType, tsTupleType, tsTypeAliasDeclaration, tsTypeAnnotation, tsTypeAssertion, tsTypeLiteral, tsTypeOperator, tsTypeParameter, tsTypeParameterDeclaration, tsTypeParameterInstantiation, tsTypePredicate, tsTypeQuery, tsTypeReference, tsUndefinedKeyword, tsUnionType, tsUnknownKeyword, tsVoidKeyword, tupleExpression, tupleTypeAnnotation, typeAlias, typeAnnotation, typeCastExpression, typeParameter, typeParameterDeclaration, typeParameterInstantiation, typeofTypeAnnotation, unaryExpression, unionTypeAnnotation, updateExpression, v8IntrinsicIdentifier, validate, _default$1 as valueToNode, variableDeclaration, variableDeclarator, variance, voidTypeAnnotation, whileStatement, withStatement, yieldExpression };
Note: See TracBrowser for help on using the repository browser.