@types/babel-types

Version 7.0.15
Published 9 months ago
118 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

isExportDe

@types/babel-types

Install

Overview

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable react

Functions

function anyTypeAnnotation

function arrayExpression

function arrayPattern

function arrayTypeAnnotation

function arrowFunctionExpression

function assertAnyTypeAnnotation

function assertArrayExpression

function assertArrayPattern

function assertArrayTypeAnnotation

function assertArrowFunctionExpression

function assertAssignmentExpression

function assertAssignmentPattern

function assertAwaitExpression

function assertBinary

function assertBinaryExpression

function assertBindExpression

function assertBlock

function assertBlockParent

function assertBlockStatement

function assertBooleanLiteral

function assertBooleanLiteralTypeAnnotation

function assertBooleanTypeAnnotation

function assertBreakStatement

function assertCallExpression

function assertCatchClause

function assertClass

function assertClassBody

function assertClassDeclaration

function assertClassExpression

function assertClassImplements

function assertClassMethod

function assertClassProperty

function assertCompletionStatement

function assertConditional

function assertConditionalExpression

function assertContinueStatement

function assertDebuggerStatement

function assertDeclaration

function assertDeclareClass

function assertDeclareFunction

function assertDeclareInterface

function assertDeclareModule

function assertDeclareTypeAlias

function assertDeclareVariable

function assertDecorator

function assertDirective

function assertDirectiveLiteral

function assertDoExpression

function assertDoWhileStatement

function assertEmptyStatement

function assertExistentialTypeParam

function assertExportAllDeclaration

function assertExportDeclaration

function assertExportDefaultDeclaration

function assertExportDefaultSpecifier

function assertExportNamedDeclaration

function assertExportNamespaceSpecifier

function assertExportSpecifier

function assertExpression

function assertExpressionStatement

function assertExpressionWrapper

function assertFile

function assertFlow

function assertFlowBaseAnnotation

function assertFlowDeclaration

function assertFor

function assertForInStatement

function assertForOfStatement

function assertForStatement