@types/babel-types

Version 7.0.16
Published 1 month ago
117 kB
No dependencies
MIT license

Install

npm i @types/babel-types

yarn add @types/babel-types

pnpm add @types/babel-types

Overview

TypeScript definitions for babel-types

Index

Variables

variable react

const react: ReactHelpers;

Functions

function anyTypeAnnotation

anyTypeAnnotation: () => AnyTypeAnnotation;

function arrayExpression

arrayExpression: (
    elements?: Array<null | Expression | SpreadElement>
) => ArrayExpression;

function arrayPattern

arrayPattern: (
    elements?: Expression[],
    typeAnnotation?: TypeAnnotation
) => ArrayPattern;

function arrayTypeAnnotation

arrayTypeAnnotation: (elementType?: FlowTypeAnnotation) => ArrayTypeAnnotation;

function arrowFunctionExpression

arrowFunctionExpression: (
    params?: LVal[],
    body?: BlockStatement | Expression,
    async?: boolean
) => ArrowFunctionExpression;

function assertAnyTypeAnnotation

assertAnyTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is AnyTypeAnnotation;

function assertArrayExpression

assertArrayExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ArrayExpression;

function assertArrayPattern

assertArrayPattern: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ArrayPattern;

function assertArrayTypeAnnotation

assertArrayTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ArrayTypeAnnotation;

function assertArrowFunctionExpression

assertArrowFunctionExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ArrowFunctionExpression;

function assertAssignmentExpression

assertAssignmentExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is AssignmentExpression;

function assertAssignmentPattern

assertAssignmentPattern: (
    node: object | null | undefined,
    opts?: object
) => asserts node is AssignmentPattern;

function assertAwaitExpression

assertAwaitExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is AwaitExpression;

function assertBinary

assertBinary: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Binary;

function assertBinaryExpression

assertBinaryExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BinaryExpression;

function assertBindExpression

assertBindExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BindExpression;

function assertBlock

assertBlock: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Block;

function assertBlockParent

assertBlockParent: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BlockParent;

function assertBlockStatement

assertBlockStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BlockStatement;

function assertBooleanLiteral

assertBooleanLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BooleanLiteral;

function assertBooleanLiteralTypeAnnotation

assertBooleanLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BooleanLiteralTypeAnnotation;

function assertBooleanTypeAnnotation

assertBooleanTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BooleanTypeAnnotation;

function assertBreakStatement

assertBreakStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is BreakStatement;

function assertCallExpression

assertCallExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is CallExpression;

function assertCatchClause

assertCatchClause: (
    node: object | null | undefined,
    opts?: object
) => asserts node is CatchClause;

function assertClass

assertClass: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Class;

function assertClassBody

assertClassBody: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassBody;

function assertClassDeclaration

assertClassDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassDeclaration;

function assertClassExpression

assertClassExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassExpression;

function assertClassImplements

assertClassImplements: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassImplements;

function assertClassMethod

assertClassMethod: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassMethod;

function assertClassProperty

assertClassProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ClassProperty;

function assertCompletionStatement

assertCompletionStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is CompletionStatement;

function assertConditional

assertConditional: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Conditional;

function assertConditionalExpression

assertConditionalExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ConditionalExpression;

function assertContinueStatement

assertContinueStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ContinueStatement;

function assertDebuggerStatement

assertDebuggerStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DebuggerStatement;

function assertDeclaration

assertDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Declaration;

function assertDeclareClass

assertDeclareClass: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareClass;

function assertDeclareFunction

assertDeclareFunction: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareFunction;

function assertDeclareInterface

assertDeclareInterface: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareInterface;

function assertDeclareModule

assertDeclareModule: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareModule;

function assertDeclareTypeAlias

assertDeclareTypeAlias: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareTypeAlias;

function assertDeclareVariable

assertDeclareVariable: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DeclareVariable;

function assertDecorator

assertDecorator: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Decorator;

function assertDirective

assertDirective: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Directive;

function assertDirectiveLiteral

assertDirectiveLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DirectiveLiteral;

function assertDoExpression

assertDoExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DoExpression;

function assertDoWhileStatement

assertDoWhileStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is DoWhileStatement;

function assertEmptyStatement

assertEmptyStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is EmptyStatement;

function assertExistentialTypeParam

assertExistentialTypeParam: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExistentialTypeParam;

function assertExportAllDeclaration

assertExportAllDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportAllDeclaration;

function assertExportDeclaration

assertExportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportDeclaration;

function assertExportDefaultDeclaration

assertExportDefaultDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportDefaultDeclaration;

function assertExportDefaultSpecifier

assertExportDefaultSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportDefaultSpecifier;

function assertExportNamedDeclaration

assertExportNamedDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportNamedDeclaration;

function assertExportNamespaceSpecifier

assertExportNamespaceSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportNamespaceSpecifier;

function assertExportSpecifier

assertExportSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExportSpecifier;

function assertExpression

assertExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Expression;

function assertExpressionStatement

assertExpressionStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExpressionStatement;

function assertExpressionWrapper

assertExpressionWrapper: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ExpressionWrapper;

function assertFile

assertFile: (
    node: object | null | undefined,
    opts?: object
) => asserts node is File;

function assertFlow

assertFlow: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Flow;

function assertFlowBaseAnnotation

assertFlowBaseAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FlowBaseAnnotation;

function assertFlowDeclaration

assertFlowDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FlowDeclaration;

function assertFor

assertFor: (
    node: object | null | undefined,
    opts?: object
) => asserts node is For;

function assertForInStatement

assertForInStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ForInStatement;

function assertForOfStatement

assertForOfStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ForOfStatement;

function assertForStatement

assertForStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ForStatement;

function assertForXStatement

assertForXStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ForXStatement;

function assertFunction

assertFunction: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Function;

function assertFunctionDeclaration

assertFunctionDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FunctionDeclaration;

function assertFunctionExpression

assertFunctionExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FunctionExpression;

function assertFunctionParent

assertFunctionParent: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FunctionParent;

function assertFunctionTypeAnnotation

assertFunctionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FunctionTypeAnnotation;

function assertFunctionTypeParam

assertFunctionTypeParam: (
    node: object | null | undefined,
    opts?: object
) => asserts node is FunctionTypeParam;

function assertGenericTypeAnnotation

assertGenericTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is GenericTypeAnnotation;

function assertIdentifier

assertIdentifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Identifier;

function assertIfStatement

assertIfStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is IfStatement;

function assertImmutable

assertImmutable: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Immutable;

function assertImportDeclaration

assertImportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ImportDeclaration;

function assertImportDefaultSpecifier

assertImportDefaultSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ImportDefaultSpecifier;

function assertImportNamespaceSpecifier

assertImportNamespaceSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ImportNamespaceSpecifier;

function assertImportSpecifier

assertImportSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ImportSpecifier;

function assertInterfaceDeclaration

assertInterfaceDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is InterfaceDeclaration;

function assertInterfaceExtends

assertInterfaceExtends: (
    node: object | null | undefined,
    opts?: object
) => asserts node is InterfaceExtends;

function assertIntersectionTypeAnnotation

assertIntersectionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is IntersectionTypeAnnotation;

function assertJSX

assertJSX: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSX;

function assertJSXAttribute

assertJSXAttribute: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXAttribute;

function assertJSXClosingElement

assertJSXClosingElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXClosingElement;

function assertJSXElement

assertJSXElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXElement;

function assertJSXEmptyExpression

assertJSXEmptyExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXEmptyExpression;

function assertJSXExpressionContainer

assertJSXExpressionContainer: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXExpressionContainer;

function assertJSXIdentifier

assertJSXIdentifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXIdentifier;

function assertJSXMemberExpression

assertJSXMemberExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXMemberExpression;

function assertJSXNamespacedName

assertJSXNamespacedName: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXNamespacedName;

function assertJSXOpeningElement

assertJSXOpeningElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXOpeningElement;

function assertJSXSpreadAttribute

assertJSXSpreadAttribute: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXSpreadAttribute;

function assertJSXText

assertJSXText: (
    node: object | null | undefined,
    opts?: object
) => asserts node is JSXText;

function assertLabeledStatement

assertLabeledStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is LabeledStatement;

function assertLiteral

assertLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Literal;

function assertLogicalExpression

assertLogicalExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is LogicalExpression;

function assertLoop

assertLoop: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Loop;

function assertLVal

assertLVal: (
    node: object | null | undefined,
    opts?: object
) => asserts node is LVal;

function assertMemberExpression

assertMemberExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is MemberExpression;

function assertMetaProperty

assertMetaProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is MetaProperty;

function assertMethod

assertMethod: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Method;

function assertMixedTypeAnnotation

assertMixedTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is MixedTypeAnnotation;

function assertModuleDeclaration

assertModuleDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ModuleDeclaration;

function assertModuleSpecifier

assertModuleSpecifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ModuleSpecifier;

function assertNewExpression

assertNewExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NewExpression;

function assertNoop

assertNoop: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Noop;

function assertNullableTypeAnnotation

assertNullableTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NullableTypeAnnotation;

function assertNullLiteral

assertNullLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NullLiteral;

function assertNullLiteralTypeAnnotation

assertNullLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NullLiteralTypeAnnotation;

function assertNumberLiteral

assertNumberLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NumericLiteral;

Deprecated
Use assertNumericLiteral

function assertNumberTypeAnnotation

assertNumberTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NumberTypeAnnotation;

function assertNumericLiteral

assertNumericLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NumericLiteral;

function assertNumericLiteralTypeAnnotation

assertNumericLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is NumericLiteralTypeAnnotation;

function assertObjectExpression

assertObjectExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectExpression;

function assertObjectMember

assertObjectMember: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectMember;

function assertObjectMethod

assertObjectMethod: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectMethod;

function assertObjectPattern

assertObjectPattern: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectPattern;

function assertObjectProperty

assertObjectProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectProperty;

function assertObjectTypeAnnotation

assertObjectTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectTypeAnnotation;

function assertObjectTypeCallProperty

assertObjectTypeCallProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectTypeCallProperty;

function assertObjectTypeIndexer

assertObjectTypeIndexer: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectTypeIndexer;

function assertObjectTypeProperty

assertObjectTypeProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ObjectTypeProperty;

function assertParenthesizedExpression

assertParenthesizedExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ParenthesizedExpression;

function assertPattern

assertPattern: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Pattern;

function assertProgram

assertProgram: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Program;

function assertProperty

assertProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Property;

function assertPureish

assertPureish: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Pureish;

function assertQualifiedTypeIdentifier

assertQualifiedTypeIdentifier: (
    node: object | null | undefined,
    opts?: object
) => asserts node is QualifiedTypeIdentifier;

function assertRegexLiteral

assertRegexLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is RegExpLiteral;

Deprecated
Use assertRegExpLiteral

function assertRegExpLiteral

assertRegExpLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is RegExpLiteral;

function assertRestElement

assertRestElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is RestElement;

function assertRestProperty

assertRestProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is RestProperty;

function assertReturnStatement

assertReturnStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ReturnStatement;

function assertScopable

assertScopable: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Scopable;

function assertSequenceExpression

assertSequenceExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is SequenceExpression;

function assertSpreadElement

assertSpreadElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is SpreadElement;

function assertSpreadProperty

assertSpreadProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is SpreadProperty;

function assertStatement

assertStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Statement;

function assertStringLiteral

assertStringLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is StringLiteral;

function assertStringLiteralTypeAnnotation

assertStringLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is StringLiteralTypeAnnotation;

function assertStringTypeAnnotation

assertStringTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is StringTypeAnnotation;

function assertSuper

assertSuper: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Super;

function assertSwitchCase

assertSwitchCase: (
    node: object | null | undefined,
    opts?: object
) => asserts node is SwitchCase;

function assertSwitchStatement

assertSwitchStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is SwitchStatement;

function assertTaggedTemplateExpression

assertTaggedTemplateExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TaggedTemplateExpression;

function assertTemplateElement

assertTemplateElement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TemplateElement;

function assertTemplateLiteral

assertTemplateLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TemplateLiteral;

function assertTerminatorless

assertTerminatorless: (
    node: object | null | undefined,
    opts?: object
) => asserts node is Terminatorless;

function assertThisExpression

assertThisExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ThisExpression;

function assertThisTypeAnnotation

assertThisTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ThisTypeAnnotation;

function assertThrowStatement

assertThrowStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is ThrowStatement;

function assertTryStatement

assertTryStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TryStatement;

function assertTSAnyKeyword

assertTSAnyKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSAnyKeyword;

function assertTSArrayType

assertTSArrayType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSArrayType;

function assertTSAsExpression

assertTSAsExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSAsExpression;

function assertTSBooleanKeyword

assertTSBooleanKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSBooleanKeyword;

function assertTSCallSignatureDeclaration

assertTSCallSignatureDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSCallSignatureDeclaration;

function assertTSConstructorType

assertTSConstructorType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSConstructorType;

function assertTSConstructSignatureDeclaration

assertTSConstructSignatureDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSConstructSignatureDeclaration;

function assertTSDeclareFunction

assertTSDeclareFunction: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSDeclareFunction;

function assertTSDeclareMethod

assertTSDeclareMethod: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSDeclareMethod;

function assertTSEnumDeclaration

assertTSEnumDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSEnumDeclaration;

function assertTSEnumMember

assertTSEnumMember: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSEnumMember;

function assertTSExportAssignment

assertTSExportAssignment: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSExportAssignment;

function assertTSExpressionWithTypeArguments

assertTSExpressionWithTypeArguments: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSExpressionWithTypeArguments;

function assertTSExternalModuleReference

assertTSExternalModuleReference: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSExternalModuleReference;

function assertTSFunctionType

assertTSFunctionType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSFunctionType;

function assertTSImportEqualsDeclaration

assertTSImportEqualsDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSImportEqualsDeclaration;

function assertTSIndexedAccessType

assertTSIndexedAccessType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSIndexedAccessType;

function assertTSIndexSignature

assertTSIndexSignature: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSIndexSignature;

function assertTSInterfaceBody

assertTSInterfaceBody: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSInterfaceBody;

function assertTSInterfaceDeclaration

assertTSInterfaceDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSInterfaceDeclaration;

function assertTSIntersectionType

assertTSIntersectionType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSIntersectionType;

function assertTSLiteralType

assertTSLiteralType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSLiteralType;

function assertTSMappedType

assertTSMappedType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSMappedType;

function assertTSMethodSignature

assertTSMethodSignature: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSMethodSignature;

function assertTSModuleBlock

assertTSModuleBlock: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSModuleBlock;

function assertTSModuleDeclaration

assertTSModuleDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSModuleDeclaration;

function assertTSNamespaceExportDeclaration

assertTSNamespaceExportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSNamespaceExportDeclaration;

function assertTSNeverKeyword

assertTSNeverKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSNeverKeyword;

function assertTSNonNullExpression

assertTSNonNullExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSNonNullExpression;

function assertTSNullKeyword

assertTSNullKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSNullKeyword;

function assertTSNumberKeyword

assertTSNumberKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSNumberKeyword;

function assertTSObjectKeyword

assertTSObjectKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSObjectKeyword;

function assertTSParameterProperty

assertTSParameterProperty: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSParameterProperty;

function assertTSParenthesizedType

assertTSParenthesizedType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSParenthesizedType;

function assertTSPropertySignature

assertTSPropertySignature: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSPropertySignature;

function assertTSQualifiedName

assertTSQualifiedName: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSQualifiedName;

function assertTSStringKeyword

assertTSStringKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSStringKeyword;

function assertTSSymbolKeyword

assertTSSymbolKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSSymbolKeyword;

function assertTSThisType

assertTSThisType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSThisType;

function assertTSTupleType

assertTSTupleType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTupleType;

function assertTSTypeAliasDeclaration

assertTSTypeAliasDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeAliasDeclaration;

function assertTSTypeAnnotation

assertTSTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeAnnotation;

function assertTSTypeAssertion

assertTSTypeAssertion: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeAssertion;

function assertTSTypeLiteral

assertTSTypeLiteral: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeLiteral;

function assertTSTypeOperator

assertTSTypeOperator: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeOperator;

function assertTSTypeParameter

assertTSTypeParameter: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeParameter;

function assertTSTypeParameterDeclaration

assertTSTypeParameterDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeParameterDeclaration;

function assertTSTypeParameterInstantiation

assertTSTypeParameterInstantiation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeParameterInstantiation;

function assertTSTypePredicate

assertTSTypePredicate: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypePredicate;

function assertTSTypeQuery

assertTSTypeQuery: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeQuery;

function assertTSTypeReference

assertTSTypeReference: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSTypeReference;

function assertTSUndefinedKeyword

assertTSUndefinedKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSUndefinedKeyword;

function assertTSUnionType

assertTSUnionType: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSUnionType;

function assertTSVoidKeyword

assertTSVoidKeyword: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TSVoidKeyword;

function assertTupleTypeAnnotation

assertTupleTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TupleTypeAnnotation;

function assertTypeAlias

assertTypeAlias: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeAlias;

function assertTypeAnnotation

assertTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeAnnotation;

function assertTypeCastExpression

assertTypeCastExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeCastExpression;

function assertTypeofTypeAnnotation

assertTypeofTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeofTypeAnnotation;

function assertTypeParameter

assertTypeParameter: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeParameter;

function assertTypeParameterDeclaration

assertTypeParameterDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeParameterDeclaration;

function assertTypeParameterInstantiation

assertTypeParameterInstantiation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is TypeParameterInstantiation;

function assertUnaryExpression

assertUnaryExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is UnaryExpression;

function assertUnaryLike

assertUnaryLike: (
    node: object | null | undefined,
    opts?: object
) => asserts node is UnaryLike;

function assertUnionTypeAnnotation

assertUnionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is UnionTypeAnnotation;

function assertUpdateExpression

assertUpdateExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is UpdateExpression;

function assertUserWhitespacable

assertUserWhitespacable: (
    node: object | null | undefined,
    opts?: object
) => asserts node is UserWhitespacable;

function assertVariableDeclaration

assertVariableDeclaration: (
    node: object | null | undefined,
    opts?: object
) => asserts node is VariableDeclaration;

function assertVariableDeclarator

assertVariableDeclarator: (
    node: object | null | undefined,
    opts?: object
) => asserts node is VariableDeclarator;

function assertVoidTypeAnnotation

assertVoidTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => asserts node is VoidTypeAnnotation;

function assertWhile

assertWhile: (
    node: object | null | undefined,
    opts?: object
) => asserts node is While;

function assertWhileStatement

assertWhileStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is WhileStatement;

function assertWithStatement

assertWithStatement: (
    node: object | null | undefined,
    opts?: object
) => asserts node is WithStatement;

function assertYieldExpression

assertYieldExpression: (
    node: object | null | undefined,
    opts?: object
) => asserts node is YieldExpression;

function assignmentExpression

assignmentExpression: (
    operator?: string,
    left?: LVal,
    right?: Expression
) => AssignmentExpression;

function assignmentPattern

assignmentPattern: (left?: Identifier, right?: Expression) => AssignmentPattern;

function awaitExpression

awaitExpression: (argument?: Expression) => AwaitExpression;

function binaryExpression

binaryExpression: (
    operator?:
        | '+'
        | '-'
        | '/'
        | '%'
        | '*'
        | '**'
        | '&'
        | '|'
        | '>>'
        | '>>>'
        | '<<'
        | '^'
        | '=='
        | '==='
        | '!='
        | '!=='
        | 'in'
        | 'instanceof'
        | '>'
        | '<'
        | '>='
        | '<=',
    left?: Expression,
    right?: Expression
) => BinaryExpression;

function bindExpression

bindExpression: (object?: Expression, callee?: Expression) => BindExpression;

function blockStatement

blockStatement: (body?: Statement[], directives?: Directive[]) => BlockStatement;

function booleanLiteral

booleanLiteral: (value?: boolean) => BooleanLiteral;

function booleanLiteralTypeAnnotation

booleanLiteralTypeAnnotation: () => BooleanLiteralTypeAnnotation;

function booleanTypeAnnotation

booleanTypeAnnotation: () => BooleanTypeAnnotation;

function breakStatement

breakStatement: (label?: Identifier) => BreakStatement;

function callExpression

callExpression: (
    callee?: Expression,
    _arguments?: Array<Expression | SpreadElement>
) => CallExpression;

function catchClause

catchClause: (param?: Identifier, body?: BlockStatement) => CatchClause;

function classBody

classBody: (body?: Array<ClassMethod | ClassProperty>) => ClassBody;

function classDeclaration

classDeclaration: (
    id?: Identifier,
    superClass?: Expression,
    body?: ClassBody,
    decorators?: Decorator[]
) => ClassDeclaration;

function classExpression

classExpression: (
    id?: Identifier,
    superClass?: Expression,
    body?: ClassBody,
    decorators?: Decorator[]
) => ClassExpression;

function classImplements

classImplements: (
    id?: Identifier,
    typeParameters?: TypeParameterInstantiation
) => ClassImplements;

function classMethod

classMethod: (
    kind?: 'constructor' | 'method' | 'get' | 'set',
    key?: Expression,
    params?: LVal[],
    body?: BlockStatement,
    computed?: boolean,
    _static?: boolean
) => ClassMethod;

function classProperty

classProperty: (
    key?: Identifier,
    value?: Expression,
    typeAnnotation?: TypeAnnotation,
    decorators?: Decorator[]
) => ClassProperty;

function conditionalExpression

conditionalExpression: (
    test?: Expression,
    consequent?: Expression,
    alternate?: Expression
) => ConditionalExpression;

function continueStatement

continueStatement: (label?: Identifier) => ContinueStatement;

function debuggerStatement

debuggerStatement: () => DebuggerStatement;

function declareClass

declareClass: (
    id?: Identifier,
    typeParameters?: TypeParameterDeclaration,
    _extends?: InterfaceExtends[],
    body?: ObjectTypeAnnotation
) => DeclareClass;

function declareFunction

declareFunction: (id?: Identifier) => DeclareFunction;

function declareInterface

declareInterface: (
    id?: Identifier,
    typeParameters?: TypeParameterDeclaration,
    _extends?: InterfaceExtends[],
    body?: ObjectTypeAnnotation
) => DeclareInterface;

function declareModule

declareModule: (
    id?: StringLiteral | Identifier,
    body?: BlockStatement
) => DeclareModule;

function declareTypeAlias

declareTypeAlias: (
    id?: Identifier,
    typeParameters?: TypeParameterDeclaration,
    right?: FlowTypeAnnotation
) => DeclareTypeAlias;

function declareVariable

declareVariable: (id?: Identifier) => DeclareVariable;

function decorator

decorator: (expression?: Expression) => Decorator;

function directive

directive: (value?: DirectiveLiteral) => Directive;

function directiveLiteral

directiveLiteral: (value?: string) => DirectiveLiteral;

function doExpression

doExpression: (body?: BlockStatement) => DoExpression;

function doWhileStatement

doWhileStatement: (test?: Expression, body?: Statement) => DoWhileStatement;

function emptyStatement

emptyStatement: () => EmptyStatement;

function existentialTypeParam

existentialTypeParam: () => ExistentialTypeParam;

function exportAllDeclaration

exportAllDeclaration: (source?: StringLiteral) => ExportAllDeclaration;

function exportDefaultDeclaration

exportDefaultDeclaration: (
    declaration?: FunctionDeclaration | ClassDeclaration | Expression
) => ExportDefaultDeclaration;

function exportDefaultSpecifier

exportDefaultSpecifier: (exported?: Identifier) => ExportDefaultSpecifier;

function exportNamedDeclaration

exportNamedDeclaration: (
    declaration?: Declaration,
    specifiers?: ExportSpecifier[],
    source?: StringLiteral
) => ExportNamedDeclaration;

function exportNamespaceSpecifier

exportNamespaceSpecifier: (exported?: Identifier) => ExportNamespaceSpecifier;

function exportSpecifier

exportSpecifier: (local?: Identifier, exported?: Identifier) => ExportSpecifier;

function expressionStatement

expressionStatement: (expression?: Expression) => ExpressionStatement;

function file

file: (program?: Program, comments?: Comment[], tokens?: any[]) => File;

function forInStatement

forInStatement: (
    left?: VariableDeclaration | LVal,
    right?: Expression,
    body?: Statement
) => ForInStatement;

function forOfStatement

forOfStatement: (
    left?: VariableDeclaration | LVal,
    right?: Expression,
    body?: Statement
) => ForOfStatement;

function forStatement

forStatement: (
    init?: VariableDeclaration | Expression,
    test?: Expression,
    update?: Expression,
    body?: Statement
) => ForStatement;

function functionDeclaration

functionDeclaration: (
    id?: Identifier,
    params?: LVal[],
    body?: BlockStatement,
    generator?: boolean,
    async?: boolean
) => FunctionDeclaration;

function functionExpression

functionExpression: (
    id?: Identifier,
    params?: LVal[],
    body?: BlockStatement,
    generator?: boolean,
    async?: boolean
) => FunctionExpression;

function functionTypeAnnotation

functionTypeAnnotation: (
    typeParameters?: TypeParameterDeclaration,
    params?: FunctionTypeParam[],
    rest?: FunctionTypeParam,
    returnType?: FlowTypeAnnotation
) => FunctionTypeAnnotation;

function functionTypeParam

functionTypeParam: (
    name?: Identifier,
    typeAnnotation?: FlowTypeAnnotation
) => FunctionTypeParam;

function genericTypeAnnotation

genericTypeAnnotation: (
    id?: Identifier,
    typeParameters?: TypeParameterInstantiation
) => GenericTypeAnnotation;

function identifier

identifier: (name?: string) => Identifier;

function ifStatement

ifStatement: (
    test?: Expression,
    consequent?: Statement,
    alternate?: Statement
) => IfStatement;

function importDeclaration

importDeclaration: (
    specifiers?: Array<
        ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
    >,
    source?: StringLiteral
) => ImportDeclaration;

function importDefaultSpecifier

importDefaultSpecifier: (local?: Identifier) => ImportDefaultSpecifier;

function importNamespaceSpecifier

importNamespaceSpecifier: (local?: Identifier) => ImportNamespaceSpecifier;

function importSpecifier

importSpecifier: (local?: Identifier, imported?: Identifier) => ImportSpecifier;

function interfaceDeclaration

interfaceDeclaration: (
    id?: Identifier,
    typeParameters?: TypeParameterDeclaration,
    _extends?: InterfaceExtends[],
    body?: ObjectTypeAnnotation
) => InterfaceDeclaration;

function interfaceExtends

interfaceExtends: (
    id?: Identifier,
    typeParameters?: TypeParameterInstantiation
) => InterfaceExtends;

function intersectionTypeAnnotation

intersectionTypeAnnotation: (
    types?: FlowTypeAnnotation[]
) => IntersectionTypeAnnotation;

function isAnyTypeAnnotation

isAnyTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is AnyTypeAnnotation;

function isArrayExpression

isArrayExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ArrayExpression;

function isArrayPattern

isArrayPattern: (
    node: object | null | undefined,
    opts?: object
) => node is ArrayPattern;

function isArrayTypeAnnotation

isArrayTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is ArrayTypeAnnotation;

function isArrowFunctionExpression

isArrowFunctionExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ArrowFunctionExpression;

function isAssignmentExpression

isAssignmentExpression: (
    node: object | null | undefined,
    opts?: object
) => node is AssignmentExpression;

function isAssignmentPattern

isAssignmentPattern: (
    node: object | null | undefined,
    opts?: object
) => node is AssignmentPattern;

function isAwaitExpression

isAwaitExpression: (
    node: object | null | undefined,
    opts?: object
) => node is AwaitExpression;

function isBinary

isBinary: (node: object | null | undefined, opts?: object) => node is Binary;

function isBinaryExpression

isBinaryExpression: (
    node: object | null | undefined,
    opts?: object
) => node is BinaryExpression;

function isBindExpression

isBindExpression: (
    node: object | null | undefined,
    opts?: object
) => node is BindExpression;

function isBindingIdentifier

isBindingIdentifier: (
    node: object | null | undefined,
    opts?: object
) => node is Identifier;

function isBlock

isBlock: (node: object | null | undefined, opts?: object) => node is Block;

function isBlockParent

isBlockParent: (
    node: object | null | undefined,
    opts?: object
) => node is BlockParent;

function isBlockScoped

isBlockScoped: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionDeclaration | VariableDeclaration | ClassDeclaration;

function isBlockStatement

isBlockStatement: (
    node: object | null | undefined,
    opts?: object
) => node is BlockStatement;

function isBooleanLiteral

isBooleanLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is BooleanLiteral;

function isBooleanLiteralTypeAnnotation

isBooleanLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is BooleanLiteralTypeAnnotation;

function isBooleanTypeAnnotation

isBooleanTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is BooleanTypeAnnotation;

function isBreakStatement

isBreakStatement: (
    node: object | null | undefined,
    opts?: object
) => node is BreakStatement;

function isCallExpression

isCallExpression: (
    node: object | null | undefined,
    opts?: object
) => node is CallExpression;

function isCatchClause

