ast-types

ast-types

Version 0.14.2
Published 4 years ago
484 kB
1 dependency
MIT license

Install

npm i ast-types

yarn add ast-types

pnpm add ast-types

Overview

Esprima-compatible implementation of the Mozilla JS Parser API

Index

Variables

variable astNodesAreEquivalent

const astNodesAreEquivalent: {
    (a: any, b: any, problemPath?: any): boolean;
    assert(a: any, b: any): void;
};

variable builders

const builders: builders;

variable builtInTypes

const builtInTypes: {
    string: Type<string>;
    function: Type<Function>;
    array: Type<any[]>;
    object: Type<{ [key: string]: any }>;
    RegExp: Type<RegExp>;
    Date: Type<Date>;
    number: Type<number>;
    boolean: Type<boolean>;
    null: Type<null>;
    undefined: Type<undefined>;
};

variable NodePath

const NodePath: NodePathConstructor;

variable Path

const Path: PathConstructor;

variable PathVisitor

const PathVisitor: PathVisitorConstructor;

variable Type

const Type: {
    or(...types: any[]): Type<any>;
    from<T>(value: any, name?: string | undefined): Type<T>;
    def(typeName: string): import('./lib/types').Def<any>;
    hasDef(typeName: string): boolean;
};

Functions

function defineMethod

defineMethod: (name: any, func?: Function | undefined) => Function;

function eachField

eachField: (
    object: any,
    callback: (name: any, value: any) => any,
    context?: any
) => void;

function finalize

finalize: () => void;

function getBuilderName

getBuilderName: (typeName: any) => any;

function getFieldNames

getFieldNames: (object: any) => string[];

function getFieldValue

getFieldValue: (object: any, fieldName: any) => any;

function getSupertypeNames

getSupertypeNames: (typeName: string) => string[];

function someField

someField: (
    object: any,
    callback: (name: any, value: any) => any,
    context?: any
) => boolean;

function use

use: <T>(plugin: Plugin<T>) => T;

function visit

visit: <M = {}>(node: ASTNode, methods?: Visitor<M>) => any;

Interfaces

interface AnyType

interface AnyType {}

method arrayOf

arrayOf: () => AnyType;

method assert

assert: (value: any, deep?: Deep) => boolean;

method check

check: (value: any, deep?: Deep) => boolean;

method toString

toString: () => string;

interface ASTNode

interface ASTNode {}

property type

type: string;

interface builders

interface builders {}

property anyTypeAnnotation

anyTypeAnnotation: AnyTypeAnnotationBuilder;

property arrayExpression

arrayExpression: ArrayExpressionBuilder;

property arrayPattern

arrayPattern: ArrayPatternBuilder;

property arrayTypeAnnotation

arrayTypeAnnotation: ArrayTypeAnnotationBuilder;

property arrowFunctionExpression

arrowFunctionExpression: ArrowFunctionExpressionBuilder;

property assignmentExpression

assignmentExpression: AssignmentExpressionBuilder;

property assignmentPattern

assignmentPattern: AssignmentPatternBuilder;

property awaitExpression

awaitExpression: AwaitExpressionBuilder;

property bigIntLiteral

bigIntLiteral: BigIntLiteralBuilder;

property bigIntLiteralTypeAnnotation

bigIntLiteralTypeAnnotation: BigIntLiteralTypeAnnotationBuilder;

property bigIntTypeAnnotation

bigIntTypeAnnotation: BigIntTypeAnnotationBuilder;

property binaryExpression

binaryExpression: BinaryExpressionBuilder;

property bindExpression

bindExpression: BindExpressionBuilder;

property block

block: BlockBuilder;

property blockStatement

blockStatement: BlockStatementBuilder;

property booleanLiteral

booleanLiteral: BooleanLiteralBuilder;

property booleanLiteralTypeAnnotation

booleanLiteralTypeAnnotation: BooleanLiteralTypeAnnotationBuilder;

property booleanTypeAnnotation

booleanTypeAnnotation: BooleanTypeAnnotationBuilder;

property breakStatement

breakStatement: BreakStatementBuilder;

property callExpression

callExpression: CallExpressionBuilder;

property catchClause

catchClause: CatchClauseBuilder;

property chainExpression

chainExpression: ChainExpressionBuilder;

property classBody

classBody: ClassBodyBuilder;

property classDeclaration

classDeclaration: ClassDeclarationBuilder;

property classExpression

classExpression: ClassExpressionBuilder;

property classImplements

classImplements: ClassImplementsBuilder;

property classMethod

classMethod: ClassMethodBuilder;

property classPrivateMethod

classPrivateMethod: ClassPrivateMethodBuilder;

property classPrivateProperty

classPrivateProperty: ClassPrivatePropertyBuilder;

property classProperty

classProperty: ClassPropertyBuilder;

property classPropertyDefinition

classPropertyDefinition: ClassPropertyDefinitionBuilder;

property commentBlock

commentBlock: CommentBlockBuilder;

property commentLine

commentLine: CommentLineBuilder;

property comprehensionBlock

comprehensionBlock: ComprehensionBlockBuilder;

property comprehensionExpression

comprehensionExpression: ComprehensionExpressionBuilder;

property conditionalExpression

conditionalExpression: ConditionalExpressionBuilder;

property continueStatement

continueStatement: ContinueStatementBuilder;

property debuggerStatement

debuggerStatement: DebuggerStatementBuilder;

property declareClass

declareClass: DeclareClassBuilder;

property declaredPredicate

declaredPredicate: DeclaredPredicateBuilder;

property declareExportAllDeclaration

declareExportAllDeclaration: DeclareExportAllDeclarationBuilder;

property declareExportDeclaration

declareExportDeclaration: DeclareExportDeclarationBuilder;

property declareFunction

declareFunction: DeclareFunctionBuilder;

property declareInterface

declareInterface: DeclareInterfaceBuilder;

property declareModule

declareModule: DeclareModuleBuilder;

property declareModuleExports

declareModuleExports: DeclareModuleExportsBuilder;

property declareOpaqueType

declareOpaqueType: DeclareOpaqueTypeBuilder;

property declareTypeAlias

declareTypeAlias: DeclareTypeAliasBuilder;

property declareVariable

declareVariable: DeclareVariableBuilder;

property decorator

decorator: DecoratorBuilder;

property directive

directive: DirectiveBuilder;

property directiveLiteral

directiveLiteral: DirectiveLiteralBuilder;

property doExpression

doExpression: DoExpressionBuilder;

property doWhileStatement

doWhileStatement: DoWhileStatementBuilder;

property emptyStatement

emptyStatement: EmptyStatementBuilder;

property emptyTypeAnnotation

emptyTypeAnnotation: EmptyTypeAnnotationBuilder;

property enumBooleanBody

enumBooleanBody: EnumBooleanBodyBuilder;

property enumBooleanMember

enumBooleanMember: EnumBooleanMemberBuilder;

property enumDeclaration

enumDeclaration: EnumDeclarationBuilder;

property enumDefaultedMember

enumDefaultedMember: EnumDefaultedMemberBuilder;

property enumNumberBody

enumNumberBody: EnumNumberBodyBuilder;

property enumNumberMember

enumNumberMember: EnumNumberMemberBuilder;

property enumStringBody

enumStringBody: EnumStringBodyBuilder;

property enumStringMember

enumStringMember: EnumStringMemberBuilder;

property enumSymbolBody

enumSymbolBody: EnumSymbolBodyBuilder;

property existentialTypeParam

existentialTypeParam: ExistentialTypeParamBuilder;

property existsTypeAnnotation

existsTypeAnnotation: ExistsTypeAnnotationBuilder;

property exportAllDeclaration

exportAllDeclaration: ExportAllDeclarationBuilder;

property exportBatchSpecifier

exportBatchSpecifier: ExportBatchSpecifierBuilder;

property exportDeclaration

exportDeclaration: ExportDeclarationBuilder;

property exportDefaultDeclaration

exportDefaultDeclaration: ExportDefaultDeclarationBuilder;

property exportDefaultSpecifier

exportDefaultSpecifier: ExportDefaultSpecifierBuilder;

property exportNamedDeclaration

exportNamedDeclaration: ExportNamedDeclarationBuilder;

property exportNamespaceSpecifier

exportNamespaceSpecifier: ExportNamespaceSpecifierBuilder;

property exportSpecifier

exportSpecifier: ExportSpecifierBuilder;

property expressionStatement

expressionStatement: ExpressionStatementBuilder;

property file

file: FileBuilder;

property forAwaitStatement

forAwaitStatement: ForAwaitStatementBuilder;

property forInStatement

forInStatement: ForInStatementBuilder;

property forOfStatement

forOfStatement: ForOfStatementBuilder;

property forStatement

forStatement: ForStatementBuilder;

property functionDeclaration

functionDeclaration: FunctionDeclarationBuilder;

property functionExpression

functionExpression: FunctionExpressionBuilder;

property functionTypeAnnotation

functionTypeAnnotation: FunctionTypeAnnotationBuilder;

property functionTypeParam

functionTypeParam: FunctionTypeParamBuilder;

property generatorExpression

generatorExpression: GeneratorExpressionBuilder;

property genericTypeAnnotation

genericTypeAnnotation: GenericTypeAnnotationBuilder;

property identifier

identifier: IdentifierBuilder;

property ifStatement

ifStatement: IfStatementBuilder;

property import

import: ImportBuilder;

property importDeclaration

importDeclaration: ImportDeclarationBuilder;

property importDefaultSpecifier

importDefaultSpecifier: ImportDefaultSpecifierBuilder;

property importExpression

importExpression: ImportExpressionBuilder;

property importNamespaceSpecifier

importNamespaceSpecifier: ImportNamespaceSpecifierBuilder;

property importSpecifier

importSpecifier: ImportSpecifierBuilder;

property inferredPredicate

inferredPredicate: InferredPredicateBuilder;

property interfaceDeclaration

interfaceDeclaration: InterfaceDeclarationBuilder;

property interfaceExtends

interfaceExtends: InterfaceExtendsBuilder;

property interfaceTypeAnnotation

interfaceTypeAnnotation: InterfaceTypeAnnotationBuilder;

property interpreterDirective

interpreterDirective: InterpreterDirectiveBuilder;

property intersectionTypeAnnotation

intersectionTypeAnnotation: IntersectionTypeAnnotationBuilder;

property jsxAttribute

jsxAttribute: JSXAttributeBuilder;

property jsxClosingElement

jsxClosingElement: JSXClosingElementBuilder;

property jsxClosingFragment

jsxClosingFragment: JSXClosingFragmentBuilder;

property jsxElement

jsxElement: JSXElementBuilder;

property jsxEmptyExpression

jsxEmptyExpression: JSXEmptyExpressionBuilder;

property jsxExpressionContainer

jsxExpressionContainer: JSXExpressionContainerBuilder;

property jsxFragment

jsxFragment: JSXFragmentBuilder;

property jsxIdentifier

jsxIdentifier: JSXIdentifierBuilder;

property jsxMemberExpression

jsxMemberExpression: JSXMemberExpressionBuilder;

property jsxNamespacedName

jsxNamespacedName: JSXNamespacedNameBuilder;

property jsxOpeningElement

jsxOpeningElement: JSXOpeningElementBuilder;

property jsxOpeningFragment

jsxOpeningFragment: JSXOpeningFragmentBuilder;

property jsxSpreadAttribute

jsxSpreadAttribute: JSXSpreadAttributeBuilder;

property jsxSpreadChild

jsxSpreadChild: JSXSpreadChildBuilder;

property jsxText

jsxText: JSXTextBuilder;

property labeledStatement

labeledStatement: LabeledStatementBuilder;

property line

line: LineBuilder;

property literal

literal: LiteralBuilder;

property logicalExpression

logicalExpression: LogicalExpressionBuilder;

property memberExpression

memberExpression: MemberExpressionBuilder;

property memberTypeAnnotation

memberTypeAnnotation: MemberTypeAnnotationBuilder;

property metaProperty

metaProperty: MetaPropertyBuilder;

property methodDefinition

methodDefinition: MethodDefinitionBuilder;

property mixedTypeAnnotation

mixedTypeAnnotation: MixedTypeAnnotationBuilder;

property newExpression

newExpression: NewExpressionBuilder;

property noop

noop: NoopBuilder;

property nullableTypeAnnotation

nullableTypeAnnotation: NullableTypeAnnotationBuilder;

property nullLiteral

nullLiteral: NullLiteralBuilder;

property nullLiteralTypeAnnotation

nullLiteralTypeAnnotation: NullLiteralTypeAnnotationBuilder;

property nullTypeAnnotation

nullTypeAnnotation: NullTypeAnnotationBuilder;

property numberLiteralTypeAnnotation

numberLiteralTypeAnnotation: NumberLiteralTypeAnnotationBuilder;

property numberTypeAnnotation

numberTypeAnnotation: NumberTypeAnnotationBuilder;

property numericLiteral

numericLiteral: NumericLiteralBuilder;

property numericLiteralTypeAnnotation

numericLiteralTypeAnnotation: NumericLiteralTypeAnnotationBuilder;

property objectExpression

objectExpression: ObjectExpressionBuilder;

property objectMethod

objectMethod: ObjectMethodBuilder;

property objectPattern

objectPattern: ObjectPatternBuilder;

property objectProperty

objectProperty: ObjectPropertyBuilder;

property objectTypeAnnotation

objectTypeAnnotation: ObjectTypeAnnotationBuilder;

property objectTypeCallProperty

objectTypeCallProperty: ObjectTypeCallPropertyBuilder;

property objectTypeIndexer

objectTypeIndexer: ObjectTypeIndexerBuilder;

property objectTypeInternalSlot

objectTypeInternalSlot: ObjectTypeInternalSlotBuilder;

property objectTypeProperty

objectTypeProperty: ObjectTypePropertyBuilder;

property objectTypeSpreadProperty

objectTypeSpreadProperty: ObjectTypeSpreadPropertyBuilder;

property opaqueType

opaqueType: OpaqueTypeBuilder;

property optionalCallExpression

optionalCallExpression: OptionalCallExpressionBuilder;

property optionalMemberExpression

optionalMemberExpression: OptionalMemberExpressionBuilder;

property parenthesizedExpression

parenthesizedExpression: ParenthesizedExpressionBuilder;

property privateName

privateName: PrivateNameBuilder;

property program

program: ProgramBuilder;

property property

property: PropertyBuilder;

property propertyPattern

propertyPattern: PropertyPatternBuilder;

property qualifiedTypeIdentifier

qualifiedTypeIdentifier: QualifiedTypeIdentifierBuilder;

property regExpLiteral

regExpLiteral: RegExpLiteralBuilder;

property restElement

restElement: RestElementBuilder;

property restProperty

restProperty: RestPropertyBuilder;

property returnStatement

returnStatement: ReturnStatementBuilder;

property sequenceExpression

sequenceExpression: SequenceExpressionBuilder;

property spreadElement

spreadElement: SpreadElementBuilder;

property spreadElementPattern

spreadElementPattern: SpreadElementPatternBuilder;

property spreadProperty

spreadProperty: SpreadPropertyBuilder;

property spreadPropertyPattern

spreadPropertyPattern: SpreadPropertyPatternBuilder;

property stringLiteral

stringLiteral: StringLiteralBuilder;

property stringLiteralTypeAnnotation

stringLiteralTypeAnnotation: StringLiteralTypeAnnotationBuilder;

property stringTypeAnnotation

stringTypeAnnotation: StringTypeAnnotationBuilder;

property super

super: SuperBuilder;

property switchCase

switchCase: SwitchCaseBuilder;

property switchStatement

switchStatement: SwitchStatementBuilder;

property symbolTypeAnnotation

symbolTypeAnnotation: SymbolTypeAnnotationBuilder;

property taggedTemplateExpression

taggedTemplateExpression: TaggedTemplateExpressionBuilder;

property templateElement

templateElement: TemplateElementBuilder;

property templateLiteral

templateLiteral: TemplateLiteralBuilder;

property thisExpression

thisExpression: ThisExpressionBuilder;

property thisTypeAnnotation

thisTypeAnnotation: ThisTypeAnnotationBuilder;

property throwStatement

throwStatement: ThrowStatementBuilder;

property tryStatement

tryStatement: TryStatementBuilder;

property tsAnyKeyword

tsAnyKeyword: TSAnyKeywordBuilder;

property tsArrayType

tsArrayType: TSArrayTypeBuilder;

property tsAsExpression

tsAsExpression: TSAsExpressionBuilder;

property tsBigIntKeyword

tsBigIntKeyword: TSBigIntKeywordBuilder;

property tsBooleanKeyword

tsBooleanKeyword: TSBooleanKeywordBuilder;

property tsCallSignatureDeclaration

tsCallSignatureDeclaration: TSCallSignatureDeclarationBuilder;

property tsConditionalType

tsConditionalType: TSConditionalTypeBuilder;

property tsConstructorType

tsConstructorType: TSConstructorTypeBuilder;

property tsConstructSignatureDeclaration

tsConstructSignatureDeclaration: TSConstructSignatureDeclarationBuilder;

property tsDeclareFunction

tsDeclareFunction: TSDeclareFunctionBuilder;

property tsDeclareMethod

tsDeclareMethod: TSDeclareMethodBuilder;

property tsEnumDeclaration

tsEnumDeclaration: TSEnumDeclarationBuilder;

property tsEnumMember

tsEnumMember: TSEnumMemberBuilder;

property tsExportAssignment

tsExportAssignment: TSExportAssignmentBuilder;

property tsExpressionWithTypeArguments

tsExpressionWithTypeArguments: TSExpressionWithTypeArgumentsBuilder;

property tsExternalModuleReference

tsExternalModuleReference: TSExternalModuleReferenceBuilder;

property tsFunctionType

tsFunctionType: TSFunctionTypeBuilder;

property tsImportEqualsDeclaration

tsImportEqualsDeclaration: TSImportEqualsDeclarationBuilder;

property tsImportType

tsImportType: TSImportTypeBuilder;

property tsIndexedAccessType

tsIndexedAccessType: TSIndexedAccessTypeBuilder;

property tsIndexSignature

tsIndexSignature: TSIndexSignatureBuilder;

property tsInferType

tsInferType: TSInferTypeBuilder;

property tsInterfaceBody

tsInterfaceBody: TSInterfaceBodyBuilder;

property tsInterfaceDeclaration

tsInterfaceDeclaration: TSInterfaceDeclarationBuilder;

property tsIntersectionType

tsIntersectionType: TSIntersectionTypeBuilder;

property tsLiteralType

tsLiteralType: TSLiteralTypeBuilder;

property tsMappedType

tsMappedType: TSMappedTypeBuilder;

property tsMethodSignature

tsMethodSignature: TSMethodSignatureBuilder;

