Debian Codegraph @

types-babel-types/index.d.ts

raw
1 // Type definitions for babel-types 7.0
2 // Project: https://github.com/babel/babel/tree/master/packages/babel-types, https://babeljs.io
3 // Definitions by: Troy Gerwien <https://github.com/yortus>
4 // Sam Baxter <https://github.com/baxtersa>
5 // Marvin Hagemeister <https://github.com/marvinhagemeister>
6 // Boris Cherny <https://github.com/bcherny>
7 // ExE Boss <https://github.com/ExE-Boss>
8 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
9
10 export interface Comment {
11 value: string;
12 start: number;
13 end: number;
14 loc: SourceLocation;
15 }
16
17 export interface CommentBlock extends Comment {
18 type: "CommentBlock";
19 }
20
21 export interface CommentLine extends Comment {
22 type: "CommentLine";
23 }
24
25 export interface SourceLocation {
26 start: {
27 line: number;
28 column: number;
29 };
30
31 end: {
32 line: number;
33 column: number;
34 };
35 }
36
37 export interface Node {
38 type: string;
39 leadingComments?: Comment[] | undefined;
40 innerComments?: Comment[] | undefined;
41 trailingComments?: Comment[] | undefined;
42 start: number;
43 end: number;
44 loc: SourceLocation;
45 }
46
47 export interface ArrayExpression extends Node {
48 type: "ArrayExpression";
49 elements: Array<null | Expression | SpreadElement>;
50 }
51
52 export interface AssignmentExpression extends Node {
53 type: "AssignmentExpression";
54 operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
55 left: LVal;
56 right: Expression;
57 }
58
59 export interface BinaryExpression extends Node {
60 type: "BinaryExpression";
61 operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
62 left: Expression;
63 right: Expression;
64 }
65
66 export interface Directive extends Node {
67 type: "Directive";
68 value: DirectiveLiteral;
69 }
70
71 export interface DirectiveLiteral extends Node {
72 type: "DirectiveLiteral";
73 value: string;
74 }
75
76 export interface BlockStatement extends Node {
77 type: "BlockStatement";
78 directives?: Directive[] | undefined;
79 body: Statement[];
80 }
81
82 export interface BreakStatement extends Node {
83 type: "BreakStatement";
84 label: Identifier;
85 }
86
87 export interface CallExpression extends Node {
88 type: "CallExpression";
89 callee: Expression | Super;
90 arguments: Array<Expression | SpreadElement>;
91 }
92
93 export interface CatchClause extends Node {
94 type: "CatchClause";
95 param: Identifier;
96 body: BlockStatement;
97 }
98
99 export interface ConditionalExpression extends Node {
100 type: "ConditionalExpression";
101 test: Expression;
102 consequent: Expression;
103 alternate: Expression;
104 }
105
106 export interface ContinueStatement extends Node {
107 type: "ContinueStatement";
108 label: Identifier;
109 }
110
111 export interface DebuggerStatement extends Node {
112 type: "DebuggerStatement";
113 }
114
115 export interface DoWhileStatement extends Node {
116 type: "DoWhileStatement";
117 test: Expression;
118 body: Statement;
119 }
120
121 export interface EmptyStatement extends Node {
122 type: "EmptyStatement";
123 }
124
125 export interface ExpressionStatement extends Node {
126 type: "ExpressionStatement";
127 expression: Expression;
128 }
129
130 export interface File extends Node {
131 type: "File";
132 program: Program;
133 comments: Comment[];
134 tokens: any[];
135 }
136
137 export interface ForInStatement extends Node {
138 type: "ForInStatement";
139 left: VariableDeclaration | LVal;
140 right: Expression;
141 body: Statement;
142 }
143
144 export interface ForStatement extends Node {
145 type: "ForStatement";
146 init: VariableDeclaration | Expression;
147 test: Expression;
148 update: Expression;
149 body: Statement;
150 }
151
152 export interface FunctionDeclaration extends Node {
153 type: "FunctionDeclaration";
154 id: Identifier;
155 params: LVal[];
156 body: BlockStatement;
157 generator: boolean;
158 async: boolean;
159 returnType?: TypeAnnotation | undefined;
160 typeParameters?: TypeParameterDeclaration | undefined;
161 }
162
163 export interface FunctionExpression extends Node {
164 type: "FunctionExpression";
165 id: Identifier;
166 params: LVal[];
167 body: BlockStatement;
168 generator: boolean;
169 async: boolean;
170 returnType?: TypeAnnotation | undefined;
171 typeParameters?: TypeParameterDeclaration | undefined;
172 }
173
174 export interface Identifier extends Node {
175 type: "Identifier";
176 name: string;
177 typeAnnotation?: TypeAnnotation | undefined;
178 }
179
180 export interface IfStatement extends Node {
181 type: "IfStatement";
182 test: Expression;
183 consequent: Statement;
184 alternate: Statement;
185 }
186
187 export interface LabeledStatement extends Node {
188 type: "LabeledStatement";
189 label: Identifier;
190 body: Statement;
191 }
192
193 export interface StringLiteral extends Node {
194 type: "StringLiteral";
195 value: string;
196 }
197
198 export interface NumericLiteral extends Node {
199 type: "NumericLiteral";
200 value: number;
201 }
202
203 export interface NullLiteral extends Node {
204 type: "NullLiteral";
205 }
206
207 export interface BooleanLiteral extends Node {
208 type: "BooleanLiteral";
209 value: boolean;
210 }
211
212 export interface RegExpLiteral extends Node {
213 type: "RegExpLiteral";
214 pattern: string;
215 flags?: string | undefined;
216 }
217
218 export interface LogicalExpression extends Node {
219 type: "LogicalExpression";
220 operator: "||" | "&&";
221 left: Expression;
222 right: Expression;
223 }
224
225 export interface MemberExpression extends Node {
226 type: "MemberExpression";
227 object: Expression | Super;
228 property: Expression;
229 computed: boolean;
230 }
231
232 export interface NewExpression extends Node {
233 type: "NewExpression";
234 callee: Expression | Super;
235 arguments: Array<Expression | SpreadElement>;
236 }
237
238 export interface Program extends Node {
239 type: "Program";
240 sourceType: "script" | "module";
241 directives?: Directive[] | undefined;
242 body: Array<Statement | ModuleDeclaration>;
243 }
244
245 export interface ObjectExpression extends Node {
246 type: "ObjectExpression";
247 properties: Array<ObjectProperty | ObjectMethod | SpreadProperty>;
248 }
249
250 export interface ObjectMethod extends Node {
251 type: "ObjectMethod";
252 key: Expression;
253 kind: "get" | "set" | "method";
254 shorthand: boolean;
255 computed: boolean;
256 value: Expression;
257 decorators?: Decorator[] | undefined;
258 id: Identifier;
259 params: LVal[];
260 body: BlockStatement;
261 generator: boolean;
262 async: boolean;
263 returnType?: TypeAnnotation | undefined;
264 typeParameters?: TypeParameterDeclaration | undefined;
265 }
266
267 export interface ObjectProperty extends Node {
268 type: "ObjectProperty";
269 key: Expression;
270 computed: boolean;
271 value: Expression;
272 decorators?: Decorator[] | undefined;
273 shorthand: boolean;
274 }
275
276 export interface RestElement extends Node {
277 type: "RestElement";
278 argument: LVal;
279 typeAnnotation?: TypeAnnotation | undefined;
280 }
281
282 export interface ReturnStatement extends Node {
283 type: "ReturnStatement";
284 argument: Expression;
285 }
286
287 export interface SequenceExpression extends Node {
288 type: "SequenceExpression";
289 expressions: Expression[];
290 }
291
292 export interface SwitchCase extends Node {
293 type: "SwitchCase";
294 test: Expression;
295 consequent: Statement[];
296 }
297
298 export interface SwitchStatement extends Node {
299 type: "SwitchStatement";
300 discriminant: Expression;
301 cases: SwitchCase[];
302 }
303
304 export interface ThisExpression extends Node {
305 type: "ThisExpression";
306 }
307
308 export interface ThrowStatement extends Node {
309 type: "ThrowStatement";
310 argument: Expression;
311 }
312
313 export interface TryStatement extends Node {
314 type: "TryStatement";
315 block: BlockStatement;
316 handler: CatchClause;
317 finalizer: BlockStatement;
318 }
319
320 export interface UnaryExpression extends Node {
321 type: "UnaryExpression";
322 operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
323 prefix: boolean;
324 argument: Expression;
325 }
326
327 export interface UpdateExpression extends Node {
328 type: "UpdateExpression";
329 operator: "++" | "--";
330 prefix: boolean;
331 argument: Expression;
332 }
333
334 export interface VariableDeclaration extends Node {
335 type: "VariableDeclaration";
336 declarations: VariableDeclarator[];
337 kind: "var" | "let" | "const";
338 }
339
340 export interface VariableDeclarator extends Node {
341 type: "VariableDeclarator";
342 id: LVal;
343 init: Expression;
344 }
345
346 export interface WhileStatement extends Node {
347 type: "WhileStatement";
348 test: Expression;
349 body: Statement;
350 }
351
352 export interface WithStatement extends Node {
353 type: "WithStatement";
354 object: Expression;
355 body: BlockStatement | Statement;
356 }
357
358 export interface AssignmentPattern extends Node {
359 type: "AssignmentPattern";
360 left: Identifier;
361 right: Expression;
362 }
363
364 export interface ArrayPattern extends Node {
365 type: "ArrayPattern";
366 elements: Expression[];
367 typeAnnotation?: TypeAnnotation | undefined;
368 }
369
370 export interface ArrowFunctionExpression extends Node {
371 type: "ArrowFunctionExpression";
372 id: Identifier;
373 params: LVal[];
374 body: BlockStatement | Expression;
375 generator: boolean;
376 async: boolean;
377 expression: boolean;
378 returnType?: TypeAnnotation | undefined;
379 typeParameters?: TypeParameterDeclaration | undefined;
380 }
381
382 export interface ClassBody extends Node {
383 type: "ClassBody";
384 body: Array<ClassMethod | ClassProperty>;
385 }
386
387 export interface ClassDeclaration extends Node {
388 type: "ClassDeclaration";
389 id: Identifier;
390 superClass: Expression;
391 body: ClassBody;
392 decorators?: Decorator[] | undefined;
393 implements?: ClassImplements[] | undefined;
394 mixins?: any[] | undefined;
395 typeParameters?: TypeParameterDeclaration | undefined;
396 superTypeParameters?: TypeParameterInstantiation | undefined;
397 }
398
399 export interface ClassExpression extends Node {
400 type: "ClassExpression";
401 id: Identifier;
402 superClass: Expression;
403 body: ClassBody;
404 decorators?: Decorator[] | undefined;
405 implements?: ClassImplements[] | undefined;
406 mixins?: any[] | undefined;
407 typeParameters?: TypeParameterDeclaration | undefined;
408 superTypeParameters?: TypeParameterInstantiation | undefined;
409 }
410
411 export interface ExportAllDeclaration extends Node {
412 type: "ExportAllDeclaration";
413 source: StringLiteral;
414 }
415
416 export interface ExportDefaultDeclaration extends Node {
417 type: "ExportDefaultDeclaration";
418 declaration: Declaration | Expression;
419 }
420
421 export interface ExportNamedDeclaration extends Node {
422 type: "ExportNamedDeclaration";
423 declaration: Declaration;
424 specifiers: ExportSpecifier[];
425 source: StringLiteral | null;
426 }
427
428 export interface ExportSpecifier extends Node {
429 type: "ExportSpecifier";
430 local: Identifier;
431 imported: Identifier;
432 exported: Identifier;
433 }
434
435 export interface ForOfStatement extends Node {
436 type: "ForOfStatement";
437 left: VariableDeclaration | LVal;
438 right: Expression;
439 body: Statement;
440 }
441
442 export interface ImportDeclaration extends Node {
443 type: "ImportDeclaration";
444 specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
445 source: StringLiteral;
446 }
447
448 export interface ImportDefaultSpecifier extends Node {
449 type: "ImportDefaultSpecifier";
450 local: Identifier;
451 }
452
453 export interface ImportNamespaceSpecifier extends Node {
454 type: "ImportNamespaceSpecifier";
455 local: Identifier;
456 }
457
458 export interface ImportSpecifier extends Node {
459 type: "ImportSpecifier";
460 local: Identifier;
461 imported: Identifier;
462 }
463
464 export interface MetaProperty extends Node {
465 type: "MetaProperty";
466 meta: Identifier;
467 property: Identifier;
468 }
469
470 export interface ClassMethod extends Node {
471 type: "ClassMethod";
472 key: Expression;
473 value?: FunctionExpression | undefined;
474 kind: "constructor" | "method" | "get" | "set";
475 computed: boolean;
476 static: boolean;
477 decorators?: Decorator[] | undefined;
478 id: Identifier;
479 params: LVal[];
480 body: BlockStatement;
481 generator: boolean;
482 async: boolean;
483 expression: boolean;
484 returnType?: TypeAnnotation | undefined;
485 typeParameters?: TypeParameterDeclaration | undefined;
486 }
487
488 // See: https://github.com/babel/babel/blob/master/doc/ast/spec.md#objectpattern
489 export interface AssignmentProperty extends Node {
490 type: "ObjectProperty";
491 key: Expression;
492 computed: boolean;
493 value: Pattern;
494 decorators?: Decorator[] | undefined;
495 shorthand: boolean;
496 }
497
498 export interface ObjectPattern extends Node {
499 type: "ObjectPattern";
500 properties: Array<AssignmentProperty | RestProperty>;
501 typeAnnotation?: TypeAnnotation | undefined;
502 }
503
504 export interface SpreadElement extends Node {
505 type: "SpreadElement";
506 argument: Expression;
507 }
508
509 export interface Super extends Node {
510 type: "Super";
511 }
512
513 export interface TaggedTemplateExpression extends Node {
514 type: "TaggedTemplateExpression";
515 tag: Expression;
516 quasi: TemplateLiteral;
517 }
518
519 export interface TemplateElement extends Node {
520 type: "TemplateElement";
521 tail: boolean;
522 value: {
523 cooked: string;
524 raw: string;
525 };
526 }
527
528 export interface TemplateLiteral extends Node {
529 type: "TemplateLiteral";
530 quasis: TemplateElement[];
531 expressions: Expression[];
532 }
533
534 export interface YieldExpression extends Node {
535 type: "YieldExpression";
536 argument: Expression;
537 delegate: boolean;
538 }
539
540 export interface AnyTypeAnnotation extends Node {
541 type: "AnyTypeAnnotation";
542 }
543
544 export interface ArrayTypeAnnotation extends Node {
545 type: "ArrayTypeAnnotation";
546 elementType: FlowTypeAnnotation;
547 }
548
549 export interface BooleanTypeAnnotation extends Node {
550 type: "BooleanTypeAnnotation";
551 }
552
553 export interface BooleanLiteralTypeAnnotation extends Node {
554 type: "BooleanLiteralTypeAnnotation";
555 }
556
557 export interface NullLiteralTypeAnnotation extends Node {
558 type: "NullLiteralTypeAnnotation";
559 }
560
561 export interface ClassImplements extends Node {
562 type: "ClassImplements";
563 id: Identifier;
564 typeParameters: TypeParameterInstantiation;
565 }
566
567 export interface ClassProperty extends Node {
568 type: "ClassProperty";
569 key: Identifier;
570 value: Expression;
571 decorators?: Decorator[] | undefined;
572 typeAnnotation?: TypeAnnotation | undefined;
573 }
574
575 export interface DeclareClass extends Node {
576 type: "DeclareClass";
577 id: Identifier;
578 typeParameters: TypeParameterDeclaration;
579 extends: InterfaceExtends[];
580 body: ObjectTypeAnnotation;
581 }
582
583 export interface DeclareFunction extends Node {
584 type: "DeclareFunction";
585 id: Identifier;
586 }
587
588 export interface DeclareInterface extends Node {
589 type: "DeclareInterface";
590 id: Identifier;
591 typeParameters: TypeParameterDeclaration;
592 extends: InterfaceExtends[];
593 body: ObjectTypeAnnotation;
594 }
595
596 export interface DeclareModule extends Node {
597 type: "DeclareModule";
598 id: StringLiteral | Identifier;
599 body: BlockStatement;
600 }
601
602 export interface DeclareTypeAlias extends Node {
603 type: "DeclareTypeAlias";
604 id: Identifier;
605 typeParameters: TypeParameterDeclaration;
606 right: FlowTypeAnnotation;
607 }
608
609 export interface DeclareVariable extends Node {
610 type: "DeclareVariable";
611 id: Identifier;
612 }
613
614 export interface ExistentialTypeParam extends Node {
615 type: "ExistentialTypeParam";
616 }
617
618 export interface FunctionTypeAnnotation extends Node {
619 type: "FunctionTypeAnnotation";
620 typeParameters: TypeParameterDeclaration;
621 params: FunctionTypeParam[];
622 rest: FunctionTypeParam;
623 returnType: FlowTypeAnnotation;
624 }
625
626 export interface FunctionTypeParam extends Node {
627 type: "FunctionTypeParam";
628 name: Identifier;
629 typeAnnotation: FlowTypeAnnotation;
630 }
631
632 export interface GenericTypeAnnotation extends Node {
633 type: "GenericTypeAnnotation";
634 id: Identifier;
635 typeParameters: TypeParameterInstantiation;
636 }
637
638 export interface InterfaceExtends extends Node {
639 type: "InterfaceExtends";
640 id: Identifier;
641 typeParameters: TypeParameterInstantiation;
642 }
643
644 export interface InterfaceDeclaration extends Node {
645 type: "InterfaceDeclaration";
646 id: Identifier;
647 typeParameters: TypeParameterDeclaration;
648 extends: InterfaceExtends[];
649 mixins?: any[] | undefined;
650 body: ObjectTypeAnnotation;
651 }
652
653 export interface IntersectionTypeAnnotation extends Node {
654 type: "IntersectionTypeAnnotation";
655 types: FlowTypeAnnotation[];
656 }
657
658 export interface MixedTypeAnnotation extends Node {
659 type: "MixedTypeAnnotation";
660 }
661
662 export interface NullableTypeAnnotation extends Node {
663 type: "NullableTypeAnnotation";
664 typeAnnotation: FlowTypeAnnotation;
665 }
666
667 export interface NumericLiteralTypeAnnotation extends Node {
668 type: "NumericLiteralTypeAnnotation";
669 }
670
671 export interface NumberTypeAnnotation extends Node {
672 type: "NumberTypeAnnotation";
673 }
674
675 export interface StringLiteralTypeAnnotation extends Node {
676 type: "StringLiteralTypeAnnotation";
677 }
678
679 export interface StringTypeAnnotation extends Node {
680 type: "StringTypeAnnotation";
681 }
682
683 export interface ThisTypeAnnotation extends Node {
684 type: "ThisTypeAnnotation";
685 }
686
687 export interface TupleTypeAnnotation extends Node {
688 type: "TupleTypeAnnotation";
689 types: FlowTypeAnnotation[];
690 }
691
692 export interface TypeofTypeAnnotation extends Node {
693 type: "TypeofTypeAnnotation";
694 argument: FlowTypeAnnotation;
695 }
696
697 export interface TypeAlias extends Node {
698 type: "TypeAlias";
699 id: Identifier;
700 typeParameters: TypeParameterDeclaration;
701 right: FlowTypeAnnotation;
702 }
703
704 export interface TypeAnnotation extends Node {
705 type: "TypeAnnotation";
706 typeAnnotation: FlowTypeAnnotation;
707 }
708
709 export interface TypeCastExpression extends Node {
710 type: "TypeCastExpression";
711 expression: Expression;
712 typeAnnotation: FlowTypeAnnotation;
713 }
714
715 export interface TypeParameter extends Node {
716 type: "TypeParameterDeclaration";
717 bound: TypeAnnotation | null;
718 default: Flow | null;
719 name: string | null;
720 }
721
722 export interface TypeParameterDeclaration extends Node {
723 type: "TypeParameterDeclaration";
724 params: Identifier[];
725 }
726
727 export interface TypeParameterInstantiation extends Node {
728 type: "TypeParameterInstantiation";
729 params: FlowTypeAnnotation[];
730 }
731
732 export interface ObjectTypeAnnotation extends Node {
733 type: "ObjectTypeAnnotation";
734 properties: ObjectTypeProperty[];
735 indexers: ObjectTypeIndexer[];
736 callProperties: ObjectTypeCallProperty[];
737 }
738
739 export interface ObjectTypeCallProperty extends Node {
740 type: "ObjectTypeCallProperty";
741 value: FlowTypeAnnotation;
742 }
743
744 export interface ObjectTypeIndexer extends Node {
745 type: "ObjectTypeIndexer";
746 id: Expression;
747 key: FlowTypeAnnotation;
748 value: FlowTypeAnnotation;
749 }
750
751 export interface ObjectTypeProperty extends Node {
752 type: "ObjectTypeProperty";
753 key: Expression;
754 value: FlowTypeAnnotation;
755 }
756
757 export interface QualifiedTypeIdentifier extends Node {
758 type: "QualifiedTypeIdentifier";
759 id: Identifier;
760 qualification: Identifier | QualifiedTypeIdentifier;
761 }
762
763 export interface UnionTypeAnnotation extends Node {
764 type: "UnionTypeAnnotation";
765 types: FlowTypeAnnotation[];
766 }
767
768 export interface VoidTypeAnnotation extends Node {
769 type: "VoidTypeAnnotation";
770 }
771
772 export interface JSXAttribute extends Node {
773 type: "JSXAttribute";
774 name: JSXIdentifier | JSXNamespacedName;
775 value: JSXElement | StringLiteral | JSXExpressionContainer | null;
776 }
777
778 export interface JSXClosingElement extends Node {
779 type: "JSXClosingElement";
780 name: JSXIdentifier | JSXMemberExpression;
781 }
782
783 export interface JSXElement extends Node {
784 type: "JSXElement";
785 openingElement: JSXOpeningElement;
786 closingElement: JSXClosingElement;
787 children: Array<JSXElement | JSXExpressionContainer | JSXText>;
788 selfClosing?: boolean | undefined;
789 }
790
791 export interface JSXEmptyExpression extends Node {
792 type: "JSXEmptyExpression";
793 }
794
795 export interface JSXExpressionContainer extends Node {
796 type: "JSXExpressionContainer";
797 expression: Expression;
798 }
799
800 export interface JSXIdentifier extends Node {
801 type: "JSXIdentifier";
802 name: string;
803 }
804
805 export interface JSXMemberExpression extends Node {
806 type: "JSXMemberExpression";
807 object: JSXMemberExpression | JSXIdentifier;
808 property: JSXIdentifier;
809 }
810
811 export interface JSXNamespacedName extends Node {
812 type: "JSXNamespacedName";
813 namespace: JSXIdentifier;
814 name: JSXIdentifier;
815 }
816
817 export interface JSXOpeningElement extends Node {
818 type: "JSXOpeningElement";
819 name: JSXIdentifier | JSXMemberExpression;
820 selfClosing: boolean;
821 attributes: JSXAttribute[];
822 }
823
824 export interface JSXSpreadAttribute extends Node {
825 type: "JSXSpreadAttribute";
826 argument: Expression;
827 }
828
829 export interface JSXText extends Node {
830 type: "JSXText";
831 value: string;
832 }
833
834 export interface Noop extends Node {
835 type: "Noop";
836 }
837
838 export interface ParenthesizedExpression extends Node {
839 type: "ParenthesizedExpression";
840 expression: Expression;
841 }
842
843 export interface AwaitExpression extends Node {
844 type: "AwaitExpression";
845 argument: Expression;
846 }
847
848 export interface BindExpression extends Node {
849 type: "BindExpression";
850 object: Expression;
851 callee: Expression;
852 }
853
854 export interface Decorator extends Node {
855 type: "Decorator";
856 expression: Expression;
857 }
858
859 export interface DoExpression extends Node {
860 type: "DoExpression";
861 body: BlockStatement;
862 }
863
864 export interface ExportDefaultSpecifier extends Node {
865 type: "ExportDefaultSpecifier";
866 exported: Identifier;
867 }
868
869 export interface ExportNamespaceSpecifier extends Node {
870 type: "ExportNamespaceSpecifier";
871 exported: Identifier;
872 }
873
874 export interface RestProperty extends Node {
875 type: "RestProperty";
876 argument: LVal;
877 }
878
879 export interface SpreadProperty extends Node {
880 type: "SpreadProperty";
881 argument: Expression;
882 }
883
884 export interface TSAnyKeyword extends Node {
885 type: "TSAnyKeyword";
886 }
887
888 export interface TSArrayType extends Node {
889 type: "TSArrayType";
890 elementType: TSType;
891 }
892
893 export interface TSAsExpression extends Node {
894 type: "TSAsExpression";
895 expression: Expression;
896 typeAnnotation: TSType;
897 }
898
899 export interface TSBooleanKeyword extends Node {
900 type: "TSBooleanKeyword";
901 }
902
903 export interface TSCallSignatureDeclaration extends Node {
904 type: "TSCallSignatureDeclaration";
905 typeParameters: TypeParameterDeclaration | null;
906 parameters: Array<Identifier | RestElement> | null;
907 typeAnnotation: TSTypeAnnotation | null;
908 }
909
910 export interface TSConstructSignatureDeclaration extends Node {
911 type: "TSConstructSignatureDeclaration";
912 typeParameters: TypeParameterDeclaration | null;
913 parameters: Array<Identifier | RestElement> | null;
914 typeAnnotation: TSTypeAnnotation | null;
915 }
916
917 export interface TSConstructorType extends Node {
918 type: "TSConstructorType";
919 typeParameters: TypeParameterDeclaration | null;
920 typeAnnotation: TSTypeAnnotation | null;
921 parameters: Array<Identifier | RestElement> | null;
922 }
923
924 export interface TSDeclareFunction extends Node {
925 type: "TSDeclareFunction";
926 id: Identifier | null;
927 typeParameters: TypeParameterDeclaration | Noop | null;
928 params: LVal[];
929 returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
930 async: boolean;
931 declare: boolean | null;
932 generator: boolean;
933 }
934
935 export interface TSDeclareMethod extends Node {
936 type: "TSDeclareMethod";
937 decorators: Decorator[] | null;
938 key: Expression;
939 typeParameters: TypeParameterDeclaration | Noop | null;
940 params: LVal[];
941 returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
942 abstract: boolean | null;
943 access: "public" | "private" | "protected" | null;
944 accessibility: "public" | "private" | "protected" | null;
945 async: boolean;
946 computed: boolean;
947 generator: boolean;
948 kind: "get" | "set" | "method" | "constructor";
949 optional: boolean | null;
950 static: boolean | null;
951 }
952
953 export interface TSEnumDeclaration extends Node {
954 type: "TSEnumDeclaration";
955 id: Identifier;
956 members: TSEnumMember[];
957 const: boolean | null;
958 declare: boolean | null;
959 initializer: Expression | null;
960 }
961
962 export interface TSEnumMember extends Node {
963 type: "TSEnumMember";
964 id: Identifier | StringLiteral;
965 initializer: Expression | null;
966 }
967
968 export interface TSExportAssignment extends Node {
969 type: "TSExportAssignment";
970 expression: Expression;
971 }
972
973 export interface TSExpressionWithTypeArguments extends Node {
974 type: "TSExpressionWithTypeArguments";
975 expression: TSEntityName;
976 typeParameters: TypeParameterInstantiation | null;
977 }
978
979 export interface TSExternalModuleReference extends Node {
980 type: "TSExternalModuleReference";
981 expression: StringLiteral;
982 }
983
984 export interface TSFunctionType extends Node {
985 type: "TSFunctionType";
986 typeParameters: TypeParameterDeclaration | null;
987 typeAnnotation: TSTypeAnnotation | null;
988 parameters: Array<Identifier | RestElement> | null;
989 }
990
991 export interface TSImportEqualsDeclaration extends Node {
992 type: "TSImportEqualsDeclaration";
993 id: Identifier;
994 moduleReference: TSEntityName | TSExternalModuleReference;
995 isExport: boolean | null;
996 }
997
998 export interface TSIndexSignature extends Node {
999 type: "TSIndexSignature";
1000 parameters: Identifier[];
1001 typeAnnotation: TSTypeAnnotation | null;
1002 readonly: boolean | null;
1003 }
1004
1005 export interface TSIndexedAccessType extends Node {
1006 type: "TSIndexedAccessType";
1007 objectType: TSType;
1008 indexType: TSType;
1009 }
1010
1011 export interface TSInterfaceBody extends Node {
1012 type: "TSInterfaceBody";
1013 body: TSTypeElement[];
1014 }
1015
1016 export interface TSInterfaceDeclaration extends Node {
1017 type: "TSInterfaceDeclaration";
1018 id: Identifier;
1019 typeParameters: TypeParameterDeclaration | null;
1020 extends: TSExpressionWithTypeArguments[] | null;
1021 body: TSInterfaceBody;
1022 declare: boolean | null;
1023 }
1024
1025 export interface TSIntersectionType extends Node {
1026 type: "TSIntersectionType";
1027 types: TSType[];
1028 }
1029
1030 export interface TSLiteralType extends Node {
1031 type: "TSLiteralType";
1032 literal: NumericLiteral | StringLiteral | BooleanLiteral;
1033 }
1034
1035 export interface TSMappedType extends Node {
1036 type: "TSMappedType";
1037 typeParameter: TypeParameter;
1038 typeAnnotation: TSType | null;
1039 optional: boolean | null;
1040 readonly: boolean | null;
1041 }
1042
1043 export interface TSMethodSignature extends Node {
1044 type: "TSMethodSignature";
1045 key: Expression;
1046 typeParameters: TypeParameterDeclaration | null;
1047 parameters: Array<Identifier | RestElement> | null;
1048 typeAnnotation: TSTypeAnnotation | null;
1049 computed: boolean | null;
1050 optional: boolean | null;
1051 }
1052
1053 export interface TSModuleBlock extends Node {
1054 type: "TSModuleBlock";
1055 body: Statement[];
1056 }
1057
1058 export interface TSModuleDeclaration extends Node {
1059 type: "TSModuleDeclaration";
1060 id: Identifier | StringLiteral;
1061 body: TSModuleBlock | TSModuleDeclaration;
1062 declare: boolean | null;
1063 global: boolean | null;
1064 }
1065
1066 export interface TSNamespaceExportDeclaration extends Node {
1067 type: "TSNamespaceExportDeclaration";
1068 id: Identifier;
1069 }
1070
1071 export interface TSNeverKeyword extends Node {
1072 type: "TSNeverKeyword";
1073 }
1074
1075 export interface TSNonNullExpression extends Node {
1076 type: "TSNonNullExpression";
1077 expression: Expression;
1078 }
1079
1080 export interface TSNullKeyword extends Node {
1081 type: "TSNullKeyword";
1082 }
1083
1084 export interface TSNumberKeyword extends Node {
1085 type: "TSNumberKeyword";
1086 }
1087
1088 export interface TSObjectKeyword extends Node {
1089 type: "TSObjectKeyword";
1090 }
1091
1092 export interface TSParameterProperty extends Node {
1093 type: "TSParameterProperty";
1094 parameter: Identifier | AssignmentPattern;
1095 accessibility: 'public' | 'private' | 'protected' | null;
1096 readonly: boolean | null;
1097 }
1098
1099 export interface TSParenthesizedType extends Node {
1100 type: "TSParenthesizedType";
1101 typeAnnotation: TSType;
1102 }
1103
1104 export interface TSPropertySignature extends Node {
1105 type: "TSPropertySignature";
1106 key: Expression;
1107 typeAnnotation: TSTypeAnnotation | null;
1108 initializer: Expression | null;
1109 computed: boolean | null;
1110 optional: boolean | null;
1111 readonly: boolean | null;
1112 }
1113
1114 export interface TSQualifiedName extends Node {
1115 type: "TSQualifiedName";
1116 left: TSEntityName;
1117 right: Identifier;
1118 }
1119
1120 export interface TSStringKeyword extends Node {
1121 type: "TSStringKeyword";
1122 }
1123
1124 export interface TSSymbolKeyword extends Node {
1125 type: "TSSymbolKeyword";
1126 }
1127
1128 export interface TSThisType extends Node {
1129 type: "TSThisType";
1130 }
1131
1132 export interface TSTupleType extends Node {
1133 type: "TSTupleType";
1134 elementTypes: TSType[];
1135 }
1136
1137 export interface TSTypeAliasDeclaration extends Node {
1138 type: "TSTypeAliasDeclaration";
1139 id: Identifier;
1140 typeParameters: TypeParameterDeclaration | null;
1141 typeAnnotation: TSType;
1142 declare: boolean | null;
1143 }
1144
1145 export interface TSTypeAnnotation extends Node {
1146 type: "TSTypeAnnotation";
1147 typeAnnotation: TSType;
1148 }
1149
1150 export interface TSTypeAssertion extends Node {
1151 type: "TSTypeAssertion";
1152 typeAnnotation: TSType;
1153 expression: Expression;
1154 }
1155
1156 export interface TSTypeLiteral extends Node {
1157 type: "TSTypeLiteral";
1158 members: TSTypeElement[];
1159 }
1160
1161 export interface TSTypeOperator extends Node {
1162 type: "TSTypeOperator";
1163 typeAnnotation: TSType;
1164 operator: string | null;
1165 }
1166
1167 export interface TSTypeParameter extends Node {
1168 type: "TSTypeParameter";
1169 constraint: TSType | null;
1170 default: TSType | null;
1171 name: string | null;
1172 }
1173
1174 export interface TSTypeParameterDeclaration extends Node {
1175 type: "TSTypeParameterDeclaration";
1176 params: TSTypeParameter[];
1177 }
1178
1179 export interface TSTypeParameterInstantiation extends Node {
1180 type: "TSTypeParameterInstantiation";
1181 params: TSType[];
1182 }
1183
1184 export interface TSTypePredicate extends Node {
1185 type: "TSTypePredicate";
1186 parameterName: Identifier | TSThisType;
1187 typeAnnotation: TSTypeAnnotation;
1188 }
1189
1190 export interface TSTypeQuery extends Node {
1191 type: "TSTypeQuery";
1192 exprName: TSEntityName;
1193 }
1194
1195 export interface TSTypeReference extends Node {
1196 type: "TSTypeReference";
1197 typeName: TSEntityName;
1198 typeParameters: TypeParameterInstantiation | null;
1199 }
1200
1201 export interface TSUndefinedKeyword extends Node {
1202 type: "TSUndefinedKeyword";
1203 }
1204
1205 export interface TSUnionType extends Node {
1206 type: "TSUnionType";
1207 types: TSType[];
1208 }
1209
1210 export interface TSVoidKeyword extends Node {
1211 type: "TSVoidKeyword";
1212 }
1213
1214 export type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression
1215 | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | BooleanLiteral
1216 | NullLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression
1217 | SequenceExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression
1218 | ClassExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression
1219 | TypeCastExpression | JSXElement | JSXEmptyExpression | JSXIdentifier | JSXMemberExpression
1220 | ParenthesizedExpression | AwaitExpression | BindExpression | DoExpression | TSAsExpression
1221 | TSNonNullExpression | TSTypeAssertion;
1222
1223 export type Binary = BinaryExpression | LogicalExpression;
1224
1225 export type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement
1226 | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement
1227 | ArrowFunctionExpression | ClassDeclaration | ClassExpression | ForOfStatement | ClassMethod;
1228
1229 export type BlockParent = BlockStatement | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration
1230 | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression
1231 | ForOfStatement | ClassMethod;
1232
1233 export type Block = BlockStatement | Program;
1234
1235 export type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement
1236 | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement
1237 | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration
1238 | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration
1239 | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface
1240 | DeclareModule | DeclareTypeAlias | DeclareVariable | InterfaceDeclaration | TypeAlias | TSDeclareFunction
1241 | TSEnumDeclaration | TSExportAssignment | TSImportEqualsDeclaration | TSInterfaceDeclaration
1242 | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration;
1243
1244 export type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression;
1245 export type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement;
1246 export type Conditional = ConditionalExpression | IfStatement;
1247 export type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement;
1248 export type While = DoWhileStatement | WhileStatement;
1249 export type ExpressionWrapper = ExpressionStatement | TypeCastExpression | ParenthesizedExpression;
1250 export type For = ForInStatement | ForStatement | ForOfStatement;
1251 export type ForXStatement = ForInStatement | ForOfStatement;
1252 export type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod;
1253 export type FunctionParent = FunctionDeclaration | FunctionExpression | Program | ObjectMethod | ArrowFunctionExpression | ClassMethod;
1254 export type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral | ArrowFunctionExpression | ClassDeclaration | ClassExpression;
1255
1256 export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration
1257 | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction
1258 | DeclareInterface | DeclareModule | DeclareTypeAlias | DeclareVariable | InterfaceDeclaration | TypeAlias
1259 | TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration;
1260
1261 export type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern
1262 | TSParameterProperty;
1263 export type Literal = StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral | RegExpLiteral | TemplateLiteral;
1264 export type Immutable = StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXOpeningElement;
1265 export type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty;
1266 export type Method = ObjectMethod | ClassMethod;
1267 export type ObjectMember = ObjectMethod | ObjectProperty;
1268 export type Property = ObjectProperty | ClassProperty;
1269 export type UnaryLike = UnaryExpression | SpreadElement | RestProperty | SpreadProperty;
1270 export type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern;
1271 export type Class = ClassDeclaration | ClassExpression;
1272 export type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration;
1273 export type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration;
1274 export type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier;
1275
1276 export type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation
1277 | ClassImplements | ClassProperty | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule
1278 | DeclareTypeAlias | DeclareVariable | ExistentialTypeParam | FunctionTypeAnnotation | FunctionTypeParam
1279 | GenericTypeAnnotation | InterfaceExtends | InterfaceDeclaration | IntersectionTypeAnnotation
1280 | MixedTypeAnnotation | NullableTypeAnnotation | NumericLiteralTypeAnnotation | NumberTypeAnnotation
1281 | StringLiteralTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation
1282 | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameterDeclaration
1283 | TypeParameterInstantiation | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer
1284 | ObjectTypeProperty | QualifiedTypeIdentifier | UnionTypeAnnotation | VoidTypeAnnotation;
1285
1286 export type FlowTypeAnnotation = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation
1287 | BooleanLiteralTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | IntersectionTypeAnnotation
1288 | MixedTypeAnnotation | NullableTypeAnnotation | NumericLiteralTypeAnnotation | NumberTypeAnnotation
1289 | StringLiteralTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation
1290 | TypeofTypeAnnotation | TypeAnnotation | ObjectTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation;
1291
1292 export type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | MixedTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation;
1293 export type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareTypeAlias | DeclareVariable | InterfaceDeclaration | TypeAlias;
1294
1295 export type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer
1296 | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText;
1297
1298 export type TSType = TSAnyKeyword | TSArrayType | TSBooleanKeyword | TSConstructorType | TSExpressionWithTypeArguments
1299 | TSFunctionType | TSIndexedAccessType | TSIntersectionType | TSLiteralType | TSMappedType | TSNeverKeyword
1300 | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSParenthesizedType | TSStringKeyword | TSSymbolKeyword
1301 | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypePredicate | TSTypeQuery | TSTypeReference
1302 | TSUndefinedKeyword | TSUnionType | TSVoidKeyword;
1303
1304 export type TSEntityName = Identifier | TSQualifiedName;
1305
1306 export type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature
1307 | TSMethodSignature | TSPropertySignature;
1308
1309 export function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
1310 export function assignmentExpression(operator?: string, left?: LVal, right?: Expression): AssignmentExpression;
1311 export function binaryExpression(
1312 operator?: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=",
1313 left?: Expression,
1314 right?: Expression
1315 ): BinaryExpression;
1316 export function directive(value?: DirectiveLiteral): Directive;
1317 export function directiveLiteral(value?: string): DirectiveLiteral;
1318 export function blockStatement(body?: Statement[], directives?: Directive[]): BlockStatement;
1319 export function breakStatement(label?: Identifier): BreakStatement;
1320 export function callExpression(callee?: Expression, _arguments?: Array<Expression | SpreadElement>): CallExpression;
1321 export function catchClause(param?: Identifier, body?: BlockStatement): CatchClause;
1322 export function conditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression;
1323 export function continueStatement(label?: Identifier): ContinueStatement;
1324 export function debuggerStatement(): DebuggerStatement;
1325 export function doWhileStatement(test?: Expression, body?: Statement): DoWhileStatement;
1326 export function emptyStatement(): EmptyStatement;
1327 export function expressionStatement(expression?: Expression): ExpressionStatement;
1328 export function file(program?: Program, comments?: Comment[], tokens?: any[]): File;
1329 export function forInStatement(left?: VariableDeclaration | LVal, right?: Expression, body?: Statement): ForInStatement;
1330 export function forStatement(init?: VariableDeclaration | Expression, test?: Expression, update?: Expression, body?: Statement): ForStatement;
1331 export function functionDeclaration(id?: Identifier, params?: LVal[], body?: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
1332 export function functionExpression(id?: Identifier, params?: LVal[], body?: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
1333 export function identifier(name?: string): Identifier;
1334 export function ifStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement;
1335 export function labeledStatement(label?: Identifier, body?: Statement): LabeledStatement;
1336 export function stringLiteral(value?: string): StringLiteral;
1337 export function numericLiteral(value?: number): NumericLiteral;
1338 export function nullLiteral(): NullLiteral;
1339 export function booleanLiteral(value?: boolean): BooleanLiteral;
1340 export function regExpLiteral(pattern?: string, flags?: string): RegExpLiteral;
1341 export function logicalExpression(operator?: "||" | "&&", left?: Expression, right?: Expression): LogicalExpression;
1342 export function memberExpression(object?: Expression | Super, property?: Expression, computed?: boolean): MemberExpression;
1343 export function newExpression(callee?: Expression | Super, _arguments?: Array<Expression | SpreadElement>): NewExpression;
1344 export function program(body?: Array<Statement | ModuleDeclaration>, directives?: Directive[]): Program;
1345 export function objectExpression(properties?: Array<ObjectProperty | ObjectMethod | SpreadProperty>): ObjectExpression;
1346 export function objectMethod(kind?: "get" | "set" | "method", key?: Expression, params?: LVal[], body?: BlockStatement, computed?: boolean): ObjectMethod;
1347 export function objectProperty(key?: Expression, value?: Expression, computed?: boolean, shorthand?: boolean, decorators?: Decorator[]): ObjectProperty;
1348 export function restElement(argument?: LVal, typeAnnotation?: TypeAnnotation): RestElement;
1349 export function returnStatement(argument?: Expression): ReturnStatement;
1350 export function sequenceExpression(expressions?: Expression[]): SequenceExpression;
1351 export function switchCase(test?: Expression, consequent?: Statement[]): SwitchCase;
1352 export function switchStatement(discriminant?: Expression, cases?: SwitchCase[]): SwitchStatement;
1353 export function thisExpression(): ThisExpression;
1354 export function throwStatement(argument?: Expression): ThrowStatement;
1355 export function tryStatement(block?: BlockStatement, handler?: CatchClause, finalizer?: BlockStatement): TryStatement;
1356 export function unaryExpression(operator?: "void" | "delete" | "!" | "+" | "-" | "++" | "--" | "~" | "typeof", argument?: Expression, prefix?: boolean): UnaryExpression;
1357 export function updateExpression(operator?: "++" | "--", argument?: Expression, prefix?: boolean): UpdateExpression;
1358 export function variableDeclaration(kind?: "var" | "let" | "const", declarations?: VariableDeclarator[]): VariableDeclaration;
1359 export function variableDeclarator(id?: LVal, init?: Expression): VariableDeclarator;
1360 export function whileStatement(test?: Expression, body?: BlockStatement | Statement): WhileStatement;
1361 export function withStatement(object?: Expression, body?: BlockStatement | Statement): WithStatement;
1362 export function assignmentPattern(left?: Identifier, right?: Expression): AssignmentPattern;
1363 export function arrayPattern(elements?: Expression[], typeAnnotation?: TypeAnnotation): ArrayPattern;
1364 export function arrowFunctionExpression(params?: LVal[], body?: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
1365 export function classBody(body?: Array<ClassMethod | ClassProperty>): ClassBody;
1366 export function classDeclaration(id?: Identifier, superClass?: Expression, body?: ClassBody, decorators?: Decorator[]): ClassDeclaration;
1367 export function classExpression(id?: Identifier, superClass?: Expression, body?: ClassBody, decorators?: Decorator[]): ClassExpression;
1368 export function exportAllDeclaration(source?: StringLiteral): ExportAllDeclaration;
1369 export function exportDefaultDeclaration(declaration?: FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration;
1370 export function exportNamedDeclaration(declaration?: Declaration, specifiers?: ExportSpecifier[], source?: StringLiteral): ExportNamedDeclaration;
1371 export function exportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier;
1372 export function forOfStatement(left?: VariableDeclaration | LVal, right?: Expression, body?: Statement): ForOfStatement;
1373 export function importDeclaration(specifiers?: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source?: StringLiteral): ImportDeclaration;
1374 export function importDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier;
1375 export function importNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier;
1376 export function importSpecifier(local?: Identifier, imported?: Identifier): ImportSpecifier;
1377 export function metaProperty(meta?: string, property?: string): MetaProperty;
1378 export function classMethod(kind?: "constructor" | "method" | "get" | "set", key?: Expression, params?: LVal[], body?: BlockStatement, computed?: boolean, _static?: boolean): ClassMethod;
1379 export function objectPattern(properties?: Array<AssignmentProperty | RestProperty>, typeAnnotation?: TypeAnnotation): ObjectPattern;
1380 export function spreadElement(argument?: Expression): SpreadElement;
1381 export function taggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral): TaggedTemplateExpression;
1382 export function templateElement(value?: { cooked?: string | undefined; raw?: string | undefined; }, tail?: boolean): TemplateElement;
1383 export function templateLiteral(quasis?: TemplateElement[], expressions?: Expression[]): TemplateLiteral;
1384 export function yieldExpression(argument?: Expression, delegate?: boolean): YieldExpression;
1385 export function anyTypeAnnotation(): AnyTypeAnnotation;
1386 export function arrayTypeAnnotation(elementType?: FlowTypeAnnotation): ArrayTypeAnnotation;
1387 export function booleanTypeAnnotation(): BooleanTypeAnnotation;
1388 export function booleanLiteralTypeAnnotation(): BooleanLiteralTypeAnnotation;
1389 export function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
1390 export function classImplements(id?: Identifier, typeParameters?: TypeParameterInstantiation): ClassImplements;
1391 export function classProperty(key?: Identifier, value?: Expression, typeAnnotation?: TypeAnnotation, decorators?: Decorator[]): ClassProperty;
1392 export function declareClass(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): DeclareClass;
1393 export function declareFunction(id?: Identifier): DeclareFunction;
1394 export function declareInterface(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): DeclareInterface;
1395 export function declareModule(id?: StringLiteral | Identifier, body?: BlockStatement): DeclareModule;
1396 export function declareTypeAlias(id?: Identifier, typeParameters?: TypeParameterDeclaration, right?: FlowTypeAnnotation): DeclareTypeAlias;
1397 export function declareVariable(id?: Identifier): DeclareVariable;
1398 export function existentialTypeParam(): ExistentialTypeParam;
1399 export function functionTypeAnnotation(typeParameters?: TypeParameterDeclaration, params?: FunctionTypeParam[], rest?: FunctionTypeParam, returnType?: FlowTypeAnnotation): FunctionTypeAnnotation;
1400 export function functionTypeParam(name?: Identifier, typeAnnotation?: FlowTypeAnnotation): FunctionTypeParam;
1401 export function genericTypeAnnotation(id?: Identifier, typeParameters?: TypeParameterInstantiation): GenericTypeAnnotation;
1402 export function interfaceExtends(id?: Identifier, typeParameters?: TypeParameterInstantiation): InterfaceExtends;
1403 export function interfaceDeclaration(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): InterfaceDeclaration;
1404 export function intersectionTypeAnnotation(types?: FlowTypeAnnotation[]): IntersectionTypeAnnotation;
1405 export function mixedTypeAnnotation(): MixedTypeAnnotation;
1406 export function nullableTypeAnnotation(typeAnnotation?: FlowTypeAnnotation): NullableTypeAnnotation;
1407 export function numericLiteralTypeAnnotation(): NumericLiteralTypeAnnotation;
1408 export function numberTypeAnnotation(): NumberTypeAnnotation;
1409 export function stringLiteralTypeAnnotation(): StringLiteralTypeAnnotation;
1410 export function stringTypeAnnotation(): StringTypeAnnotation;
1411 export function thisTypeAnnotation(): ThisTypeAnnotation;
1412 export function tupleTypeAnnotation(types?: FlowTypeAnnotation[]): TupleTypeAnnotation;
1413 export function typeofTypeAnnotation(argument?: FlowTypeAnnotation): TypeofTypeAnnotation;
1414 export function typeAlias(id?: Identifier, typeParameters?: TypeParameterDeclaration, right?: FlowTypeAnnotation): TypeAlias;
1415 export function typeAnnotation(typeAnnotation?: FlowTypeAnnotation): TypeAnnotation;
1416 export function typeCastExpression(expression?: Expression, typeAnnotation?: FlowTypeAnnotation): TypeCastExpression;
1417 export function typeParameter(bound?: TypeAnnotation, default_?: Flow): TypeParameter;
1418 export function typeParameterDeclaration(params?: Identifier[]): TypeParameterDeclaration;
1419 export function typeParameterInstantiation(params?: FlowTypeAnnotation[]): TypeParameterInstantiation;
1420 export function objectTypeAnnotation(properties?: ObjectTypeProperty[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[]): ObjectTypeAnnotation;
1421 export function objectTypeCallProperty(value?: FlowTypeAnnotation): ObjectTypeCallProperty;
1422 export function objectTypeIndexer(id?: Expression, key?: FlowTypeAnnotation, value?: FlowTypeAnnotation): ObjectTypeIndexer;
1423 export function objectTypeProperty(key?: Expression, value?: FlowTypeAnnotation): ObjectTypeProperty;
1424 export function qualifiedTypeIdentifier(id?: Identifier, qualification?: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;
1425 export function unionTypeAnnotation(types?: FlowTypeAnnotation[]): UnionTypeAnnotation;
1426 export function voidTypeAnnotation(): VoidTypeAnnotation;
1427 export function jSXAttribute(name?: JSXIdentifier | JSXNamespacedName, value?: JSXElement | StringLiteral | JSXExpressionContainer | null): JSXAttribute;
1428 export function jSXClosingElement(name?: JSXIdentifier | JSXMemberExpression): JSXClosingElement;
1429 export function jSXElement(openingElement?: JSXOpeningElement, closingElement?: JSXClosingElement, children?: Array<JSXElement | JSXExpressionContainer | JSXText>, selfClosing?: boolean): JSXElement;
1430 export function jSXEmptyExpression(): JSXEmptyExpression;
1431 export function jSXExpressionContainer(expression?: Expression): JSXExpressionContainer;
1432 export function jSXIdentifier(name?: string): JSXIdentifier;
1433 export function jSXMemberExpression(object?: JSXMemberExpression | JSXIdentifier, property?: JSXIdentifier): JSXMemberExpression;
1434 export function jSXNamespacedName(namespace?: JSXIdentifier, name?: JSXIdentifier): JSXNamespacedName;
1435 export function jSXOpeningElement(name?: JSXIdentifier | JSXMemberExpression, attributes?: JSXAttribute[], selfClosing?: boolean): JSXOpeningElement;
1436 export function jSXSpreadAttribute(argument?: Expression): JSXSpreadAttribute;
1437 export function jSXText(value?: string): JSXText;
1438 export function noop(): Noop;
1439 export function parenthesizedExpression(expression?: Expression): ParenthesizedExpression;
1440 export function awaitExpression(argument?: Expression): AwaitExpression;
1441 export function bindExpression(object?: Expression, callee?: Expression): BindExpression;
1442 export function decorator(expression?: Expression): Decorator;
1443 export function doExpression(body?: BlockStatement): DoExpression;
1444 export function exportDefaultSpecifier(exported?: Identifier): ExportDefaultSpecifier;
1445 export function exportNamespaceSpecifier(exported?: Identifier): ExportNamespaceSpecifier;
1446 export function restProperty(argument?: LVal): RestProperty;
1447 export function spreadProperty(argument?: Expression): SpreadProperty;
1448
1449 export function TSAnyKeyword(): TSAnyKeyword;
1450 export function TSArrayType(elementType: TSType): TSArrayType;
1451 export function TSAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;
1452 export function TSBooleanKeyword(): TSBooleanKeyword;
1453 export function TSCallSignatureDeclaration(typeParameters?: TypeParameterDeclaration, parameters?: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation): TSCallSignatureDeclaration;
1454 export function TSConstructSignatureDeclaration(typeParameters?: TypeParameterDeclaration, parameters?: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation): TSTypeElement;
1455 export function TSConstructorType(typeParameters?: TypeParameterDeclaration, typeAnnotation?: TSTypeAnnotation): TSConstructorType;
1456 export function TSDeclareFunction(
1457 id: Identifier | undefined | null,
1458 typeParameters: TypeParameterDeclaration | Noop | undefined | null,
1459 params: LVal[],
1460 returnType: TypeAnnotation | TSTypeAnnotation | Noop | undefined | null): TSDeclareFunction;
1461 export function TSDeclareMethod(
1462 decorators: Decorator[] | undefined | null,
1463 key: Expression,
1464 typeParameters: TypeParameterDeclaration | Noop | undefined | null,
1465 params: LVal[],
1466 returnType?: TypeAnnotation | TSTypeAnnotation | Noop): TSDeclareMethod;
1467 export function TSEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration;
1468 export function TSEnumMember(id: Identifier | StringLiteral, initializer?: Expression): TSEnumMember;
1469 export function TSExportAssignment(expression: Expression): TSExportAssignment;
1470 export function TSExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TypeParameterInstantiation): TSExpressionWithTypeArguments;
1471 export function TSExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;
1472 export function TSFunctionType(typeParameters?: TypeParameterDeclaration, typeAnnotation?: TSTypeAnnotation): TSFunctionType;
1473 export function TSImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration;
1474 export function TSIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation): TSIndexSignature;
1475 export function TSIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
1476 export function TSInterfaceBody(body: TSTypeElement[]): TSInterfaceBody;
1477 export function TSInterfaceDeclaration(
1478 id: Identifier,
1479 typeParameters: TypeParameterDeclaration | undefined | null,
1480 extends_: TSExpressionWithTypeArguments[] | undefined | null,
1481 body: TSInterfaceBody): TSInterfaceDeclaration;
1482 export function TSIntersectionType(types: TSType[]): TSIntersectionType;
1483 export function TSLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral): TSLiteralType;
1484 export function TSMappedType(typeParameter: TypeParameter, typeAnnotation?: TSType): TSMappedType;
1485 export function TSMethodSignature(key: Expression, typeParameters?: TypeParameterDeclaration, parameters?: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation): TSMethodSignature;
1486 export function TSModuleBlock(body: Statement[]): TSModuleBlock;
1487 export function TSModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;
1488 export function TSNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;
1489 export function TSNeverKeyword(): TSNeverKeyword;
1490 export function TSNonNullExpression(expression: Expression): TSNonNullExpression;
1491 export function TSNullKeyword(): TSNullKeyword;
1492 export function TSNumberKeyword(): TSNumberKeyword;
1493 export function TSObjectKeyword(): TSObjectKeyword;
1494 export function TSParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
1495 export function TSParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
1496 export function TSPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation, initializer?: Expression): TSPropertySignature;
1497 export function TSQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
1498 export function TSStringKeyword(): TSStringKeyword;
1499 export function TSSymbolKeyword(): TSSymbolKeyword;
1500 export function TSThisType(): TSThisType;
1501 export function TSTupleType(elementTypes: TSType[]): TSTupleType;
1502 export function TSTypeAliasDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | undefined | null, typeAnnotation: TSType): TSTypeAliasDeclaration;
1503 export function TSTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
1504 export function TSTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
1505 export function TSTypeLiteral(members: TSTypeElement[]): TSTypeLiteral;
1506 export function TSTypeOperator(typeAnnotation: TSType): TSTypeOperator;
1507 export function TSTypeParameter(constraint?: TSType, default_?: TSType): TSTypeParameter;
1508 export function TSTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration;
1509 export function TSTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation;
1510 export function TSTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation: TSTypeAnnotation): TSTypePredicate;
1511 export function TSTypeQuery(exprName: TSEntityName): TSTypeQuery;
1512 export function TSTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation): TSTypeReference;
1513 export function TSUndefinedKeyword(): TSUndefinedKeyword;
1514 export function TSUnionType(types: TSType[]): TSUnionType;
1515 export function TSVoidKeyword(): TSVoidKeyword;
1516
1517 export function isArrayExpression(node: object | null | undefined, opts?: object): node is ArrayExpression;
1518 export function isAssignmentExpression(node: object | null | undefined, opts?: object): node is AssignmentExpression;
1519 export function isBinaryExpression(node: object | null | undefined, opts?: object): node is BinaryExpression;
1520 export function isDirective(node: object | null | undefined, opts?: object): node is Directive;
1521 export function isDirectiveLiteral(node: object | null | undefined, opts?: object): node is DirectiveLiteral;
1522 export function isBlockStatement(node: object | null | undefined, opts?: object): node is BlockStatement;
1523 export function isBreakStatement(node: object | null | undefined, opts?: object): node is BreakStatement;
1524 export function isCallExpression(node: object | null | undefined, opts?: object): node is CallExpression;
1525 export function isCatchClause(node: object | null | undefined, opts?: object): node is CatchClause;
1526 export function isConditionalExpression(node: object | null | undefined, opts?: object): node is ConditionalExpression;
1527 export function isContinueStatement(node: object | null | undefined, opts?: object): node is ContinueStatement;
1528 export function isDebuggerStatement(node: object | null | undefined, opts?: object): node is DebuggerStatement;
1529 export function isDoWhileStatement(node: object | null | undefined, opts?: object): node is DoWhileStatement;
1530 export function isEmptyStatement(node: object | null | undefined, opts?: object): node is EmptyStatement;
1531 export function isExpressionStatement(node: object | null | undefined, opts?: object): node is ExpressionStatement;
1532 export function isFile(node: object | null | undefined, opts?: object): node is File;
1533 export function isForInStatement(node: object | null | undefined, opts?: object): node is ForInStatement;
1534 export function isForStatement(node: object | null | undefined, opts?: object): node is ForStatement;
1535 export function isFunctionDeclaration(node: object | null | undefined, opts?: object): node is FunctionDeclaration;
1536 export function isFunctionExpression(node: object | null | undefined, opts?: object): node is FunctionExpression;
1537 export function isIdentifier(node: object | null | undefined, opts?: object): node is Identifier;
1538 export function isIfStatement(node: object | null | undefined, opts?: object): node is IfStatement;
1539 export function isLabeledStatement(node: object | null | undefined, opts?: object): node is LabeledStatement;
1540 export function isStringLiteral(node: object | null | undefined, opts?: object): node is StringLiteral;
1541 export function isNumericLiteral(node: object | null | undefined, opts?: object): node is NumericLiteral;
1542
1543 /** @deprecated Use `isNumericLiteral` */
1544 export function isNumberLiteral(node: object | null | undefined, opts?: object): node is NumericLiteral;
1545 export function isNullLiteral(node: object | null | undefined, opts?: object): node is NullLiteral;
1546 export function isBooleanLiteral(node: object | null | undefined, opts?: object): node is BooleanLiteral;
1547 export function isRegExpLiteral(node: object | null | undefined, opts?: object): node is RegExpLiteral;
1548
1549 /** @deprecated Use `isRegExpLiteral` */
1550 export function isRegexLiteral(node: object | null | undefined, opts?: object): node is RegExpLiteral;
1551 export function isLogicalExpression(node: object | null | undefined, opts?: object): node is LogicalExpression;
1552 export function isMemberExpression(node: object | null | undefined, opts?: object): node is MemberExpression;
1553 export function isNewExpression(node: object | null | undefined, opts?: object): node is NewExpression;
1554 export function isProgram(node: object | null | undefined, opts?: object): node is Program;
1555 export function isObjectExpression(node: object | null | undefined, opts?: object): node is ObjectExpression;
1556 export function isObjectMethod(node: object | null | undefined, opts?: object): node is ObjectMethod;
1557 export function isObjectProperty(node: object | null | undefined, opts?: object): node is ObjectProperty;
1558 export function isRestElement(node: object | null | undefined, opts?: object): node is RestElement;
1559 export function isReturnStatement(node: object | null | undefined, opts?: object): node is ReturnStatement;
1560 export function isSequenceExpression(node: object | null | undefined, opts?: object): node is SequenceExpression;
1561 export function isSwitchCase(node: object | null | undefined, opts?: object): node is SwitchCase;
1562 export function isSwitchStatement(node: object | null | undefined, opts?: object): node is SwitchStatement;
1563 export function isThisExpression(node: object | null | undefined, opts?: object): node is ThisExpression;
1564 export function isThrowStatement(node: object | null | undefined, opts?: object): node is ThrowStatement;
1565 export function isTryStatement(node: object | null | undefined, opts?: object): node is TryStatement;
1566 export function isUnaryExpression(node: object | null | undefined, opts?: object): node is UnaryExpression;
1567 export function isUpdateExpression(node: object | null | undefined, opts?: object): node is UpdateExpression;
1568 export function isVariableDeclaration(node: object | null | undefined, opts?: object): node is VariableDeclaration;
1569 export function isVariableDeclarator(node: object | null | undefined, opts?: object): node is VariableDeclarator;
1570 export function isWhileStatement(node: object | null | undefined, opts?: object): node is WhileStatement;
1571 export function isWithStatement(node: object | null | undefined, opts?: object): node is WithStatement;
1572 export function isAssignmentPattern(node: object | null | undefined, opts?: object): node is AssignmentPattern;
1573 export function isArrayPattern(node: object | null | undefined, opts?: object): node is ArrayPattern;
1574 export function isArrowFunctionExpression(node: object | null | undefined, opts?: object): node is ArrowFunctionExpression;
1575 export function isClassBody(node: object | null | undefined, opts?: object): node is ClassBody;
1576 export function isClassDeclaration(node: object | null | undefined, opts?: object): node is ClassDeclaration;
1577 export function isClassExpression(node: object | null | undefined, opts?: object): node is ClassExpression;
1578 export function isExportAllDeclaration(node: object | null | undefined, opts?: object): node is ExportAllDeclaration;
1579 export function isExportDefaultDeclaration(node: object | null | undefined, opts?: object): node is ExportDefaultDeclaration;
1580 export function isExportNamedDeclaration(node: object | null | undefined, opts?: object): node is ExportNamedDeclaration;
1581 export function isExportSpecifier(node: object | null | undefined, opts?: object): node is ExportSpecifier;
1582 export function isForOfStatement(node: object | null | undefined, opts?: object): node is ForOfStatement;
1583 export function isImportDeclaration(node: object | null | undefined, opts?: object): node is ImportDeclaration;
1584 export function isImportDefaultSpecifier(node: object | null | undefined, opts?: object): node is ImportDefaultSpecifier;
1585 export function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object): node is ImportNamespaceSpecifier;
1586 export function isImportSpecifier(node: object | null | undefined, opts?: object): node is ImportSpecifier;
1587 export function isMetaProperty(node: object | null | undefined, opts?: object): node is MetaProperty;
1588 export function isClassMethod(node: object | null | undefined, opts?: object): node is ClassMethod;
1589 export function isObjectPattern(node: object | null | undefined, opts?: object): node is ObjectPattern;
1590 export function isSpreadElement(node: object | null | undefined, opts?: object): node is SpreadElement;
1591 export function isSuper(node: object | null | undefined, opts?: object): node is Super;
1592 export function isTaggedTemplateExpression(node: object | null | undefined, opts?: object): node is TaggedTemplateExpression;
1593 export function isTemplateElement(node: object | null | undefined, opts?: object): node is TemplateElement;
1594 export function isTemplateLiteral(node: object | null | undefined, opts?: object): node is TemplateLiteral;
1595 export function isYieldExpression(node: object | null | undefined, opts?: object): node is YieldExpression;
1596 export function isAnyTypeAnnotation(node: object | null | undefined, opts?: object): node is AnyTypeAnnotation;
1597 export function isArrayTypeAnnotation(node: object | null | undefined, opts?: object): node is ArrayTypeAnnotation;
1598 export function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object): node is BooleanTypeAnnotation;
1599 export function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is BooleanLiteralTypeAnnotation;
1600 export function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is NullLiteralTypeAnnotation;
1601 export function isClassImplements(node: object | null | undefined, opts?: object): node is ClassImplements;
1602 export function isClassProperty(node: object | null | undefined, opts?: object): node is ClassProperty;
1603 export function isDeclareClass(node: object | null | undefined, opts?: object): node is DeclareClass;
1604 export function isDeclareFunction(node: object | null | undefined, opts?: object): node is DeclareFunction;
1605 export function isDeclareInterface(node: object | null | undefined, opts?: object): node is DeclareInterface;
1606 export function isDeclareModule(node: object | null | undefined, opts?: object): node is DeclareModule;
1607 export function isDeclareTypeAlias(node: object | null | undefined, opts?: object): node is DeclareTypeAlias;
1608 export function isDeclareVariable(node: object | null | undefined, opts?: object): node is DeclareVariable;
1609 export function isExistentialTypeParam(node: object | null | undefined, opts?: object): node is ExistentialTypeParam;
1610 export function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object): node is FunctionTypeAnnotation;
1611 export function isFunctionTypeParam(node: object | null | undefined, opts?: object): node is FunctionTypeParam;
1612 export function isGenericTypeAnnotation(node: object | null | undefined, opts?: object): node is GenericTypeAnnotation;
1613 export function isInterfaceExtends(node: object | null | undefined, opts?: object): node is InterfaceExtends;
1614 export function isInterfaceDeclaration(node: object | null | undefined, opts?: object): node is InterfaceDeclaration;
1615 export function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object): node is IntersectionTypeAnnotation;
1616 export function isMixedTypeAnnotation(node: object | null | undefined, opts?: object): node is MixedTypeAnnotation;
1617 export function isNullableTypeAnnotation(node: object | null | undefined, opts?: object): node is NullableTypeAnnotation;
1618 export function isNumericLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is NumericLiteralTypeAnnotation;
1619 export function isNumberTypeAnnotation(node: object | null | undefined, opts?: object): node is NumberTypeAnnotation;
1620 export function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object): node is StringLiteralTypeAnnotation;
1621 export function isStringTypeAnnotation(node: object | null | undefined, opts?: object): node is StringTypeAnnotation;
1622 export function isThisTypeAnnotation(node: object | null | undefined, opts?: object): node is ThisTypeAnnotation;
1623 export function isTupleTypeAnnotation(node: object | null | undefined, opts?: object): node is TupleTypeAnnotation;
1624 export function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object): node is TypeofTypeAnnotation;
1625 export function isTypeAlias(node: object | null | undefined, opts?: object): node is TypeAlias;
1626 export function isTypeAnnotation(node: object | null | undefined, opts?: object): node is TypeAnnotation;
1627 export function isTypeCastExpression(node: object | null | undefined, opts?: object): node is TypeCastExpression;
1628 export function isTypeParameter(node: object | null | undefined, opts?: object): node is TypeParameter;
1629 export function isTypeParameterDeclaration(node: object | null | undefined, opts?: object): node is TypeParameterDeclaration;
1630 export function isTypeParameterInstantiation(node: object | null | undefined, opts?: object): node is TypeParameterInstantiation;
1631 export function isObjectTypeAnnotation(node: object | null | undefined, opts?: object): node is ObjectTypeAnnotation;
1632 export function isObjectTypeCallProperty(node: object | null | undefined, opts?: object): node is ObjectTypeCallProperty;
1633 export function isObjectTypeIndexer(node: object | null | undefined, opts?: object): node is ObjectTypeIndexer;
1634 export function isObjectTypeProperty(node: object | null | undefined, opts?: object): node is ObjectTypeProperty;
1635 export function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object): node is QualifiedTypeIdentifier;
1636 export function isUnionTypeAnnotation(node: object | null | undefined, opts?: object): node is UnionTypeAnnotation;
1637 export function isVoidTypeAnnotation(node: object | null | undefined, opts?: object): node is VoidTypeAnnotation;
1638 export function isJSXAttribute(node: object | null | undefined, opts?: object): node is JSXAttribute;
1639 export function isJSXClosingElement(node: object | null | undefined, opts?: object): node is JSXClosingElement;
1640 export function isJSXElement(node: object | null | undefined, opts?: object): node is JSXElement;
1641 export function isJSXEmptyExpression(node: object | null | undefined, opts?: object): node is JSXEmptyExpression;
1642 export function isJSXExpressionContainer(node: object | null | undefined, opts?: object): node is JSXExpressionContainer;
1643 export function isJSXIdentifier(node: object | null | undefined, opts?: object): node is JSXIdentifier;
1644 export function isJSXMemberExpression(node: object | null | undefined, opts?: object): node is JSXMemberExpression;
1645 export function isJSXNamespacedName(node: object | null | undefined, opts?: object): node is JSXNamespacedName;
1646 export function isJSXOpeningElement(node: object | null | undefined, opts?: object): node is JSXOpeningElement;
1647 export function isJSXSpreadAttribute(node: object | null | undefined, opts?: object): node is JSXSpreadAttribute;
1648 export function isJSXText(node: object | null | undefined, opts?: object): node is JSXText;
1649 export function isNoop(node: object | null | undefined, opts?: object): node is Noop;
1650 export function isParenthesizedExpression(node: object | null | undefined, opts?: object): node is ParenthesizedExpression;
1651 export function isAwaitExpression(node: object | null | undefined, opts?: object): node is AwaitExpression;
1652 export function isBindExpression(node: object | null | undefined, opts?: object): node is BindExpression;
1653 export function isDecorator(node: object | null | undefined, opts?: object): node is Decorator;
1654 export function isDoExpression(node: object | null | undefined, opts?: object): node is DoExpression;
1655 export function isExportDefaultSpecifier(node: object | null | undefined, opts?: object): node is ExportDefaultSpecifier;
1656 export function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object): node is ExportNamespaceSpecifier;
1657 export function isRestProperty(node: object | null | undefined, opts?: object): node is RestProperty;
1658 export function isSpreadProperty(node: object | null | undefined, opts?: object): node is SpreadProperty;
1659 export function isExpression(node: object | null | undefined, opts?: object): node is Expression;
1660 export function isBinary(node: object | null | undefined, opts?: object): node is Binary;
1661 export function isScopable(node: object | null | undefined, opts?: object): node is Scopable;
1662 export function isBlockParent(node: object | null | undefined, opts?: object): node is BlockParent;
1663 export function isBlock(node: object | null | undefined, opts?: object): node is Block;
1664 export function isStatement(node: object | null | undefined, opts?: object): node is Statement;
1665 export function isTerminatorless(node: object | null | undefined, opts?: object): node is Terminatorless;
1666 export function isCompletionStatement(node: object | null | undefined, opts?: object): node is CompletionStatement;
1667 export function isConditional(node: object | null | undefined, opts?: object): node is Conditional;
1668 export function isLoop(node: object | null | undefined, opts?: object): node is Loop;
1669 export function isWhile(node: object | null | undefined, opts?: object): node is While;
1670 export function isExpressionWrapper(node: object | null | undefined, opts?: object): node is ExpressionWrapper;
1671 export function isFor(node: object | null | undefined, opts?: object): node is For;
1672 export function isForXStatement(node: object | null | undefined, opts?: object): node is ForXStatement;
1673 // tslint:disable-next-line ban-types
1674 export function isFunction(node: object | null | undefined, opts?: object): node is Function;
1675 export function isFunctionParent(node: object | null | undefined, opts?: object): node is FunctionParent;
1676 export function isPureish(node: object | null | undefined, opts?: object): node is Pureish;
1677 export function isDeclaration(node: object | null | undefined, opts?: object): node is Declaration;
1678 export function isLVal(node: object | null | undefined, opts?: object): node is LVal;
1679 export function isLiteral(node: object | null | undefined, opts?: object): node is Literal;
1680 export function isImmutable(node: object | null | undefined, opts?: object): node is Immutable;
1681 export function isUserWhitespacable(node: object | null | undefined, opts?: object): node is UserWhitespacable;
1682 export function isMethod(node: object | null | undefined, opts?: object): node is Method;
1683 export function isObjectMember(node: object | null | undefined, opts?: object): node is ObjectMember;
1684 export function isProperty(node: object | null | undefined, opts?: object): node is Property;
1685 export function isUnaryLike(node: object | null | undefined, opts?: object): node is UnaryLike;
1686 export function isPattern(node: object | null | undefined, opts?: object): node is Pattern;
1687 export function isClass(node: object | null | undefined, opts?: object): node is Class;
1688 export function isModuleDeclaration(node: object | null | undefined, opts?: object): node is ModuleDeclaration;
1689 export function isExportDeclaration(node: object | null | undefined, opts?: object): node is ExportDeclaration;
1690 export function isModuleSpecifier(node: object | null | undefined, opts?: object): node is ModuleSpecifier;
1691 export function isFlow(node: object | null | undefined, opts?: object): node is Flow;
1692 export function isFlowBaseAnnotation(node: object | null | undefined, opts?: object): node is FlowBaseAnnotation;
1693 export function isFlowDeclaration(node: object | null | undefined, opts?: object): node is FlowDeclaration;
1694 export function isJSX(node: object | null | undefined, opts?: object): node is JSX;
1695
1696 export function isReferencedIdentifier(node: object | null | undefined, opts?: object): node is Identifier | JSXIdentifier;
1697 export function isReferencedMemberExpression(node: object | null | undefined, opts?: object): node is MemberExpression;
1698 export function isBindingIdentifier(node: object | null | undefined, opts?: object): node is Identifier;
1699 export function isScope(node: object | null | undefined, opts?: object): node is Scopable;
1700 export function isReferenced(node: object | null | undefined, opts?: object): boolean;
1701 export function isBlockScoped(node: object | null | undefined, opts?: object): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration;
1702 export function isVar(node: object | null | undefined, opts?: object): node is VariableDeclaration;
1703 export function isUser(node: object | null | undefined, opts?: object): boolean;
1704 export function isGenerated(node: object | null | undefined, opts?: object): boolean;
1705 export function isPure(node: object | null | undefined, opts?: object): boolean;
1706
1707 export function isTSAnyKeyword(node: object | null | undefined, opts?: object): node is TSAnyKeyword;
1708 export function isTSArrayType(node: object | null | undefined, opts?: object): node is TSArrayType;
1709 export function isTSAsExpression(node: object | null | undefined, opts?: object): node is TSAsExpression;
1710 export function isTSBooleanKeyword(node: object | null | undefined, opts?: object): node is TSBooleanKeyword;
1711 export function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object): node is TSCallSignatureDeclaration;
1712 export function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object): node is TSTypeElement;
1713 export function isTSConstructorType(node: object | null | undefined, opts?: object): node is TSConstructorType;
1714 export function isTSDeclareFunction(node: object | null | undefined, opts?: object): node is TSDeclareFunction;
1715 export function isTSDeclareMethod(node: object | null | undefined, opts?: object): node is TSDeclareMethod;
1716 export function isTSEnumDeclaration(node: object | null | undefined, opts?: object): node is TSEnumDeclaration;
1717 export function isTSEnumMember(node: object | null | undefined, opts?: object): node is TSEnumMember;
1718 export function isTSExportAssignment(node: object | null | undefined, opts?: object): node is TSExportAssignment;
1719 export function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object): node is TSExpressionWithTypeArguments;
1720 export function isTSExternalModuleReference(node: object | null | undefined, opts?: object): node is TSExternalModuleReference;
1721 export function isTSFunctionType(node: object | null | undefined, opts?: object): node is TSFunctionType;
1722 export function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object): node is TSImportEqualsDeclaration;
1723 export function isTSIndexSignature(node: object | null | undefined, opts?: object): node is TSIndexSignature;
1724 export function isTSIndexedAccessType(node: object | null | undefined, opts?: object): node is TSIndexedAccessType;
1725 export function isTSInterfaceBody(node: object | null | undefined, opts?: object): node is TSInterfaceBody;
1726 export function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object): node is TSInterfaceDeclaration;
1727 export function isTSIntersectionType(node: object | null | undefined, opts?: object): node is TSIntersectionType;
1728 export function isTSLiteralType(node: object | null | undefined, opts?: object): node is TSLiteralType;
1729 export function isTSMappedType(node: object | null | undefined, opts?: object): node is TSMappedType;
1730 export function isTSMethodSignature(node: object | null | undefined, opts?: object): node is TSMethodSignature;
1731 export function isTSModuleBlock(node: object | null | undefined, opts?: object): node is TSModuleBlock;
1732 export function isTSModuleDeclaration(node: object | null | undefined, opts?: object): node is TSModuleDeclaration;
1733 export function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object): node is TSNamespaceExportDeclaration;
1734 export function isTSNeverKeyword(node: object | null | undefined, opts?: object): node is TSNeverKeyword;
1735 export function isTSNonNullExpression(node: object | null | undefined, opts?: object): node is TSNonNullExpression;
1736 export function isTSNullKeyword(node: object | null | undefined, opts?: object): node is TSNullKeyword;
1737 export function isTSNumberKeyword(node: object | null | undefined, opts?: object): node is TSNumberKeyword;
1738 export function isTSObjectKeyword(node: object | null | undefined, opts?: object): node is TSObjectKeyword;
1739 export function isTSParameterProperty(node: object | null | undefined, opts?: object): node is TSParameterProperty;
1740 export function isTSParenthesizedType(node: object | null | undefined, opts?: object): node is TSParenthesizedType;
1741 export function isTSPropertySignature(node: object | null | undefined, opts?: object): node is TSPropertySignature;
1742 export function isTSQualifiedName(node: object | null | undefined, opts?: object): node is TSQualifiedName;
1743 export function isTSStringKeyword(node: object | null | undefined, opts?: object): node is TSStringKeyword;
1744 export function isTSSymbolKeyword(node: object | null | undefined, opts?: object): node is TSSymbolKeyword;
1745 export function isTSThisType(node: object | null | undefined, opts?: object): node is TSThisType;
1746 export function isTSTupleType(node: object | null | undefined, opts?: object): node is TSTupleType;
1747 export function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object): node is TSTypeAliasDeclaration;
1748 export function isTSTypeAnnotation(node: object | null | undefined, opts?: object): node is TSTypeAnnotation;
1749 export function isTSTypeAssertion(node: object | null | undefined, opts?: object): node is TSTypeAssertion;
1750 export function isTSTypeLiteral(node: object | null | undefined, opts?: object): node is TSTypeLiteral;
1751 export function isTSTypeOperator(node: object | null | undefined, opts?: object): node is TSTypeOperator;
1752 export function isTSTypeParameter(node: object | null | undefined, opts?: object): node is TSTypeParameter;
1753 export function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object): node is TSTypeParameterDeclaration;
1754 export function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object): node is TSTypeParameterInstantiation;
1755 export function isTSTypePredicate(node: object | null | undefined, opts?: object): node is TSTypePredicate;
1756 export function isTSTypeQuery(node: object | null | undefined, opts?: object): node is TSTypeQuery;
1757 export function isTSTypeReference(node: object | null | undefined, opts?: object): node is TSTypeReference;
1758 export function isTSUndefinedKeyword(node: object | null | undefined, opts?: object): node is TSUndefinedKeyword;
1759 export function isTSUnionType(node: object | null | undefined, opts?: object): node is TSUnionType;
1760 export function isTSVoidKeyword(node: object | null | undefined, opts?: object): node is TSVoidKeyword;
1761
1762 // React specific
1763 export interface ReactHelpers {
1764 isCompatTag(tagName?: string): boolean;
1765 buildChildren(node: object): Node[];
1766 }
1767 export const react: ReactHelpers;
1768
1769 export function assertArrayExpression(node: object | null | undefined, opts?: object): asserts node is ArrayExpression;
1770 export function assertAssignmentExpression(node: object | null | undefined, opts?: object): asserts node is AssignmentExpression;
1771 export function assertBinaryExpression(node: object | null | undefined, opts?: object): asserts node is BinaryExpression;
1772 export function assertDirective(node: object | null | undefined, opts?: object): asserts node is Directive;
1773 export function assertDirectiveLiteral(node: object | null | undefined, opts?: object): asserts node is DirectiveLiteral;
1774 export function assertBlockStatement(node: object | null | undefined, opts?: object): asserts node is BlockStatement;
1775 export function assertBreakStatement(node: object | null | undefined, opts?: object): asserts node is BreakStatement;
1776 export function assertCallExpression(node: object | null | undefined, opts?: object): asserts node is CallExpression;
1777 export function assertCatchClause(node: object | null | undefined, opts?: object): asserts node is CatchClause;
1778 export function assertConditionalExpression(node: object | null | undefined, opts?: object): asserts node is ConditionalExpression;
1779 export function assertContinueStatement(node: object | null | undefined, opts?: object): asserts node is ContinueStatement;
1780 export function assertDebuggerStatement(node: object | null | undefined, opts?: object): asserts node is DebuggerStatement;
1781 export function assertDoWhileStatement(node: object | null | undefined, opts?: object): asserts node is DoWhileStatement;
1782 export function assertEmptyStatement(node: object | null | undefined, opts?: object): asserts node is EmptyStatement;
1783 export function assertExpressionStatement(node: object | null | undefined, opts?: object): asserts node is ExpressionStatement;
1784 export function assertFile(node: object | null | undefined, opts?: object): asserts node is File;
1785 export function assertForInStatement(node: object | null | undefined, opts?: object): asserts node is ForInStatement;
1786 export function assertForStatement(node: object | null | undefined, opts?: object): asserts node is ForStatement;
1787 export function assertFunctionDeclaration(node: object | null | undefined, opts?: object): asserts node is FunctionDeclaration;
1788 export function assertFunctionExpression(node: object | null | undefined, opts?: object): asserts node is FunctionExpression;
1789 export function assertIdentifier(node: object | null | undefined, opts?: object): asserts node is Identifier;
1790 export function assertIfStatement(node: object | null | undefined, opts?: object): asserts node is IfStatement;
1791 export function assertLabeledStatement(node: object | null | undefined, opts?: object): asserts node is LabeledStatement;
1792 export function assertStringLiteral(node: object | null | undefined, opts?: object): asserts node is StringLiteral;
1793 export function assertNumericLiteral(node: object | null | undefined, opts?: object): asserts node is NumericLiteral;
1794
1795 /** @deprecated Use `assertNumericLiteral` */
1796 export function assertNumberLiteral(node: object | null | undefined, opts?: object): asserts node is NumericLiteral;
1797 export function assertNullLiteral(node: object | null | undefined, opts?: object): asserts node is NullLiteral;
1798 export function assertBooleanLiteral(node: object | null | undefined, opts?: object): asserts node is BooleanLiteral;
1799 export function assertRegExpLiteral(node: object | null | undefined, opts?: object): asserts node is RegExpLiteral;
1800
1801 /** @deprecated Use `assertRegExpLiteral` */
1802 export function assertRegexLiteral(node: object | null | undefined, opts?: object): asserts node is RegExpLiteral;
1803 export function assertLogicalExpression(node: object | null | undefined, opts?: object): asserts node is LogicalExpression;
1804 export function assertMemberExpression(node: object | null | undefined, opts?: object): asserts node is MemberExpression;
1805 export function assertNewExpression(node: object | null | undefined, opts?: object): asserts node is NewExpression;
1806 export function assertProgram(node: object | null | undefined, opts?: object): asserts node is Program;
1807 export function assertObjectExpression(node: object | null | undefined, opts?: object): asserts node is ObjectExpression;
1808 export function assertObjectMethod(node: object | null | undefined, opts?: object): asserts node is ObjectMethod;
1809 export function assertObjectProperty(node: object | null | undefined, opts?: object): asserts node is ObjectProperty;
1810 export function assertRestElement(node: object | null | undefined, opts?: object): asserts node is RestElement;
1811 export function assertReturnStatement(node: object | null | undefined, opts?: object): asserts node is ReturnStatement;
1812 export function assertSequenceExpression(node: object | null | undefined, opts?: object): asserts node is SequenceExpression;
1813 export function assertSwitchCase(node: object | null | undefined, opts?: object): asserts node is SwitchCase;
1814 export function assertSwitchStatement(node: object | null | undefined, opts?: object): asserts node is SwitchStatement;
1815 export function assertThisExpression(node: object | null | undefined, opts?: object): asserts node is ThisExpression;
1816 export function assertThrowStatement(node: object | null | undefined, opts?: object): asserts node is ThrowStatement;
1817 export function assertTryStatement(node: object | null | undefined, opts?: object): asserts node is TryStatement;
1818 export function assertUnaryExpression(node: object | null | undefined, opts?: object): asserts node is UnaryExpression;
1819 export function assertUpdateExpression(node: object | null | undefined, opts?: object): asserts node is UpdateExpression;
1820 export function assertVariableDeclaration(node: object | null | undefined, opts?: object): asserts node is VariableDeclaration;
1821 export function assertVariableDeclarator(node: object | null | undefined, opts?: object): asserts node is VariableDeclarator;
1822 export function assertWhileStatement(node: object | null | undefined, opts?: object): asserts node is WhileStatement;
1823 export function assertWithStatement(node: object | null | undefined, opts?: object): asserts node is WithStatement;
1824 export function assertAssignmentPattern(node: object | null | undefined, opts?: object): asserts node is AssignmentPattern;
1825 export function assertArrayPattern(node: object | null | undefined, opts?: object): asserts node is ArrayPattern;
1826 export function assertArrowFunctionExpression(node: object | null | undefined, opts?: object): asserts node is ArrowFunctionExpression;
1827 export function assertClassBody(node: object | null | undefined, opts?: object): asserts node is ClassBody;
1828 export function assertClassDeclaration(node: object | null | undefined, opts?: object): asserts node is ClassDeclaration;
1829 export function assertClassExpression(node: object | null | undefined, opts?: object): asserts node is ClassExpression;
1830 export function assertExportAllDeclaration(node: object | null | undefined, opts?: object): asserts node is ExportAllDeclaration;
1831 export function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object): asserts node is ExportDefaultDeclaration;
1832 export function assertExportNamedDeclaration(node: object | null | undefined, opts?: object): asserts node is ExportNamedDeclaration;
1833 export function assertExportSpecifier(node: object | null | undefined, opts?: object): asserts node is ExportSpecifier;
1834 export function assertForOfStatement(node: object | null | undefined, opts?: object): asserts node is ForOfStatement;
1835 export function assertImportDeclaration(node: object | null | undefined, opts?: object): asserts node is ImportDeclaration;
1836 export function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object): asserts node is ImportDefaultSpecifier;
1837 export function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object): asserts node is ImportNamespaceSpecifier;
1838 export function assertImportSpecifier(node: object | null | undefined, opts?: object): asserts node is ImportSpecifier;
1839 export function assertMetaProperty(node: object | null | undefined, opts?: object): asserts node is MetaProperty;
1840 export function assertClassMethod(node: object | null | undefined, opts?: object): asserts node is ClassMethod;
1841 export function assertObjectPattern(node: object | null | undefined, opts?: object): asserts node is ObjectPattern;
1842 export function assertSpreadElement(node: object | null | undefined, opts?: object): asserts node is SpreadElement;
1843 export function assertSuper(node: object | null | undefined, opts?: object): asserts node is Super;
1844 export function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object): asserts node is TaggedTemplateExpression;
1845 export function assertTemplateElement(node: object | null | undefined, opts?: object): asserts node is TemplateElement;
1846 export function assertTemplateLiteral(node: object | null | undefined, opts?: object): asserts node is TemplateLiteral;
1847 export function assertYieldExpression(node: object | null | undefined, opts?: object): asserts node is YieldExpression;
1848 export function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is AnyTypeAnnotation;
1849 export function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is ArrayTypeAnnotation;
1850 export function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is BooleanTypeAnnotation;
1851 export function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is BooleanLiteralTypeAnnotation;
1852 export function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is NullLiteralTypeAnnotation;
1853 export function assertClassImplements(node: object | null | undefined, opts?: object): asserts node is ClassImplements;
1854 export function assertClassProperty(node: object | null | undefined, opts?: object): asserts node is ClassProperty;
1855 export function assertDeclareClass(node: object | null | undefined, opts?: object): asserts node is DeclareClass;
1856 export function assertDeclareFunction(node: object | null | undefined, opts?: object): asserts node is DeclareFunction;
1857 export function assertDeclareInterface(node: object | null | undefined, opts?: object): asserts node is DeclareInterface;
1858 export function assertDeclareModule(node: object | null | undefined, opts?: object): asserts node is DeclareModule;
1859 export function assertDeclareTypeAlias(node: object | null | undefined, opts?: object): asserts node is DeclareTypeAlias;
1860 export function assertDeclareVariable(node: object | null | undefined, opts?: object): asserts node is DeclareVariable;
1861 export function assertExistentialTypeParam(node: object | null | undefined, opts?: object): asserts node is ExistentialTypeParam;
1862 export function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is FunctionTypeAnnotation;
1863 export function assertFunctionTypeParam(node: object | null | undefined, opts?: object): asserts node is FunctionTypeParam;
1864 export function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is GenericTypeAnnotation;
1865 export function assertInterfaceExtends(node: object | null | undefined, opts?: object): asserts node is InterfaceExtends;
1866 export function assertInterfaceDeclaration(node: object | null | undefined, opts?: object): asserts node is InterfaceDeclaration;
1867 export function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is IntersectionTypeAnnotation;
1868 export function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is MixedTypeAnnotation;
1869 export function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is NullableTypeAnnotation;
1870 export function assertNumericLiteralTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is NumericLiteralTypeAnnotation;
1871 export function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is NumberTypeAnnotation;
1872 export function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is StringLiteralTypeAnnotation;
1873 export function assertStringTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is StringTypeAnnotation;
1874 export function assertThisTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is ThisTypeAnnotation;
1875 export function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is TupleTypeAnnotation;
1876 export function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is TypeofTypeAnnotation;
1877 export function assertTypeAlias(node: object | null | undefined, opts?: object): asserts node is TypeAlias;
1878 export function assertTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is TypeAnnotation;
1879 export function assertTypeCastExpression(node: object | null | undefined, opts?: object): asserts node is TypeCastExpression;
1880 export function assertTypeParameter(node: object | null | undefined, opts?: object): asserts node is TypeParameter;
1881 export function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object): asserts node is TypeParameterDeclaration;
1882 export function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object): asserts node is TypeParameterInstantiation;
1883 export function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is ObjectTypeAnnotation;
1884 export function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object): asserts node is ObjectTypeCallProperty;
1885 export function assertObjectTypeIndexer(node: object | null | undefined, opts?: object): asserts node is ObjectTypeIndexer;
1886 export function assertObjectTypeProperty(node: object | null | undefined, opts?: object): asserts node is ObjectTypeProperty;
1887 export function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object): asserts node is QualifiedTypeIdentifier;
1888 export function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is UnionTypeAnnotation;
1889 export function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is VoidTypeAnnotation;
1890 export function assertJSXAttribute(node: object | null | undefined, opts?: object): asserts node is JSXAttribute;
1891 export function assertJSXClosingElement(node: object | null | undefined, opts?: object): asserts node is JSXClosingElement;
1892 export function assertJSXElement(node: object | null | undefined, opts?: object): asserts node is JSXElement;
1893 export function assertJSXEmptyExpression(node: object | null | undefined, opts?: object): asserts node is JSXEmptyExpression;
1894 export function assertJSXExpressionContainer(node: object | null | undefined, opts?: object): asserts node is JSXExpressionContainer;
1895 export function assertJSXIdentifier(node: object | null | undefined, opts?: object): asserts node is JSXIdentifier;
1896 export function assertJSXMemberExpression(node: object | null | undefined, opts?: object): asserts node is JSXMemberExpression;
1897 export function assertJSXNamespacedName(node: object | null | undefined, opts?: object): asserts node is JSXNamespacedName;
1898 export function assertJSXOpeningElement(node: object | null | undefined, opts?: object): asserts node is JSXOpeningElement;
1899 export function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object): asserts node is JSXSpreadAttribute;
1900 export function assertJSXText(node: object | null | undefined, opts?: object): asserts node is JSXText;
1901 export function assertNoop(node: object | null | undefined, opts?: object): asserts node is Noop;
1902 export function assertParenthesizedExpression(node: object | null | undefined, opts?: object): asserts node is ParenthesizedExpression;
1903 export function assertAwaitExpression(node: object | null | undefined, opts?: object): asserts node is AwaitExpression;
1904 export function assertBindExpression(node: object | null | undefined, opts?: object): asserts node is BindExpression;
1905 export function assertDecorator(node: object | null | undefined, opts?: object): asserts node is Decorator;
1906 export function assertDoExpression(node: object | null | undefined, opts?: object): asserts node is DoExpression;
1907 export function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object): asserts node is ExportDefaultSpecifier;
1908 export function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object): asserts node is ExportNamespaceSpecifier;
1909 export function assertRestProperty(node: object | null | undefined, opts?: object): asserts node is RestProperty;
1910 export function assertSpreadProperty(node: object | null | undefined, opts?: object): asserts node is SpreadProperty;
1911 export function assertExpression(node: object | null | undefined, opts?: object): asserts node is Expression;
1912 export function assertBinary(node: object | null | undefined, opts?: object): asserts node is Binary;
1913 export function assertScopable(node: object | null | undefined, opts?: object): asserts node is Scopable;
1914 export function assertBlockParent(node: object | null | undefined, opts?: object): asserts node is BlockParent;
1915 export function assertBlock(node: object | null | undefined, opts?: object): asserts node is Block;
1916 export function assertStatement(node: object | null | undefined, opts?: object): asserts node is Statement;
1917 export function assertTerminatorless(node: object | null | undefined, opts?: object): asserts node is Terminatorless;
1918 export function assertCompletionStatement(node: object | null | undefined, opts?: object): asserts node is CompletionStatement;
1919 export function assertConditional(node: object | null | undefined, opts?: object): asserts node is Conditional;
1920 export function assertLoop(node: object | null | undefined, opts?: object): asserts node is Loop;
1921 export function assertWhile(node: object | null | undefined, opts?: object): asserts node is While;
1922 export function assertExpressionWrapper(node: object | null | undefined, opts?: object): asserts node is ExpressionWrapper;
1923 export function assertFor(node: object | null | undefined, opts?: object): asserts node is For;
1924 export function assertForXStatement(node: object | null | undefined, opts?: object): asserts node is ForXStatement;
1925 // tslint:disable-next-line ban-types
1926 export function assertFunction(node: object | null | undefined, opts?: object): asserts node is Function;
1927 export function assertFunctionParent(node: object | null | undefined, opts?: object): asserts node is FunctionParent;
1928 export function assertPureish(node: object | null | undefined, opts?: object): asserts node is Pureish;
1929 export function assertDeclaration(node: object | null | undefined, opts?: object): asserts node is Declaration;
1930 export function assertLVal(node: object | null | undefined, opts?: object): asserts node is LVal;
1931 export function assertLiteral(node: object | null | undefined, opts?: object): asserts node is Literal;
1932 export function assertImmutable(node: object | null | undefined, opts?: object): asserts node is Immutable;
1933 export function assertUserWhitespacable(node: object | null | undefined, opts?: object): asserts node is UserWhitespacable;
1934 export function assertMethod(node: object | null | undefined, opts?: object): asserts node is Method;
1935 export function assertObjectMember(node: object | null | undefined, opts?: object): asserts node is ObjectMember;
1936 export function assertProperty(node: object | null | undefined, opts?: object): asserts node is Property;
1937 export function assertUnaryLike(node: object | null | undefined, opts?: object): asserts node is UnaryLike;
1938 export function assertPattern(node: object | null | undefined, opts?: object): asserts node is Pattern;
1939 export function assertClass(node: object | null | undefined, opts?: object): asserts node is Class;
1940 export function assertModuleDeclaration(node: object | null | undefined, opts?: object): asserts node is ModuleDeclaration;
1941 export function assertExportDeclaration(node: object | null | undefined, opts?: object): asserts node is ExportDeclaration;
1942 export function assertModuleSpecifier(node: object | null | undefined, opts?: object): asserts node is ModuleSpecifier;
1943 export function assertFlow(node: object | null | undefined, opts?: object): asserts node is Flow;
1944 export function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object): asserts node is FlowBaseAnnotation;
1945 export function assertFlowDeclaration(node: object | null | undefined, opts?: object): asserts node is FlowDeclaration;
1946 export function assertJSX(node: object | null | undefined, opts?: object): asserts node is JSX;
1947
1948 export function assertTSAnyKeyword(node: object | null | undefined, opts?: object): asserts node is TSAnyKeyword;
1949 export function assertTSArrayType(node: object | null | undefined, opts?: object): asserts node is TSArrayType;
1950 export function assertTSAsExpression(node: object | null | undefined, opts?: object): asserts node is TSAsExpression;
1951 export function assertTSBooleanKeyword(node: object | null | undefined, opts?: object): asserts node is TSBooleanKeyword;
1952 export function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object): asserts node is TSCallSignatureDeclaration;
1953 export function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object): asserts node is TSConstructSignatureDeclaration;
1954 export function assertTSConstructorType(node: object | null | undefined, opts?: object): asserts node is TSConstructorType;
1955 export function assertTSDeclareFunction(node: object | null | undefined, opts?: object): asserts node is TSDeclareFunction;
1956 export function assertTSDeclareMethod(node: object | null | undefined, opts?: object): asserts node is TSDeclareMethod;
1957 export function assertTSEnumDeclaration(node: object | null | undefined, opts?: object): asserts node is TSEnumDeclaration;
1958 export function assertTSEnumMember(node: object | null | undefined, opts?: object): asserts node is TSEnumMember;
1959 export function assertTSExportAssignment(node: object | null | undefined, opts?: object): asserts node is TSExportAssignment;
1960 export function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object): asserts node is TSExpressionWithTypeArguments;
1961 export function assertTSExternalModuleReference(node: object | null | undefined, opts?: object): asserts node is TSExternalModuleReference;
1962 export function assertTSFunctionType(node: object | null | undefined, opts?: object): asserts node is TSFunctionType;
1963 export function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object): asserts node is TSImportEqualsDeclaration;
1964 export function assertTSIndexSignature(node: object | null | undefined, opts?: object): asserts node is TSIndexSignature;
1965 export function assertTSIndexedAccessType(node: object | null | undefined, opts?: object): asserts node is TSIndexedAccessType;
1966 export function assertTSInterfaceBody(node: object | null | undefined, opts?: object): asserts node is TSInterfaceBody;
1967 export function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object): asserts node is TSInterfaceDeclaration;
1968 export function assertTSIntersectionType(node: object | null | undefined, opts?: object): asserts node is TSIntersectionType;
1969 export function assertTSLiteralType(node: object | null | undefined, opts?: object): asserts node is TSLiteralType;
1970 export function assertTSMappedType(node: object | null | undefined, opts?: object): asserts node is TSMappedType;
1971 export function assertTSMethodSignature(node: object | null | undefined, opts?: object): asserts node is TSMethodSignature;
1972 export function assertTSModuleBlock(node: object | null | undefined, opts?: object): asserts node is TSModuleBlock;
1973 export function assertTSModuleDeclaration(node: object | null | undefined, opts?: object): asserts node is TSModuleDeclaration;
1974 export function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object): asserts node is TSNamespaceExportDeclaration;
1975 export function assertTSNeverKeyword(node: object | null | undefined, opts?: object): asserts node is TSNeverKeyword;
1976 export function assertTSNonNullExpression(node: object | null | undefined, opts?: object): asserts node is TSNonNullExpression;
1977 export function assertTSNullKeyword(node: object | null | undefined, opts?: object): asserts node is TSNullKeyword;
1978 export function assertTSNumberKeyword(node: object | null | undefined, opts?: object): asserts node is TSNumberKeyword;
1979 export function assertTSObjectKeyword(node: object | null | undefined, opts?: object): asserts node is TSObjectKeyword;
1980 export function assertTSParameterProperty(node: object | null | undefined, opts?: object): asserts node is TSParameterProperty;
1981 export function assertTSParenthesizedType(node: object | null | undefined, opts?: object): asserts node is TSParenthesizedType;
1982 export function assertTSPropertySignature(node: object | null | undefined, opts?: object): asserts node is TSPropertySignature;
1983 export function assertTSQualifiedName(node: object | null | undefined, opts?: object): asserts node is TSQualifiedName;
1984 export function assertTSStringKeyword(node: object | null | undefined, opts?: object): asserts node is TSStringKeyword;
1985 export function assertTSSymbolKeyword(node: object | null | undefined, opts?: object): asserts node is TSSymbolKeyword;
1986 export function assertTSThisType(node: object | null | undefined, opts?: object): asserts node is TSThisType;
1987 export function assertTSTupleType(node: object | null | undefined, opts?: object): asserts node is TSTupleType;
1988 export function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object): asserts node is TSTypeAliasDeclaration;
1989 export function assertTSTypeAnnotation(node: object | null | undefined, opts?: object): asserts node is TSTypeAnnotation;
1990 export function assertTSTypeAssertion(node: object | null | undefined, opts?: object): asserts node is TSTypeAssertion;
1991 export function assertTSTypeLiteral(node: object | null | undefined, opts?: object): asserts node is TSTypeLiteral;
1992 export function assertTSTypeOperator(node: object | null | undefined, opts?: object): asserts node is TSTypeOperator;
1993 export function assertTSTypeParameter(node: object | null | undefined, opts?: object): asserts node is TSTypeParameter;
1994 export function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object): asserts node is TSTypeParameterDeclaration;
1995 export function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object): asserts node is TSTypeParameterInstantiation;
1996 export function assertTSTypePredicate(node: object | null | undefined, opts?: object): asserts node is TSTypePredicate;
1997 export function assertTSTypeQuery(node: object | null | undefined, opts?: object): asserts node is TSTypeQuery;
1998 export function assertTSTypeReference(node: object | null | undefined, opts?: object): asserts node is TSTypeReference;
1999 export function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object): asserts node is TSUndefinedKeyword;
2000 export function assertTSUnionType(node: object | null | undefined, opts?: object): asserts node is TSUnionType;
2001 export function assertTSVoidKeyword(node: object | null | undefined, opts?: object): asserts node is TSVoidKeyword;