isCatchClause: (
    node: object | null | undefined,
    opts?: object
) => node is CatchClause;

function isClass

isClass: (node: object | null | undefined, opts?: object) => node is Class;

function isClassBody

isClassBody: (
    node: object | null | undefined,
    opts?: object
) => node is ClassBody;

function isClassDeclaration

isClassDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ClassDeclaration;

function isClassExpression

isClassExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ClassExpression;

function isClassImplements

isClassImplements: (
    node: object | null | undefined,
    opts?: object
) => node is ClassImplements;

function isClassMethod

isClassMethod: (
    node: object | null | undefined,
    opts?: object
) => node is ClassMethod;

function isClassProperty

isClassProperty: (
    node: object | null | undefined,
    opts?: object
) => node is ClassProperty;

function isCompletionStatement

isCompletionStatement: (
    node: object | null | undefined,
    opts?: object
) => node is CompletionStatement;

function isConditional

isConditional: (
    node: object | null | undefined,
    opts?: object
) => node is Conditional;

function isConditionalExpression

isConditionalExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ConditionalExpression;

function isContinueStatement

isContinueStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ContinueStatement;

function isDebuggerStatement

isDebuggerStatement: (
    node: object | null | undefined,
    opts?: object
) => node is DebuggerStatement;

function isDeclaration

isDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is Declaration;

function isDeclareClass

isDeclareClass: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareClass;

function isDeclareFunction

isDeclareFunction: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareFunction;

function isDeclareInterface

isDeclareInterface: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareInterface;

function isDeclareModule

isDeclareModule: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareModule;

function isDeclareTypeAlias

isDeclareTypeAlias: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareTypeAlias;

function isDeclareVariable

isDeclareVariable: (
    node: object | null | undefined,
    opts?: object
) => node is DeclareVariable;

function isDecorator

isDecorator: (
    node: object | null | undefined,
    opts?: object
) => node is Decorator;

function isDirective

isDirective: (
    node: object | null | undefined,
    opts?: object
) => node is Directive;

function isDirectiveLiteral

isDirectiveLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is DirectiveLiteral;

function isDoExpression

isDoExpression: (
    node: object | null | undefined,
    opts?: object
) => node is DoExpression;

function isDoWhileStatement

isDoWhileStatement: (
    node: object | null | undefined,
    opts?: object
) => node is DoWhileStatement;

function isEmptyStatement

isEmptyStatement: (
    node: object | null | undefined,
    opts?: object
) => node is EmptyStatement;

function isExistentialTypeParam

isExistentialTypeParam: (
    node: object | null | undefined,
    opts?: object
) => node is ExistentialTypeParam;

function isExportAllDeclaration

isExportAllDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ExportAllDeclaration;

function isExportDeclaration

isExportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ExportDeclaration;

function isExportDefaultDeclaration

isExportDefaultDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ExportDefaultDeclaration;

function isExportDefaultSpecifier

isExportDefaultSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ExportDefaultSpecifier;

function isExportNamedDeclaration

isExportNamedDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ExportNamedDeclaration;

function isExportNamespaceSpecifier

isExportNamespaceSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ExportNamespaceSpecifier;

function isExportSpecifier

isExportSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ExportSpecifier;

function isExpression

isExpression: (
    node: object | null | undefined,
    opts?: object
) => node is Expression;

function isExpressionStatement

isExpressionStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ExpressionStatement;

function isExpressionWrapper

isExpressionWrapper: (
    node: object | null | undefined,
    opts?: object
) => node is ExpressionWrapper;

function isFile

isFile: (node: object | null | undefined, opts?: object) => node is File;

function isFlow

isFlow: (node: object | null | undefined, opts?: object) => node is Flow;

function isFlowBaseAnnotation

isFlowBaseAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is FlowBaseAnnotation;

function isFlowDeclaration

isFlowDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is FlowDeclaration;

function isFor

isFor: (node: object | null | undefined, opts?: object) => node is For;

function isForInStatement

isForInStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ForInStatement;

function isForOfStatement

isForOfStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ForOfStatement;

function isForStatement

isForStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ForStatement;

function isForXStatement

isForXStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ForXStatement;

function isFunction

isFunction: (node: object | null | undefined, opts?: object) => node is Function;

function isFunctionDeclaration

isFunctionDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionDeclaration;

function isFunctionExpression

isFunctionExpression: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionExpression;

function isFunctionParent

isFunctionParent: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionParent;

function isFunctionTypeAnnotation

isFunctionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionTypeAnnotation;

function isFunctionTypeParam

isFunctionTypeParam: (
    node: object | null | undefined,
    opts?: object
) => node is FunctionTypeParam;

function isGenerated

isGenerated: (node: object | null | undefined, opts?: object) => boolean;

function isGenericTypeAnnotation

isGenericTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is GenericTypeAnnotation;

function isIdentifier

isIdentifier: (
    node: object | null | undefined,
    opts?: object
) => node is Identifier;

function isIfStatement

isIfStatement: (
    node: object | null | undefined,
    opts?: object
) => node is IfStatement;

function isImmutable

isImmutable: (
    node: object | null | undefined,
    opts?: object
) => node is Immutable;

function isImportDeclaration

isImportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ImportDeclaration;

function isImportDefaultSpecifier

isImportDefaultSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ImportDefaultSpecifier;

function isImportNamespaceSpecifier

isImportNamespaceSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ImportNamespaceSpecifier;

function isImportSpecifier

isImportSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ImportSpecifier;

function isInterfaceDeclaration

isInterfaceDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is InterfaceDeclaration;

function isInterfaceExtends

isInterfaceExtends: (
    node: object | null | undefined,
    opts?: object
) => node is InterfaceExtends;

function isIntersectionTypeAnnotation

isIntersectionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is IntersectionTypeAnnotation;

function isJSX

isJSX: (node: object | null | undefined, opts?: object) => node is JSX;

function isJSXAttribute

isJSXAttribute: (
    node: object | null | undefined,
    opts?: object
) => node is JSXAttribute;

function isJSXClosingElement

isJSXClosingElement: (
    node: object | null | undefined,
    opts?: object
) => node is JSXClosingElement;

function isJSXElement

isJSXElement: (
    node: object | null | undefined,
    opts?: object
) => node is JSXElement;

function isJSXEmptyExpression

isJSXEmptyExpression: (
    node: object | null | undefined,
    opts?: object
) => node is JSXEmptyExpression;

function isJSXExpressionContainer

isJSXExpressionContainer: (
    node: object | null | undefined,
    opts?: object
) => node is JSXExpressionContainer;

function isJSXIdentifier

isJSXIdentifier: (
    node: object | null | undefined,
    opts?: object
) => node is JSXIdentifier;

function isJSXMemberExpression

isJSXMemberExpression: (
    node: object | null | undefined,
    opts?: object
) => node is JSXMemberExpression;

function isJSXNamespacedName

isJSXNamespacedName: (
    node: object | null | undefined,
    opts?: object
) => node is JSXNamespacedName;

function isJSXOpeningElement

isJSXOpeningElement: (
    node: object | null | undefined,
    opts?: object
) => node is JSXOpeningElement;

function isJSXSpreadAttribute

isJSXSpreadAttribute: (
    node: object | null | undefined,
    opts?: object
) => node is JSXSpreadAttribute;

function isJSXText

isJSXText: (node: object | null | undefined, opts?: object) => node is JSXText;

function isLabeledStatement

isLabeledStatement: (
    node: object | null | undefined,
    opts?: object
) => node is LabeledStatement;

function isLiteral

isLiteral: (node: object | null | undefined, opts?: object) => node is Literal;

function isLogicalExpression

isLogicalExpression: (
    node: object | null | undefined,
    opts?: object
) => node is LogicalExpression;

function isLoop

isLoop: (node: object | null | undefined, opts?: object) => node is Loop;

function isLVal

isLVal: (node: object | null | undefined, opts?: object) => node is LVal;

function isMemberExpression

isMemberExpression: (
    node: object | null | undefined,
    opts?: object
) => node is MemberExpression;

function isMetaProperty

isMetaProperty: (
    node: object | null | undefined,
    opts?: object
) => node is MetaProperty;

function isMethod

isMethod: (node: object | null | undefined, opts?: object) => node is Method;

function isMixedTypeAnnotation

isMixedTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is MixedTypeAnnotation;

function isModuleDeclaration

isModuleDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is ModuleDeclaration;

function isModuleSpecifier

isModuleSpecifier: (
    node: object | null | undefined,
    opts?: object
) => node is ModuleSpecifier;

function isNewExpression

isNewExpression: (
    node: object | null | undefined,
    opts?: object
) => node is NewExpression;

function isNoop

isNoop: (node: object | null | undefined, opts?: object) => node is Noop;

function isNullableTypeAnnotation

isNullableTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is NullableTypeAnnotation;

function isNullLiteral

isNullLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is NullLiteral;

function isNullLiteralTypeAnnotation

isNullLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is NullLiteralTypeAnnotation;

function isNumberLiteral

isNumberLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is NumericLiteral;

Deprecated
Use isNumericLiteral

function isNumberTypeAnnotation

isNumberTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is NumberTypeAnnotation;

function isNumericLiteral

isNumericLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is NumericLiteral;

function isNumericLiteralTypeAnnotation

isNumericLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is NumericLiteralTypeAnnotation;

function isObjectExpression

isObjectExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectExpression;

function isObjectMember

isObjectMember: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectMember;

function isObjectMethod

isObjectMethod: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectMethod;

function isObjectPattern

isObjectPattern: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectPattern;

function isObjectProperty

isObjectProperty: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectProperty;

function isObjectTypeAnnotation

isObjectTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectTypeAnnotation;

function isObjectTypeCallProperty

isObjectTypeCallProperty: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectTypeCallProperty;

function isObjectTypeIndexer

isObjectTypeIndexer: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectTypeIndexer;

function isObjectTypeProperty

isObjectTypeProperty: (
    node: object | null | undefined,
    opts?: object
) => node is ObjectTypeProperty;

function isParenthesizedExpression

isParenthesizedExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ParenthesizedExpression;

function isPattern

isPattern: (node: object | null | undefined, opts?: object) => node is Pattern;

function isProgram

isProgram: (node: object | null | undefined, opts?: object) => node is Program;

function isProperty

isProperty: (node: object | null | undefined, opts?: object) => node is Property;

function isPure

isPure: (node: object | null | undefined, opts?: object) => boolean;

function isPureish

isPureish: (node: object | null | undefined, opts?: object) => node is Pureish;

function isQualifiedTypeIdentifier

isQualifiedTypeIdentifier: (
    node: object | null | undefined,
    opts?: object
) => node is QualifiedTypeIdentifier;

function isReferenced

isReferenced: (node: object | null | undefined, opts?: object) => boolean;

function isReferencedIdentifier

isReferencedIdentifier: (
    node: object | null | undefined,
    opts?: object
) => node is Identifier | JSXIdentifier;

function isReferencedMemberExpression

isReferencedMemberExpression: (
    node: object | null | undefined,
    opts?: object
) => node is MemberExpression;

function isRegexLiteral

isRegexLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is RegExpLiteral;

Deprecated
Use isRegExpLiteral

function isRegExpLiteral

isRegExpLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is RegExpLiteral;

function isRestElement

isRestElement: (
    node: object | null | undefined,
    opts?: object
) => node is RestElement;

function isRestProperty

isRestProperty: (
    node: object | null | undefined,
    opts?: object
) => node is RestProperty;

function isReturnStatement

isReturnStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ReturnStatement;

function isScopable

isScopable: (node: object | null | undefined, opts?: object) => node is Scopable;

function isScope

isScope: (node: object | null | undefined, opts?: object) => node is Scopable;

function isSequenceExpression

isSequenceExpression: (
    node: object | null | undefined,
    opts?: object
) => node is SequenceExpression;

function isSpreadElement

isSpreadElement: (
    node: object | null | undefined,
    opts?: object
) => node is SpreadElement;

function isSpreadProperty

isSpreadProperty: (
    node: object | null | undefined,
    opts?: object
) => node is SpreadProperty;

function isStatement

isStatement: (
    node: object | null | undefined,
    opts?: object
) => node is Statement;

function isStringLiteral

isStringLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is StringLiteral;

function isStringLiteralTypeAnnotation

isStringLiteralTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is StringLiteralTypeAnnotation;

function isStringTypeAnnotation

isStringTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is StringTypeAnnotation;

function isSuper

isSuper: (node: object | null | undefined, opts?: object) => node is Super;

function isSwitchCase

isSwitchCase: (
    node: object | null | undefined,
    opts?: object
) => node is SwitchCase;

function isSwitchStatement

isSwitchStatement: (
    node: object | null | undefined,
    opts?: object
) => node is SwitchStatement;

function isTaggedTemplateExpression

isTaggedTemplateExpression: (
    node: object | null | undefined,
    opts?: object
) => node is TaggedTemplateExpression;

function isTemplateElement

isTemplateElement: (
    node: object | null | undefined,
    opts?: object
) => node is TemplateElement;

function isTemplateLiteral

isTemplateLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is TemplateLiteral;

function isTerminatorless

isTerminatorless: (
    node: object | null | undefined,
    opts?: object
) => node is Terminatorless;

function isThisExpression

isThisExpression: (
    node: object | null | undefined,
    opts?: object
) => node is ThisExpression;

function isThisTypeAnnotation

isThisTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is ThisTypeAnnotation;

function isThrowStatement

isThrowStatement: (
    node: object | null | undefined,
    opts?: object
) => node is ThrowStatement;

function isTryStatement

isTryStatement: (
    node: object | null | undefined,
    opts?: object
) => node is TryStatement;

function isTSAnyKeyword

isTSAnyKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSAnyKeyword;

function isTSArrayType

isTSArrayType: (
    node: object | null | undefined,
    opts?: object
) => node is TSArrayType;

function isTSAsExpression

isTSAsExpression: (
    node: object | null | undefined,
    opts?: object
) => node is TSAsExpression;

function isTSBooleanKeyword

isTSBooleanKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSBooleanKeyword;

function isTSCallSignatureDeclaration

isTSCallSignatureDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSCallSignatureDeclaration;

function isTSConstructorType

isTSConstructorType: (
    node: object | null | undefined,
    opts?: object
) => node is TSConstructorType;

function isTSConstructSignatureDeclaration

isTSConstructSignatureDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeElement;

function isTSDeclareFunction

isTSDeclareFunction: (
    node: object | null | undefined,
    opts?: object
) => node is TSDeclareFunction;

function isTSDeclareMethod

isTSDeclareMethod: (
    node: object | null | undefined,
    opts?: object
) => node is TSDeclareMethod;