property tsModuleBlock

tsModuleBlock: TSModuleBlockBuilder;

property tsModuleDeclaration

tsModuleDeclaration: TSModuleDeclarationBuilder;

property tsNamedTupleMember

tsNamedTupleMember: TSNamedTupleMemberBuilder;

property tsNamespaceExportDeclaration

tsNamespaceExportDeclaration: TSNamespaceExportDeclarationBuilder;

property tsNeverKeyword

tsNeverKeyword: TSNeverKeywordBuilder;

property tsNonNullExpression

tsNonNullExpression: TSNonNullExpressionBuilder;

property tsNullKeyword

tsNullKeyword: TSNullKeywordBuilder;

property tsNumberKeyword

tsNumberKeyword: TSNumberKeywordBuilder;

property tsObjectKeyword

tsObjectKeyword: TSObjectKeywordBuilder;

property tsOptionalType

tsOptionalType: TSOptionalTypeBuilder;

property tsParameterProperty

tsParameterProperty: TSParameterPropertyBuilder;

property tsParenthesizedType

tsParenthesizedType: TSParenthesizedTypeBuilder;

property tsPropertySignature

tsPropertySignature: TSPropertySignatureBuilder;

property tsQualifiedName

tsQualifiedName: TSQualifiedNameBuilder;

property tsRestType

tsRestType: TSRestTypeBuilder;

property tsStringKeyword

tsStringKeyword: TSStringKeywordBuilder;

property tsSymbolKeyword

tsSymbolKeyword: TSSymbolKeywordBuilder;

property tsThisType

tsThisType: TSThisTypeBuilder;

property tsTupleType

tsTupleType: TSTupleTypeBuilder;

property tsTypeAliasDeclaration

tsTypeAliasDeclaration: TSTypeAliasDeclarationBuilder;

property tsTypeAnnotation

tsTypeAnnotation: TSTypeAnnotationBuilder;

property tsTypeAssertion

tsTypeAssertion: TSTypeAssertionBuilder;

property tsTypeLiteral

tsTypeLiteral: TSTypeLiteralBuilder;

property tsTypeOperator

tsTypeOperator: TSTypeOperatorBuilder;

property tsTypeParameter

tsTypeParameter: TSTypeParameterBuilder;

property tsTypeParameterDeclaration

tsTypeParameterDeclaration: TSTypeParameterDeclarationBuilder;

property tsTypeParameterInstantiation

tsTypeParameterInstantiation: TSTypeParameterInstantiationBuilder;

property tsTypePredicate

tsTypePredicate: TSTypePredicateBuilder;

property tsTypeQuery

tsTypeQuery: TSTypeQueryBuilder;

property tsTypeReference

tsTypeReference: TSTypeReferenceBuilder;

property tsUndefinedKeyword

tsUndefinedKeyword: TSUndefinedKeywordBuilder;

property tsUnionType

tsUnionType: TSUnionTypeBuilder;

property tsUnknownKeyword

tsUnknownKeyword: TSUnknownKeywordBuilder;

property tsVoidKeyword

tsVoidKeyword: TSVoidKeywordBuilder;

property tupleTypeAnnotation

tupleTypeAnnotation: TupleTypeAnnotationBuilder;

property typeAlias

typeAlias: TypeAliasBuilder;

property typeAnnotation

typeAnnotation: TypeAnnotationBuilder;

property typeCastExpression

typeCastExpression: TypeCastExpressionBuilder;

property typeofTypeAnnotation

typeofTypeAnnotation: TypeofTypeAnnotationBuilder;

property typeParameter

typeParameter: TypeParameterBuilder;

property typeParameterDeclaration

typeParameterDeclaration: TypeParameterDeclarationBuilder;

property typeParameterInstantiation

typeParameterInstantiation: TypeParameterInstantiationBuilder;

property unaryExpression

unaryExpression: UnaryExpressionBuilder;

property unionTypeAnnotation

unionTypeAnnotation: UnionTypeAnnotationBuilder;

property updateExpression

updateExpression: UpdateExpressionBuilder;

property variableDeclaration

variableDeclaration: VariableDeclarationBuilder;

property variableDeclarator

variableDeclarator: VariableDeclaratorBuilder;

property variance

variance: VarianceBuilder;

property voidTypeAnnotation

voidTypeAnnotation: VoidTypeAnnotationBuilder;

property whileStatement

whileStatement: WhileStatementBuilder;

property withStatement

withStatement: WithStatementBuilder;

property yieldExpression

yieldExpression: YieldExpressionBuilder;

index signature

[builderName: string]: any;

interface NodePath

interface NodePath<N = any, V = any> extends Path<V> {}

property node

node: N;

property parent

parent: any;

property replace

replace: Path['replace'];

property scope

scope: any;

method canBeFirstInStatement

canBeFirstInStatement: () => boolean;

method firstInStatement

firstInStatement: () => boolean;

method getValueProperty

getValueProperty: (name: any) => any;

method needsParens

needsParens: (assumeExpressionContext?: boolean) => boolean;

method prune

prune: (...args: any[]) => any;

interface Visitor

interface Visitor<M = {}> {}

method visitAnyTypeAnnotation

visitAnyTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.AnyTypeAnnotation>
) => any;

method visitArrayExpression

visitArrayExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ArrayExpression>
) => any;

method visitArrayPattern

visitArrayPattern: (
    this: Context & M,
    path: NodePath<namedTypes.ArrayPattern>
) => any;

method visitArrayTypeAnnotation

visitArrayTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.ArrayTypeAnnotation>
) => any;

method visitArrowFunctionExpression

visitArrowFunctionExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ArrowFunctionExpression>
) => any;

method visitAssignmentExpression

visitAssignmentExpression: (
    this: Context & M,
    path: NodePath<namedTypes.AssignmentExpression>
) => any;

method visitAssignmentPattern

visitAssignmentPattern: (
    this: Context & M,
    path: NodePath<namedTypes.AssignmentPattern>
) => any;

method visitAwaitExpression

visitAwaitExpression: (
    this: Context & M,
    path: NodePath<namedTypes.AwaitExpression>
) => any;

method visitBigIntLiteral

visitBigIntLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.BigIntLiteral>
) => any;

method visitBigIntLiteralTypeAnnotation

visitBigIntLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.BigIntLiteralTypeAnnotation>
) => any;

method visitBigIntTypeAnnotation

visitBigIntTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.BigIntTypeAnnotation>
) => any;

method visitBinaryExpression

visitBinaryExpression: (
    this: Context & M,
    path: NodePath<namedTypes.BinaryExpression>
) => any;

method visitBindExpression

visitBindExpression: (
    this: Context & M,
    path: NodePath<namedTypes.BindExpression>
) => any;

method visitBlock

visitBlock: (this: Context & M, path: NodePath<namedTypes.Block>) => any;

method visitBlockStatement

visitBlockStatement: (
    this: Context & M,
    path: NodePath<namedTypes.BlockStatement>
) => any;

method visitBooleanLiteral

visitBooleanLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.BooleanLiteral>
) => any;

method visitBooleanLiteralTypeAnnotation

visitBooleanLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.BooleanLiteralTypeAnnotation>
) => any;

method visitBooleanTypeAnnotation

visitBooleanTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.BooleanTypeAnnotation>
) => any;

method visitBreakStatement

visitBreakStatement: (
    this: Context & M,
    path: NodePath<namedTypes.BreakStatement>
) => any;

method visitCallExpression

visitCallExpression: (
    this: Context & M,
    path: NodePath<namedTypes.CallExpression>
) => any;

method visitCatchClause

visitCatchClause: (
    this: Context & M,
    path: NodePath<namedTypes.CatchClause>
) => any;

method visitChainElement

visitChainElement: (
    this: Context & M,
    path: NodePath<namedTypes.ChainElement>
) => any;

method visitChainExpression

visitChainExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ChainExpression>
) => any;

method visitClassBody

visitClassBody: (this: Context & M, path: NodePath<namedTypes.ClassBody>) => any;

method visitClassDeclaration

visitClassDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ClassDeclaration>
) => any;

method visitClassExpression

visitClassExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ClassExpression>
) => any;

method visitClassImplements

visitClassImplements: (
    this: Context & M,
    path: NodePath<namedTypes.ClassImplements>
) => any;

method visitClassMethod

visitClassMethod: (
    this: Context & M,
    path: NodePath<namedTypes.ClassMethod>
) => any;

method visitClassPrivateMethod

visitClassPrivateMethod: (
    this: Context & M,
    path: NodePath<namedTypes.ClassPrivateMethod>
) => any;

method visitClassPrivateProperty

visitClassPrivateProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ClassPrivateProperty>
) => any;

method visitClassProperty

visitClassProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ClassProperty>
) => any;

method visitClassPropertyDefinition

visitClassPropertyDefinition: (
    this: Context & M,
    path: NodePath<namedTypes.ClassPropertyDefinition>
) => any;

method visitComment

visitComment: (this: Context & M, path: NodePath<namedTypes.Comment>) => any;

method visitCommentBlock

visitCommentBlock: (
    this: Context & M,
    path: NodePath<namedTypes.CommentBlock>
) => any;

method visitCommentLine

visitCommentLine: (
    this: Context & M,
    path: NodePath<namedTypes.CommentLine>
) => any;

method visitComprehensionBlock

visitComprehensionBlock: (
    this: Context & M,
    path: NodePath<namedTypes.ComprehensionBlock>
) => any;

method visitComprehensionExpression

visitComprehensionExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ComprehensionExpression>
) => any;

method visitConditionalExpression

visitConditionalExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ConditionalExpression>
) => any;

method visitContinueStatement

visitContinueStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ContinueStatement>
) => any;

method visitDebuggerStatement

visitDebuggerStatement: (
    this: Context & M,
    path: NodePath<namedTypes.DebuggerStatement>
) => any;

method visitDeclaration

visitDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.Declaration>
) => any;

method visitDeclareClass

visitDeclareClass: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareClass>
) => any;

method visitDeclaredPredicate

visitDeclaredPredicate: (
    this: Context & M,
    path: NodePath<namedTypes.DeclaredPredicate>
) => any;

method visitDeclareExportAllDeclaration

visitDeclareExportAllDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareExportAllDeclaration>
) => any;

method visitDeclareExportDeclaration

visitDeclareExportDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareExportDeclaration>
) => any;

method visitDeclareFunction

visitDeclareFunction: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareFunction>
) => any;

method visitDeclareInterface

visitDeclareInterface: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareInterface>
) => any;

method visitDeclareModule

visitDeclareModule: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareModule>
) => any;

method visitDeclareModuleExports

visitDeclareModuleExports: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareModuleExports>
) => any;

method visitDeclareOpaqueType

visitDeclareOpaqueType: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareOpaqueType>
) => any;

method visitDeclareTypeAlias

visitDeclareTypeAlias: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareTypeAlias>
) => any;

method visitDeclareVariable

visitDeclareVariable: (
    this: Context & M,
    path: NodePath<namedTypes.DeclareVariable>
) => any;

method visitDecorator

visitDecorator: (this: Context & M, path: NodePath<namedTypes.Decorator>) => any;

method visitDirective

visitDirective: (this: Context & M, path: NodePath<namedTypes.Directive>) => any;

method visitDirectiveLiteral

visitDirectiveLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.DirectiveLiteral>
) => any;

method visitDoExpression

visitDoExpression: (
    this: Context & M,
    path: NodePath<namedTypes.DoExpression>
) => any;

method visitDoWhileStatement

visitDoWhileStatement: (
    this: Context & M,
    path: NodePath<namedTypes.DoWhileStatement>
) => any;

method visitEmptyStatement

visitEmptyStatement: (
    this: Context & M,
    path: NodePath<namedTypes.EmptyStatement>
) => any;

method visitEmptyTypeAnnotation

visitEmptyTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.EmptyTypeAnnotation>
) => any;

method visitEnumBooleanBody

visitEnumBooleanBody: (
    this: Context & M,
    path: NodePath<namedTypes.EnumBooleanBody>
) => any;

method visitEnumBooleanMember

visitEnumBooleanMember: (
    this: Context & M,
    path: NodePath<namedTypes.EnumBooleanMember>
) => any;

method visitEnumDeclaration

visitEnumDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.EnumDeclaration>
) => any;

method visitEnumDefaultedMember

visitEnumDefaultedMember: (
    this: Context & M,
    path: NodePath<namedTypes.EnumDefaultedMember>
) => any;

method visitEnumNumberBody

visitEnumNumberBody: (
    this: Context & M,
    path: NodePath<namedTypes.EnumNumberBody>
) => any;

method visitEnumNumberMember

visitEnumNumberMember: (
    this: Context & M,
    path: NodePath<namedTypes.EnumNumberMember>
) => any;

method visitEnumStringBody

visitEnumStringBody: (
    this: Context & M,
    path: NodePath<namedTypes.EnumStringBody>
) => any;

method visitEnumStringMember

visitEnumStringMember: (
    this: Context & M,
    path: NodePath<namedTypes.EnumStringMember>
) => any;

method visitEnumSymbolBody

visitEnumSymbolBody: (
    this: Context & M,
    path: NodePath<namedTypes.EnumSymbolBody>
) => any;

method visitExistentialTypeParam

visitExistentialTypeParam: (
    this: Context & M,
    path: NodePath<namedTypes.ExistentialTypeParam>
) => any;

method visitExistsTypeAnnotation

visitExistsTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.ExistsTypeAnnotation>
) => any;

method visitExportAllDeclaration

visitExportAllDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ExportAllDeclaration>
) => any;

method visitExportBatchSpecifier

visitExportBatchSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ExportBatchSpecifier>
) => any;

method visitExportDeclaration

visitExportDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ExportDeclaration>
) => any;

method visitExportDefaultDeclaration

visitExportDefaultDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ExportDefaultDeclaration>
) => any;

method visitExportDefaultSpecifier

visitExportDefaultSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ExportDefaultSpecifier>
) => any;

method visitExportNamedDeclaration

visitExportNamedDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ExportNamedDeclaration>
) => any;

method visitExportNamespaceSpecifier

visitExportNamespaceSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ExportNamespaceSpecifier>
) => any;

method visitExportSpecifier

visitExportSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ExportSpecifier>
) => any;

method visitExpression

visitExpression: (
    this: Context & M,
    path: NodePath<namedTypes.Expression>
) => any;

method visitExpressionStatement

visitExpressionStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ExpressionStatement>
) => any;

method visitFile

visitFile: (this: Context & M, path: NodePath<namedTypes.File>) => any;

method visitFlow

visitFlow: (this: Context & M, path: NodePath<namedTypes.Flow>) => any;

method visitFlowPredicate

visitFlowPredicate: (
    this: Context & M,
    path: NodePath<namedTypes.FlowPredicate>
) => any;

method visitFlowType

visitFlowType: (this: Context & M, path: NodePath<namedTypes.FlowType>) => any;

method visitForAwaitStatement

visitForAwaitStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ForAwaitStatement>
) => any;

method visitForInStatement

visitForInStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ForInStatement>
) => any;

method visitForOfStatement

visitForOfStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ForOfStatement>
) => any;

method visitForStatement

visitForStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ForStatement>
) => any;

method visitFunction

visitFunction: (this: Context & M, path: NodePath<namedTypes.Function>) => any;

method visitFunctionDeclaration

visitFunctionDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.FunctionDeclaration>
) => any;

method visitFunctionExpression

visitFunctionExpression: (
    this: Context & M,
    path: NodePath<namedTypes.FunctionExpression>
) => any;

method visitFunctionTypeAnnotation

visitFunctionTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.FunctionTypeAnnotation>
) => any;

method visitFunctionTypeParam

visitFunctionTypeParam: (
    this: Context & M,
    path: NodePath<namedTypes.FunctionTypeParam>
) => any;

method visitGeneratorExpression

visitGeneratorExpression: (
    this: Context & M,
    path: NodePath<namedTypes.GeneratorExpression>
) => any;

method visitGenericTypeAnnotation

visitGenericTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.GenericTypeAnnotation>
) => any;

method visitIdentifier

visitIdentifier: (
    this: Context & M,
    path: NodePath<namedTypes.Identifier>
) => any;

method visitIfStatement

visitIfStatement: (
    this: Context & M,
    path: NodePath<namedTypes.IfStatement>
) => any;

method visitImport

visitImport: (this: Context & M, path: NodePath<namedTypes.Import>) => any;

method visitImportDeclaration

visitImportDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.ImportDeclaration>
) => any;

method visitImportDefaultSpecifier

visitImportDefaultSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ImportDefaultSpecifier>
) => any;

method visitImportExpression

visitImportExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ImportExpression>
) => any;

method visitImportNamespaceSpecifier

visitImportNamespaceSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ImportNamespaceSpecifier>
) => any;

method visitImportSpecifier

visitImportSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ImportSpecifier>
) => any;

method visitInferredPredicate

visitInferredPredicate: (
    this: Context & M,
    path: NodePath<namedTypes.InferredPredicate>
) => any;

method visitInterfaceDeclaration

visitInterfaceDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.InterfaceDeclaration>
) => any;

method visitInterfaceExtends

visitInterfaceExtends: (
    this: Context & M,
    path: NodePath<namedTypes.InterfaceExtends>
) => any;

method visitInterfaceTypeAnnotation

visitInterfaceTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.InterfaceTypeAnnotation>
) => any;

method visitInterpreterDirective

visitInterpreterDirective: (
    this: Context & M,
    path: NodePath<namedTypes.InterpreterDirective>
) => any;

method visitIntersectionTypeAnnotation

visitIntersectionTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.IntersectionTypeAnnotation>
) => any;

method visitJSXAttribute

visitJSXAttribute: (
    this: Context & M,
    path: NodePath<namedTypes.JSXAttribute>
) => any;

method visitJSXClosingElement

visitJSXClosingElement: (
    this: Context & M,
    path: NodePath<namedTypes.JSXClosingElement>
) => any;

method visitJSXClosingFragment

visitJSXClosingFragment: (
    this: Context & M,
    path: NodePath<namedTypes.JSXClosingFragment>
) => any;

method visitJSXElement

visitJSXElement: (
    this: Context & M,
    path: NodePath<namedTypes.JSXElement>
) => any;

method visitJSXEmptyExpression

visitJSXEmptyExpression: (
    this: Context & M,
    path: NodePath<namedTypes.JSXEmptyExpression>
) => any;

method visitJSXExpressionContainer

visitJSXExpressionContainer: (
    this: Context & M,
    path: NodePath<namedTypes.JSXExpressionContainer>
) => any;

method visitJSXFragment

visitJSXFragment: (
    this: Context & M,
    path: NodePath<namedTypes.JSXFragment>
) => any;

method visitJSXIdentifier