function isTSEnumDeclaration

isTSEnumDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSEnumDeclaration;

function isTSEnumMember

isTSEnumMember: (
    node: object | null | undefined,
    opts?: object
) => node is TSEnumMember;

function isTSExportAssignment

isTSExportAssignment: (
    node: object | null | undefined,
    opts?: object
) => node is TSExportAssignment;

function isTSExpressionWithTypeArguments

isTSExpressionWithTypeArguments: (
    node: object | null | undefined,
    opts?: object
) => node is TSExpressionWithTypeArguments;

function isTSExternalModuleReference

isTSExternalModuleReference: (
    node: object | null | undefined,
    opts?: object
) => node is TSExternalModuleReference;

function isTSFunctionType

isTSFunctionType: (
    node: object | null | undefined,
    opts?: object
) => node is TSFunctionType;

function isTSImportEqualsDeclaration

isTSImportEqualsDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSImportEqualsDeclaration;

function isTSIndexedAccessType

isTSIndexedAccessType: (
    node: object | null | undefined,
    opts?: object
) => node is TSIndexedAccessType;

function isTSIndexSignature

isTSIndexSignature: (
    node: object | null | undefined,
    opts?: object
) => node is TSIndexSignature;

function isTSInterfaceBody

isTSInterfaceBody: (
    node: object | null | undefined,
    opts?: object
) => node is TSInterfaceBody;

function isTSInterfaceDeclaration

isTSInterfaceDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSInterfaceDeclaration;

function isTSIntersectionType

isTSIntersectionType: (
    node: object | null | undefined,
    opts?: object
) => node is TSIntersectionType;

function isTSLiteralType

isTSLiteralType: (
    node: object | null | undefined,
    opts?: object
) => node is TSLiteralType;

function isTSMappedType

isTSMappedType: (
    node: object | null | undefined,
    opts?: object
) => node is TSMappedType;

function isTSMethodSignature

isTSMethodSignature: (
    node: object | null | undefined,
    opts?: object
) => node is TSMethodSignature;

function isTSModuleBlock

isTSModuleBlock: (
    node: object | null | undefined,
    opts?: object
) => node is TSModuleBlock;

function isTSModuleDeclaration

isTSModuleDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSModuleDeclaration;

function isTSNamespaceExportDeclaration

isTSNamespaceExportDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSNamespaceExportDeclaration;

function isTSNeverKeyword

isTSNeverKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSNeverKeyword;

function isTSNonNullExpression

isTSNonNullExpression: (
    node: object | null | undefined,
    opts?: object
) => node is TSNonNullExpression;

function isTSNullKeyword

isTSNullKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSNullKeyword;

function isTSNumberKeyword

isTSNumberKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSNumberKeyword;

function isTSObjectKeyword

isTSObjectKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSObjectKeyword;

function isTSParameterProperty

isTSParameterProperty: (
    node: object | null | undefined,
    opts?: object
) => node is TSParameterProperty;

function isTSParenthesizedType

isTSParenthesizedType: (
    node: object | null | undefined,
    opts?: object
) => node is TSParenthesizedType;

function isTSPropertySignature

isTSPropertySignature: (
    node: object | null | undefined,
    opts?: object
) => node is TSPropertySignature;

function isTSQualifiedName

isTSQualifiedName: (
    node: object | null | undefined,
    opts?: object
) => node is TSQualifiedName;

function isTSStringKeyword

isTSStringKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSStringKeyword;

function isTSSymbolKeyword

isTSSymbolKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSSymbolKeyword;

function isTSThisType

isTSThisType: (
    node: object | null | undefined,
    opts?: object
) => node is TSThisType;

function isTSTupleType

isTSTupleType: (
    node: object | null | undefined,
    opts?: object
) => node is TSTupleType;

function isTSTypeAliasDeclaration

isTSTypeAliasDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeAliasDeclaration;

function isTSTypeAnnotation

isTSTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeAnnotation;

function isTSTypeAssertion

isTSTypeAssertion: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeAssertion;

function isTSTypeLiteral

isTSTypeLiteral: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeLiteral;

function isTSTypeOperator

isTSTypeOperator: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeOperator;

function isTSTypeParameter

isTSTypeParameter: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeParameter;

function isTSTypeParameterDeclaration

isTSTypeParameterDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeParameterDeclaration;

function isTSTypeParameterInstantiation

isTSTypeParameterInstantiation: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeParameterInstantiation;

function isTSTypePredicate

isTSTypePredicate: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypePredicate;

function isTSTypeQuery

isTSTypeQuery: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeQuery;

function isTSTypeReference

isTSTypeReference: (
    node: object | null | undefined,
    opts?: object
) => node is TSTypeReference;

function isTSUndefinedKeyword

isTSUndefinedKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSUndefinedKeyword;

function isTSUnionType

isTSUnionType: (
    node: object | null | undefined,
    opts?: object
) => node is TSUnionType;

function isTSVoidKeyword

isTSVoidKeyword: (
    node: object | null | undefined,
    opts?: object
) => node is TSVoidKeyword;

function isTupleTypeAnnotation

isTupleTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is TupleTypeAnnotation;

function isTypeAlias

isTypeAlias: (
    node: object | null | undefined,
    opts?: object
) => node is TypeAlias;

function isTypeAnnotation

isTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is TypeAnnotation;

function isTypeCastExpression

isTypeCastExpression: (
    node: object | null | undefined,
    opts?: object
) => node is TypeCastExpression;

function isTypeofTypeAnnotation

isTypeofTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is TypeofTypeAnnotation;

function isTypeParameter

isTypeParameter: (
    node: object | null | undefined,
    opts?: object
) => node is TypeParameter;

function isTypeParameterDeclaration

isTypeParameterDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is TypeParameterDeclaration;

function isTypeParameterInstantiation

isTypeParameterInstantiation: (
    node: object | null | undefined,
    opts?: object
) => node is TypeParameterInstantiation;

function isUnaryExpression

isUnaryExpression: (
    node: object | null | undefined,
    opts?: object
) => node is UnaryExpression;

function isUnaryLike

isUnaryLike: (
    node: object | null | undefined,
    opts?: object
) => node is UnaryLike;

function isUnionTypeAnnotation

isUnionTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is UnionTypeAnnotation;

function isUpdateExpression

isUpdateExpression: (
    node: object | null | undefined,
    opts?: object
) => node is UpdateExpression;

function isUser

isUser: (node: object | null | undefined, opts?: object) => boolean;

function isUserWhitespacable

isUserWhitespacable: (
    node: object | null | undefined,
    opts?: object
) => node is UserWhitespacable;

function isVar

isVar: (
    node: object | null | undefined,
    opts?: object
) => node is VariableDeclaration;

function isVariableDeclaration

isVariableDeclaration: (
    node: object | null | undefined,
    opts?: object
) => node is VariableDeclaration;

function isVariableDeclarator

isVariableDeclarator: (
    node: object | null | undefined,
    opts?: object
) => node is VariableDeclarator;

function isVoidTypeAnnotation

isVoidTypeAnnotation: (
    node: object | null | undefined,
    opts?: object
) => node is VoidTypeAnnotation;

function isWhile

isWhile: (node: object | null | undefined, opts?: object) => node is While;

function isWhileStatement

isWhileStatement: (
    node: object | null | undefined,
    opts?: object
) => node is WhileStatement;

function isWithStatement

isWithStatement: (
    node: object | null | undefined,
    opts?: object
) => node is WithStatement;

function isYieldExpression

isYieldExpression: (
    node: object | null | undefined,
    opts?: object
) => node is YieldExpression;

function jSXAttribute

jSXAttribute: (
    name?: JSXIdentifier | JSXNamespacedName,
    value?: JSXElement | StringLiteral | JSXExpressionContainer | null
) => JSXAttribute;

function jSXClosingElement

jSXClosingElement: (
    name?: JSXIdentifier | JSXMemberExpression
) => JSXClosingElement;

function jSXElement

jSXElement: (
    openingElement?: JSXOpeningElement,
    closingElement?: JSXClosingElement,
    children?: Array<JSXElement | JSXExpressionContainer | JSXText>,
    selfClosing?: boolean
) => JSXElement;

function jSXEmptyExpression

jSXEmptyExpression: () => JSXEmptyExpression;

function jSXExpressionContainer

jSXExpressionContainer: (expression?: Expression) => JSXExpressionContainer;

function jSXIdentifier

jSXIdentifier: (name?: string) => JSXIdentifier;

function jSXMemberExpression

jSXMemberExpression: (
    object?: JSXMemberExpression | JSXIdentifier,
    property?: JSXIdentifier
) => JSXMemberExpression;

function jSXNamespacedName

jSXNamespacedName: (
    namespace?: JSXIdentifier,
    name?: JSXIdentifier
) => JSXNamespacedName;

function jSXOpeningElement

jSXOpeningElement: (
    name?: JSXIdentifier | JSXMemberExpression,
    attributes?: JSXAttribute[],
    selfClosing?: boolean
) => JSXOpeningElement;

function jSXSpreadAttribute

jSXSpreadAttribute: (argument?: Expression) => JSXSpreadAttribute;

function jSXText

jSXText: (value?: string) => JSXText;

function labeledStatement

labeledStatement: (label?: Identifier, body?: Statement) => LabeledStatement;

function logicalExpression

logicalExpression: (
    operator?: '||' | '&&',
    left?: Expression,
    right?: Expression
) => LogicalExpression;

function memberExpression

memberExpression: (
    object?: Expression | Super,
    property?: Expression,
    computed?: boolean
) => MemberExpression;

function metaProperty

metaProperty: (meta?: string, property?: string) => MetaProperty;

function mixedTypeAnnotation

mixedTypeAnnotation: () => MixedTypeAnnotation;

function newExpression

newExpression: (
    callee?: Expression | Super,
    _arguments?: Array<Expression | SpreadElement>
) => NewExpression;

function noop

noop: () => Noop;

function nullableTypeAnnotation

nullableTypeAnnotation: (
    typeAnnotation?: FlowTypeAnnotation
) => NullableTypeAnnotation;

function nullLiteral

nullLiteral: () => NullLiteral;

function nullLiteralTypeAnnotation

nullLiteralTypeAnnotation: () => NullLiteralTypeAnnotation;

function numberTypeAnnotation

numberTypeAnnotation: () => NumberTypeAnnotation;

function numericLiteral

numericLiteral: (value?: number) => NumericLiteral;

function numericLiteralTypeAnnotation

numericLiteralTypeAnnotation: () => NumericLiteralTypeAnnotation;

function objectExpression

objectExpression: (
    properties?: Array<ObjectProperty | ObjectMethod | SpreadProperty>
) => ObjectExpression;

function objectMethod

objectMethod: (
    kind?: 'get' | 'set' | 'method',
    key?: Expression,
    params?: LVal[],
    body?: BlockStatement,
    computed?: boolean
) => ObjectMethod;

function objectPattern

objectPattern: (
    properties?: Array<AssignmentProperty | RestProperty>,
    typeAnnotation?: TypeAnnotation
) => ObjectPattern;

function objectProperty

objectProperty: (
    key?: Expression,
    value?: Expression,
    computed?: boolean,
    shorthand?: boolean,
    decorators?: Decorator[]
) => ObjectProperty;

function objectTypeAnnotation

objectTypeAnnotation: (
    properties?: ObjectTypeProperty[],
    indexers?: ObjectTypeIndexer[],
    callProperties?: ObjectTypeCallProperty[]
) => ObjectTypeAnnotation;

function objectTypeCallProperty

objectTypeCallProperty: (value?: FlowTypeAnnotation) => ObjectTypeCallProperty;

function objectTypeIndexer

objectTypeIndexer: (
    id?: Expression,
    key?: FlowTypeAnnotation,
    value?: FlowTypeAnnotation
) => ObjectTypeIndexer;

function objectTypeProperty

objectTypeProperty: (
    key?: Expression,
    value?: FlowTypeAnnotation
) => ObjectTypeProperty;

function parenthesizedExpression

parenthesizedExpression: (expression?: Expression) => ParenthesizedExpression;

function program

program: (
    body?: Array<Statement | ModuleDeclaration>,
    directives?: Directive[]
) => Program;

function qualifiedTypeIdentifier

qualifiedTypeIdentifier: (
    id?: Identifier,
    qualification?: Identifier | QualifiedTypeIdentifier
) => QualifiedTypeIdentifier;

function regExpLiteral

regExpLiteral: (pattern?: string, flags?: string) => RegExpLiteral;

function restElement

restElement: (argument?: LVal, typeAnnotation?: TypeAnnotation) => RestElement;

function restProperty

restProperty: (argument?: LVal) => RestProperty;

function returnStatement

returnStatement: (argument?: Expression) => ReturnStatement;

function sequenceExpression

sequenceExpression: (expressions?: Expression[]) => SequenceExpression;

function spreadElement

spreadElement: (argument?: Expression) => SpreadElement;

function spreadProperty

spreadProperty: (argument?: Expression) => SpreadProperty;

function stringLiteral

stringLiteral: (value?: string) => StringLiteral;

function stringLiteralTypeAnnotation

stringLiteralTypeAnnotation: () => StringLiteralTypeAnnotation;

function stringTypeAnnotation

stringTypeAnnotation: () => StringTypeAnnotation;

function switchCase

switchCase: (test?: Expression, consequent?: Statement[]) => SwitchCase;

function switchStatement

switchStatement: (
    discriminant?: Expression,
    cases?: SwitchCase[]
) => SwitchStatement;

function taggedTemplateExpression

taggedTemplateExpression: (
    tag?: Expression,
    quasi?: TemplateLiteral
) => TaggedTemplateExpression;

function templateElement

templateElement: (
    value?: { cooked?: string | undefined; raw?: string | undefined },
    tail?: boolean
) => TemplateElement;

function templateLiteral

templateLiteral: (
    quasis?: TemplateElement[],
    expressions?: Expression[]
) => TemplateLiteral;

function thisExpression

thisExpression: () => ThisExpression;

function thisTypeAnnotation

thisTypeAnnotation: () => ThisTypeAnnotation;

function throwStatement

throwStatement: (argument?: Expression) => ThrowStatement;

function tryStatement

tryStatement: (
    block?: BlockStatement,
    handler?: CatchClause,
    finalizer?: BlockStatement
) => TryStatement;

function TSAnyKeyword

TSAnyKeyword: () => TSAnyKeyword;

function TSArrayType

TSArrayType: (elementType: TSType) => TSArrayType;

function TSAsExpression

TSAsExpression: (
    expression: Expression,
    typeAnnotation: TSType
) => TSAsExpression;

function TSBooleanKeyword

TSBooleanKeyword: () => TSBooleanKeyword;

function TSCallSignatureDeclaration

TSCallSignatureDeclaration: (
    typeParameters?: TypeParameterDeclaration,
    parameters?: Array<Identifier | RestElement>,
    typeAnnotation?: TSTypeAnnotation
) => TSCallSignatureDeclaration;

function TSConstructorType

TSConstructorType: (
    typeParameters?: TypeParameterDeclaration,
    typeAnnotation?: TSTypeAnnotation
) => TSConstructorType;

function TSConstructSignatureDeclaration

TSConstructSignatureDeclaration: (
    typeParameters?: TypeParameterDeclaration,
    parameters?: Array<Identifier | RestElement>,
    typeAnnotation?: TSTypeAnnotation
) => TSTypeElement;

function TSDeclareFunction

TSDeclareFunction: (
    id: Identifier | undefined | null,
    typeParameters: TypeParameterDeclaration | Noop | undefined | null,
    params: LVal[],
    returnType: TypeAnnotation | TSTypeAnnotation | Noop | undefined | null
) => TSDeclareFunction;

function TSDeclareMethod

TSDeclareMethod: (
    decorators: Decorator[] | undefined | null,
    key: Expression,
    typeParameters: TypeParameterDeclaration | Noop | undefined | null,
    params: LVal[],
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop
) => TSDeclareMethod;

function TSEnumDeclaration

TSEnumDeclaration: (
    id: Identifier,
    members: TSEnumMember[]
) => TSEnumDeclaration;

function TSEnumMember

TSEnumMember: (
    id: Identifier | StringLiteral,
    initializer?: Expression
) => TSEnumMember;

function TSExportAssignment

TSExportAssignment: (expression: Expression) => TSExportAssignment;

function TSExpressionWithTypeArguments

TSExpressionWithTypeArguments: (
    expression: TSEntityName,
    typeParameters?: TypeParameterInstantiation
) => TSExpressionWithTypeArguments;

function TSExternalModuleReference

TSExternalModuleReference: (
    expression: StringLiteral
) => TSExternalModuleReference;

function TSFunctionType

TSFunctionType: (
    typeParameters?: TypeParameterDeclaration,
    typeAnnotation?: TSTypeAnnotation
) => TSFunctionType;

function TSImportEqualsDeclaration

TSImportEqualsDeclaration: (
    id: Identifier,
    moduleReference: TSEntityName | TSExternalModuleReference
) => TSImportEqualsDeclaration;

function TSIndexedAccessType

TSIndexedAccessType: (
    objectType: TSType,
    indexType: TSType
) => TSIndexedAccessType;

function TSIndexSignature

TSIndexSignature: (
    parameters: Identifier[],
    typeAnnotation?: TSTypeAnnotation
) => TSIndexSignature;

function TSInterfaceBody

TSInterfaceBody: (body: TSTypeElement[]) => TSInterfaceBody;

function TSInterfaceDeclaration

TSInterfaceDeclaration: (
    id: Identifier,
    typeParameters: TypeParameterDeclaration | undefined | null,
    extends_: TSExpressionWithTypeArguments[] | undefined | null,
    body: TSInterfaceBody
) => TSInterfaceDeclaration;

function TSIntersectionType

TSIntersectionType: (types: TSType[]) => TSIntersectionType;

function TSLiteralType

TSLiteralType: (
    literal: NumericLiteral | StringLiteral | BooleanLiteral
) => TSLiteralType;

function TSMappedType

TSMappedType: (
    typeParameter: TypeParameter,
    typeAnnotation?: TSType
) => TSMappedType;

function TSMethodSignature

TSMethodSignature: (
    key: Expression,
    typeParameters?: TypeParameterDeclaration,
    parameters?: Array<Identifier | RestElement>,
    typeAnnotation?: TSTypeAnnotation
) => TSMethodSignature;

function TSModuleBlock

TSModuleBlock: (body: Statement[]) => TSModuleBlock;

function TSModuleDeclaration

TSModuleDeclaration: (
    id: Identifier | StringLiteral,
    body: TSModuleBlock | TSModuleDeclaration
) => TSModuleDeclaration;

function TSNamespaceExportDeclaration

TSNamespaceExportDeclaration: (id: Identifier) => TSNamespaceExportDeclaration;

function TSNeverKeyword

TSNeverKeyword: () => TSNeverKeyword;

function TSNonNullExpression

TSNonNullExpression: (expression: Expression) => TSNonNullExpression;

function TSNullKeyword

TSNullKeyword: () => TSNullKeyword;

function TSNumberKeyword

TSNumberKeyword: () => TSNumberKeyword;

function TSObjectKeyword

TSObjectKeyword: () => TSObjectKeyword;

function TSParameterProperty

TSParameterProperty: (
    parameter: Identifier | AssignmentPattern
) => TSParameterProperty;

function TSParenthesizedType

TSParenthesizedType: (typeAnnotation: TSType) => TSParenthesizedType;

function TSPropertySignature

TSPropertySignature: (
    key: Expression,
    typeAnnotation?: TSTypeAnnotation,
    initializer?: Expression
) => TSPropertySignature;

function TSQualifiedName

TSQualifiedName: (left: TSEntityName, right: Identifier) => TSQualifiedName;

function TSStringKeyword

TSStringKeyword: () => TSStringKeyword;

function TSSymbolKeyword

TSSymbolKeyword: () => TSSymbolKeyword;

function TSThisType

TSThisType: () => TSThisType;

function TSTupleType

TSTupleType: (elementTypes: TSType[]) => TSTupleType;

function TSTypeAliasDeclaration

TSTypeAliasDeclaration: (
    id: Identifier,
    typeParameters: TypeParameterDeclaration | undefined | null,
    typeAnnotation: TSType
) => TSTypeAliasDeclaration;

function TSTypeAnnotation

TSTypeAnnotation: (typeAnnotation: TSType) => TSTypeAnnotation;

function TSTypeAssertion

TSTypeAssertion: (
    typeAnnotation: TSType,
    expression: Expression
) => TSTypeAssertion;

function TSTypeLiteral

TSTypeLiteral: (members: TSTypeElement[]) => TSTypeLiteral;

function TSTypeOperator

TSTypeOperator: (typeAnnotation: TSType) => TSTypeOperator;

function TSTypeParameter

TSTypeParameter: (constraint?: TSType, default_?: TSType) => TSTypeParameter;

function TSTypeParameterDeclaration

TSTypeParameterDeclaration: (
    params: TSTypeParameter[]
) => TSTypeParameterDeclaration;

function TSTypeParameterInstantiation

TSTypeParameterInstantiation: (params: TSType[]) => TSTypeParameterInstantiation;

function TSTypePredicate

TSTypePredicate: (
    parameterName: Identifier | TSThisType,
    typeAnnotation: TSTypeAnnotation
) => TSTypePredicate;

function TSTypeQuery

TSTypeQuery: (exprName: TSEntityName) => TSTypeQuery;

function TSTypeReference

TSTypeReference: (
    typeName: TSEntityName,
    typeParameters?: TSTypeParameterInstantiation
) => TSTypeReference;

function TSUndefinedKeyword

TSUndefinedKeyword: () => TSUndefinedKeyword;

function TSUnionType

TSUnionType: (types: TSType[]) => TSUnionType;

function TSVoidKeyword

TSVoidKeyword: () => TSVoidKeyword;

function tupleTypeAnnotation

tupleTypeAnnotation: (types?: FlowTypeAnnotation[]) => TupleTypeAnnotation;

function typeAlias

typeAlias: (
    id?: Identifier,
    typeParameters?: TypeParameterDeclaration,
    right?: FlowTypeAnnotation
) => TypeAlias;

function typeAnnotation

typeAnnotation: (typeAnnotation?: FlowTypeAnnotation) => TypeAnnotation;

function typeCastExpression

typeCastExpression: (
    expression?: Expression,
    typeAnnotation?: FlowTypeAnnotation
) => TypeCastExpression;

function typeofTypeAnnotation

typeofTypeAnnotation: (argument?: FlowTypeAnnotation) => TypeofTypeAnnotation;

function typeParameter

typeParameter: (bound?: TypeAnnotation, default_?: Flow) => TypeParameter;

function typeParameterDeclaration

typeParameterDeclaration: (params?: Identifier[]) => TypeParameterDeclaration;

function typeParameterInstantiation

typeParameterInstantiation: (
    params?: FlowTypeAnnotation[]
) => TypeParameterInstantiation;

function unaryExpression

unaryExpression: (
    operator?: 'void' | 'delete' | '!' | '+' | '-' | '++' | '--' | '~' | 'typeof',
    argument?: Expression,
    prefix?: boolean
) => UnaryExpression;

function unionTypeAnnotation

unionTypeAnnotation: (types?: FlowTypeAnnotation[]) => UnionTypeAnnotation;

function updateExpression

updateExpression: (
    operator?: '++' | '--',
    argument?: Expression,
    prefix?: boolean
) => UpdateExpression;

function variableDeclaration

variableDeclaration: (
    kind?: 'var' | 'let' | 'const',
    declarations?: VariableDeclarator[]
) => VariableDeclaration;

function variableDeclarator

variableDeclarator: (id?: LVal, init?: Expression) => VariableDeclarator;

function voidTypeAnnotation

voidTypeAnnotation: () => VoidTypeAnnotation;

function whileStatement

whileStatement: (
    test?: Expression,
    body?: BlockStatement | Statement
) => WhileStatement;

function withStatement

withStatement: (
    object?: Expression,
    body?: BlockStatement | Statement
) => WithStatement;

function yieldExpression

yieldExpression: (argument?: Expression, delegate?: boolean) => YieldExpression;

Interfaces

interface AnyTypeAnnotation

interface AnyTypeAnnotation extends Node {}

property type

type: 'AnyTypeAnnotation';

interface ArrayExpression

interface ArrayExpression extends Node {}

property elements

elements: Array<null | Expression | SpreadElement>;

property type

type: 'ArrayExpression';

interface ArrayPattern

interface ArrayPattern extends Node {}

property elements

elements: Expression[];

property type

type: 'ArrayPattern';

property typeAnnotation

typeAnnotation?: TypeAnnotation | undefined;

interface ArrayTypeAnnotation

interface ArrayTypeAnnotation extends Node {}

property elementType

elementType: FlowTypeAnnotation;

property type

type: 'ArrayTypeAnnotation';

interface ArrowFunctionExpression

interface ArrowFunctionExpression extends Node {}

property async

async: boolean;

property body

body: BlockStatement | Expression;

property expression

expression: boolean;

property generator

generator: boolean;

property id

id: Identifier;

property params

params: LVal[];

property returnType

returnType?: TypeAnnotation | undefined;

property type

type: 'ArrowFunctionExpression';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

interface AssignmentExpression

interface AssignmentExpression extends Node {}

property left

left: LVal;

property operator

operator:
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '<<='
    | '>>='
    | '>>>='
    | '|='
    | '^='
    | '&=';

property right

right: Expression;

property type

type: 'AssignmentExpression';

interface AssignmentPattern

interface AssignmentPattern extends Node {}

property left

left: Identifier;

property right

right: Expression;

property type

type: 'AssignmentPattern';

interface AssignmentProperty

interface AssignmentProperty extends Node {}

property computed

computed: boolean;

property decorators

decorators?: Decorator[] | undefined;

property key

key: Expression;

property shorthand

shorthand: boolean;

property type

type: 'ObjectProperty';

property value

value: Pattern;

interface AwaitExpression

interface AwaitExpression extends Node {}

property argument

argument: Expression;

property type

type: 'AwaitExpression';

interface BinaryExpression

interface BinaryExpression extends Node {}

property left

left: Expression;

property operator

operator:
    | '+'
    | '-'
    | '/'
    | '%'
    | '*'
    | '**'
    | '&'
    | '|'
    | '>>'
    | '>>>'
    | '<<'
    | '^'
    | '=='
    | '==='
    | '!='
    | '!=='
    | 'in'
    | 'instanceof'
    | '>'
    | '<'
    | '>='
    | '<=';

property right

right: Expression;

property type

type: 'BinaryExpression';

interface BindExpression

interface BindExpression extends Node {}

property callee

callee: Expression;

property object

object: Expression;

property type

type: 'BindExpression';

interface BlockStatement

interface BlockStatement extends Node {}

property body

body: Statement[];

property directives

directives?: Directive[] | undefined;

property type

type: 'BlockStatement';

interface BooleanLiteral

interface BooleanLiteral extends Node {}

property type

type: 'BooleanLiteral';

property value

value: boolean;

interface BooleanLiteralTypeAnnotation

interface BooleanLiteralTypeAnnotation extends Node {}

property type

type: 'BooleanLiteralTypeAnnotation';

interface BooleanTypeAnnotation

interface BooleanTypeAnnotation extends Node {}

property type

type: 'BooleanTypeAnnotation';

interface BreakStatement

interface BreakStatement extends Node {}

property label

label: Identifier;

property type

type: 'BreakStatement';

interface CallExpression

interface CallExpression extends Node {}

property arguments

arguments: Array<Expression | SpreadElement>;

property callee

callee: Expression | Super;

property type

type: 'CallExpression';

interface CatchClause

interface CatchClause extends Node {}

property body

body: BlockStatement;

property param

param: Identifier;

property type

type: 'CatchClause';

interface ClassBody

interface ClassBody extends Node {}

property body

body: Array<ClassMethod | ClassProperty>;

property type

type: 'ClassBody';

interface ClassDeclaration

interface ClassDeclaration extends Node {}

property body

body: ClassBody;

property decorators

decorators?: Decorator[] | undefined;

property id

id: Identifier;

property implements

implements?: ClassImplements[] | undefined;

property mixins

mixins?: any[] | undefined;

property superClass

superClass: Expression;

property superTypeParameters

superTypeParameters?: TypeParameterInstantiation | undefined;

property type

type: 'ClassDeclaration';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

interface ClassExpression

interface ClassExpression extends Node {}

property body

body: ClassBody;

property decorators

decorators?: Decorator[] | undefined;

property id

id: Identifier;

property implements

implements?: ClassImplements[] | undefined;

property mixins

mixins?: any[] | undefined;

property superClass

superClass: Expression;

property superTypeParameters

superTypeParameters?: TypeParameterInstantiation | undefined;

property type

type: 'ClassExpression';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

interface ClassImplements

interface ClassImplements extends Node {}

property id

id: Identifier;

property type

type: 'ClassImplements';

property typeParameters

typeParameters: TypeParameterInstantiation;

interface ClassMethod

interface ClassMethod extends Node {}

property async

async: boolean;

property body

body: BlockStatement;

property computed

computed: boolean;

property decorators

decorators?: Decorator[] | undefined;

property expression

expression: boolean;

property generator

generator: boolean;