visitJSXIdentifier: (
    this: Context & M,
    path: NodePath<namedTypes.JSXIdentifier>
) => any;

method visitJSXMemberExpression

visitJSXMemberExpression: (
    this: Context & M,
    path: NodePath<namedTypes.JSXMemberExpression>
) => any;

method visitJSXNamespacedName

visitJSXNamespacedName: (
    this: Context & M,
    path: NodePath<namedTypes.JSXNamespacedName>
) => any;

method visitJSXOpeningElement

visitJSXOpeningElement: (
    this: Context & M,
    path: NodePath<namedTypes.JSXOpeningElement>
) => any;

method visitJSXOpeningFragment

visitJSXOpeningFragment: (
    this: Context & M,
    path: NodePath<namedTypes.JSXOpeningFragment>
) => any;

method visitJSXSpreadAttribute

visitJSXSpreadAttribute: (
    this: Context & M,
    path: NodePath<namedTypes.JSXSpreadAttribute>
) => any;

method visitJSXSpreadChild

visitJSXSpreadChild: (
    this: Context & M,
    path: NodePath<namedTypes.JSXSpreadChild>
) => any;

method visitJSXText

visitJSXText: (this: Context & M, path: NodePath<namedTypes.JSXText>) => any;

method visitLabeledStatement

visitLabeledStatement: (
    this: Context & M,
    path: NodePath<namedTypes.LabeledStatement>
) => any;

method visitLine

visitLine: (this: Context & M, path: NodePath<namedTypes.Line>) => any;

method visitLiteral

visitLiteral: (this: Context & M, path: NodePath<namedTypes.Literal>) => any;

method visitLogicalExpression

visitLogicalExpression: (
    this: Context & M,
    path: NodePath<namedTypes.LogicalExpression>
) => any;

method visitMemberExpression

visitMemberExpression: (
    this: Context & M,
    path: NodePath<namedTypes.MemberExpression>
) => any;

method visitMemberTypeAnnotation

visitMemberTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.MemberTypeAnnotation>
) => any;

method visitMetaProperty

visitMetaProperty: (
    this: Context & M,
    path: NodePath<namedTypes.MetaProperty>
) => any;

method visitMethodDefinition

visitMethodDefinition: (
    this: Context & M,
    path: NodePath<namedTypes.MethodDefinition>
) => any;

method visitMixedTypeAnnotation

visitMixedTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.MixedTypeAnnotation>
) => any;

method visitModuleSpecifier

visitModuleSpecifier: (
    this: Context & M,
    path: NodePath<namedTypes.ModuleSpecifier>
) => any;

method visitNewExpression

visitNewExpression: (
    this: Context & M,
    path: NodePath<namedTypes.NewExpression>
) => any;

method visitNode

visitNode: (this: Context & M, path: NodePath<namedTypes.Node>) => any;

method visitNoop

visitNoop: (this: Context & M, path: NodePath<namedTypes.Noop>) => any;

method visitNullableTypeAnnotation

visitNullableTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NullableTypeAnnotation>
) => any;

method visitNullLiteral

visitNullLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.NullLiteral>
) => any;

method visitNullLiteralTypeAnnotation

visitNullLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NullLiteralTypeAnnotation>
) => any;

method visitNullTypeAnnotation

visitNullTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NullTypeAnnotation>
) => any;

method visitNumberLiteralTypeAnnotation

visitNumberLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NumberLiteralTypeAnnotation>
) => any;

method visitNumberTypeAnnotation

visitNumberTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NumberTypeAnnotation>
) => any;

method visitNumericLiteral

visitNumericLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.NumericLiteral>
) => any;

method visitNumericLiteralTypeAnnotation

visitNumericLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.NumericLiteralTypeAnnotation>
) => any;

method visitObjectExpression

visitObjectExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectExpression>
) => any;

method visitObjectMethod

visitObjectMethod: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectMethod>
) => any;

method visitObjectPattern

visitObjectPattern: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectPattern>
) => any;

method visitObjectProperty

visitObjectProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectProperty>
) => any;

method visitObjectTypeAnnotation

visitObjectTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeAnnotation>
) => any;

method visitObjectTypeCallProperty

visitObjectTypeCallProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeCallProperty>
) => any;

method visitObjectTypeIndexer

visitObjectTypeIndexer: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeIndexer>
) => any;

method visitObjectTypeInternalSlot

visitObjectTypeInternalSlot: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeInternalSlot>
) => any;

method visitObjectTypeProperty

visitObjectTypeProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeProperty>
) => any;

method visitObjectTypeSpreadProperty

visitObjectTypeSpreadProperty: (
    this: Context & M,
    path: NodePath<namedTypes.ObjectTypeSpreadProperty>
) => any;

method visitOpaqueType

visitOpaqueType: (
    this: Context & M,
    path: NodePath<namedTypes.OpaqueType>
) => any;

method visitOptionalCallExpression

visitOptionalCallExpression: (
    this: Context & M,
    path: NodePath<namedTypes.OptionalCallExpression>
) => any;

method visitOptionalMemberExpression

visitOptionalMemberExpression: (
    this: Context & M,
    path: NodePath<namedTypes.OptionalMemberExpression>
) => any;

method visitParenthesizedExpression

visitParenthesizedExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ParenthesizedExpression>
) => any;

method visitPattern

visitPattern: (this: Context & M, path: NodePath<namedTypes.Pattern>) => any;

method visitPosition

visitPosition: (this: Context & M, path: NodePath<namedTypes.Position>) => any;

method visitPrintable

visitPrintable: (this: Context & M, path: NodePath<namedTypes.Printable>) => any;

method visitPrivateName

visitPrivateName: (
    this: Context & M,
    path: NodePath<namedTypes.PrivateName>
) => any;

method visitProgram

visitProgram: (this: Context & M, path: NodePath<namedTypes.Program>) => any;

method visitProperty

visitProperty: (this: Context & M, path: NodePath<namedTypes.Property>) => any;

method visitPropertyPattern

visitPropertyPattern: (
    this: Context & M,
    path: NodePath<namedTypes.PropertyPattern>
) => any;

method visitQualifiedTypeIdentifier

visitQualifiedTypeIdentifier: (
    this: Context & M,
    path: NodePath<namedTypes.QualifiedTypeIdentifier>
) => any;

method visitRegExpLiteral

visitRegExpLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.RegExpLiteral>
) => any;

method visitRestElement

visitRestElement: (
    this: Context & M,
    path: NodePath<namedTypes.RestElement>
) => any;

method visitRestProperty

visitRestProperty: (
    this: Context & M,
    path: NodePath<namedTypes.RestProperty>
) => any;

method visitReturnStatement

visitReturnStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ReturnStatement>
) => any;

method visitSequenceExpression

visitSequenceExpression: (
    this: Context & M,
    path: NodePath<namedTypes.SequenceExpression>
) => any;

method visitSourceLocation

visitSourceLocation: (
    this: Context & M,
    path: NodePath<namedTypes.SourceLocation>
) => any;

method visitSpecifier

visitSpecifier: (this: Context & M, path: NodePath<namedTypes.Specifier>) => any;

method visitSpreadElement

visitSpreadElement: (
    this: Context & M,
    path: NodePath<namedTypes.SpreadElement>
) => any;

method visitSpreadElementPattern

visitSpreadElementPattern: (
    this: Context & M,
    path: NodePath<namedTypes.SpreadElementPattern>
) => any;

method visitSpreadProperty

visitSpreadProperty: (
    this: Context & M,
    path: NodePath<namedTypes.SpreadProperty>
) => any;

method visitSpreadPropertyPattern

visitSpreadPropertyPattern: (
    this: Context & M,
    path: NodePath<namedTypes.SpreadPropertyPattern>
) => any;

method visitStatement

visitStatement: (this: Context & M, path: NodePath<namedTypes.Statement>) => any;

method visitStringLiteral

visitStringLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.StringLiteral>
) => any;

method visitStringLiteralTypeAnnotation

visitStringLiteralTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.StringLiteralTypeAnnotation>
) => any;

method visitStringTypeAnnotation

visitStringTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.StringTypeAnnotation>
) => any;

method visitSuper

visitSuper: (this: Context & M, path: NodePath<namedTypes.Super>) => any;

method visitSwitchCase

visitSwitchCase: (
    this: Context & M,
    path: NodePath<namedTypes.SwitchCase>
) => any;

method visitSwitchStatement

visitSwitchStatement: (
    this: Context & M,
    path: NodePath<namedTypes.SwitchStatement>
) => any;

method visitSymbolTypeAnnotation

visitSymbolTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.SymbolTypeAnnotation>
) => any;

method visitTaggedTemplateExpression

visitTaggedTemplateExpression: (
    this: Context & M,
    path: NodePath<namedTypes.TaggedTemplateExpression>
) => any;

method visitTemplateElement

visitTemplateElement: (
    this: Context & M,
    path: NodePath<namedTypes.TemplateElement>
) => any;

method visitTemplateLiteral

visitTemplateLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.TemplateLiteral>
) => any;

method visitThisExpression

visitThisExpression: (
    this: Context & M,
    path: NodePath<namedTypes.ThisExpression>
) => any;

method visitThisTypeAnnotation

visitThisTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.ThisTypeAnnotation>
) => any;

method visitThrowStatement

visitThrowStatement: (
    this: Context & M,
    path: NodePath<namedTypes.ThrowStatement>
) => any;

method visitTryStatement

visitTryStatement: (
    this: Context & M,
    path: NodePath<namedTypes.TryStatement>
) => any;

method visitTSAnyKeyword

visitTSAnyKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSAnyKeyword>
) => any;

method visitTSArrayType

visitTSArrayType: (
    this: Context & M,
    path: NodePath<namedTypes.TSArrayType>
) => any;

method visitTSAsExpression

visitTSAsExpression: (
    this: Context & M,
    path: NodePath<namedTypes.TSAsExpression>
) => any;

method visitTSBigIntKeyword

visitTSBigIntKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSBigIntKeyword>
) => any;

method visitTSBooleanKeyword

visitTSBooleanKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSBooleanKeyword>
) => any;

method visitTSCallSignatureDeclaration

visitTSCallSignatureDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSCallSignatureDeclaration>
) => any;

method visitTSConditionalType

visitTSConditionalType: (
    this: Context & M,
    path: NodePath<namedTypes.TSConditionalType>
) => any;

method visitTSConstructorType

visitTSConstructorType: (
    this: Context & M,
    path: NodePath<namedTypes.TSConstructorType>
) => any;

method visitTSConstructSignatureDeclaration

visitTSConstructSignatureDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSConstructSignatureDeclaration>
) => any;

method visitTSDeclareFunction

visitTSDeclareFunction: (
    this: Context & M,
    path: NodePath<namedTypes.TSDeclareFunction>
) => any;

method visitTSDeclareMethod

visitTSDeclareMethod: (
    this: Context & M,
    path: NodePath<namedTypes.TSDeclareMethod>
) => any;

method visitTSEnumDeclaration

visitTSEnumDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSEnumDeclaration>
) => any;

method visitTSEnumMember

visitTSEnumMember: (
    this: Context & M,
    path: NodePath<namedTypes.TSEnumMember>
) => any;

method visitTSExportAssignment

visitTSExportAssignment: (
    this: Context & M,
    path: NodePath<namedTypes.TSExportAssignment>
) => any;

method visitTSExpressionWithTypeArguments

visitTSExpressionWithTypeArguments: (
    this: Context & M,
    path: NodePath<namedTypes.TSExpressionWithTypeArguments>
) => any;

method visitTSExternalModuleReference

visitTSExternalModuleReference: (
    this: Context & M,
    path: NodePath<namedTypes.TSExternalModuleReference>
) => any;

method visitTSFunctionType

visitTSFunctionType: (
    this: Context & M,
    path: NodePath<namedTypes.TSFunctionType>
) => any;

method visitTSHasOptionalTypeAnnotation

visitTSHasOptionalTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.TSHasOptionalTypeAnnotation>
) => any;

method visitTSHasOptionalTypeParameterInstantiation

visitTSHasOptionalTypeParameterInstantiation: (
    this: Context & M,
    path: NodePath<namedTypes.TSHasOptionalTypeParameterInstantiation>
) => any;

method visitTSHasOptionalTypeParameters

visitTSHasOptionalTypeParameters: (
    this: Context & M,
    path: NodePath<namedTypes.TSHasOptionalTypeParameters>
) => any;

method visitTSImportEqualsDeclaration

visitTSImportEqualsDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSImportEqualsDeclaration>
) => any;

method visitTSImportType

visitTSImportType: (
    this: Context & M,
    path: NodePath<namedTypes.TSImportType>
) => any;

method visitTSIndexedAccessType

visitTSIndexedAccessType: (
    this: Context & M,
    path: NodePath<namedTypes.TSIndexedAccessType>
) => any;

method visitTSIndexSignature

visitTSIndexSignature: (
    this: Context & M,
    path: NodePath<namedTypes.TSIndexSignature>
) => any;

method visitTSInferType

visitTSInferType: (
    this: Context & M,
    path: NodePath<namedTypes.TSInferType>
) => any;

method visitTSInterfaceBody

visitTSInterfaceBody: (
    this: Context & M,
    path: NodePath<namedTypes.TSInterfaceBody>
) => any;

method visitTSInterfaceDeclaration

visitTSInterfaceDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSInterfaceDeclaration>
) => any;

method visitTSIntersectionType

visitTSIntersectionType: (
    this: Context & M,
    path: NodePath<namedTypes.TSIntersectionType>
) => any;

method visitTSLiteralType

visitTSLiteralType: (
    this: Context & M,
    path: NodePath<namedTypes.TSLiteralType>
) => any;

method visitTSMappedType

visitTSMappedType: (
    this: Context & M,
    path: NodePath<namedTypes.TSMappedType>
) => any;

method visitTSMethodSignature

visitTSMethodSignature: (
    this: Context & M,
    path: NodePath<namedTypes.TSMethodSignature>
) => any;

method visitTSModuleBlock

visitTSModuleBlock: (
    this: Context & M,
    path: NodePath<namedTypes.TSModuleBlock>
) => any;

method visitTSModuleDeclaration

visitTSModuleDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSModuleDeclaration>
) => any;

method visitTSNamedTupleMember

visitTSNamedTupleMember: (
    this: Context & M,
    path: NodePath<namedTypes.TSNamedTupleMember>
) => any;

method visitTSNamespaceExportDeclaration

visitTSNamespaceExportDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSNamespaceExportDeclaration>
) => any;

method visitTSNeverKeyword

visitTSNeverKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSNeverKeyword>
) => any;

method visitTSNonNullExpression

visitTSNonNullExpression: (
    this: Context & M,
    path: NodePath<namedTypes.TSNonNullExpression>
) => any;

method visitTSNullKeyword

visitTSNullKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSNullKeyword>
) => any;

method visitTSNumberKeyword

visitTSNumberKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSNumberKeyword>
) => any;

method visitTSObjectKeyword

visitTSObjectKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSObjectKeyword>
) => any;

method visitTSOptionalType

visitTSOptionalType: (
    this: Context & M,
    path: NodePath<namedTypes.TSOptionalType>
) => any;

method visitTSParameterProperty

visitTSParameterProperty: (
    this: Context & M,
    path: NodePath<namedTypes.TSParameterProperty>
) => any;

method visitTSParenthesizedType

visitTSParenthesizedType: (
    this: Context & M,
    path: NodePath<namedTypes.TSParenthesizedType>
) => any;

method visitTSPropertySignature

visitTSPropertySignature: (
    this: Context & M,
    path: NodePath<namedTypes.TSPropertySignature>
) => any;

method visitTSQualifiedName

visitTSQualifiedName: (
    this: Context & M,
    path: NodePath<namedTypes.TSQualifiedName>
) => any;

method visitTSRestType

visitTSRestType: (
    this: Context & M,
    path: NodePath<namedTypes.TSRestType>
) => any;

method visitTSStringKeyword

visitTSStringKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSStringKeyword>
) => any;

method visitTSSymbolKeyword

visitTSSymbolKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSSymbolKeyword>
) => any;

method visitTSThisType

visitTSThisType: (
    this: Context & M,
    path: NodePath<namedTypes.TSThisType>
) => any;

method visitTSTupleType

visitTSTupleType: (
    this: Context & M,
    path: NodePath<namedTypes.TSTupleType>
) => any;

method visitTSType

visitTSType: (this: Context & M, path: NodePath<namedTypes.TSType>) => any;

method visitTSTypeAliasDeclaration

visitTSTypeAliasDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeAliasDeclaration>
) => any;

method visitTSTypeAnnotation

visitTSTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeAnnotation>
) => any;

method visitTSTypeAssertion

visitTSTypeAssertion: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeAssertion>
) => any;

method visitTSTypeLiteral

visitTSTypeLiteral: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeLiteral>
) => any;

method visitTSTypeOperator

visitTSTypeOperator: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeOperator>
) => any;

method visitTSTypeParameter

visitTSTypeParameter: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeParameter>
) => any;

method visitTSTypeParameterDeclaration

visitTSTypeParameterDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeParameterDeclaration>
) => any;

method visitTSTypeParameterInstantiation

visitTSTypeParameterInstantiation: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeParameterInstantiation>
) => any;

method visitTSTypePredicate

visitTSTypePredicate: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypePredicate>
) => any;

method visitTSTypeQuery

visitTSTypeQuery: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeQuery>
) => any;

method visitTSTypeReference

visitTSTypeReference: (
    this: Context & M,
    path: NodePath<namedTypes.TSTypeReference>
) => any;

method visitTSUndefinedKeyword

visitTSUndefinedKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSUndefinedKeyword>
) => any;

method visitTSUnionType

visitTSUnionType: (
    this: Context & M,
    path: NodePath<namedTypes.TSUnionType>
) => any;

method visitTSUnknownKeyword

visitTSUnknownKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSUnknownKeyword>
) => any;

method visitTSVoidKeyword

visitTSVoidKeyword: (
    this: Context & M,
    path: NodePath<namedTypes.TSVoidKeyword>
) => any;

method visitTupleTypeAnnotation

visitTupleTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.TupleTypeAnnotation>
) => any;

method visitTypeAlias

visitTypeAlias: (this: Context & M, path: NodePath<namedTypes.TypeAlias>) => any;

method visitTypeAnnotation

visitTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.TypeAnnotation>
) => any;

method visitTypeCastExpression

visitTypeCastExpression: (
    this: Context & M,
    path: NodePath<namedTypes.TypeCastExpression>
) => any;

method visitTypeofTypeAnnotation

visitTypeofTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.TypeofTypeAnnotation>
) => any;

method visitTypeParameter

visitTypeParameter: (
    this: Context & M,
    path: NodePath<namedTypes.TypeParameter>
) => any;

method visitTypeParameterDeclaration

visitTypeParameterDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.TypeParameterDeclaration>
) => any;

method visitTypeParameterInstantiation

visitTypeParameterInstantiation: (
    this: Context & M,
    path: NodePath<namedTypes.TypeParameterInstantiation>
) => any;

method visitUnaryExpression

visitUnaryExpression: (
    this: Context & M,
    path: NodePath<namedTypes.UnaryExpression>
) => any;

method visitUnionTypeAnnotation

visitUnionTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.UnionTypeAnnotation>
) => any;

method visitUpdateExpression

visitUpdateExpression: (
    this: Context & M,
    path: NodePath<namedTypes.UpdateExpression>
) => any;

method visitVariableDeclaration

visitVariableDeclaration: (
    this: Context & M,
    path: NodePath<namedTypes.VariableDeclaration>
) => any;

method visitVariableDeclarator

visitVariableDeclarator: (
    this: Context & M,
    path: NodePath<namedTypes.VariableDeclarator>
) => any;

method visitVariance

visitVariance: (this: Context & M, path: NodePath<namedTypes.Variance>) => any;

method visitVoidTypeAnnotation

visitVoidTypeAnnotation: (
    this: Context & M,
    path: NodePath<namedTypes.VoidTypeAnnotation>
) => any;

method visitWhileStatement

visitWhileStatement: (
    this: Context & M,
    path: NodePath<namedTypes.WhileStatement>
) => any;

method visitWithStatement

visitWithStatement: (
    this: Context & M,
    path: NodePath<namedTypes.WithStatement>
) => any;

method visitYieldExpression

visitYieldExpression: (
    this: Context & M,
    path: NodePath<namedTypes.YieldExpression>
) => any;

Type Aliases

type Field

type FieldType<T> = Field<T>;

type Type

type Type<T> =
    | ArrayType<T>
    | IdentityType<T>
    | ObjectType<T>
    | OrType<T>
    | PredicateType<T>;

Namespaces

namespace namedTypes

namespace namedTypes {}

variable AnyTypeAnnotation

let AnyTypeAnnotation: Type<AnyTypeAnnotation>;

variable ArrayExpression

let ArrayExpression: Type<ArrayExpression>;

variable ArrayPattern

let ArrayPattern: Type<ArrayPattern>;

variable ArrayTypeAnnotation

let ArrayTypeAnnotation: Type<ArrayTypeAnnotation>;

variable ArrowFunctionExpression

let ArrowFunctionExpression: Type<ArrowFunctionExpression>;

variable AssignmentExpression

let AssignmentExpression: Type<AssignmentExpression>;

variable AssignmentPattern

let AssignmentPattern: Type<AssignmentPattern>;

variable AwaitExpression

let AwaitExpression: Type<AwaitExpression>;

variable BigIntLiteral

let BigIntLiteral: Type<BigIntLiteral>;

variable BigIntLiteralTypeAnnotation

let BigIntLiteralTypeAnnotation: Type<BigIntLiteralTypeAnnotation>;

variable BigIntTypeAnnotation

let BigIntTypeAnnotation: Type<BigIntTypeAnnotation>;

variable BinaryExpression

let BinaryExpression: Type<BinaryExpression>;

variable BindExpression

let BindExpression: Type<BindExpression>;

variable Block

let Block: Type<Block>;

variable BlockStatement

let BlockStatement: Type<BlockStatement>;

variable BooleanLiteral

let BooleanLiteral: Type<BooleanLiteral>;

variable BooleanLiteralTypeAnnotation

let BooleanLiteralTypeAnnotation: Type<BooleanLiteralTypeAnnotation>;

variable BooleanTypeAnnotation

let BooleanTypeAnnotation: Type<BooleanTypeAnnotation>;

variable BreakStatement

let BreakStatement: Type<BreakStatement>;

variable CallExpression

let CallExpression: Type<CallExpression>;

variable CatchClause

let CatchClause: Type<CatchClause>;

variable ChainElement

let ChainElement: Type<ChainElement>;

variable ChainExpression

let ChainExpression: Type<ChainExpression>;

variable ClassBody

let ClassBody: Type<ClassBody>;

variable ClassDeclaration

let ClassDeclaration: Type<ClassDeclaration>;

variable ClassExpression

let ClassExpression: Type<ClassExpression>;

variable ClassImplements

let ClassImplements: Type<ClassImplements>;

variable ClassMethod

let ClassMethod: Type<ClassMethod>;

variable ClassPrivateMethod

let ClassPrivateMethod: Type<ClassPrivateMethod>;

variable ClassPrivateProperty

let ClassPrivateProperty: Type<ClassPrivateProperty>;

variable ClassProperty

let ClassProperty: Type<ClassProperty>;

variable ClassPropertyDefinition

let ClassPropertyDefinition: Type<ClassPropertyDefinition>;

variable Comment

let Comment: Type<Comment>;

variable CommentBlock

let CommentBlock: Type<CommentBlock>;

variable CommentLine

let CommentLine: Type<CommentLine>;

variable ComprehensionBlock

let ComprehensionBlock: Type<ComprehensionBlock>;

variable ComprehensionExpression

let ComprehensionExpression: Type<ComprehensionExpression>;

variable ConditionalExpression

let ConditionalExpression: Type<ConditionalExpression>;

variable ContinueStatement

let ContinueStatement: Type<ContinueStatement>;

variable DebuggerStatement

let DebuggerStatement: Type<DebuggerStatement>;

variable Declaration

let Declaration: Type<Declaration>;

variable DeclareClass

let DeclareClass: Type<DeclareClass>;

variable DeclaredPredicate

let DeclaredPredicate: Type<DeclaredPredicate>;

variable DeclareExportAllDeclaration

let DeclareExportAllDeclaration: Type<DeclareExportAllDeclaration>;

variable DeclareExportDeclaration

let DeclareExportDeclaration: Type<DeclareExportDeclaration>;

variable DeclareFunction

let DeclareFunction: Type<DeclareFunction>;

variable DeclareInterface

let DeclareInterface: Type<DeclareInterface>;

variable DeclareModule

let DeclareModule: Type<DeclareModule>;

variable DeclareModuleExports

let DeclareModuleExports: Type<DeclareModuleExports>;

variable DeclareOpaqueType

let DeclareOpaqueType: Type<DeclareOpaqueType>;

variable DeclareTypeAlias

let DeclareTypeAlias: Type<DeclareTypeAlias>;

variable DeclareVariable

let DeclareVariable: Type<DeclareVariable>;

variable Decorator

let Decorator: Type<Decorator>;

variable Directive

let Directive: Type<Directive>;

variable DirectiveLiteral

let DirectiveLiteral: Type<DirectiveLiteral>;

variable DoExpression

let DoExpression: Type<DoExpression>;

variable DoWhileStatement

let DoWhileStatement: Type<DoWhileStatement>;

variable EmptyStatement

let EmptyStatement: Type<EmptyStatement>;

variable EmptyTypeAnnotation

let EmptyTypeAnnotation: Type<EmptyTypeAnnotation>;

variable EnumBooleanBody

let EnumBooleanBody: Type<EnumBooleanBody>;

variable EnumBooleanMember

let EnumBooleanMember: Type<EnumBooleanMember>;

variable EnumDeclaration

let EnumDeclaration: Type<EnumDeclaration>;

variable EnumDefaultedMember

let EnumDefaultedMember: Type<EnumDefaultedMember>;

variable EnumNumberBody

let EnumNumberBody: Type<EnumNumberBody>;

variable EnumNumberMember

let EnumNumberMember: Type<EnumNumberMember>;

variable EnumStringBody

let EnumStringBody: Type<EnumStringBody>;

variable EnumStringMember

let EnumStringMember: Type<EnumStringMember>;

variable EnumSymbolBody

let EnumSymbolBody: Type<EnumSymbolBody>;

variable ExistentialTypeParam

let ExistentialTypeParam: Type<ExistentialTypeParam>;

variable ExistsTypeAnnotation

let ExistsTypeAnnotation: Type<ExistsTypeAnnotation>;

variable ExportAllDeclaration

let ExportAllDeclaration: Type<ExportAllDeclaration>;

variable ExportBatchSpecifier

let ExportBatchSpecifier: Type<ExportBatchSpecifier>;

variable ExportDeclaration

let ExportDeclaration: Type<ExportDeclaration>;

variable ExportDefaultDeclaration

let ExportDefaultDeclaration: Type<ExportDefaultDeclaration>;

variable ExportDefaultSpecifier

let ExportDefaultSpecifier: Type<ExportDefaultSpecifier>;

variable ExportNamedDeclaration

let ExportNamedDeclaration: Type<ExportNamedDeclaration>;

variable ExportNamespaceSpecifier

let ExportNamespaceSpecifier: Type<ExportNamespaceSpecifier>;

variable ExportSpecifier

let ExportSpecifier: Type<ExportSpecifier>;

variable Expression

let Expression: Type<Expression>;

variable ExpressionStatement

let ExpressionStatement: Type<ExpressionStatement>;

variable File

let File: Type<File>;

variable Flow

let Flow: Type<Flow>;

variable FlowPredicate

let FlowPredicate: Type<FlowPredicate>;

variable FlowType

let FlowType: Type<FlowType>;

variable ForAwaitStatement

let ForAwaitStatement: Type<ForAwaitStatement>;

variable ForInStatement

let ForInStatement: Type<ForInStatement>;

variable ForOfStatement

let ForOfStatement: Type<ForOfStatement>;

variable ForStatement

let ForStatement: Type<ForStatement>;

variable Function

let Function: Type<Function>;

variable FunctionDeclaration

let FunctionDeclaration: Type<FunctionDeclaration>;

variable FunctionExpression

let FunctionExpression: Type<FunctionExpression>;

variable FunctionTypeAnnotation

let FunctionTypeAnnotation: Type<FunctionTypeAnnotation>;

variable FunctionTypeParam

let FunctionTypeParam: Type<FunctionTypeParam>;

variable GeneratorExpression

let GeneratorExpression: Type<GeneratorExpression>;

variable GenericTypeAnnotation

let GenericTypeAnnotation: Type<GenericTypeAnnotation>;

variable Identifier

let Identifier: Type<Identifier>;

variable IfStatement

let IfStatement: Type<IfStatement>;

variable Import

let Import: Type<Import>;

variable ImportDeclaration

let ImportDeclaration: Type<ImportDeclaration>;

variable ImportDefaultSpecifier

let ImportDefaultSpecifier: Type<ImportDefaultSpecifier>;

variable ImportExpression

let ImportExpression: Type<ImportExpression>;

variable ImportNamespaceSpecifier

let ImportNamespaceSpecifier: Type<ImportNamespaceSpecifier>;

variable ImportSpecifier

let ImportSpecifier: Type<ImportSpecifier>;

variable InferredPredicate

let InferredPredicate: Type<InferredPredicate>;

variable InterfaceDeclaration

let InterfaceDeclaration: Type<InterfaceDeclaration>;

variable InterfaceExtends

let InterfaceExtends: Type<InterfaceExtends>;

variable InterfaceTypeAnnotation

let InterfaceTypeAnnotation: Type<InterfaceTypeAnnotation>;

variable InterpreterDirective

let InterpreterDirective: Type<InterpreterDirective>;

variable IntersectionTypeAnnotation

let IntersectionTypeAnnotation: Type<IntersectionTypeAnnotation>;

variable JSXAttribute

let JSXAttribute: Type<JSXAttribute>;

variable JSXClosingElement

let JSXClosingElement: Type<JSXClosingElement>;

variable JSXClosingFragment

let JSXClosingFragment: Type<JSXClosingFragment>;

variable JSXElement

let JSXElement: Type<JSXElement>;

variable JSXEmptyExpression

let JSXEmptyExpression: Type<JSXEmptyExpression>;

variable JSXExpressionContainer

let JSXExpressionContainer: Type<JSXExpressionContainer>;

variable JSXFragment

let JSXFragment: Type<JSXFragment>;

variable JSXIdentifier

let JSXIdentifier: Type<JSXIdentifier>;

variable JSXMemberExpression

let JSXMemberExpression: Type<JSXMemberExpression>;

variable JSXNamespacedName

let JSXNamespacedName: Type<JSXNamespacedName>;

variable JSXOpeningElement

let JSXOpeningElement: Type<JSXOpeningElement>;

variable JSXOpeningFragment

let JSXOpeningFragment: Type<JSXOpeningFragment>;

variable JSXSpreadAttribute

let JSXSpreadAttribute: Type<JSXSpreadAttribute>;

variable JSXSpreadChild

let JSXSpreadChild: Type<JSXSpreadChild>;

variable JSXText

let JSXText: Type<JSXText>;

variable LabeledStatement

let LabeledStatement: Type<LabeledStatement>;

variable Line

let Line: Type<Line>;

variable Literal

let Literal: Type<Literal>;

variable LogicalExpression

let LogicalExpression: Type<LogicalExpression>;

variable MemberExpression

let MemberExpression: Type<MemberExpression>;

variable MemberTypeAnnotation

let MemberTypeAnnotation: Type<MemberTypeAnnotation>;

variable MetaProperty

let MetaProperty: Type<MetaProperty>;

variable MethodDefinition

let MethodDefinition: Type<MethodDefinition>;

variable MixedTypeAnnotation

let MixedTypeAnnotation: Type<MixedTypeAnnotation>;

variable ModuleSpecifier

let ModuleSpecifier: Type<ModuleSpecifier>;

variable NewExpression

let NewExpression: Type<NewExpression>;

variable Node

let Node: Type<Node>;

variable Noop

let Noop: Type<Noop>;

variable NullableTypeAnnotation

let NullableTypeAnnotation: Type<NullableTypeAnnotation>;

variable NullLiteral

let NullLiteral: Type<NullLiteral>;

variable NullLiteralTypeAnnotation

let NullLiteralTypeAnnotation: Type<NullLiteralTypeAnnotation>;

variable NullTypeAnnotation

let NullTypeAnnotation: Type<NullTypeAnnotation>;

variable NumberLiteralTypeAnnotation

let NumberLiteralTypeAnnotation: Type<NumberLiteralTypeAnnotation>;

variable NumberTypeAnnotation

let NumberTypeAnnotation: Type<NumberTypeAnnotation>;

variable NumericLiteral

let NumericLiteral: Type<NumericLiteral>;

variable NumericLiteralTypeAnnotation

let NumericLiteralTypeAnnotation: Type<NumericLiteralTypeAnnotation>;

variable ObjectExpression

let ObjectExpression: Type<ObjectExpression>;

variable ObjectMethod

let ObjectMethod: Type<ObjectMethod>;

variable ObjectPattern

let ObjectPattern: Type<ObjectPattern>;

variable ObjectProperty

let ObjectProperty: Type<ObjectProperty>;

variable ObjectTypeAnnotation

let ObjectTypeAnnotation: Type<ObjectTypeAnnotation>;

variable ObjectTypeCallProperty

let ObjectTypeCallProperty: Type<ObjectTypeCallProperty>;

variable ObjectTypeIndexer

let ObjectTypeIndexer: Type<ObjectTypeIndexer>;

variable ObjectTypeInternalSlot

let ObjectTypeInternalSlot: Type<ObjectTypeInternalSlot>;

variable ObjectTypeProperty

let ObjectTypeProperty: Type<ObjectTypeProperty>;

variable ObjectTypeSpreadProperty

let ObjectTypeSpreadProperty: Type<ObjectTypeSpreadProperty>;

variable OpaqueType

let OpaqueType: Type<OpaqueType>;

variable OptionalCallExpression

let OptionalCallExpression: Type<OptionalCallExpression>;

variable OptionalMemberExpression

let OptionalMemberExpression: Type<OptionalMemberExpression>;

variable ParenthesizedExpression

let ParenthesizedExpression: Type<ParenthesizedExpression>;

variable Pattern

let Pattern: Type<Pattern>;

variable Position

let Position: Type<Position>;

variable Printable

let Printable: Type<Printable>;

variable PrivateName

let PrivateName: Type<PrivateName>;

variable Program

let Program: Type<Program>;

variable Property

let Property: Type<Property>;

variable PropertyPattern

let PropertyPattern: Type<PropertyPattern>;

variable QualifiedTypeIdentifier

let QualifiedTypeIdentifier: Type<QualifiedTypeIdentifier>;

variable RegExpLiteral

let RegExpLiteral: Type<RegExpLiteral>;

variable RestElement

let RestElement: Type<RestElement>;

variable RestProperty

let RestProperty: Type<RestProperty>;

variable ReturnStatement

let ReturnStatement: Type<ReturnStatement>;

variable SequenceExpression

let SequenceExpression: Type<SequenceExpression>;

variable SourceLocation

let SourceLocation: Type<SourceLocation>;

variable Specifier

let Specifier: Type<Specifier>;

variable SpreadElement

let SpreadElement: Type<SpreadElement>;

variable SpreadElementPattern

let SpreadElementPattern: Type<SpreadElementPattern>;

variable SpreadProperty

let SpreadProperty: Type<SpreadProperty>;

variable SpreadPropertyPattern

let SpreadPropertyPattern: Type<SpreadPropertyPattern>;

variable Statement

let Statement: Type<Statement>;

variable StringLiteral

let StringLiteral: Type<StringLiteral>;

variable StringLiteralTypeAnnotation

let StringLiteralTypeAnnotation: Type<StringLiteralTypeAnnotation>;

variable StringTypeAnnotation

let StringTypeAnnotation: Type<StringTypeAnnotation>;

variable Super

let Super: Type<Super>;

variable SwitchCase

let SwitchCase: Type<SwitchCase>;

variable SwitchStatement

let SwitchStatement: Type<SwitchStatement>;

variable SymbolTypeAnnotation

let SymbolTypeAnnotation: Type<SymbolTypeAnnotation>;

variable TaggedTemplateExpression

let TaggedTemplateExpression: Type<TaggedTemplateExpression>;

variable TemplateElement

let TemplateElement: Type<TemplateElement>;

variable TemplateLiteral

let TemplateLiteral: Type<TemplateLiteral>;

variable ThisExpression

let ThisExpression: Type<ThisExpression>;

variable ThisTypeAnnotation

let ThisTypeAnnotation: Type<ThisTypeAnnotation>;

variable ThrowStatement

let ThrowStatement: Type<ThrowStatement>;

variable TryStatement

let TryStatement: Type<TryStatement>;

variable TSAnyKeyword

let TSAnyKeyword: Type<TSAnyKeyword>;

variable TSArrayType

let TSArrayType: Type<TSArrayType>;

variable TSAsExpression

let TSAsExpression: Type<TSAsExpression>;

variable TSBigIntKeyword

let TSBigIntKeyword: Type<TSBigIntKeyword>;

variable TSBooleanKeyword

let TSBooleanKeyword: Type<TSBooleanKeyword>;