property id

id: Identifier;

property key

key: Expression;

property kind

kind: 'constructor' | 'method' | 'get' | 'set';

property params

params: LVal[];

property returnType

returnType?: TypeAnnotation | undefined;

property static

static: boolean;

property type

type: 'ClassMethod';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

property value

value?: FunctionExpression | undefined;

interface ClassProperty

interface ClassProperty extends Node {}

property decorators

decorators?: Decorator[] | undefined;

property key

key: Identifier;

property type

type: 'ClassProperty';

property typeAnnotation

typeAnnotation?: TypeAnnotation | undefined;

property value

value: Expression;

interface Comment

interface Comment {}

property end

end: number;

property loc

loc: SourceLocation;

property start

start: number;

property value

value: string;

interface CommentBlock

interface CommentBlock extends Comment {}

property type

type: 'CommentBlock';

interface CommentLine

interface CommentLine extends Comment {}

property type

type: 'CommentLine';

interface ConditionalExpression

interface ConditionalExpression extends Node {}

property alternate

alternate: Expression;

property consequent

consequent: Expression;

property test

test: Expression;

property type

type: 'ConditionalExpression';

interface ContinueStatement

interface ContinueStatement extends Node {}

property label

label: Identifier;

property type

type: 'ContinueStatement';

interface DebuggerStatement

interface DebuggerStatement extends Node {}

property type

type: 'DebuggerStatement';

interface DeclareClass

interface DeclareClass extends Node {}

property body

body: ObjectTypeAnnotation;

property extends

extends: InterfaceExtends[];

property id

id: Identifier;

property type

type: 'DeclareClass';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface DeclareFunction

interface DeclareFunction extends Node {}

property id

id: Identifier;

property type

type: 'DeclareFunction';

interface DeclareInterface

interface DeclareInterface extends Node {}

property body

body: ObjectTypeAnnotation;

property extends

extends: InterfaceExtends[];

property id

id: Identifier;

property type

type: 'DeclareInterface';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface DeclareModule

interface DeclareModule extends Node {}

property body

body: BlockStatement;

property id

id: StringLiteral | Identifier;

property type

type: 'DeclareModule';

interface DeclareTypeAlias

interface DeclareTypeAlias extends Node {}

property id

id: Identifier;

property right

right: FlowTypeAnnotation;

property type

type: 'DeclareTypeAlias';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface DeclareVariable

interface DeclareVariable extends Node {}

property id

id: Identifier;

property type

type: 'DeclareVariable';

interface Decorator

interface Decorator extends Node {}

property expression

expression: Expression;

property type

type: 'Decorator';

interface Directive

interface Directive extends Node {}

property type

type: 'Directive';

property value

value: DirectiveLiteral;

interface DirectiveLiteral

interface DirectiveLiteral extends Node {}

property type

type: 'DirectiveLiteral';

property value

value: string;

interface DoExpression

interface DoExpression extends Node {}

property body

body: BlockStatement;

property type

type: 'DoExpression';

interface DoWhileStatement

interface DoWhileStatement extends Node {}

property body

body: Statement;

property test

test: Expression;

property type

type: 'DoWhileStatement';

interface EmptyStatement

interface EmptyStatement extends Node {}

property type

type: 'EmptyStatement';

interface ExistentialTypeParam

interface ExistentialTypeParam extends Node {}

property type

type: 'ExistentialTypeParam';

interface ExportAllDeclaration

interface ExportAllDeclaration extends Node {}

property source

source: StringLiteral;

property type

type: 'ExportAllDeclaration';

interface ExportDefaultDeclaration

interface ExportDefaultDeclaration extends Node {}

property declaration

declaration: Declaration | Expression;

property type

type: 'ExportDefaultDeclaration';

interface ExportDefaultSpecifier

interface ExportDefaultSpecifier extends Node {}

property exported

exported: Identifier;

property type

type: 'ExportDefaultSpecifier';

interface ExportNamedDeclaration

interface ExportNamedDeclaration extends Node {}

property declaration

declaration: Declaration;

property source

source: StringLiteral | null;

property specifiers

specifiers: ExportSpecifier[];

property type

type: 'ExportNamedDeclaration';

interface ExportNamespaceSpecifier

interface ExportNamespaceSpecifier extends Node {}

property exported

exported: Identifier;

property type

type: 'ExportNamespaceSpecifier';

interface ExportSpecifier

interface ExportSpecifier extends Node {}

property exported

exported: Identifier;

property imported

imported: Identifier;

property local

local: Identifier;

property type

type: 'ExportSpecifier';

interface ExpressionStatement

interface ExpressionStatement extends Node {}

property expression

expression: Expression;

property type

type: 'ExpressionStatement';

interface File

interface File extends Node {}

property comments

comments: Comment[];

property program

program: Program;

property tokens

tokens: any[];

property type

type: 'File';

interface ForInStatement

interface ForInStatement extends Node {}

property body

body: Statement;

property left

left: VariableDeclaration | LVal;

property right

right: Expression;

property type

type: 'ForInStatement';

interface ForOfStatement

interface ForOfStatement extends Node {}

property body

body: Statement;

property left

left: VariableDeclaration | LVal;

property right

right: Expression;

property type

type: 'ForOfStatement';

interface ForStatement

interface ForStatement extends Node {}

property body

body: Statement;

property init

init: VariableDeclaration | Expression;

property test

test: Expression;

property type

type: 'ForStatement';

property update

update: Expression;

interface FunctionDeclaration

interface FunctionDeclaration extends Node {}

property async

async: boolean;

property body

body: BlockStatement;

property generator

generator: boolean;

property id

id: Identifier;

property params

params: LVal[];

property returnType

returnType?: TypeAnnotation | undefined;

property type

type: 'FunctionDeclaration';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

interface FunctionExpression

interface FunctionExpression extends Node {}

property async

async: boolean;

property body

body: BlockStatement;

property generator

generator: boolean;

property id

id: Identifier;

property params

params: LVal[];

property returnType

returnType?: TypeAnnotation | undefined;

property type

type: 'FunctionExpression';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

interface FunctionTypeAnnotation

interface FunctionTypeAnnotation extends Node {}

property params

params: FunctionTypeParam[];

property rest

rest: FunctionTypeParam;

property returnType

returnType: FlowTypeAnnotation;

property type

type: 'FunctionTypeAnnotation';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface FunctionTypeParam

interface FunctionTypeParam extends Node {}

property name

name: Identifier;

property type

type: 'FunctionTypeParam';

property typeAnnotation

typeAnnotation: FlowTypeAnnotation;

interface GenericTypeAnnotation

interface GenericTypeAnnotation extends Node {}

property id

id: Identifier;

property type

type: 'GenericTypeAnnotation';

property typeParameters

typeParameters: TypeParameterInstantiation;

interface Identifier

interface Identifier extends Node {}

property name

name: string;

property type

type: 'Identifier';

property typeAnnotation

typeAnnotation?: TypeAnnotation | undefined;

interface IfStatement

interface IfStatement extends Node {}

property alternate

alternate: Statement;

property consequent

consequent: Statement;

property test

test: Expression;

property type

type: 'IfStatement';

interface ImportDeclaration

interface ImportDeclaration extends Node {}

property source

source: StringLiteral;

property specifiers

specifiers: Array<
    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
>;

property type

type: 'ImportDeclaration';

interface ImportDefaultSpecifier

interface ImportDefaultSpecifier extends Node {}

property local

local: Identifier;

property type

type: 'ImportDefaultSpecifier';

interface ImportNamespaceSpecifier

interface ImportNamespaceSpecifier extends Node {}

property local

local: Identifier;

property type

type: 'ImportNamespaceSpecifier';

interface ImportSpecifier

interface ImportSpecifier extends Node {}

property imported

imported: Identifier;

property local

local: Identifier;

property type

type: 'ImportSpecifier';

interface InterfaceDeclaration

interface InterfaceDeclaration extends Node {}

property body

body: ObjectTypeAnnotation;

property extends

extends: InterfaceExtends[];

property id

id: Identifier;

property mixins

mixins?: any[] | undefined;

property type

type: 'InterfaceDeclaration';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface InterfaceExtends

interface InterfaceExtends extends Node {}

property id

id: Identifier;

property type

type: 'InterfaceExtends';

property typeParameters

typeParameters: TypeParameterInstantiation;

interface IntersectionTypeAnnotation

interface IntersectionTypeAnnotation extends Node {}

property type

type: 'IntersectionTypeAnnotation';

property types

types: FlowTypeAnnotation[];

interface JSXAttribute

interface JSXAttribute extends Node {}

property name

name: JSXIdentifier | JSXNamespacedName;

property type

type: 'JSXAttribute';

property value

value: JSXElement | StringLiteral | JSXExpressionContainer | null;

interface JSXClosingElement

interface JSXClosingElement extends Node {}

property name

name: JSXIdentifier | JSXMemberExpression;

property type

type: 'JSXClosingElement';

interface JSXElement

interface JSXElement extends Node {}

property children

children: Array<JSXElement | JSXExpressionContainer | JSXText>;

property closingElement

closingElement: JSXClosingElement;

property openingElement

openingElement: JSXOpeningElement;

property selfClosing

selfClosing?: boolean | undefined;

property type

type: 'JSXElement';

interface JSXEmptyExpression

interface JSXEmptyExpression extends Node {}

property type

type: 'JSXEmptyExpression';

interface JSXExpressionContainer

interface JSXExpressionContainer extends Node {}

property expression

expression: Expression;

property type

type: 'JSXExpressionContainer';

interface JSXIdentifier

interface JSXIdentifier extends Node {}

property name

name: string;

property type

type: 'JSXIdentifier';

interface JSXMemberExpression

interface JSXMemberExpression extends Node {}

property object

object: JSXMemberExpression | JSXIdentifier;

property property

property: JSXIdentifier;

property type

type: 'JSXMemberExpression';

interface JSXNamespacedName

interface JSXNamespacedName extends Node {}

property name

name: JSXIdentifier;

property namespace

namespace: JSXIdentifier;

property type

type: 'JSXNamespacedName';

interface JSXOpeningElement

interface JSXOpeningElement extends Node {}

property attributes

attributes: JSXAttribute[];

property name

name: JSXIdentifier | JSXMemberExpression;

property selfClosing

selfClosing: boolean;

property type

type: 'JSXOpeningElement';

interface JSXSpreadAttribute

interface JSXSpreadAttribute extends Node {}

property argument

argument: Expression;

property type

type: 'JSXSpreadAttribute';

interface JSXText

interface JSXText extends Node {}

property type

type: 'JSXText';

property value

value: string;

interface LabeledStatement

interface LabeledStatement extends Node {}

property body

body: Statement;

property label

label: Identifier;

property type

type: 'LabeledStatement';

interface LogicalExpression

interface LogicalExpression extends Node {}

property left

left: Expression;

property operator

operator: '||' | '&&';

property right

right: Expression;

property type

type: 'LogicalExpression';

interface MemberExpression

interface MemberExpression extends Node {}

property computed

computed: boolean;

property object

object: Expression | Super;

property property

property: Expression;

property type

type: 'MemberExpression';

interface MetaProperty

interface MetaProperty extends Node {}

property meta

meta: Identifier;

property property

property: Identifier;

property type

type: 'MetaProperty';

interface MixedTypeAnnotation

interface MixedTypeAnnotation extends Node {}

property type

type: 'MixedTypeAnnotation';

interface NewExpression

interface NewExpression extends Node {}

property arguments

arguments: Array<Expression | SpreadElement>;

property callee

callee: Expression | Super;

property type

type: 'NewExpression';

interface Node

interface Node {}

property end

end: number;

property innerComments

innerComments?: Comment[] | undefined;

property leadingComments

leadingComments?: Comment[] | undefined;

property loc

loc: SourceLocation;

property start

start: number;

property trailingComments

trailingComments?: Comment[] | undefined;

property type

type: string;

interface Noop

interface Noop extends Node {}

property type

type: 'Noop';

interface NullableTypeAnnotation

interface NullableTypeAnnotation extends Node {}

property type

type: 'NullableTypeAnnotation';

property typeAnnotation

typeAnnotation: FlowTypeAnnotation;

interface NullLiteral

interface NullLiteral extends Node {}

property type

type: 'NullLiteral';

interface NullLiteralTypeAnnotation

interface NullLiteralTypeAnnotation extends Node {}

property type

type: 'NullLiteralTypeAnnotation';

interface NumberTypeAnnotation

interface NumberTypeAnnotation extends Node {}

property type

type: 'NumberTypeAnnotation';

interface NumericLiteral

interface NumericLiteral extends Node {}

property type

type: 'NumericLiteral';

property value

value: number;

interface NumericLiteralTypeAnnotation

interface NumericLiteralTypeAnnotation extends Node {}

property type

type: 'NumericLiteralTypeAnnotation';

interface ObjectExpression

interface ObjectExpression extends Node {}

property properties

properties: Array<ObjectProperty | ObjectMethod | SpreadProperty>;

property type

type: 'ObjectExpression';

interface ObjectMethod

interface ObjectMethod extends Node {}

property async

async: boolean;

property body

body: BlockStatement;

property computed

computed: boolean;

property decorators

decorators?: Decorator[] | undefined;

property generator

generator: boolean;

property id

id: Identifier;

property key

key: Expression;

property kind

kind: 'get' | 'set' | 'method';

property params

params: LVal[];

property returnType

returnType?: TypeAnnotation | undefined;

property shorthand

shorthand: boolean;

property type

type: 'ObjectMethod';

property typeParameters

typeParameters?: TypeParameterDeclaration | undefined;

property value

value: Expression;

interface ObjectPattern

interface ObjectPattern extends Node {}

property properties

properties: Array<AssignmentProperty | RestProperty>;

property type

type: 'ObjectPattern';

property typeAnnotation

typeAnnotation?: TypeAnnotation | undefined;

interface ObjectProperty

interface ObjectProperty extends Node {}

property computed

computed: boolean;

property decorators

decorators?: Decorator[] | undefined;

property key

key: Expression;

property shorthand

shorthand: boolean;

property type

type: 'ObjectProperty';

property value

value: Expression;

interface ObjectTypeAnnotation

interface ObjectTypeAnnotation extends Node {}

property callProperties

callProperties: ObjectTypeCallProperty[];

property indexers

indexers: ObjectTypeIndexer[];

property properties

properties: ObjectTypeProperty[];

property type

type: 'ObjectTypeAnnotation';

interface ObjectTypeCallProperty

interface ObjectTypeCallProperty extends Node {}

property type

type: 'ObjectTypeCallProperty';

property value

value: FlowTypeAnnotation;

interface ObjectTypeIndexer

interface ObjectTypeIndexer extends Node {}

property id