variable TSCallSignatureDeclaration

let TSCallSignatureDeclaration: Type<TSCallSignatureDeclaration>;

variable TSConditionalType

let TSConditionalType: Type<TSConditionalType>;

variable TSConstructorType

let TSConstructorType: Type<TSConstructorType>;

variable TSConstructSignatureDeclaration

let TSConstructSignatureDeclaration: Type<TSConstructSignatureDeclaration>;

variable TSDeclareFunction

let TSDeclareFunction: Type<TSDeclareFunction>;

variable TSDeclareMethod

let TSDeclareMethod: Type<TSDeclareMethod>;

variable TSEnumDeclaration

let TSEnumDeclaration: Type<TSEnumDeclaration>;

variable TSEnumMember

let TSEnumMember: Type<TSEnumMember>;

variable TSExportAssignment

let TSExportAssignment: Type<TSExportAssignment>;

variable TSExpressionWithTypeArguments

let TSExpressionWithTypeArguments: Type<TSExpressionWithTypeArguments>;

variable TSExternalModuleReference

let TSExternalModuleReference: Type<TSExternalModuleReference>;

variable TSFunctionType

let TSFunctionType: Type<TSFunctionType>;

variable TSHasOptionalTypeAnnotation

let TSHasOptionalTypeAnnotation: Type<TSHasOptionalTypeAnnotation>;

variable TSHasOptionalTypeParameterInstantiation

let TSHasOptionalTypeParameterInstantiation: Type<TSHasOptionalTypeParameterInstantiation>;

variable TSHasOptionalTypeParameters

let TSHasOptionalTypeParameters: Type<TSHasOptionalTypeParameters>;

variable TSImportEqualsDeclaration

let TSImportEqualsDeclaration: Type<TSImportEqualsDeclaration>;

variable TSImportType

let TSImportType: Type<TSImportType>;

variable TSIndexedAccessType

let TSIndexedAccessType: Type<TSIndexedAccessType>;

variable TSIndexSignature

let TSIndexSignature: Type<TSIndexSignature>;

variable TSInferType

let TSInferType: Type<TSInferType>;

variable TSInterfaceBody

let TSInterfaceBody: Type<TSInterfaceBody>;

variable TSInterfaceDeclaration

let TSInterfaceDeclaration: Type<TSInterfaceDeclaration>;

variable TSIntersectionType

let TSIntersectionType: Type<TSIntersectionType>;

variable TSLiteralType

let TSLiteralType: Type<TSLiteralType>;

variable TSMappedType

let TSMappedType: Type<TSMappedType>;

variable TSMethodSignature

let TSMethodSignature: Type<TSMethodSignature>;

variable TSModuleBlock

let TSModuleBlock: Type<TSModuleBlock>;

variable TSModuleDeclaration

let TSModuleDeclaration: Type<TSModuleDeclaration>;

variable TSNamedTupleMember

let TSNamedTupleMember: Type<TSNamedTupleMember>;

variable TSNamespaceExportDeclaration

let TSNamespaceExportDeclaration: Type<TSNamespaceExportDeclaration>;

variable TSNeverKeyword

let TSNeverKeyword: Type<TSNeverKeyword>;

variable TSNonNullExpression

let TSNonNullExpression: Type<TSNonNullExpression>;

variable TSNullKeyword

let TSNullKeyword: Type<TSNullKeyword>;

variable TSNumberKeyword

let TSNumberKeyword: Type<TSNumberKeyword>;

variable TSObjectKeyword

let TSObjectKeyword: Type<TSObjectKeyword>;

variable TSOptionalType

let TSOptionalType: Type<TSOptionalType>;

variable TSParameterProperty

let TSParameterProperty: Type<TSParameterProperty>;

variable TSParenthesizedType

let TSParenthesizedType: Type<TSParenthesizedType>;

variable TSPropertySignature

let TSPropertySignature: Type<TSPropertySignature>;

variable TSQualifiedName

let TSQualifiedName: Type<TSQualifiedName>;

variable TSRestType

let TSRestType: Type<TSRestType>;

variable TSStringKeyword

let TSStringKeyword: Type<TSStringKeyword>;

variable TSSymbolKeyword

let TSSymbolKeyword: Type<TSSymbolKeyword>;

variable TSThisType

let TSThisType: Type<TSThisType>;

variable TSTupleType

let TSTupleType: Type<TSTupleType>;

variable TSType

let TSType: Type<TSType>;

variable TSTypeAliasDeclaration

let TSTypeAliasDeclaration: Type<TSTypeAliasDeclaration>;

variable TSTypeAnnotation

let TSTypeAnnotation: Type<TSTypeAnnotation>;

variable TSTypeAssertion

let TSTypeAssertion: Type<TSTypeAssertion>;

variable TSTypeLiteral

let TSTypeLiteral: Type<TSTypeLiteral>;

variable TSTypeOperator

let TSTypeOperator: Type<TSTypeOperator>;

variable TSTypeParameter

let TSTypeParameter: Type<TSTypeParameter>;

variable TSTypeParameterDeclaration

let TSTypeParameterDeclaration: Type<TSTypeParameterDeclaration>;

variable TSTypeParameterInstantiation

let TSTypeParameterInstantiation: Type<TSTypeParameterInstantiation>;

variable TSTypePredicate

let TSTypePredicate: Type<TSTypePredicate>;

variable TSTypeQuery

let TSTypeQuery: Type<TSTypeQuery>;

variable TSTypeReference

let TSTypeReference: Type<TSTypeReference>;

variable TSUndefinedKeyword

let TSUndefinedKeyword: Type<TSUndefinedKeyword>;

variable TSUnionType

let TSUnionType: Type<TSUnionType>;

variable TSUnknownKeyword

let TSUnknownKeyword: Type<TSUnknownKeyword>;

variable TSVoidKeyword

let TSVoidKeyword: Type<TSVoidKeyword>;

variable TupleTypeAnnotation

let TupleTypeAnnotation: Type<TupleTypeAnnotation>;

variable TypeAlias

let TypeAlias: Type<TypeAlias>;

variable TypeAnnotation

let TypeAnnotation: Type<TypeAnnotation>;

variable TypeCastExpression

let TypeCastExpression: Type<TypeCastExpression>;

variable TypeofTypeAnnotation

let TypeofTypeAnnotation: Type<TypeofTypeAnnotation>;

variable TypeParameter

let TypeParameter: Type<TypeParameter>;

variable TypeParameterDeclaration

let TypeParameterDeclaration: Type<TypeParameterDeclaration>;

variable TypeParameterInstantiation

let TypeParameterInstantiation: Type<TypeParameterInstantiation>;

variable UnaryExpression

let UnaryExpression: Type<UnaryExpression>;

variable UnionTypeAnnotation

let UnionTypeAnnotation: Type<UnionTypeAnnotation>;

variable UpdateExpression

let UpdateExpression: Type<UpdateExpression>;

variable VariableDeclaration

let VariableDeclaration: Type<VariableDeclaration>;

variable VariableDeclarator

let VariableDeclarator: Type<VariableDeclarator>;

variable Variance

let Variance: Type<Variance>;

variable VoidTypeAnnotation

let VoidTypeAnnotation: Type<VoidTypeAnnotation>;

variable WhileStatement

let WhileStatement: Type<WhileStatement>;

variable WithStatement

let WithStatement: Type<WithStatement>;

variable YieldExpression

let YieldExpression: Type<YieldExpression>;

interface AnyTypeAnnotation

interface AnyTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'AnyTypeAnnotation';

interface ArrayExpression

interface ArrayExpression extends Omit<Expression, 'type'> {}

property elements

elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[];

property type

type: 'ArrayExpression';

interface ArrayPattern

interface ArrayPattern extends Omit<Pattern, 'type'> {}

property elements

elements: (K.PatternKind | K.SpreadElementKind | null)[];

property type

type: 'ArrayPattern';

interface ArrayTypeAnnotation

interface ArrayTypeAnnotation extends Omit<FlowType, 'type'> {}

property elementType

elementType: K.FlowTypeKind;

property type

type: 'ArrayTypeAnnotation';

interface ArrowFunctionExpression

interface ArrowFunctionExpression
    extends Omit<Function, 'type' | 'id' | 'body' | 'generator'>,
        Omit<Expression, 'type'> {}

property body

body: K.BlockStatementKind | K.ExpressionKind;

property generator

generator?: false;

property id

id?: null;

property type

type: 'ArrowFunctionExpression';

interface AssignmentExpression

interface AssignmentExpression extends Omit<Expression, 'type'> {}

property left

left: K.PatternKind | K.MemberExpressionKind;

property operator

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

property right

right: K.ExpressionKind;

property type

type: 'AssignmentExpression';

interface AssignmentPattern

interface AssignmentPattern extends Omit<Pattern, 'type'> {}

property left

left: K.PatternKind;

property right

right: K.ExpressionKind;

property type

type: 'AssignmentPattern';

interface AwaitExpression

interface AwaitExpression extends Omit<Expression, 'type'> {}

property all

all?: boolean;

property argument

argument: K.ExpressionKind | null;

property type

type: 'AwaitExpression';

interface BigIntLiteral

interface BigIntLiteral extends Omit<Literal, 'type' | 'value'> {}

property extra

extra?: {
    rawValue: string;
    raw: string;
};

property type

type: 'BigIntLiteral';

property value

value: string | number;

interface BigIntLiteralTypeAnnotation

interface BigIntLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property raw

raw: string;

property type

type: 'BigIntLiteralTypeAnnotation';

property value

value: null;

interface BigIntTypeAnnotation

interface BigIntTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'BigIntTypeAnnotation';

interface BinaryExpression

interface BinaryExpression extends Omit<Expression, 'type'> {}

property left

left: K.ExpressionKind;

property operator

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

property right

right: K.ExpressionKind;

property type

type: 'BinaryExpression';

interface BindExpression

interface BindExpression extends Omit<Expression, 'type'> {}

property callee

callee: K.ExpressionKind;

property object

object: K.ExpressionKind | null;

property type

type: 'BindExpression';

interface Block

interface Block extends Comment {}

property type

type: 'Block';

interface BlockStatement

interface BlockStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind[];

property directives

directives?: K.DirectiveKind[];

property type

type: 'BlockStatement';

interface BooleanLiteral

interface BooleanLiteral extends Omit<Literal, 'type' | 'value'> {}

property type

type: 'BooleanLiteral';

property value

value: boolean;

interface BooleanLiteralTypeAnnotation

interface BooleanLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property raw

raw: string;

property type

type: 'BooleanLiteralTypeAnnotation';

property value

value: boolean;

interface BooleanTypeAnnotation

interface BooleanTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'BooleanTypeAnnotation';

interface BreakStatement

interface BreakStatement extends Omit<Statement, 'type'> {}

property label

label?: K.IdentifierKind | null;

property type

type: 'BreakStatement';

interface CallExpression

interface CallExpression
    extends Omit<Expression, 'type'>,
        Omit<ChainElement, 'type'> {}

property arguments

arguments: (K.ExpressionKind | K.SpreadElementKind)[];

property callee

callee: K.ExpressionKind;

property type

type: 'CallExpression';

property typeArguments

typeArguments?: null | K.TypeParameterInstantiationKind;

interface CatchClause

interface CatchClause extends Omit<Node, 'type'> {}

property body

body: K.BlockStatementKind;

property guard

guard?: K.ExpressionKind | null;

property param

param?: K.PatternKind | null;

property type

type: 'CatchClause';

interface ChainElement

interface ChainElement extends Node {}

property optional

optional?: boolean;

interface ChainExpression

interface ChainExpression extends Omit<Expression, 'type'> {}

property expression

expression: K.ChainElementKind;

property type

type: 'ChainExpression';

interface ClassBody

interface ClassBody extends Omit<Declaration, 'type'> {}

property body

body: (
    | K.MethodDefinitionKind
    | K.VariableDeclaratorKind
    | K.ClassPropertyDefinitionKind
    | K.ClassPropertyKind
    | K.ClassPrivatePropertyKind
    | K.ClassMethodKind
    | K.ClassPrivateMethodKind
    | K.TSDeclareMethodKind
    | K.TSCallSignatureDeclarationKind
    | K.TSConstructSignatureDeclarationKind
    | K.TSIndexSignatureKind
    | K.TSMethodSignatureKind
    | K.TSPropertySignatureKind
)[];

property type

type: 'ClassBody';

interface ClassDeclaration

interface ClassDeclaration extends Omit<Declaration, 'type'> {}

property body

body: K.ClassBodyKind;

property id

id: K.IdentifierKind | null;

property implements

implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[];

property superClass

superClass?: K.ExpressionKind | null;

property superTypeParameters

superTypeParameters?:
    | K.TypeParameterInstantiationKind
    | K.TSTypeParameterInstantiationKind
    | null;

property type

type: 'ClassDeclaration';

property typeParameters

typeParameters?:
    | K.TypeParameterDeclarationKind
    | K.TSTypeParameterDeclarationKind
    | null;

interface ClassExpression

interface ClassExpression extends Omit<Expression, 'type'> {}

property body

body: K.ClassBodyKind;

property id

id?: K.IdentifierKind | null;

property implements

implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[];

property superClass

superClass?: K.ExpressionKind | null;

property superTypeParameters

superTypeParameters?:
    | K.TypeParameterInstantiationKind
    | K.TSTypeParameterInstantiationKind
    | null;

property type

type: 'ClassExpression';

property typeParameters

typeParameters?:
    | K.TypeParameterDeclarationKind
    | K.TSTypeParameterDeclarationKind
    | null;

interface ClassImplements

interface ClassImplements extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind;

property superClass

superClass?: K.ExpressionKind | null;

property type

type: 'ClassImplements';

property typeParameters

typeParameters?: K.TypeParameterInstantiationKind | null;

interface ClassMethod

interface ClassMethod
    extends Omit<Declaration, 'type'>,
        Omit<Function, 'type' | 'body'> {}

property abstract

abstract?: boolean | null;

property access

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

property accessibility

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

property body

body: K.BlockStatementKind;

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property kind

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

property optional

optional?: boolean | null;

property static

static?: boolean | null;

property type

type: 'ClassMethod';

interface ClassPrivateMethod

interface ClassPrivateMethod
    extends Omit<Declaration, 'type'>,
        Omit<Function, 'type' | 'body'> {}

property abstract

abstract?: boolean | null;

property access

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

property accessibility

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

property body

body: K.BlockStatementKind;

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property key

key: K.PrivateNameKind;

property kind

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

property optional

optional?: boolean | null;

property static

static?: boolean | null;

property type

type: 'ClassPrivateMethod';

interface ClassPrivateProperty

interface ClassPrivateProperty
    extends Omit<ClassProperty, 'type' | 'key' | 'value'> {}

property key

key: K.PrivateNameKind;

property type

type: 'ClassPrivateProperty';

property value

value?: K.ExpressionKind | null;

interface ClassProperty

interface ClassProperty extends Omit<Declaration, 'type'> {}

property access

access?: 'public' | 'private' | 'protected' | undefined;

property computed

computed?: boolean;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property static

static?: boolean;

property type

type: 'ClassProperty';

property typeAnnotation

typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;

property value

value: K.ExpressionKind | null;

property variance

variance?: K.VarianceKind | 'plus' | 'minus' | null;

interface ClassPropertyDefinition

interface ClassPropertyDefinition extends Omit<Declaration, 'type'> {}

property definition

definition:
    | K.MethodDefinitionKind
    | K.VariableDeclaratorKind
    | K.ClassPropertyDefinitionKind
    | K.ClassPropertyKind;

property type

type: 'ClassPropertyDefinition';

interface Comment

interface Comment extends Printable {}

property leading

leading?: boolean;

property trailing

trailing?: boolean;

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 ComprehensionBlock

interface ComprehensionBlock extends Omit<Node, 'type'> {}

property each

each: boolean;

property left

left: K.PatternKind;

property right

right: K.ExpressionKind;

property type

type: 'ComprehensionBlock';

interface ComprehensionExpression

interface ComprehensionExpression extends Omit<Expression, 'type'> {}

property blocks

blocks: K.ComprehensionBlockKind[];

property body

body: K.ExpressionKind;

property filter

filter: K.ExpressionKind | null;

property type

type: 'ComprehensionExpression';

interface ConditionalExpression

interface ConditionalExpression extends Omit<Expression, 'type'> {}

property alternate

alternate: K.ExpressionKind;

property consequent

consequent: K.ExpressionKind;

property test

test: K.ExpressionKind;

property type

type: 'ConditionalExpression';

interface ContinueStatement

interface ContinueStatement extends Omit<Statement, 'type'> {}

property label

label?: K.IdentifierKind | null;

property type

type: 'ContinueStatement';

interface DebuggerStatement

interface DebuggerStatement extends Omit<Statement, 'type'> {}

property type

type: 'DebuggerStatement';

interface Declaration

interface Declaration extends Statement {}

interface DeclareClass

interface DeclareClass extends Omit<InterfaceDeclaration, 'type'> {}

property type

type: 'DeclareClass';

interface DeclaredPredicate

interface DeclaredPredicate extends Omit<FlowPredicate, 'type'> {}

property type

type: 'DeclaredPredicate';

property value

value: K.ExpressionKind;

interface DeclareExportAllDeclaration

interface DeclareExportAllDeclaration extends Omit<Declaration, 'type'> {}

property source

source?: K.LiteralKind | null;

property type

type: 'DeclareExportAllDeclaration';

interface DeclareExportDeclaration

interface DeclareExportDeclaration extends Omit<Declaration, 'type'> {}

property declaration

declaration:
    | K.DeclareVariableKind
    | K.DeclareFunctionKind
    | K.DeclareClassKind
    | K.FlowTypeKind
    | K.TypeAliasKind
    | K.DeclareOpaqueTypeKind
    | K.InterfaceDeclarationKind
    | null;

property default

default: boolean;

property source

source?: K.LiteralKind | null;

property specifiers

specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];

property type

type: 'DeclareExportDeclaration';

interface DeclareFunction

interface DeclareFunction extends Omit<Statement, 'type'> {}

property id

id: K.IdentifierKind;

property predicate

predicate?: K.FlowPredicateKind | null;

property type

type: 'DeclareFunction';

interface DeclareInterface

interface DeclareInterface extends Omit<InterfaceDeclaration, 'type'> {}

property type

type: 'DeclareInterface';

interface DeclareModule

interface DeclareModule extends Omit<Statement, 'type'> {}

property body

body: K.BlockStatementKind;

property id

id: K.IdentifierKind | K.LiteralKind;

property type

type: 'DeclareModule';

interface DeclareModuleExports

interface DeclareModuleExports extends Omit<Statement, 'type'> {}

property type

type: 'DeclareModuleExports';

property typeAnnotation

typeAnnotation: K.TypeAnnotationKind;

interface DeclareOpaqueType

interface DeclareOpaqueType extends Omit<OpaqueType, 'type' | 'impltype'> {}

property impltype

impltype: K.FlowTypeKind | null;

property type

type: 'DeclareOpaqueType';

interface DeclareTypeAlias

interface DeclareTypeAlias extends Omit<TypeAlias, 'type'> {}

property type

type: 'DeclareTypeAlias';

interface DeclareVariable

interface DeclareVariable extends Omit<Statement, 'type'> {}

property id

id: K.IdentifierKind;

property type

type: 'DeclareVariable';

interface Decorator

interface Decorator extends Omit<Node, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'Decorator';

interface Directive

interface Directive extends Omit<Node, 'type'> {}

property type

type: 'Directive';

property value

value: K.DirectiveLiteralKind;

interface DirectiveLiteral

interface DirectiveLiteral extends Omit<Node, 'type'>, Omit<Expression, 'type'> {}

property type

type: 'DirectiveLiteral';

property value

value?: string;

interface DoExpression

interface DoExpression extends Omit<Expression, 'type'> {}

property body

body: K.StatementKind[];

property type

type: 'DoExpression';

interface DoWhileStatement

interface DoWhileStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property test

test: K.ExpressionKind;

property type

type: 'DoWhileStatement';

interface EmptyStatement

interface EmptyStatement extends Omit<Statement, 'type'> {}

property type

type: 'EmptyStatement';

interface EmptyTypeAnnotation

interface EmptyTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'EmptyTypeAnnotation';

interface EnumBooleanBody

interface EnumBooleanBody {}

property explicitType

explicitType: boolean;

property members

members: K.EnumBooleanMemberKind[];

property type

type: 'EnumBooleanBody';

interface EnumBooleanMember

interface EnumBooleanMember {}

property id

id: K.IdentifierKind;

property init

init: K.LiteralKind | boolean;

property type

type: 'EnumBooleanMember';

interface EnumDeclaration

interface EnumDeclaration extends Omit<Declaration, 'type'> {}

property body

body:
    | K.EnumBooleanBodyKind
    | K.EnumNumberBodyKind
    | K.EnumStringBodyKind
    | K.EnumSymbolBodyKind;

property id

id: K.IdentifierKind;

property type

type: 'EnumDeclaration';

interface EnumDefaultedMember

interface EnumDefaultedMember {}

property id

id: K.IdentifierKind;

property type

type: 'EnumDefaultedMember';

interface EnumNumberBody

interface EnumNumberBody {}

property explicitType

explicitType: boolean;

property members

members: K.EnumNumberMemberKind[];

property type

type: 'EnumNumberBody';

interface EnumNumberMember

interface EnumNumberMember {}

property id

id: K.IdentifierKind;

property init

init: K.LiteralKind;

property type

type: 'EnumNumberMember';

interface EnumStringBody

interface EnumStringBody {}

property explicitType

explicitType: boolean;

property members

members: K.EnumStringMemberKind[] | K.EnumDefaultedMemberKind[];

property type

type: 'EnumStringBody';

interface EnumStringMember

interface EnumStringMember {}

property id

id: K.IdentifierKind;

property init

init: K.LiteralKind;

property type

type: 'EnumStringMember';

interface EnumSymbolBody

interface EnumSymbolBody {}

property members

members: K.EnumDefaultedMemberKind[];

property type

type: 'EnumSymbolBody';

interface ExistentialTypeParam

interface ExistentialTypeParam extends Omit<FlowType, 'type'> {}

property type

type: 'ExistentialTypeParam';

interface ExistsTypeAnnotation

interface ExistsTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'ExistsTypeAnnotation';

interface ExportAllDeclaration

interface ExportAllDeclaration extends Omit<Declaration, 'type'> {}

property exported

exported: K.IdentifierKind | null;

property source

source: K.LiteralKind;

property type

type: 'ExportAllDeclaration';

interface ExportBatchSpecifier

interface ExportBatchSpecifier extends Omit<Specifier, 'type'> {}

property type

type: 'ExportBatchSpecifier';

interface ExportDeclaration

interface ExportDeclaration extends Omit<Declaration, 'type'> {}

property declaration

declaration: K.DeclarationKind | K.ExpressionKind | null;

property default

default: boolean;

property source

source?: K.LiteralKind | null;

property specifiers

specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[];

property type

type: 'ExportDeclaration';

interface ExportDefaultDeclaration

interface ExportDefaultDeclaration extends Omit<Declaration, 'type'> {}

property declaration

declaration: K.DeclarationKind | K.ExpressionKind;

property type

type: 'ExportDefaultDeclaration';

interface ExportDefaultSpecifier

interface ExportDefaultSpecifier extends Omit<Specifier, 'type'> {}

property exported

exported: K.IdentifierKind;

property type

type: 'ExportDefaultSpecifier';

interface ExportNamedDeclaration

interface ExportNamedDeclaration extends Omit<Declaration, 'type'> {}

property declaration

declaration: K.DeclarationKind | null;

property source

source?: K.LiteralKind | null;

property specifiers

specifiers?: K.ExportSpecifierKind[];

property type

type: 'ExportNamedDeclaration';

interface ExportNamespaceSpecifier

interface ExportNamespaceSpecifier extends Omit<Specifier, 'type'> {}

property exported

exported: K.IdentifierKind;

property type

type: 'ExportNamespaceSpecifier';

interface ExportSpecifier

interface ExportSpecifier extends Omit<ModuleSpecifier, 'type'> {}

property exported

exported: K.IdentifierKind;

property type

type: 'ExportSpecifier';

interface Expression

interface Expression extends Node {}

interface ExpressionStatement

interface ExpressionStatement extends Omit<Statement, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'ExpressionStatement';

interface File

interface File extends Omit<Node, 'type'> {}

property name

name?: string | null;

property program

program: K.ProgramKind;

property type

type: 'File';

interface Flow

interface Flow extends Node {}

interface FlowPredicate

interface FlowPredicate extends Flow {}

interface FlowType

interface FlowType extends Flow {}

interface ForAwaitStatement

interface ForAwaitStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property left

left: K.VariableDeclarationKind | K.ExpressionKind;

property right

right: K.ExpressionKind;

property type

type: 'ForAwaitStatement';

interface ForInStatement

interface ForInStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property left

left: K.VariableDeclarationKind | K.ExpressionKind;

property right

right: K.ExpressionKind;

property type

type: 'ForInStatement';

interface ForOfStatement

interface ForOfStatement extends Omit<Statement, 'type'> {}

property await

await?: boolean;

property body

body: K.StatementKind;

property left

left: K.VariableDeclarationKind | K.PatternKind;

property right

right: K.ExpressionKind;

property type

type: 'ForOfStatement';

interface ForStatement

interface ForStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property init

init: K.VariableDeclarationKind | K.ExpressionKind | null;

property test

test: K.ExpressionKind | null;

property type

type: 'ForStatement';

property update

update: K.ExpressionKind | null;

interface Function

interface Function extends Node {}

property async

async?: boolean;

property body

body: K.BlockStatementKind;

property defaults

defaults?: (K.ExpressionKind | null)[];

property expression

expression?: boolean;

property generator

generator?: boolean;

property id

id?: K.IdentifierKind | null;

property params

params: K.PatternKind[];

property predicate

predicate?: K.FlowPredicateKind | null;

property rest

rest?: K.IdentifierKind | null;

property returnType

returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;

property typeParameters

typeParameters?:
    | K.TypeParameterDeclarationKind
    | K.TSTypeParameterDeclarationKind
    | null;

interface FunctionDeclaration

interface FunctionDeclaration
    extends Omit<Function, 'type' | 'id'>,
        Omit<Declaration, 'type'> {}

property id

id: K.IdentifierKind | null;

property type

type: 'FunctionDeclaration';

interface FunctionExpression

interface FunctionExpression
    extends Omit<Function, 'type'>,
        Omit<Expression, 'type'> {}

property type

type: 'FunctionExpression';

interface FunctionTypeAnnotation

interface FunctionTypeAnnotation extends Omit<FlowType, 'type'> {}

property params

params: K.FunctionTypeParamKind[];

property rest

rest: K.FunctionTypeParamKind | null;

property returnType

returnType: K.FlowTypeKind;

property type

type: 'FunctionTypeAnnotation';

property typeParameters

typeParameters: K.TypeParameterDeclarationKind | null;

interface FunctionTypeParam

interface FunctionTypeParam extends Omit<Node, 'type'> {}

property name

name: K.IdentifierKind | null;

property optional

optional: boolean;

property type

type: 'FunctionTypeParam';

property typeAnnotation

typeAnnotation: K.FlowTypeKind;

interface GeneratorExpression

interface GeneratorExpression extends Omit<Expression, 'type'> {}

property blocks

blocks: K.ComprehensionBlockKind[];

property body

body: K.ExpressionKind;

property filter

filter: K.ExpressionKind | null;

property type

type: 'GeneratorExpression';

interface GenericTypeAnnotation

interface GenericTypeAnnotation extends Omit<FlowType, 'type'> {}

property id

id: K.IdentifierKind | K.QualifiedTypeIdentifierKind;

property type

type: 'GenericTypeAnnotation';

property typeParameters

typeParameters: K.TypeParameterInstantiationKind | null;

interface Identifier

interface Identifier extends Omit<Expression, 'type'>, Omit<Pattern, 'type'> {}

property name

name: string;

property optional

optional?: boolean;

property type

type: 'Identifier';

property typeAnnotation

typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;

interface IfStatement

interface IfStatement extends Omit<Statement, 'type'> {}

property alternate

alternate?: K.StatementKind | null;

property consequent

consequent: K.StatementKind;

property test

test: K.ExpressionKind;

property type

type: 'IfStatement';

interface Import

interface Import extends Omit<Expression, 'type'> {}

property type

type: 'Import';

interface ImportDeclaration

interface ImportDeclaration extends Omit<Declaration, 'type'> {}

property importKind

importKind?: 'value' | 'type' | 'typeof';

property source

source: K.LiteralKind;

property specifiers

specifiers?: (
    | K.ImportSpecifierKind
    | K.ImportNamespaceSpecifierKind
    | K.ImportDefaultSpecifierKind
)[];

property type

type: 'ImportDeclaration';

interface ImportDefaultSpecifier

interface ImportDefaultSpecifier extends Omit<ModuleSpecifier, 'type'> {}

property type

type: 'ImportDefaultSpecifier';

interface ImportExpression

interface ImportExpression extends Omit<Expression, 'type'> {}

property source

source: K.ExpressionKind;

property type

type: 'ImportExpression';

interface ImportNamespaceSpecifier

interface ImportNamespaceSpecifier extends Omit<ModuleSpecifier, 'type'> {}

property type

type: 'ImportNamespaceSpecifier';

interface ImportSpecifier

interface ImportSpecifier extends Omit<ModuleSpecifier, 'type'> {}

property imported

imported: K.IdentifierKind;

property type

type: 'ImportSpecifier';

interface InferredPredicate

interface InferredPredicate extends Omit<FlowPredicate, 'type'> {}

property type

type: 'InferredPredicate';

interface InterfaceDeclaration

interface InterfaceDeclaration extends Omit<Declaration, 'type'> {}

property body

body: K.ObjectTypeAnnotationKind;

property extends

extends: K.InterfaceExtendsKind[];

property id

id: K.IdentifierKind;

property type

type: 'InterfaceDeclaration';

property typeParameters

typeParameters?: K.TypeParameterDeclarationKind | null;

interface InterfaceExtends

interface InterfaceExtends extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind;

property type

type: 'InterfaceExtends';

property typeParameters

typeParameters?: K.TypeParameterInstantiationKind | null;

interface InterfaceTypeAnnotation

interface InterfaceTypeAnnotation extends Omit<FlowType, 'type'> {}

property body

body: K.ObjectTypeAnnotationKind;

property extends

extends?: K.InterfaceExtendsKind[] | null;

property type

type: 'InterfaceTypeAnnotation';

interface InterpreterDirective

interface InterpreterDirective extends Omit<Node, 'type'> {}

property type

type: 'InterpreterDirective';

property value

value: string;

interface IntersectionTypeAnnotation

interface IntersectionTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'IntersectionTypeAnnotation';

property types

types: K.FlowTypeKind[];

interface JSXAttribute

interface JSXAttribute extends Omit<Node, 'type'> {}

property name

name: K.JSXIdentifierKind | K.JSXNamespacedNameKind;

property type

type: 'JSXAttribute';

property value

value?:
    | K.LiteralKind
    | K.JSXExpressionContainerKind
    | K.JSXElementKind
    | K.JSXFragmentKind
    | null;

interface JSXClosingElement

interface JSXClosingElement extends Omit<Node, 'type'> {}

property name

name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;

property type

type: 'JSXClosingElement';

interface JSXClosingFragment

interface JSXClosingFragment extends Omit<Node, 'type'> {}

property type

type: 'JSXClosingFragment';

interface JSXElement

interface JSXElement extends Omit<Expression, 'type'> {}

property attributes

attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];

property children

children?: (
    | K.JSXTextKind
    | K.JSXExpressionContainerKind
    | K.JSXSpreadChildKind
    | K.JSXElementKind
    | K.JSXFragmentKind
    | K.LiteralKind
)[];

property closingElement

closingElement?: K.JSXClosingElementKind | null;

property name

name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;

property openingElement

openingElement: K.JSXOpeningElementKind;

property selfClosing

selfClosing?: boolean;

property type

type: 'JSXElement';

interface JSXEmptyExpression

interface JSXEmptyExpression extends Omit<Node, 'type'> {}

property type

type: 'JSXEmptyExpression';

interface JSXExpressionContainer

interface JSXExpressionContainer extends Omit<Expression, 'type'> {}

property expression

expression: K.ExpressionKind | K.JSXEmptyExpressionKind;

property type

type: 'JSXExpressionContainer';

interface JSXFragment

interface JSXFragment extends Omit<Expression, 'type'> {}

property children

children?: (
    | K.JSXTextKind
    | K.JSXExpressionContainerKind
    | K.JSXSpreadChildKind
    | K.JSXElementKind
    | K.JSXFragmentKind
    | K.LiteralKind
)[];

property closingFragment

closingFragment: K.JSXClosingFragmentKind;

property openingFragment

openingFragment: K.JSXOpeningFragmentKind;

property type

type: 'JSXFragment';

interface JSXIdentifier

interface JSXIdentifier extends Omit<Identifier, 'type' | 'name'> {}

property name

name: string;

property type

type: 'JSXIdentifier';

interface JSXMemberExpression

interface JSXMemberExpression
    extends Omit<MemberExpression, 'type' | 'object' | 'property' | 'computed'> {}

property computed

computed?: boolean;

property object

object: K.JSXIdentifierKind | K.JSXMemberExpressionKind;

property property

property: K.JSXIdentifierKind;

property type

type: 'JSXMemberExpression';

interface JSXNamespacedName

interface JSXNamespacedName extends Omit<Node, 'type'> {}

property name

name: K.JSXIdentifierKind;

property namespace

namespace: K.JSXIdentifierKind;

property type

type: 'JSXNamespacedName';

interface JSXOpeningElement

interface JSXOpeningElement extends Omit<Node, 'type'> {}

property attributes

attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[];

property name

name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind;

property selfClosing

selfClosing?: boolean;

property type

type: 'JSXOpeningElement';

interface JSXOpeningFragment

interface JSXOpeningFragment extends Omit<Node, 'type'> {}

property type

type: 'JSXOpeningFragment';

interface JSXSpreadAttribute

interface JSXSpreadAttribute extends Omit<Node, 'type'> {}

property argument

argument: K.ExpressionKind;

property type

type: 'JSXSpreadAttribute';

interface JSXSpreadChild

interface JSXSpreadChild extends Omit<Node, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'JSXSpreadChild';

interface JSXText

interface JSXText extends Omit<Literal, 'type' | 'value'> {}

property raw

raw?: string;

property type

type: 'JSXText';

property value

value: string;

interface LabeledStatement

interface LabeledStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property label

label: K.IdentifierKind;

property type

type: 'LabeledStatement';

interface Line

interface Line extends Comment {}

property type

type: 'Line';

interface Literal

interface Literal extends Omit<Expression, 'type'> {}

property regex

regex?: {
    pattern: string;
    flags: string;
} | null;

property type

type: 'Literal';

property value

value: string | boolean | null | number | RegExp;

interface LogicalExpression

interface LogicalExpression extends Omit<Expression, 'type'> {}

property left

left: K.ExpressionKind;

property operator

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

property right

right: K.ExpressionKind;

property type

type: 'LogicalExpression';

interface MemberExpression

interface MemberExpression
    extends Omit<Expression, 'type'>,
        Omit<ChainElement, 'type'> {}

property computed

computed?: boolean;

property object

object: K.ExpressionKind;

property property

property: K.IdentifierKind | K.ExpressionKind;

property type

type: 'MemberExpression';

interface MemberTypeAnnotation

interface MemberTypeAnnotation extends Omit<FlowType, 'type'> {}

property object

object: K.IdentifierKind;

property property

property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind;

property type

type: 'MemberTypeAnnotation';

interface MetaProperty

interface MetaProperty extends Omit<Expression, 'type'> {}

property meta

meta: K.IdentifierKind;

property property

property: K.IdentifierKind;

property type

type: 'MetaProperty';

interface MethodDefinition

interface MethodDefinition extends Omit<Declaration, 'type'> {}

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property key

key: K.ExpressionKind;

property kind

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

property static

static?: boolean;

property type

type: 'MethodDefinition';

property value

value: K.FunctionKind;

interface MixedTypeAnnotation

interface MixedTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'MixedTypeAnnotation';

interface ModuleSpecifier

interface ModuleSpecifier extends Specifier {}

property id

id?: K.IdentifierKind | null;

property local

local?: K.IdentifierKind | null;

property name

name?: K.IdentifierKind | null;

interface NewExpression

interface NewExpression extends Omit<Expression, 'type'> {}

property arguments

arguments: (K.ExpressionKind | K.SpreadElementKind)[];

property callee

callee: K.ExpressionKind;

property type

type: 'NewExpression';

property typeArguments

typeArguments?: null | K.TypeParameterInstantiationKind;

interface Node

interface Node extends Printable {}

property comments

comments?: K.CommentKind[] | null;

property type

type: string;

interface Noop

interface Noop extends Omit<Statement, 'type'> {}

property type

type: 'Noop';

interface NullableTypeAnnotation

interface NullableTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'NullableTypeAnnotation';

property typeAnnotation

typeAnnotation: K.FlowTypeKind;

interface NullLiteral

interface NullLiteral extends Omit<Literal, 'type' | 'value'> {}

property type