id: Expression;

property key

key: FlowTypeAnnotation;

property type

type: 'ObjectTypeIndexer';

property value

value: FlowTypeAnnotation;

interface ObjectTypeProperty

interface ObjectTypeProperty extends Node {}

property key

key: Expression;

property type

type: 'ObjectTypeProperty';

property value

value: FlowTypeAnnotation;

interface ParenthesizedExpression

interface ParenthesizedExpression extends Node {}

property expression

expression: Expression;

property type

type: 'ParenthesizedExpression';

interface Program

interface Program extends Node {}

property body

body: Array<Statement | ModuleDeclaration>;

property directives

directives?: Directive[] | undefined;

property sourceType

sourceType: 'script' | 'module';

property type

type: 'Program';

interface QualifiedTypeIdentifier

interface QualifiedTypeIdentifier extends Node {}

property id

id: Identifier;

property qualification

qualification: Identifier | QualifiedTypeIdentifier;

property type

type: 'QualifiedTypeIdentifier';

interface ReactHelpers

interface ReactHelpers {}

method buildChildren

buildChildren: (node: object) => Node[];

method isCompatTag

isCompatTag: (tagName?: string) => boolean;

interface RegExpLiteral

interface RegExpLiteral extends Node {}

property flags

flags?: string | undefined;

property pattern

pattern: string;

property type

type: 'RegExpLiteral';

interface RestElement

interface RestElement extends Node {}

property argument

argument: LVal;

property type

type: 'RestElement';

property typeAnnotation

typeAnnotation?: TypeAnnotation | undefined;

interface RestProperty

interface RestProperty extends Node {}

property argument

argument: LVal;

property type

type: 'RestProperty';

interface ReturnStatement

interface ReturnStatement extends Node {}

property argument

argument: Expression;

property type

type: 'ReturnStatement';

interface SequenceExpression

interface SequenceExpression extends Node {}

property expressions

expressions: Expression[];

property type

type: 'SequenceExpression';

interface SourceLocation

interface SourceLocation {}

property end

end: {
    line: number;
    column: number;
};

property start

start: {
    line: number;
    column: number;
};

interface SpreadElement

interface SpreadElement extends Node {}

property argument

argument: Expression;

property type

type: 'SpreadElement';

interface SpreadProperty

interface SpreadProperty extends Node {}

property argument

argument: Expression;

property type

type: 'SpreadProperty';

interface StringLiteral

interface StringLiteral extends Node {}

property type

type: 'StringLiteral';

property value

value: string;

interface StringLiteralTypeAnnotation

interface StringLiteralTypeAnnotation extends Node {}

property type

type: 'StringLiteralTypeAnnotation';

interface StringTypeAnnotation

interface StringTypeAnnotation extends Node {}

property type

type: 'StringTypeAnnotation';

interface Super

interface Super extends Node {}

property type

type: 'Super';

interface SwitchCase

interface SwitchCase extends Node {}

property consequent

consequent: Statement[];

property test

test: Expression;

property type

type: 'SwitchCase';

interface SwitchStatement

interface SwitchStatement extends Node {}

property cases

cases: SwitchCase[];

property discriminant

discriminant: Expression;

property type

type: 'SwitchStatement';

interface TaggedTemplateExpression

interface TaggedTemplateExpression extends Node {}

property quasi

quasi: TemplateLiteral;

property tag

tag: Expression;

property type

type: 'TaggedTemplateExpression';

interface TemplateElement

interface TemplateElement extends Node {}

property tail

tail: boolean;

property type

type: 'TemplateElement';

property value

value: {
    cooked: string;
    raw: string;
};

interface TemplateLiteral

interface TemplateLiteral extends Node {}

property expressions

expressions: Expression[];

property quasis

quasis: TemplateElement[];

property type

type: 'TemplateLiteral';

interface ThisExpression

interface ThisExpression extends Node {}

property type

type: 'ThisExpression';

interface ThisTypeAnnotation

interface ThisTypeAnnotation extends Node {}

property type

type: 'ThisTypeAnnotation';

interface ThrowStatement

interface ThrowStatement extends Node {}

property argument

argument: Expression;

property type

type: 'ThrowStatement';

interface TryStatement

interface TryStatement extends Node {}

property block

block: BlockStatement;

property finalizer

finalizer: BlockStatement;

property handler

handler: CatchClause;

property type

type: 'TryStatement';

interface TSAnyKeyword

interface TSAnyKeyword extends Node {}

property type

type: 'TSAnyKeyword';

interface TSArrayType

interface TSArrayType extends Node {}

property elementType

elementType: TSType;

property type

type: 'TSArrayType';

interface TSAsExpression

interface TSAsExpression extends Node {}

property expression

expression: Expression;

property type

type: 'TSAsExpression';

property typeAnnotation

typeAnnotation: TSType;

interface TSBooleanKeyword

interface TSBooleanKeyword extends Node {}

property type

type: 'TSBooleanKeyword';

interface TSCallSignatureDeclaration

interface TSCallSignatureDeclaration extends Node {}

property parameters

parameters: Array<Identifier | RestElement> | null;

property type

type: 'TSCallSignatureDeclaration';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSConstructorType

interface TSConstructorType extends Node {}

property parameters

parameters: Array<Identifier | RestElement> | null;

property type

type: 'TSConstructorType';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSConstructSignatureDeclaration

interface TSConstructSignatureDeclaration extends Node {}

property parameters

parameters: Array<Identifier | RestElement> | null;

property type

type: 'TSConstructSignatureDeclaration';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSDeclareFunction

interface TSDeclareFunction extends Node {}

property async

async: boolean;

property declare

declare: boolean | null;

property generator

generator: boolean;

property id

id: Identifier | null;

property params

params: LVal[];

property returnType

returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;

property type

type: 'TSDeclareFunction';

property typeParameters

typeParameters: TypeParameterDeclaration | Noop | null;

interface TSDeclareMethod

interface TSDeclareMethod extends Node {}

property abstract

abstract: boolean | null;

property access

access: 'public' | 'private' | 'protected' | null;

property accessibility

accessibility: 'public' | 'private' | 'protected' | null;

property async

async: boolean;

property computed

computed: boolean;

property decorators

decorators: Decorator[] | null;

property generator

generator: boolean;

property key

key: Expression;

property kind

kind: 'get' | 'set' | 'method' | 'constructor';

property optional

optional: boolean | null;

property params

params: LVal[];

property returnType

returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;

property static

static: boolean | null;

property type

type: 'TSDeclareMethod';

property typeParameters

typeParameters: TypeParameterDeclaration | Noop | null;

interface TSEnumDeclaration

interface TSEnumDeclaration extends Node {}

property const

const: boolean | null;

property declare

declare: boolean | null;

property id

id: Identifier;

property initializer

initializer: Expression | null;

property members

members: TSEnumMember[];

property type

type: 'TSEnumDeclaration';

interface TSEnumMember

interface TSEnumMember extends Node {}

property id

id: Identifier | StringLiteral;

property initializer

initializer: Expression | null;

property type

type: 'TSEnumMember';

interface TSExportAssignment

interface TSExportAssignment extends Node {}

property expression

expression: Expression;

property type

type: 'TSExportAssignment';

interface TSExpressionWithTypeArguments

interface TSExpressionWithTypeArguments extends Node {}

property expression

expression: TSEntityName;

property type

type: 'TSExpressionWithTypeArguments';

property typeParameters

typeParameters: TypeParameterInstantiation | null;

interface TSExternalModuleReference

interface TSExternalModuleReference extends Node {}

property expression

expression: StringLiteral;

property type

type: 'TSExternalModuleReference';

interface TSFunctionType

interface TSFunctionType extends Node {}

property parameters

parameters: Array<Identifier | RestElement> | null;

property type

type: 'TSFunctionType';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSImportEqualsDeclaration

interface TSImportEqualsDeclaration extends Node {}

property id

id: Identifier;

property isExport

isExport: boolean | null;

property moduleReference

moduleReference: TSEntityName | TSExternalModuleReference;

property type

type: 'TSImportEqualsDeclaration';

interface TSIndexedAccessType

interface TSIndexedAccessType extends Node {}

property indexType

indexType: TSType;

property objectType

objectType: TSType;

property type

type: 'TSIndexedAccessType';

interface TSIndexSignature

interface TSIndexSignature extends Node {}

property parameters

parameters: Identifier[];

property readonly

readonly: boolean | null;

property type

type: 'TSIndexSignature';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

interface TSInterfaceBody

interface TSInterfaceBody extends Node {}

property body

body: TSTypeElement[];

property type

type: 'TSInterfaceBody';

interface TSInterfaceDeclaration

interface TSInterfaceDeclaration extends Node {}

property body

body: TSInterfaceBody;

property declare

declare: boolean | null;

property extends

extends: TSExpressionWithTypeArguments[] | null;

property id

id: Identifier;

property type

type: 'TSInterfaceDeclaration';

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSIntersectionType

interface TSIntersectionType extends Node {}

property type

type: 'TSIntersectionType';

property types

types: TSType[];

interface TSLiteralType

interface TSLiteralType extends Node {}

property literal

literal: NumericLiteral | StringLiteral | BooleanLiteral;

property type

type: 'TSLiteralType';

interface TSMappedType

interface TSMappedType extends Node {}

property optional

optional: boolean | null;

property readonly

readonly: boolean | null;

property type

type: 'TSMappedType';

property typeAnnotation

typeAnnotation: TSType | null;

property typeParameter

typeParameter: TypeParameter;

interface TSMethodSignature

interface TSMethodSignature extends Node {}

property computed

computed: boolean | null;

property key

key: Expression;

property optional

optional: boolean | null;

property parameters

parameters: Array<Identifier | RestElement> | null;

property type

type: 'TSMethodSignature';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSModuleBlock

interface TSModuleBlock extends Node {}

property body

body: Statement[];

property type

type: 'TSModuleBlock';

interface TSModuleDeclaration

interface TSModuleDeclaration extends Node {}

property body

body: TSModuleBlock | TSModuleDeclaration;

property declare

declare: boolean | null;

property global

global: boolean | null;

property id

id: Identifier | StringLiteral;

property type

type: 'TSModuleDeclaration';

interface TSNamespaceExportDeclaration

interface TSNamespaceExportDeclaration extends Node {}

property id

id: Identifier;

property type

type: 'TSNamespaceExportDeclaration';

interface TSNeverKeyword

interface TSNeverKeyword extends Node {}

property type

type: 'TSNeverKeyword';

interface TSNonNullExpression

interface TSNonNullExpression extends Node {}

property expression

expression: Expression;

property type

type: 'TSNonNullExpression';

interface TSNullKeyword

interface TSNullKeyword extends Node {}

property type

type: 'TSNullKeyword';

interface TSNumberKeyword

interface TSNumberKeyword extends Node {}

property type

type: 'TSNumberKeyword';

interface TSObjectKeyword

interface TSObjectKeyword extends Node {}

property type

type: 'TSObjectKeyword';

interface TSParameterProperty

interface TSParameterProperty extends Node {}

property accessibility

accessibility: 'public' | 'private' | 'protected' | null;

property parameter

parameter: Identifier | AssignmentPattern;

property readonly

readonly: boolean | null;

property type

type: 'TSParameterProperty';

interface TSParenthesizedType

interface TSParenthesizedType extends Node {}

property type

type: 'TSParenthesizedType';

property typeAnnotation

typeAnnotation: TSType;

interface TSPropertySignature

interface TSPropertySignature extends Node {}

property computed

computed: boolean | null;

property initializer

initializer: Expression | null;

property key

key: Expression;

property optional

optional: boolean | null;

property readonly

readonly: boolean | null;

property type

type: 'TSPropertySignature';

property typeAnnotation

typeAnnotation: TSTypeAnnotation | null;

interface TSQualifiedName

interface TSQualifiedName extends Node {}

property left

left: TSEntityName;

property right

right: Identifier;

property type

type: 'TSQualifiedName';

interface TSStringKeyword

interface TSStringKeyword extends Node {}

property type

type: 'TSStringKeyword';

interface TSSymbolKeyword

interface TSSymbolKeyword extends Node {}

property type

type: 'TSSymbolKeyword';

interface TSThisType

interface TSThisType extends Node {}

property type

type: 'TSThisType';

interface TSTupleType

interface TSTupleType extends Node {}

property elementTypes

elementTypes: TSType[];

property type

type: 'TSTupleType';

interface TSTypeAliasDeclaration

interface TSTypeAliasDeclaration extends Node {}

property declare

declare: boolean | null;

property id

id: Identifier;

property type

type: 'TSTypeAliasDeclaration';

property typeAnnotation

typeAnnotation: TSType;

property typeParameters

typeParameters: TypeParameterDeclaration | null;

interface TSTypeAnnotation

interface TSTypeAnnotation extends Node {}

property type

type: 'TSTypeAnnotation';

property typeAnnotation

typeAnnotation: TSType;

interface TSTypeAssertion

interface TSTypeAssertion extends Node {}

property expression

expression: Expression;

property type

type: 'TSTypeAssertion';

property typeAnnotation

typeAnnotation: TSType;

interface TSTypeLiteral

interface TSTypeLiteral extends Node {}

property members

members: TSTypeElement[];

property type

type: 'TSTypeLiteral';

interface TSTypeOperator

interface TSTypeOperator extends Node {}

property operator

operator: string | null;

property type

type: 'TSTypeOperator';

property typeAnnotation

typeAnnotation: TSType;

interface TSTypeParameter

interface TSTypeParameter extends Node {}

property constraint

constraint: TSType | null;

property default

default: TSType | null;

property name

name: string | null;

property type

type: 'TSTypeParameter';

interface TSTypeParameterDeclaration

interface TSTypeParameterDeclaration extends Node {}

property params

params: TSTypeParameter[];

property type

type: 'TSTypeParameterDeclaration';

interface TSTypeParameterInstantiation

interface TSTypeParameterInstantiation extends Node {}

property params

params: TSType[];

property type

type: 'TSTypeParameterInstantiation';

interface TSTypePredicate

interface TSTypePredicate extends Node {}

property parameterName

parameterName: Identifier | TSThisType;

property type

type: 'TSTypePredicate';

property typeAnnotation

typeAnnotation: TSTypeAnnotation;

interface TSTypeQuery

interface TSTypeQuery extends Node {}

property exprName

exprName: TSEntityName;

property type

type: 'TSTypeQuery';

interface TSTypeReference

interface TSTypeReference extends Node {}

property type

type: 'TSTypeReference';

property typeName

typeName: TSEntityName;

property typeParameters

typeParameters: TypeParameterInstantiation | null;

interface TSUndefinedKeyword

interface TSUndefinedKeyword extends Node {}

property type