type: 'NullLiteral';

property value

value?: null;

interface NullLiteralTypeAnnotation

interface NullLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'NullLiteralTypeAnnotation';

interface NullTypeAnnotation

interface NullTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'NullTypeAnnotation';

interface NumberLiteralTypeAnnotation

interface NumberLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property raw

raw: string;

property type

type: 'NumberLiteralTypeAnnotation';

property value

value: number;

interface NumberTypeAnnotation

interface NumberTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'NumberTypeAnnotation';

interface NumericLiteral

interface NumericLiteral extends Omit<Literal, 'type' | 'value'> {}

property extra

extra?: {
    rawValue: number;
    raw: string;
};

property raw

raw?: string | null;

property type

type: 'NumericLiteral';

property value

value: number;

interface NumericLiteralTypeAnnotation

interface NumericLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property raw

raw: string;

property type

type: 'NumericLiteralTypeAnnotation';

property value

value: number;

interface ObjectExpression

interface ObjectExpression extends Omit<Expression, 'type'> {}

property properties

properties: (
    | K.PropertyKind
    | K.ObjectMethodKind
    | K.ObjectPropertyKind
    | K.SpreadPropertyKind
    | K.SpreadElementKind
)[];

property type

type: 'ObjectExpression';

interface ObjectMethod

interface ObjectMethod
    extends Omit<Node, 'type'>,
        Omit<Function, 'type' | 'params' | 'body' | 'generator' | 'async'> {}

property accessibility

accessibility?: K.LiteralKind | null;

property async

async?: boolean;

property body

body: K.BlockStatementKind;

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property generator

generator?: boolean;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property kind

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

property params

params: K.PatternKind[];

property type

type: 'ObjectMethod';

interface ObjectPattern

interface ObjectPattern extends Omit<Pattern, 'type'> {}

property decorators

decorators?: K.DecoratorKind[] | null;

property properties

properties: (
    | K.PropertyKind
    | K.PropertyPatternKind
    | K.SpreadPropertyPatternKind
    | K.SpreadPropertyKind
    | K.ObjectPropertyKind
    | K.RestPropertyKind
)[];

property type

type: 'ObjectPattern';

property typeAnnotation

typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;

interface ObjectProperty

interface ObjectProperty extends Omit<Node, 'type'> {}

property accessibility

accessibility?: K.LiteralKind | null;

property computed

computed?: boolean;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property shorthand

shorthand?: boolean;

property type

type: 'ObjectProperty';

property value

value: K.ExpressionKind | K.PatternKind;

interface ObjectTypeAnnotation

interface ObjectTypeAnnotation extends Omit<FlowType, 'type'> {}

property callProperties

callProperties?: K.ObjectTypeCallPropertyKind[];

property exact

exact?: boolean;

property indexers

indexers?: K.ObjectTypeIndexerKind[];

property inexact

inexact?: boolean | undefined;

property internalSlots

internalSlots?: K.ObjectTypeInternalSlotKind[];

property properties

properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[];

property type

type: 'ObjectTypeAnnotation';

interface ObjectTypeCallProperty

interface ObjectTypeCallProperty extends Omit<Node, 'type'> {}

property static

static?: boolean;

property type

type: 'ObjectTypeCallProperty';

property value

value: K.FunctionTypeAnnotationKind;

interface ObjectTypeIndexer

interface ObjectTypeIndexer extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind;

property key

key: K.FlowTypeKind;

property static

static?: boolean;

property type

type: 'ObjectTypeIndexer';

property value

value: K.FlowTypeKind;

property variance

variance?: K.VarianceKind | 'plus' | 'minus' | null;

interface ObjectTypeInternalSlot

interface ObjectTypeInternalSlot extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind;

property method

method: boolean;

property optional

optional: boolean;

property static

static: boolean;

property type

type: 'ObjectTypeInternalSlot';

property value

value: K.FlowTypeKind;

interface ObjectTypeProperty

interface ObjectTypeProperty extends Omit<Node, 'type'> {}

property key

key: K.LiteralKind | K.IdentifierKind;

property optional

optional: boolean;

property type

type: 'ObjectTypeProperty';

property value

value: K.FlowTypeKind;

property variance

variance?: K.VarianceKind | 'plus' | 'minus' | null;

interface ObjectTypeSpreadProperty

interface ObjectTypeSpreadProperty extends Omit<Node, 'type'> {}

property argument

argument: K.FlowTypeKind;

property type

type: 'ObjectTypeSpreadProperty';

interface OpaqueType

interface OpaqueType extends Omit<Declaration, 'type'> {}

property id

id: K.IdentifierKind;

property impltype

impltype: K.FlowTypeKind;

property supertype

supertype: K.FlowTypeKind | null;

property type

type: 'OpaqueType';

property typeParameters

typeParameters: K.TypeParameterDeclarationKind | null;

interface OptionalCallExpression

interface OptionalCallExpression extends Omit<CallExpression, 'type' | 'optional'> {}

property optional

optional?: boolean;

property type

type: 'OptionalCallExpression';

interface OptionalMemberExpression

interface OptionalMemberExpression
    extends Omit<MemberExpression, 'type' | 'optional'> {}

property optional

optional?: boolean;

property type

type: 'OptionalMemberExpression';

interface ParenthesizedExpression

interface ParenthesizedExpression extends Omit<Expression, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'ParenthesizedExpression';

interface Pattern

interface Pattern extends Node {}

interface Position

interface Position {}

property column

column: number;

property line

line: number;

interface Printable

interface Printable {}

property loc

loc?: K.SourceLocationKind | null;

interface PrivateName

interface PrivateName extends Omit<Expression, 'type'>, Omit<Pattern, 'type'> {}

property id

id: K.IdentifierKind;

property type

type: 'PrivateName';

interface Program

interface Program extends Omit<Node, 'type'> {}

property body

body: K.StatementKind[];

property directives

directives?: K.DirectiveKind[];

property interpreter

interpreter?: K.InterpreterDirectiveKind | null;

property type

type: 'Program';

interface Property

interface Property extends Omit<Node, 'type'> {}

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property kind

kind: 'init' | 'get' | 'set';

property method

method?: boolean;

property shorthand

shorthand?: boolean;

property type

type: 'Property';

property value

value: K.ExpressionKind | K.PatternKind;

interface PropertyPattern

interface PropertyPattern extends Omit<Pattern, 'type'> {}

property computed

computed?: boolean;

property key

key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind;

property pattern

pattern: K.PatternKind;

property type

type: 'PropertyPattern';

interface QualifiedTypeIdentifier

interface QualifiedTypeIdentifier extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind;

property qualification

qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind;

property type

type: 'QualifiedTypeIdentifier';

interface RegExpLiteral

interface RegExpLiteral extends Omit<Literal, 'type' | 'value'> {}

property flags

flags: string;

property pattern

pattern: string;

property type

type: 'RegExpLiteral';

property value

value?: RegExp;

interface RestElement

interface RestElement extends Omit<Pattern, 'type'> {}

property argument

argument: K.PatternKind;

property type

type: 'RestElement';

property typeAnnotation

typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null;

interface RestProperty

interface RestProperty extends Omit<Node, 'type'> {}

property argument

argument: K.ExpressionKind;

property type

type: 'RestProperty';

interface ReturnStatement

interface ReturnStatement extends Omit<Statement, 'type'> {}

property argument

argument: K.ExpressionKind | null;

property type

type: 'ReturnStatement';

interface SequenceExpression

interface SequenceExpression extends Omit<Expression, 'type'> {}

property expressions

expressions: K.ExpressionKind[];

property type

type: 'SequenceExpression';

interface SourceLocation

interface SourceLocation {}

property end

end: K.PositionKind;

property source

source?: string | null;

property start

start: K.PositionKind;

interface Specifier

interface Specifier extends Node {}

interface SpreadElement

interface SpreadElement extends Omit<Node, 'type'> {}

property argument

argument: K.ExpressionKind;

property type

type: 'SpreadElement';

interface SpreadElementPattern

interface SpreadElementPattern extends Omit<Pattern, 'type'> {}

property argument

argument: K.PatternKind;

property type

type: 'SpreadElementPattern';

interface SpreadProperty

interface SpreadProperty extends Omit<Node, 'type'> {}

property argument

argument: K.ExpressionKind;

property type

type: 'SpreadProperty';

interface SpreadPropertyPattern

interface SpreadPropertyPattern extends Omit<Pattern, 'type'> {}

property argument

argument: K.PatternKind;

property type

type: 'SpreadPropertyPattern';

interface Statement

interface Statement extends Node {}

interface StringLiteral

interface StringLiteral extends Omit<Literal, 'type' | 'value'> {}

property type

type: 'StringLiteral';

property value

value: string;

interface StringLiteralTypeAnnotation

interface StringLiteralTypeAnnotation extends Omit<FlowType, 'type'> {}

property raw

raw: string;

property type

type: 'StringLiteralTypeAnnotation';

property value

value: string;

interface StringTypeAnnotation

interface StringTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'StringTypeAnnotation';

interface Super

interface Super extends Omit<Expression, 'type'> {}

property type

type: 'Super';

interface SwitchCase

interface SwitchCase extends Omit<Node, 'type'> {}

property consequent

consequent: K.StatementKind[];

property test

test: K.ExpressionKind | null;

property type

type: 'SwitchCase';

interface SwitchStatement

interface SwitchStatement extends Omit<Statement, 'type'> {}

property cases

cases: K.SwitchCaseKind[];

property discriminant

discriminant: K.ExpressionKind;

property lexical

lexical?: boolean;

property type

type: 'SwitchStatement';

interface SymbolTypeAnnotation

interface SymbolTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'SymbolTypeAnnotation';

interface TaggedTemplateExpression

interface TaggedTemplateExpression extends Omit<Expression, 'type'> {}

property quasi

quasi: K.TemplateLiteralKind;

property tag

tag: K.ExpressionKind;

property type

type: 'TaggedTemplateExpression';

interface TemplateElement

interface TemplateElement extends Omit<Node, 'type'> {}

property tail

tail: boolean;

property type

type: 'TemplateElement';

property value

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

interface TemplateLiteral

interface TemplateLiteral extends Omit<Expression, 'type'> {}

property expressions

expressions: K.ExpressionKind[];

property quasis

quasis: K.TemplateElementKind[];

property type

type: 'TemplateLiteral';

interface ThisExpression

interface ThisExpression extends Omit<Expression, 'type'> {}

property type

type: 'ThisExpression';

interface ThisTypeAnnotation

interface ThisTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'ThisTypeAnnotation';

interface ThrowStatement

interface ThrowStatement extends Omit<Statement, 'type'> {}

property argument

argument: K.ExpressionKind;

property type

type: 'ThrowStatement';

interface TryStatement

interface TryStatement extends Omit<Statement, 'type'> {}

property block

block: K.BlockStatementKind;

property finalizer

finalizer?: K.BlockStatementKind | null;

property guardedHandlers

guardedHandlers?: K.CatchClauseKind[];

property handler

handler?: K.CatchClauseKind | null;

property handlers

handlers?: K.CatchClauseKind[];

property type

type: 'TryStatement';

interface TSAnyKeyword

interface TSAnyKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSAnyKeyword';

interface TSArrayType

interface TSArrayType extends Omit<TSType, 'type'> {}

property elementType

elementType: K.TSTypeKind;

property type

type: 'TSArrayType';

interface TSAsExpression

interface TSAsExpression extends Omit<Expression, 'type'>, Omit<Pattern, 'type'> {}

property expression

expression: K.ExpressionKind;

property extra

extra?: {
    parenthesized: boolean;
} | null;

property type

type: 'TSAsExpression';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSBigIntKeyword

interface TSBigIntKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSBigIntKeyword';

interface TSBooleanKeyword

interface TSBooleanKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSBooleanKeyword';

interface TSCallSignatureDeclaration

interface TSCallSignatureDeclaration
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters,
        TSHasOptionalTypeAnnotation {}

property parameters

parameters: (
    | K.IdentifierKind
    | K.RestElementKind
    | K.ArrayPatternKind
    | K.ObjectPatternKind
)[];

property type

type: 'TSCallSignatureDeclaration';

interface TSConditionalType

interface TSConditionalType extends Omit<TSType, 'type'> {}

property checkType

checkType: K.TSTypeKind;

property extendsType

extendsType: K.TSTypeKind;

property falseType

falseType: K.TSTypeKind;

property trueType

trueType: K.TSTypeKind;

property type

type: 'TSConditionalType';

interface TSConstructorType

interface TSConstructorType
    extends Omit<TSType, 'type'>,
        TSHasOptionalTypeParameters,
        TSHasOptionalTypeAnnotation {}

property parameters

parameters: (
    | K.IdentifierKind
    | K.RestElementKind
    | K.ArrayPatternKind
    | K.ObjectPatternKind
)[];

property type

type: 'TSConstructorType';

interface TSConstructSignatureDeclaration

interface TSConstructSignatureDeclaration
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters,
        TSHasOptionalTypeAnnotation {}

property parameters

parameters: (
    | K.IdentifierKind
    | K.RestElementKind
    | K.ArrayPatternKind
    | K.ObjectPatternKind
)[];

property type

type: 'TSConstructSignatureDeclaration';

interface TSDeclareFunction

interface TSDeclareFunction
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters {}

property async

async?: boolean;

property declare

declare?: boolean;

property generator

generator?: boolean;

property id

id?: K.IdentifierKind | null;

property params

params: K.PatternKind[];

property returnType

returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;

property type

type: 'TSDeclareFunction';

interface TSDeclareMethod

interface TSDeclareMethod
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters {}

property abstract

abstract?: boolean;

property access

access?: 'public' | 'private' | 'protected' | undefined;

property accessibility

accessibility?: 'public' | 'private' | 'protected' | undefined;

property async

async?: boolean;

property computed

computed?: boolean;

property decorators

decorators?: K.DecoratorKind[] | null;

property generator

generator?: boolean;

property key

key:
    | K.IdentifierKind
    | K.StringLiteralKind
    | K.NumericLiteralKind
    | K.ExpressionKind;

property kind

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

property optional

optional?: boolean;

property params

params: K.PatternKind[];

property returnType

returnType?: K.TSTypeAnnotationKind | K.NoopKind | null;

property static

static?: boolean;

property type

type: 'TSDeclareMethod';

interface TSEnumDeclaration

interface TSEnumDeclaration extends Omit<Declaration, 'type'> {}

property const

const?: boolean;

property declare

declare?: boolean;

property id

id: K.IdentifierKind;

property initializer

initializer?: K.ExpressionKind | null;

property members

members: K.TSEnumMemberKind[];

property type

type: 'TSEnumDeclaration';

interface TSEnumMember

interface TSEnumMember extends Omit<Node, 'type'> {}

property id

id: K.IdentifierKind | K.StringLiteralKind;

property initializer

initializer?: K.ExpressionKind | null;

property type

type: 'TSEnumMember';

interface TSExportAssignment

interface TSExportAssignment extends Omit<Statement, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'TSExportAssignment';

interface TSExpressionWithTypeArguments

interface TSExpressionWithTypeArguments
    extends Omit<TSType, 'type'>,
        TSHasOptionalTypeParameterInstantiation {}

property expression

expression: K.IdentifierKind | K.TSQualifiedNameKind;

property type

type: 'TSExpressionWithTypeArguments';

interface TSExternalModuleReference

interface TSExternalModuleReference extends Omit<Declaration, 'type'> {}

property expression

expression: K.StringLiteralKind;

property type

type: 'TSExternalModuleReference';

interface TSFunctionType

interface TSFunctionType
    extends Omit<TSType, 'type'>,
        TSHasOptionalTypeParameters,
        TSHasOptionalTypeAnnotation {}

property parameters

parameters: (
    | K.IdentifierKind
    | K.RestElementKind
    | K.ArrayPatternKind
    | K.ObjectPatternKind
)[];

property type

type: 'TSFunctionType';

interface TSHasOptionalTypeAnnotation

interface TSHasOptionalTypeAnnotation {}

property typeAnnotation

typeAnnotation?: K.TSTypeAnnotationKind | null;

interface TSHasOptionalTypeParameterInstantiation

interface TSHasOptionalTypeParameterInstantiation {}

property typeParameters

typeParameters?: K.TSTypeParameterInstantiationKind | null;

interface TSHasOptionalTypeParameters

interface TSHasOptionalTypeParameters {}

property typeParameters

typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined;

interface TSImportEqualsDeclaration

interface TSImportEqualsDeclaration extends Omit<Declaration, 'type'> {}

property id

id: K.IdentifierKind;

property isExport

isExport?: boolean;

property moduleReference

moduleReference:
    | K.IdentifierKind
    | K.TSQualifiedNameKind
    | K.TSExternalModuleReferenceKind;

property type

type: 'TSImportEqualsDeclaration';

interface TSImportType

interface TSImportType
    extends Omit<TSType, 'type'>,
        TSHasOptionalTypeParameterInstantiation {}

property argument

argument: K.StringLiteralKind;

property qualifier

qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined;

property type

type: 'TSImportType';

interface TSIndexedAccessType

interface TSIndexedAccessType extends Omit<TSType, 'type'> {}

property indexType

indexType: K.TSTypeKind;

property objectType

objectType: K.TSTypeKind;

property type

type: 'TSIndexedAccessType';

interface TSIndexSignature

interface TSIndexSignature
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeAnnotation {}

property parameters

parameters: K.IdentifierKind[];

property readonly

readonly?: boolean;

property type

type: 'TSIndexSignature';

interface TSInferType

interface TSInferType extends Omit<TSType, 'type'> {}

property type

type: 'TSInferType';

property typeParameter

typeParameter: K.TSTypeParameterKind;

interface TSInterfaceBody

interface TSInterfaceBody extends Omit<Node, 'type'> {}

property body

body: (
    | K.TSCallSignatureDeclarationKind
    | K.TSConstructSignatureDeclarationKind
    | K.TSIndexSignatureKind
    | K.TSMethodSignatureKind
    | K.TSPropertySignatureKind
)[];

property type

type: 'TSInterfaceBody';

interface TSInterfaceDeclaration

interface TSInterfaceDeclaration
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters {}

property body

body: K.TSInterfaceBodyKind;

property declare

declare?: boolean;

property extends

extends?: K.TSExpressionWithTypeArgumentsKind[] | null;

property id

id: K.IdentifierKind | K.TSQualifiedNameKind;

property type

type: 'TSInterfaceDeclaration';

interface TSIntersectionType

interface TSIntersectionType extends Omit<TSType, 'type'> {}

property type

type: 'TSIntersectionType';

property types

types: K.TSTypeKind[];

interface TSLiteralType

interface TSLiteralType extends Omit<TSType, 'type'> {}

property literal