type: 'TSUndefinedKeyword';

interface TSUnionType

interface TSUnionType extends Node {}

property type

type: 'TSUnionType';

property types

types: TSType[];

interface TSVoidKeyword

interface TSVoidKeyword extends Node {}

property type

type: 'TSVoidKeyword';

interface TupleTypeAnnotation

interface TupleTypeAnnotation extends Node {}

property type

type: 'TupleTypeAnnotation';

property types

types: FlowTypeAnnotation[];

interface TypeAlias

interface TypeAlias extends Node {}

property id

id: Identifier;

property right

right: FlowTypeAnnotation;

property type

type: 'TypeAlias';

property typeParameters

typeParameters: TypeParameterDeclaration;

interface TypeAnnotation

interface TypeAnnotation extends Node {}

property type

type: 'TypeAnnotation';

property typeAnnotation

typeAnnotation: FlowTypeAnnotation;

interface TypeCastExpression

interface TypeCastExpression extends Node {}

property expression

expression: Expression;

property type

type: 'TypeCastExpression';

property typeAnnotation

typeAnnotation: FlowTypeAnnotation;

interface TypeofTypeAnnotation

interface TypeofTypeAnnotation extends Node {}

property argument

argument: FlowTypeAnnotation;

property type

type: 'TypeofTypeAnnotation';

interface TypeParameter

interface TypeParameter extends Node {}

property bound

bound: TypeAnnotation | null;

property default

default: Flow | null;

property name

name: string | null;

property type

type: 'TypeParameterDeclaration';

interface TypeParameterDeclaration

interface TypeParameterDeclaration extends Node {}

property params

params: Identifier[];

property type

type: 'TypeParameterDeclaration';

interface TypeParameterInstantiation

interface TypeParameterInstantiation extends Node {}

property params

params: FlowTypeAnnotation[];

property type

type: 'TypeParameterInstantiation';

interface UnaryExpression

interface UnaryExpression extends Node {}

property argument

argument: Expression;

property operator

operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';

property prefix

prefix: boolean;

property type

type: 'UnaryExpression';

interface UnionTypeAnnotation

interface UnionTypeAnnotation extends Node {}

property type

type: 'UnionTypeAnnotation';

property types

types: FlowTypeAnnotation[];

interface UpdateExpression

interface UpdateExpression extends Node {}

property argument

argument: Expression;

property operator

operator: '++' | '--';

property prefix

prefix: boolean;

property type

type: 'UpdateExpression';

interface VariableDeclaration

interface VariableDeclaration extends Node {}

property declarations

declarations: VariableDeclarator[];

property kind

kind: 'var' | 'let' | 'const';

property type

type: 'VariableDeclaration';

interface VariableDeclarator

interface VariableDeclarator extends Node {}

property id

id: LVal;

property init

init: Expression;

property type

type: 'VariableDeclarator';

interface VoidTypeAnnotation

interface VoidTypeAnnotation extends Node {}

property type

type: 'VoidTypeAnnotation';

interface WhileStatement

interface WhileStatement extends Node {}

property body

body: Statement;

property test

test: Expression;

property type

type: 'WhileStatement';

interface WithStatement

interface WithStatement extends Node {}

property body

body: BlockStatement | Statement;

property object

object: Expression;

property type

type: 'WithStatement';

interface YieldExpression

interface YieldExpression extends Node {}

property argument

argument: Expression;

property delegate

delegate: boolean;

property type

type: 'YieldExpression';

Type Aliases

type Binary

type Binary = BinaryExpression | LogicalExpression;

type Block

type Block = BlockStatement | Program;

type BlockParent

type BlockParent =
    | BlockStatement
    | DoWhileStatement
    | ForInStatement
    | ForStatement
    | FunctionDeclaration
    | FunctionExpression
    | Program
    | ObjectMethod
    | SwitchStatement
    | WhileStatement
    | ArrowFunctionExpression
    | ForOfStatement
    | ClassMethod;

type Class

type Class = ClassDeclaration | ClassExpression;

type CompletionStatement

type CompletionStatement =
    | BreakStatement
    | ContinueStatement
    | ReturnStatement
    | ThrowStatement;

type Conditional

type Conditional = ConditionalExpression | IfStatement;

type Declaration

type Declaration =
    | FunctionDeclaration
    | VariableDeclaration
    | ClassDeclaration
    | ExportAllDeclaration
    | ExportDefaultDeclaration
    | ExportNamedDeclaration
    | ImportDeclaration
    | DeclareClass
    | DeclareFunction
    | DeclareInterface
    | DeclareModule
    | DeclareTypeAlias
    | DeclareVariable
    | InterfaceDeclaration
    | TypeAlias
    | TSDeclareFunction
    | TSEnumDeclaration
    | TSInterfaceDeclaration
    | TSModuleDeclaration
    | TSTypeAliasDeclaration;

type ExportDeclaration

type ExportDeclaration =
    | ExportAllDeclaration
    | ExportDefaultDeclaration
    | ExportNamedDeclaration;

type Expression

type Expression =
    | ArrayExpression
    | AssignmentExpression
    | BinaryExpression
    | CallExpression
    | ConditionalExpression
    | FunctionExpression
    | Identifier
    | StringLiteral
    | NumericLiteral
    | BooleanLiteral
    | NullLiteral
    | RegExpLiteral
    | LogicalExpression
    | MemberExpression
    | NewExpression
    | ObjectExpression
    | SequenceExpression
    | ThisExpression
    | UnaryExpression
    | UpdateExpression
    | ArrowFunctionExpression
    | ClassExpression
    | MetaProperty
    | Super
    | TaggedTemplateExpression
    | TemplateLiteral
    | YieldExpression
    | TypeCastExpression
    | JSXElement
    | JSXEmptyExpression
    | JSXIdentifier
    | JSXMemberExpression
    | ParenthesizedExpression
    | AwaitExpression
    | BindExpression
    | DoExpression
    | TSAsExpression
    | TSNonNullExpression
    | TSTypeAssertion;

type ExpressionWrapper

type ExpressionWrapper =
    | ExpressionStatement
    | TypeCastExpression
    | ParenthesizedExpression;

type Flow

type Flow =
    | AnyTypeAnnotation
    | ArrayTypeAnnotation
    | BooleanTypeAnnotation
    | BooleanLiteralTypeAnnotation
    | ClassImplements
    | ClassProperty
    | DeclareClass
    | DeclareFunction
    | DeclareInterface
    | DeclareModule
    | DeclareTypeAlias
    | DeclareVariable
    | ExistentialTypeParam
    | FunctionTypeAnnotation
    | FunctionTypeParam
    | GenericTypeAnnotation
    | InterfaceExtends
    | InterfaceDeclaration
    | IntersectionTypeAnnotation
    | MixedTypeAnnotation
    | NullableTypeAnnotation
    | NumericLiteralTypeAnnotation
    | NumberTypeAnnotation
    | StringLiteralTypeAnnotation
    | StringTypeAnnotation
    | ThisTypeAnnotation
    | TupleTypeAnnotation
    | TypeofTypeAnnotation
    | TypeAlias
    | TypeAnnotation
    | TypeCastExpression
    | TypeParameterDeclaration
    | TypeParameterInstantiation
    | ObjectTypeAnnotation
    | ObjectTypeCallProperty
    | ObjectTypeIndexer
    | ObjectTypeProperty
    | QualifiedTypeIdentifier
    | UnionTypeAnnotation
    | VoidTypeAnnotation;

type FlowBaseAnnotation

type FlowBaseAnnotation =
    | AnyTypeAnnotation
    | BooleanTypeAnnotation
    | MixedTypeAnnotation
    | NumberTypeAnnotation
    | StringTypeAnnotation
    | ThisTypeAnnotation
    | VoidTypeAnnotation;

type FlowDeclaration

type FlowDeclaration =
    | DeclareClass
    | DeclareFunction
    | DeclareInterface
    | DeclareModule
    | DeclareTypeAlias
    | DeclareVariable
    | InterfaceDeclaration
    | TypeAlias;

type FlowTypeAnnotation

type FlowTypeAnnotation =
    | AnyTypeAnnotation
    | ArrayTypeAnnotation
    | BooleanTypeAnnotation
    | BooleanLiteralTypeAnnotation
    | FunctionTypeAnnotation
    | GenericTypeAnnotation
    | IntersectionTypeAnnotation
    | MixedTypeAnnotation
    | NullableTypeAnnotation
    | NumericLiteralTypeAnnotation
    | NumberTypeAnnotation
    | StringLiteralTypeAnnotation
    | StringTypeAnnotation
    | ThisTypeAnnotation
    | TupleTypeAnnotation
    | TypeofTypeAnnotation
    | TypeAnnotation
    | ObjectTypeAnnotation
    | UnionTypeAnnotation
    | VoidTypeAnnotation;

type For

type For = ForInStatement | ForStatement | ForOfStatement;

type ForXStatement

type ForXStatement = ForInStatement | ForOfStatement;

type Function

type Function =
    | FunctionDeclaration
    | FunctionExpression
    | ObjectMethod
    | ArrowFunctionExpression
    | ClassMethod;

type FunctionParent

type FunctionParent =
    | FunctionDeclaration
    | FunctionExpression
    | Program
    | ObjectMethod
    | ArrowFunctionExpression
    | ClassMethod;

type Immutable

type Immutable =
    | StringLiteral
    | NumericLiteral
    | BooleanLiteral
    | NullLiteral
    | JSXAttribute
    | JSXClosingElement
    | JSXElement
    | JSXExpressionContainer
    | JSXOpeningElement;

type JSX

type JSX =
    | JSXAttribute
    | JSXClosingElement
    | JSXElement
    | JSXEmptyExpression
    | JSXExpressionContainer
    | JSXIdentifier
    | JSXMemberExpression
    | JSXNamespacedName
    | JSXOpeningElement
    | JSXSpreadAttribute
    | JSXText;

type Literal

type Literal =
    | StringLiteral
    | NumericLiteral
    | BooleanLiteral
    | NullLiteral
    | RegExpLiteral
    | TemplateLiteral;

type Loop

type Loop =
    | DoWhileStatement
    | ForInStatement
    | ForStatement
    | WhileStatement
    | ForOfStatement;

type LVal

type LVal =
    | Identifier
    | MemberExpression
    | RestElement
    | AssignmentPattern
    | ArrayPattern
    | ObjectPattern
    | TSParameterProperty;

type Method

type Method = ObjectMethod | ClassMethod;

type ModuleDeclaration

type ModuleDeclaration =
    | ExportAllDeclaration
    | ExportDefaultDeclaration
    | ExportNamedDeclaration
    | ImportDeclaration;

type ModuleSpecifier

type ModuleSpecifier =
    | ExportSpecifier
    | ImportDefaultSpecifier
    | ImportNamespaceSpecifier
    | ImportSpecifier
    | ExportDefaultSpecifier
    | ExportNamespaceSpecifier;

type ObjectMember

type ObjectMember = ObjectMethod | ObjectProperty;

type Pattern

type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern;

type Property

type Property = ObjectProperty | ClassProperty;

type Pureish

type Pureish =
    | FunctionDeclaration
    | FunctionExpression
    | StringLiteral
    | NumericLiteral
    | BooleanLiteral
    | NullLiteral
    | ArrowFunctionExpression
    | ClassDeclaration
    | ClassExpression;

type Scopable

type Scopable =
    | BlockStatement
    | CatchClause
    | DoWhileStatement
    | ForInStatement
    | ForStatement
    | FunctionDeclaration
    | FunctionExpression
    | Program
    | ObjectMethod
    | SwitchStatement
    | WhileStatement
    | ArrowFunctionExpression
    | ClassDeclaration
    | ClassExpression
    | ForOfStatement
    | ClassMethod;

type Statement

type Statement =
    | BlockStatement
    | BreakStatement
    | ContinueStatement
    | DebuggerStatement
    | DoWhileStatement
    | EmptyStatement
    | ExpressionStatement
    | ForInStatement
    | ForStatement
    | FunctionDeclaration
    | IfStatement
    | LabeledStatement
    | ReturnStatement
    | SwitchStatement
    | ThrowStatement
    | TryStatement
    | VariableDeclaration
    | WhileStatement
    | WithStatement
    | ClassDeclaration
    | ExportAllDeclaration
    | ExportDefaultDeclaration
    | ExportNamedDeclaration
    | ForOfStatement
    | ImportDeclaration
    | DeclareClass
    | DeclareFunction
    | DeclareInterface
    | DeclareModule
    | DeclareTypeAlias
    | DeclareVariable
    | InterfaceDeclaration
    | TypeAlias
    | TSDeclareFunction
    | TSEnumDeclaration
    | TSExportAssignment
    | TSImportEqualsDeclaration
    | TSInterfaceDeclaration
    | TSModuleDeclaration
    | TSNamespaceExportDeclaration
    | TSTypeAliasDeclaration;

type Terminatorless

type Terminatorless =
    | BreakStatement
    | ContinueStatement
    | ReturnStatement
    | ThrowStatement
    | YieldExpression
    | AwaitExpression;

type TSEntityName

type TSEntityName = Identifier | TSQualifiedName;

type TSType

type TSType =
    | TSAnyKeyword
    | TSArrayType
    | TSBooleanKeyword
    | TSConstructorType
    | TSExpressionWithTypeArguments
    | TSFunctionType
    | TSIndexedAccessType
    | TSIntersectionType
    | TSLiteralType
    | TSMappedType
    | TSNeverKeyword
    | TSNullKeyword
    | TSNumberKeyword
    | TSObjectKeyword
    | TSParenthesizedType
    | TSStringKeyword
    | TSSymbolKeyword
    | TSThisType
    | TSTupleType
    | TSTypeLiteral
    | TSTypeOperator
    | TSTypePredicate
    | TSTypeQuery
    | TSTypeReference
    | TSUndefinedKeyword
    | TSUnionType
    | TSVoidKeyword;

type TSTypeElement

type TSTypeElement =
    | TSCallSignatureDeclaration
    | TSConstructSignatureDeclaration
    | TSIndexSignature
    | TSMethodSignature
    | TSPropertySignature;

type UnaryLike

type UnaryLike = UnaryExpression | SpreadElement | RestProperty | SpreadProperty;

type UserWhitespacable

type UserWhitespacable =
    | ObjectMethod
    | ObjectProperty
    | ObjectTypeCallProperty
    | ObjectTypeIndexer
    | ObjectTypeProperty;

type While

type While = DoWhileStatement | WhileStatement;

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/babel-types.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/babel-types)

HTML

<a href="https://www.jsdocs.io/package/@types/babel-types"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 month ago.
Package analyzed in 14617 ms.
Missing or incorrect documentation? Open an issue for this package.