literal:
    | K.NumericLiteralKind
    | K.StringLiteralKind
    | K.BooleanLiteralKind
    | K.TemplateLiteralKind
    | K.UnaryExpressionKind;

property type

type: 'TSLiteralType';

interface TSMappedType

interface TSMappedType extends Omit<TSType, 'type'> {}

property optional

optional?: boolean | '+' | '-';

property readonly

readonly?: boolean | '+' | '-';

property type

type: 'TSMappedType';

property typeAnnotation

typeAnnotation?: K.TSTypeKind | null;

property typeParameter

typeParameter: K.TSTypeParameterKind;

interface TSMethodSignature

interface TSMethodSignature
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters,
        TSHasOptionalTypeAnnotation {}

property computed

computed?: boolean;

property key

key: K.ExpressionKind;

property optional

optional?: boolean;

property parameters

parameters: (
    | K.IdentifierKind
    | K.RestElementKind
    | K.ArrayPatternKind
    | K.ObjectPatternKind
)[];

property type

type: 'TSMethodSignature';

interface TSModuleBlock

interface TSModuleBlock extends Omit<Node, 'type'> {}

property body

body: K.StatementKind[];

property type

type: 'TSModuleBlock';

interface TSModuleDeclaration

interface TSModuleDeclaration extends Omit<Declaration, 'type'> {}

property body

body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null;

property declare

declare?: boolean;

property global

global?: boolean;

property id

id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind;

property type

type: 'TSModuleDeclaration';

interface TSNamedTupleMember

interface TSNamedTupleMember extends Omit<TSType, 'type'> {}

property elementType

elementType: K.TSTypeKind;

property label

label: K.IdentifierKind;

property optional

optional?: boolean;

property type

type: 'TSNamedTupleMember';

interface TSNamespaceExportDeclaration

interface TSNamespaceExportDeclaration extends Omit<Declaration, 'type'> {}

property id

id: K.IdentifierKind;

property type

type: 'TSNamespaceExportDeclaration';

interface TSNeverKeyword

interface TSNeverKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSNeverKeyword';

interface TSNonNullExpression

interface TSNonNullExpression
    extends Omit<Expression, 'type'>,
        Omit<Pattern, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'TSNonNullExpression';

interface TSNullKeyword

interface TSNullKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSNullKeyword';

interface TSNumberKeyword

interface TSNumberKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSNumberKeyword';

interface TSObjectKeyword

interface TSObjectKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSObjectKeyword';

interface TSOptionalType

interface TSOptionalType extends Omit<TSType, 'type'> {}

property type

type: 'TSOptionalType';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSParameterProperty

interface TSParameterProperty extends Omit<Pattern, 'type'> {}

property accessibility

accessibility?: 'public' | 'private' | 'protected' | undefined;

property parameter

parameter: K.IdentifierKind | K.AssignmentPatternKind;

property readonly

readonly?: boolean;

property type

type: 'TSParameterProperty';

interface TSParenthesizedType

interface TSParenthesizedType extends Omit<TSType, 'type'> {}

property type

type: 'TSParenthesizedType';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSPropertySignature

interface TSPropertySignature
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeAnnotation {}

property computed

computed?: boolean;

property initializer

initializer?: K.ExpressionKind | null;

property key

key: K.ExpressionKind;

property optional

optional?: boolean;

property readonly

readonly?: boolean;

property type

type: 'TSPropertySignature';

interface TSQualifiedName

interface TSQualifiedName extends Omit<Node, 'type'> {}

property left

left: K.IdentifierKind | K.TSQualifiedNameKind;

property right

right: K.IdentifierKind | K.TSQualifiedNameKind;

property type

type: 'TSQualifiedName';

interface TSRestType

interface TSRestType extends Omit<TSType, 'type'> {}

property type

type: 'TSRestType';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSStringKeyword

interface TSStringKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSStringKeyword';

interface TSSymbolKeyword

interface TSSymbolKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSSymbolKeyword';

interface TSThisType

interface TSThisType extends Omit<TSType, 'type'> {}

property type

type: 'TSThisType';

interface TSTupleType

interface TSTupleType extends Omit<TSType, 'type'> {}

property elementTypes

elementTypes: (K.TSTypeKind | K.TSNamedTupleMemberKind)[];

property type

type: 'TSTupleType';

interface TSType

interface TSType extends Node {}

interface TSTypeAliasDeclaration

interface TSTypeAliasDeclaration
    extends Omit<Declaration, 'type'>,
        TSHasOptionalTypeParameters {}

property declare

declare?: boolean;

property id

id: K.IdentifierKind;

property type

type: 'TSTypeAliasDeclaration';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSTypeAnnotation

interface TSTypeAnnotation extends Omit<Node, 'type'> {}

property type

type: 'TSTypeAnnotation';

property typeAnnotation

typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind;

interface TSTypeAssertion

interface TSTypeAssertion extends Omit<Expression, 'type'>, Omit<Pattern, 'type'> {}

property expression

expression: K.ExpressionKind;

property extra

extra?: {
    parenthesized: boolean;
} | null;

property type

type: 'TSTypeAssertion';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSTypeLiteral

interface TSTypeLiteral extends Omit<TSType, 'type'> {}

property members

members: (
    | K.TSCallSignatureDeclarationKind
    | K.TSConstructSignatureDeclarationKind
    | K.TSIndexSignatureKind
    | K.TSMethodSignatureKind
    | K.TSPropertySignatureKind
)[];

property type

type: 'TSTypeLiteral';

interface TSTypeOperator

interface TSTypeOperator extends Omit<TSType, 'type'> {}

property operator

operator: string;

property type

type: 'TSTypeOperator';

property typeAnnotation

typeAnnotation: K.TSTypeKind;

interface TSTypeParameter

interface TSTypeParameter extends Omit<Identifier, 'type' | 'name'> {}

property constraint

constraint?: K.TSTypeKind | undefined;

property default

default?: K.TSTypeKind | undefined;

property name

name: string;

property type

type: 'TSTypeParameter';

interface TSTypeParameterDeclaration

interface TSTypeParameterDeclaration extends Omit<Declaration, 'type'> {}

property params

params: K.TSTypeParameterKind[];

property type

type: 'TSTypeParameterDeclaration';

interface TSTypeParameterInstantiation

interface TSTypeParameterInstantiation extends Omit<Node, 'type'> {}

property params

params: K.TSTypeKind[];

property type

type: 'TSTypeParameterInstantiation';

interface TSTypePredicate

interface TSTypePredicate
    extends Omit<TSTypeAnnotation, 'type' | 'typeAnnotation'>,
        Omit<TSType, 'type'> {}

property asserts

asserts?: boolean;

property parameterName

parameterName: K.IdentifierKind | K.TSThisTypeKind;

property type

type: 'TSTypePredicate';

property typeAnnotation

typeAnnotation?: K.TSTypeAnnotationKind | null;

interface TSTypeQuery

interface TSTypeQuery extends Omit<TSType, 'type'> {}

property exprName

exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind;

property type

type: 'TSTypeQuery';

interface TSTypeReference

interface TSTypeReference
    extends Omit<TSType, 'type'>,
        TSHasOptionalTypeParameterInstantiation {}

property type

type: 'TSTypeReference';

property typeName

typeName: K.IdentifierKind | K.TSQualifiedNameKind;

interface TSUndefinedKeyword

interface TSUndefinedKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSUndefinedKeyword';

interface TSUnionType

interface TSUnionType extends Omit<TSType, 'type'> {}

property type

type: 'TSUnionType';

property types

types: K.TSTypeKind[];

interface TSUnknownKeyword

interface TSUnknownKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSUnknownKeyword';

interface TSVoidKeyword

interface TSVoidKeyword extends Omit<TSType, 'type'> {}

property type

type: 'TSVoidKeyword';

interface TupleTypeAnnotation

interface TupleTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'TupleTypeAnnotation';

property types

types: K.FlowTypeKind[];

interface TypeAlias

interface TypeAlias extends Omit<Declaration, 'type'> {}

property id

id: K.IdentifierKind;

property right

right: K.FlowTypeKind;

property type

type: 'TypeAlias';

property typeParameters

typeParameters: K.TypeParameterDeclarationKind | null;

interface TypeAnnotation

interface TypeAnnotation extends Omit<Node, 'type'> {}

property type

type: 'TypeAnnotation';

property typeAnnotation

typeAnnotation: K.FlowTypeKind;

interface TypeCastExpression

interface TypeCastExpression extends Omit<Expression, 'type'> {}

property expression

expression: K.ExpressionKind;

property type

type: 'TypeCastExpression';

property typeAnnotation

typeAnnotation: K.TypeAnnotationKind;

interface TypeofTypeAnnotation

interface TypeofTypeAnnotation extends Omit<FlowType, 'type'> {}

property argument

argument: K.FlowTypeKind;

property type

type: 'TypeofTypeAnnotation';

interface TypeParameter

interface TypeParameter extends Omit<FlowType, 'type'> {}

property bound

bound?: K.TypeAnnotationKind | null;

property default

default?: K.FlowTypeKind | null;

property name

name: string;

property type

type: 'TypeParameter';

property variance

variance?: K.VarianceKind | 'plus' | 'minus' | null;

interface TypeParameterDeclaration

interface TypeParameterDeclaration extends Omit<Node, 'type'> {}

property params

params: K.TypeParameterKind[];

property type

type: 'TypeParameterDeclaration';

interface TypeParameterInstantiation

interface TypeParameterInstantiation extends Omit<Node, 'type'> {}

property params

params: K.FlowTypeKind[];

property type

type: 'TypeParameterInstantiation';

interface UnaryExpression

interface UnaryExpression extends Omit<Expression, 'type'> {}

property argument

argument: K.ExpressionKind;

property operator

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

property prefix

prefix?: boolean;

property type

type: 'UnaryExpression';

interface UnionTypeAnnotation

interface UnionTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'UnionTypeAnnotation';

property types

types: K.FlowTypeKind[];

interface UpdateExpression

interface UpdateExpression extends Omit<Expression, 'type'> {}

property argument

argument: K.ExpressionKind;

property operator

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

property prefix

prefix: boolean;

property type

type: 'UpdateExpression';

interface VariableDeclaration

interface VariableDeclaration extends Omit<Declaration, 'type'> {}

property declarations

declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[];

property kind

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

property type

type: 'VariableDeclaration';

interface VariableDeclarator

interface VariableDeclarator extends Omit<Node, 'type'> {}

property id

id: K.PatternKind;

property init

init?: K.ExpressionKind | null;

property type

type: 'VariableDeclarator';

interface Variance

interface Variance extends Omit<Node, 'type'> {}

property kind

kind: 'plus' | 'minus';

property type

type: 'Variance';

interface VoidTypeAnnotation

interface VoidTypeAnnotation extends Omit<FlowType, 'type'> {}

property type

type: 'VoidTypeAnnotation';

interface WhileStatement

interface WhileStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property test

test: K.ExpressionKind;

property type

type: 'WhileStatement';

interface WithStatement

interface WithStatement extends Omit<Statement, 'type'> {}

property body

body: K.StatementKind;

property object

object: K.ExpressionKind;

property type

type: 'WithStatement';

interface YieldExpression

interface YieldExpression extends Omit<Expression, 'type'> {}

property argument

argument: K.ExpressionKind | null;

property delegate

delegate?: boolean;

property type

type: 'YieldExpression';

type ASTNode

type ASTNode =
    | File
    | Program
    | Identifier
    | BlockStatement
    | EmptyStatement
    | ExpressionStatement
    | IfStatement
    | LabeledStatement
    | BreakStatement
    | ContinueStatement
    | WithStatement
    | SwitchStatement
    | SwitchCase
    | ReturnStatement
    | ThrowStatement
    | TryStatement
    | CatchClause
    | WhileStatement
    | DoWhileStatement
    | ForStatement
    | VariableDeclaration
    | ForInStatement
    | DebuggerStatement
    | FunctionDeclaration
    | FunctionExpression
    | VariableDeclarator
    | ThisExpression
    | ArrayExpression
    | ObjectExpression
    | Property
    | Literal
    | SequenceExpression
    | UnaryExpression
    | BinaryExpression
    | AssignmentExpression
    | MemberExpression
    | UpdateExpression
    | LogicalExpression
    | ConditionalExpression
    | NewExpression
    | CallExpression
    | RestElement
    | TypeAnnotation
    | TSTypeAnnotation
    | SpreadElementPattern
    | ArrowFunctionExpression
    | ForOfStatement
    | YieldExpression
    | GeneratorExpression
    | ComprehensionBlock
    | ComprehensionExpression
    | ObjectProperty
    | PropertyPattern
    | ObjectPattern
    | ArrayPattern
    | SpreadElement
    | AssignmentPattern
    | MethodDefinition
    | ClassPropertyDefinition
    | ClassProperty
    | ClassBody
    | ClassDeclaration
    | ClassExpression
    | Super
    | ImportSpecifier
    | ImportDefaultSpecifier
    | ImportNamespaceSpecifier
    | ImportDeclaration
    | ExportNamedDeclaration
    | ExportSpecifier
    | ExportDefaultDeclaration
    | ExportAllDeclaration
    | TaggedTemplateExpression
    | TemplateLiteral
    | TemplateElement
    | MetaProperty
    | AwaitExpression
    | SpreadProperty
    | SpreadPropertyPattern
    | ImportExpression
    | ChainExpression
    | OptionalCallExpression
    | OptionalMemberExpression
    | JSXAttribute
    | JSXIdentifier
    | JSXNamespacedName
    | JSXExpressionContainer
    | JSXElement
    | JSXFragment
    | JSXMemberExpression
    | JSXSpreadAttribute
    | JSXEmptyExpression
    | JSXText
    | JSXSpreadChild
    | JSXOpeningElement
    | JSXClosingElement
    | JSXOpeningFragment
    | JSXClosingFragment
    | Decorator
    | PrivateName
    | ClassPrivateProperty
    | TypeParameterDeclaration
    | TSTypeParameterDeclaration
    | TypeParameterInstantiation
    | TSTypeParameterInstantiation
    | ClassImplements
    | TSExpressionWithTypeArguments
    | AnyTypeAnnotation
    | EmptyTypeAnnotation
    | MixedTypeAnnotation
    | VoidTypeAnnotation
    | SymbolTypeAnnotation
    | NumberTypeAnnotation
    | BigIntTypeAnnotation
    | NumberLiteralTypeAnnotation
    | NumericLiteralTypeAnnotation
    | BigIntLiteralTypeAnnotation
    | StringTypeAnnotation
    | StringLiteralTypeAnnotation
    | BooleanTypeAnnotation
    | BooleanLiteralTypeAnnotation
    | NullableTypeAnnotation
    | NullLiteralTypeAnnotation
    | NullTypeAnnotation
    | ThisTypeAnnotation
    | ExistsTypeAnnotation
    | ExistentialTypeParam
    | FunctionTypeAnnotation
    | FunctionTypeParam
    | ArrayTypeAnnotation
    | ObjectTypeAnnotation
    | ObjectTypeProperty
    | ObjectTypeSpreadProperty
    | ObjectTypeIndexer
    | ObjectTypeCallProperty
    | ObjectTypeInternalSlot
    | Variance
    | QualifiedTypeIdentifier
    | GenericTypeAnnotation
    | MemberTypeAnnotation
    | UnionTypeAnnotation
    | IntersectionTypeAnnotation
    | TypeofTypeAnnotation
    | TypeParameter
    | InterfaceTypeAnnotation
    | InterfaceExtends
    | InterfaceDeclaration
    | DeclareInterface
    | TypeAlias
    | DeclareTypeAlias
    | OpaqueType
    | DeclareOpaqueType
    | TypeCastExpression
    | TupleTypeAnnotation
    | DeclareVariable
    | DeclareFunction
    | DeclareClass
    | DeclareModule
    | DeclareModuleExports
    | DeclareExportDeclaration
    | ExportBatchSpecifier
    | DeclareExportAllDeclaration
    | InferredPredicate
    | DeclaredPredicate
    | EnumDeclaration
    | EnumBooleanBody
    | EnumNumberBody
    | EnumStringBody
    | EnumSymbolBody
    | EnumBooleanMember
    | EnumNumberMember
    | EnumStringMember
    | EnumDefaultedMember
    | ExportDeclaration
    | Block
    | Line
    | Noop
    | DoExpression
    | BindExpression
    | ParenthesizedExpression
    | ExportNamespaceSpecifier
    | ExportDefaultSpecifier
    | CommentBlock
    | CommentLine
    | Directive
    | DirectiveLiteral
    | InterpreterDirective
    | StringLiteral
    | NumericLiteral
    | BigIntLiteral
    | NullLiteral
    | BooleanLiteral
    | RegExpLiteral
    | ObjectMethod
    | ClassMethod
    | ClassPrivateMethod
    | RestProperty
    | ForAwaitStatement
    | Import
    | TSQualifiedName
    | TSTypeReference
    | TSAsExpression
    | TSNonNullExpression
    | TSAnyKeyword
    | TSBigIntKeyword
    | TSBooleanKeyword
    | TSNeverKeyword
    | TSNullKeyword
    | TSNumberKeyword
    | TSObjectKeyword
    | TSStringKeyword
    | TSSymbolKeyword
    | TSUndefinedKeyword
    | TSUnknownKeyword
    | TSVoidKeyword
    | TSThisType
    | TSArrayType
    | TSLiteralType
    | TSUnionType
    | TSIntersectionType
    | TSConditionalType
    | TSInferType
    | TSTypeParameter
    | TSParenthesizedType
    | TSFunctionType
    | TSConstructorType
    | TSDeclareFunction
    | TSDeclareMethod
    | TSMappedType
    | TSTupleType
    | TSNamedTupleMember
    | TSRestType
    | TSOptionalType
    | TSIndexedAccessType
    | TSTypeOperator
    | TSIndexSignature
    | TSPropertySignature
    | TSMethodSignature
    | TSTypePredicate
    | TSCallSignatureDeclaration
    | TSConstructSignatureDeclaration
    | TSEnumMember
    | TSTypeQuery
    | TSImportType
    | TSTypeLiteral
    | TSTypeAssertion
    | TSEnumDeclaration
    | TSTypeAliasDeclaration
    | TSModuleBlock
    | TSModuleDeclaration
    | TSImportEqualsDeclaration
    | TSExternalModuleReference
    | TSExportAssignment
    | TSNamespaceExportDeclaration
    | TSInterfaceBody
    | TSInterfaceDeclaration
    | TSParameterProperty;

Package Files (6)

Dependencies (1)

tslib

Dev Dependencies (18)

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/ast-types.

Markdown

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

HTML

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

Updated 2 years ago.
Package analyzed in 14724 ms.
Missing or incorrect documentation? Open an issue for this package.