import { Omit } from "../types"; import { Type } from "../lib/types"; import * as K from "./kinds"; export declare namespace namedTypes { interface Printable { loc?: K.SourceLocationKind | null; } interface SourceLocation { start: K.PositionKind; end: K.PositionKind; source?: string | null; } interface Node extends Printable { type: string; comments?: K.CommentKind[] | null; } interface Comment extends Printable { value: string; leading?: boolean; trailing?: boolean; } interface Position { line: number; column: number; } interface File extends Omit { type: "File"; program: K.ProgramKind; name?: string | null; } interface Program extends Omit { type: "Program"; body: K.StatementKind[]; directives?: K.DirectiveKind[]; interpreter?: K.InterpreterDirectiveKind | null; } interface Statement extends Node { } interface Function extends Node { id?: K.IdentifierKind | null; params: K.PatternKind[]; body: K.BlockStatementKind; generator?: boolean; async?: boolean; expression?: boolean; defaults?: (K.ExpressionKind | null)[]; rest?: K.IdentifierKind | null; returnType?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null; typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null; } interface Expression extends Node { } interface Pattern extends Node { } interface Identifier extends Omit, Omit { type: "Identifier"; name: string; optional?: boolean; typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null; } interface BlockStatement extends Omit { type: "BlockStatement"; body: K.StatementKind[]; directives?: K.DirectiveKind[]; } interface EmptyStatement extends Omit { type: "EmptyStatement"; } interface ExpressionStatement extends Omit { type: "ExpressionStatement"; expression: K.ExpressionKind; } interface IfStatement extends Omit { type: "IfStatement"; test: K.ExpressionKind; consequent: K.StatementKind; alternate?: K.StatementKind | null; } interface LabeledStatement extends Omit { type: "LabeledStatement"; label: K.IdentifierKind; body: K.StatementKind; } interface BreakStatement extends Omit { type: "BreakStatement"; label?: K.IdentifierKind | null; } interface ContinueStatement extends Omit { type: "ContinueStatement"; label?: K.IdentifierKind | null; } interface WithStatement extends Omit { type: "WithStatement"; object: K.ExpressionKind; body: K.StatementKind; } interface SwitchStatement extends Omit { type: "SwitchStatement"; discriminant: K.ExpressionKind; cases: K.SwitchCaseKind[]; lexical?: boolean; } interface SwitchCase extends Omit { type: "SwitchCase"; test: K.ExpressionKind | null; consequent: K.StatementKind[]; } interface ReturnStatement extends Omit { type: "ReturnStatement"; argument: K.ExpressionKind | null; } interface ThrowStatement extends Omit { type: "ThrowStatement"; argument: K.ExpressionKind; } interface TryStatement extends Omit { type: "TryStatement"; block: K.BlockStatementKind; handler?: K.CatchClauseKind | null; handlers?: K.CatchClauseKind[]; guardedHandlers?: K.CatchClauseKind[]; finalizer?: K.BlockStatementKind | null; } interface CatchClause extends Omit { type: "CatchClause"; param?: K.PatternKind | null; guard?: K.ExpressionKind | null; body: K.BlockStatementKind; } interface WhileStatement extends Omit { type: "WhileStatement"; test: K.ExpressionKind; body: K.StatementKind; } interface DoWhileStatement extends Omit { type: "DoWhileStatement"; body: K.StatementKind; test: K.ExpressionKind; } interface ForStatement extends Omit { type: "ForStatement"; init: K.VariableDeclarationKind | K.ExpressionKind | null; test: K.ExpressionKind | null; update: K.ExpressionKind | null; body: K.StatementKind; } interface Declaration extends Statement { } interface VariableDeclaration extends Omit { type: "VariableDeclaration"; kind: "var" | "let" | "const"; declarations: (K.VariableDeclaratorKind | K.IdentifierKind)[]; } interface ForInStatement extends Omit { type: "ForInStatement"; left: K.VariableDeclarationKind | K.ExpressionKind; right: K.ExpressionKind; body: K.StatementKind; } interface DebuggerStatement extends Omit { type: "DebuggerStatement"; } interface FunctionDeclaration extends Omit, Omit { type: "FunctionDeclaration"; id: K.IdentifierKind; } interface FunctionExpression extends Omit, Omit { type: "FunctionExpression"; } interface VariableDeclarator extends Omit { type: "VariableDeclarator"; id: K.PatternKind; init?: K.ExpressionKind | null; } interface ThisExpression extends Omit { type: "ThisExpression"; } interface ArrayExpression extends Omit { type: "ArrayExpression"; elements: (K.ExpressionKind | K.SpreadElementKind | K.RestElementKind | null)[]; } interface ObjectExpression extends Omit { type: "ObjectExpression"; properties: (K.PropertyKind | K.ObjectMethodKind | K.ObjectPropertyKind | K.SpreadPropertyKind | K.SpreadElementKind)[]; } interface Property extends Omit { type: "Property"; kind: "init" | "get" | "set"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; value: K.ExpressionKind | K.PatternKind; method?: boolean; shorthand?: boolean; computed?: boolean; decorators?: K.DecoratorKind[] | null; } interface Literal extends Omit { type: "Literal"; value: string | boolean | null | number | RegExp; regex?: { pattern: string; flags: string; } | null; } interface SequenceExpression extends Omit { type: "SequenceExpression"; expressions: K.ExpressionKind[]; } interface UnaryExpression extends Omit { type: "UnaryExpression"; operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete"; argument: K.ExpressionKind; prefix?: boolean; } interface BinaryExpression extends Omit { type: "BinaryExpression"; operator: "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "in" | "instanceof"; left: K.ExpressionKind; right: K.ExpressionKind; } interface AssignmentExpression extends Omit { type: "AssignmentExpression"; operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&="; left: K.PatternKind | K.MemberExpressionKind; right: K.ExpressionKind; } interface MemberExpression extends Omit { type: "MemberExpression"; object: K.ExpressionKind; property: K.IdentifierKind | K.ExpressionKind; computed?: boolean; } interface UpdateExpression extends Omit { type: "UpdateExpression"; operator: "++" | "--"; argument: K.ExpressionKind; prefix: boolean; } interface LogicalExpression extends Omit { type: "LogicalExpression"; operator: "||" | "&&" | "??"; left: K.ExpressionKind; right: K.ExpressionKind; } interface ConditionalExpression extends Omit { type: "ConditionalExpression"; test: K.ExpressionKind; consequent: K.ExpressionKind; alternate: K.ExpressionKind; } interface NewExpression extends Omit { type: "NewExpression"; callee: K.ExpressionKind; arguments: (K.ExpressionKind | K.SpreadElementKind)[]; typeArguments?: null | K.TypeParameterInstantiationKind; } interface CallExpression extends Omit { type: "CallExpression"; callee: K.ExpressionKind; arguments: (K.ExpressionKind | K.SpreadElementKind)[]; typeArguments?: null | K.TypeParameterInstantiationKind; } interface RestElement extends Omit { type: "RestElement"; argument: K.PatternKind; typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null; } interface TypeAnnotation extends Omit { type: "TypeAnnotation"; typeAnnotation: K.FlowTypeKind; } interface TSTypeAnnotation extends Omit { type: "TSTypeAnnotation"; typeAnnotation: K.TSTypeKind | K.TSTypeAnnotationKind; } interface SpreadElementPattern extends Omit { type: "SpreadElementPattern"; argument: K.PatternKind; } interface ArrowFunctionExpression extends Omit, Omit { type: "ArrowFunctionExpression"; id?: null; body: K.BlockStatementKind | K.ExpressionKind; generator?: false; } interface ForOfStatement extends Omit { type: "ForOfStatement"; left: K.VariableDeclarationKind | K.PatternKind; right: K.ExpressionKind; body: K.StatementKind; } interface YieldExpression extends Omit { type: "YieldExpression"; argument: K.ExpressionKind | null; delegate?: boolean; } interface GeneratorExpression extends Omit { type: "GeneratorExpression"; body: K.ExpressionKind; blocks: K.ComprehensionBlockKind[]; filter: K.ExpressionKind | null; } interface ComprehensionBlock extends Omit { type: "ComprehensionBlock"; left: K.PatternKind; right: K.ExpressionKind; each: boolean; } interface ComprehensionExpression extends Omit { type: "ComprehensionExpression"; body: K.ExpressionKind; blocks: K.ComprehensionBlockKind[]; filter: K.ExpressionKind | null; } interface ObjectProperty extends Omit { shorthand?: boolean; type: "ObjectProperty"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; value: K.ExpressionKind | K.PatternKind; accessibility?: K.LiteralKind | null; computed?: boolean; } interface PropertyPattern extends Omit { type: "PropertyPattern"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; pattern: K.PatternKind; computed?: boolean; } interface ObjectPattern extends Omit { type: "ObjectPattern"; properties: (K.PropertyKind | K.PropertyPatternKind | K.SpreadPropertyPatternKind | K.SpreadPropertyKind | K.ObjectPropertyKind | K.RestPropertyKind)[]; typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null; decorators?: K.DecoratorKind[] | null; } interface ArrayPattern extends Omit { type: "ArrayPattern"; elements: (K.PatternKind | K.SpreadElementKind | null)[]; } interface MethodDefinition extends Omit { type: "MethodDefinition"; kind: "constructor" | "method" | "get" | "set"; key: K.ExpressionKind; value: K.FunctionKind; computed?: boolean; static?: boolean; decorators?: K.DecoratorKind[] | null; } interface SpreadElement extends Omit { type: "SpreadElement"; argument: K.ExpressionKind; } interface AssignmentPattern extends Omit { type: "AssignmentPattern"; left: K.PatternKind; right: K.ExpressionKind; } interface ClassPropertyDefinition extends Omit { type: "ClassPropertyDefinition"; definition: K.MethodDefinitionKind | K.VariableDeclaratorKind | K.ClassPropertyDefinitionKind | K.ClassPropertyKind; } interface ClassProperty extends Omit { type: "ClassProperty"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; computed?: boolean; value: K.ExpressionKind | null; static?: boolean; typeAnnotation?: K.TypeAnnotationKind | K.TSTypeAnnotationKind | null; variance?: K.VarianceKind | "plus" | "minus" | null; access?: "public" | "private" | "protected" | undefined; } interface ClassBody extends Omit { type: "ClassBody"; 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)[]; } interface ClassDeclaration extends Omit { type: "ClassDeclaration"; id: K.IdentifierKind | null; body: K.ClassBodyKind; superClass?: K.ExpressionKind | null; typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null; superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null; implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[]; } interface ClassExpression extends Omit { type: "ClassExpression"; id?: K.IdentifierKind | null; body: K.ClassBodyKind; superClass?: K.ExpressionKind | null; typeParameters?: K.TypeParameterDeclarationKind | K.TSTypeParameterDeclarationKind | null; superTypeParameters?: K.TypeParameterInstantiationKind | K.TSTypeParameterInstantiationKind | null; implements?: K.ClassImplementsKind[] | K.TSExpressionWithTypeArgumentsKind[]; } interface Specifier extends Node { } interface ModuleSpecifier extends Specifier { local?: K.IdentifierKind | null; id?: K.IdentifierKind | null; name?: K.IdentifierKind | null; } interface ImportSpecifier extends Omit { type: "ImportSpecifier"; imported: K.IdentifierKind; } interface ImportNamespaceSpecifier extends Omit { type: "ImportNamespaceSpecifier"; } interface ImportDefaultSpecifier extends Omit { type: "ImportDefaultSpecifier"; } interface ImportDeclaration extends Omit { type: "ImportDeclaration"; specifiers?: (K.ImportSpecifierKind | K.ImportNamespaceSpecifierKind | K.ImportDefaultSpecifierKind)[]; source: K.LiteralKind; importKind?: "value" | "type"; } interface TaggedTemplateExpression extends Omit { type: "TaggedTemplateExpression"; tag: K.ExpressionKind; quasi: K.TemplateLiteralKind; } interface TemplateLiteral extends Omit { type: "TemplateLiteral"; quasis: K.TemplateElementKind[]; expressions: K.ExpressionKind[]; } interface TemplateElement extends Omit { type: "TemplateElement"; value: { cooked: string; raw: string; }; tail: boolean; } interface SpreadProperty extends Omit { type: "SpreadProperty"; argument: K.ExpressionKind; } interface SpreadPropertyPattern extends Omit { type: "SpreadPropertyPattern"; argument: K.PatternKind; } interface AwaitExpression extends Omit { type: "AwaitExpression"; argument: K.ExpressionKind | null; all?: boolean; } interface ImportExpression extends Omit { type: "ImportExpression"; source: K.ExpressionKind; } interface JSXAttribute extends Omit { type: "JSXAttribute"; name: K.JSXIdentifierKind | K.JSXNamespacedNameKind; value?: K.LiteralKind | K.JSXExpressionContainerKind | null; } interface JSXIdentifier extends Omit { type: "JSXIdentifier"; name: string; } interface JSXNamespacedName extends Omit { type: "JSXNamespacedName"; namespace: K.JSXIdentifierKind; name: K.JSXIdentifierKind; } interface JSXExpressionContainer extends Omit { type: "JSXExpressionContainer"; expression: K.ExpressionKind; } interface JSXMemberExpression extends Omit { type: "JSXMemberExpression"; object: K.JSXIdentifierKind | K.JSXMemberExpressionKind; property: K.JSXIdentifierKind; computed?: boolean; } interface JSXSpreadAttribute extends Omit { type: "JSXSpreadAttribute"; argument: K.ExpressionKind; } interface JSXElement extends Omit { type: "JSXElement"; openingElement: K.JSXOpeningElementKind; closingElement?: K.JSXClosingElementKind | null; children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]; name?: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind; selfClosing?: boolean; attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[]; } interface JSXOpeningElement extends Omit { type: "JSXOpeningElement"; name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind; attributes?: (K.JSXAttributeKind | K.JSXSpreadAttributeKind)[]; selfClosing?: boolean; } interface JSXClosingElement extends Omit { type: "JSXClosingElement"; name: K.JSXIdentifierKind | K.JSXNamespacedNameKind | K.JSXMemberExpressionKind; } interface JSXFragment extends Omit { type: "JSXFragment"; openingElement: K.JSXOpeningFragmentKind; closingElement: K.JSXClosingFragmentKind; children?: (K.JSXElementKind | K.JSXExpressionContainerKind | K.JSXFragmentKind | K.JSXTextKind | K.LiteralKind)[]; } interface JSXText extends Omit { type: "JSXText"; value: string; } interface JSXOpeningFragment extends Omit { type: "JSXOpeningFragment"; } interface JSXClosingFragment extends Omit { type: "JSXClosingFragment"; } interface JSXEmptyExpression extends Omit { type: "JSXEmptyExpression"; } interface JSXSpreadChild extends Omit { type: "JSXSpreadChild"; expression: K.ExpressionKind; } interface TypeParameterDeclaration extends Omit { type: "TypeParameterDeclaration"; params: K.TypeParameterKind[]; } interface TSTypeParameterDeclaration extends Omit { type: "TSTypeParameterDeclaration"; params: K.TSTypeParameterKind[]; } interface TypeParameterInstantiation extends Omit { type: "TypeParameterInstantiation"; params: K.FlowTypeKind[]; } interface TSTypeParameterInstantiation extends Omit { type: "TSTypeParameterInstantiation"; params: K.TSTypeKind[]; } interface ClassImplements extends Omit { type: "ClassImplements"; id: K.IdentifierKind; superClass?: K.ExpressionKind | null; typeParameters?: K.TypeParameterInstantiationKind | null; } interface TSType extends Node { } interface TSHasOptionalTypeParameterInstantiation { typeParameters?: K.TSTypeParameterInstantiationKind | null; } interface TSExpressionWithTypeArguments extends Omit, TSHasOptionalTypeParameterInstantiation { type: "TSExpressionWithTypeArguments"; expression: K.IdentifierKind | K.TSQualifiedNameKind; } interface Flow extends Node { } interface FlowType extends Flow { } interface AnyTypeAnnotation extends Omit { type: "AnyTypeAnnotation"; } interface EmptyTypeAnnotation extends Omit { type: "EmptyTypeAnnotation"; } interface MixedTypeAnnotation extends Omit { type: "MixedTypeAnnotation"; } interface VoidTypeAnnotation extends Omit { type: "VoidTypeAnnotation"; } interface NumberTypeAnnotation extends Omit { type: "NumberTypeAnnotation"; } interface NumberLiteralTypeAnnotation extends Omit { type: "NumberLiteralTypeAnnotation"; value: number; raw: string; } interface NumericLiteralTypeAnnotation extends Omit { type: "NumericLiteralTypeAnnotation"; value: number; raw: string; } interface StringTypeAnnotation extends Omit { type: "StringTypeAnnotation"; } interface StringLiteralTypeAnnotation extends Omit { type: "StringLiteralTypeAnnotation"; value: string; raw: string; } interface BooleanTypeAnnotation extends Omit { type: "BooleanTypeAnnotation"; } interface BooleanLiteralTypeAnnotation extends Omit { type: "BooleanLiteralTypeAnnotation"; value: boolean; raw: string; } interface NullableTypeAnnotation extends Omit { type: "NullableTypeAnnotation"; typeAnnotation: K.FlowTypeKind; } interface NullLiteralTypeAnnotation extends Omit { type: "NullLiteralTypeAnnotation"; } interface NullTypeAnnotation extends Omit { type: "NullTypeAnnotation"; } interface ThisTypeAnnotation extends Omit { type: "ThisTypeAnnotation"; } interface ExistsTypeAnnotation extends Omit { type: "ExistsTypeAnnotation"; } interface ExistentialTypeParam extends Omit { type: "ExistentialTypeParam"; } interface FunctionTypeAnnotation extends Omit { type: "FunctionTypeAnnotation"; params: K.FunctionTypeParamKind[]; returnType: K.FlowTypeKind; rest: K.FunctionTypeParamKind | null; typeParameters: K.TypeParameterDeclarationKind | null; } interface FunctionTypeParam extends Omit { type: "FunctionTypeParam"; name: K.IdentifierKind; typeAnnotation: K.FlowTypeKind; optional: boolean; } interface ArrayTypeAnnotation extends Omit { type: "ArrayTypeAnnotation"; elementType: K.FlowTypeKind; } interface ObjectTypeAnnotation extends Omit { type: "ObjectTypeAnnotation"; properties: (K.ObjectTypePropertyKind | K.ObjectTypeSpreadPropertyKind)[]; indexers?: K.ObjectTypeIndexerKind[]; callProperties?: K.ObjectTypeCallPropertyKind[]; inexact?: boolean | undefined; exact?: boolean; internalSlots?: K.ObjectTypeInternalSlotKind[]; } interface ObjectTypeProperty extends Omit { type: "ObjectTypeProperty"; key: K.LiteralKind | K.IdentifierKind; value: K.FlowTypeKind; optional: boolean; variance?: K.VarianceKind | "plus" | "minus" | null; } interface ObjectTypeSpreadProperty extends Omit { type: "ObjectTypeSpreadProperty"; argument: K.FlowTypeKind; } interface ObjectTypeIndexer extends Omit { type: "ObjectTypeIndexer"; id: K.IdentifierKind; key: K.FlowTypeKind; value: K.FlowTypeKind; variance?: K.VarianceKind | "plus" | "minus" | null; } interface ObjectTypeCallProperty extends Omit { type: "ObjectTypeCallProperty"; value: K.FunctionTypeAnnotationKind; static?: boolean; } interface ObjectTypeInternalSlot extends Omit { type: "ObjectTypeInternalSlot"; id: K.IdentifierKind; value: K.FlowTypeKind; optional: boolean; static: boolean; method: boolean; } interface Variance extends Omit { type: "Variance"; kind: "plus" | "minus"; } interface QualifiedTypeIdentifier extends Omit { type: "QualifiedTypeIdentifier"; qualification: K.IdentifierKind | K.QualifiedTypeIdentifierKind; id: K.IdentifierKind; } interface GenericTypeAnnotation extends Omit { type: "GenericTypeAnnotation"; id: K.IdentifierKind | K.QualifiedTypeIdentifierKind; typeParameters: K.TypeParameterInstantiationKind | null; } interface MemberTypeAnnotation extends Omit { type: "MemberTypeAnnotation"; object: K.IdentifierKind; property: K.MemberTypeAnnotationKind | K.GenericTypeAnnotationKind; } interface UnionTypeAnnotation extends Omit { type: "UnionTypeAnnotation"; types: K.FlowTypeKind[]; } interface IntersectionTypeAnnotation extends Omit { type: "IntersectionTypeAnnotation"; types: K.FlowTypeKind[]; } interface TypeofTypeAnnotation extends Omit { type: "TypeofTypeAnnotation"; argument: K.FlowTypeKind; } interface TypeParameter extends Omit { type: "TypeParameter"; name: string; variance?: K.VarianceKind | "plus" | "minus" | null; bound?: K.TypeAnnotationKind | null; } interface InterfaceTypeAnnotation extends Omit { type: "InterfaceTypeAnnotation"; body: K.ObjectTypeAnnotationKind; extends?: K.InterfaceExtendsKind[] | null; } interface InterfaceExtends extends Omit { type: "InterfaceExtends"; id: K.IdentifierKind; typeParameters?: K.TypeParameterInstantiationKind | null; } interface InterfaceDeclaration extends Omit { type: "InterfaceDeclaration"; id: K.IdentifierKind; typeParameters?: K.TypeParameterDeclarationKind | null; body: K.ObjectTypeAnnotationKind; extends: K.InterfaceExtendsKind[]; } interface DeclareInterface extends Omit { type: "DeclareInterface"; } interface TypeAlias extends Omit { type: "TypeAlias"; id: K.IdentifierKind; typeParameters: K.TypeParameterDeclarationKind | null; right: K.FlowTypeKind; } interface OpaqueType extends Omit { type: "OpaqueType"; id: K.IdentifierKind; typeParameters: K.TypeParameterDeclarationKind | null; impltype: K.FlowTypeKind; supertype: K.FlowTypeKind; } interface DeclareTypeAlias extends Omit { type: "DeclareTypeAlias"; } interface DeclareOpaqueType extends Omit { type: "DeclareOpaqueType"; } interface TypeCastExpression extends Omit { type: "TypeCastExpression"; expression: K.ExpressionKind; typeAnnotation: K.TypeAnnotationKind; } interface TupleTypeAnnotation extends Omit { type: "TupleTypeAnnotation"; types: K.FlowTypeKind[]; } interface DeclareVariable extends Omit { type: "DeclareVariable"; id: K.IdentifierKind; } interface DeclareFunction extends Omit { type: "DeclareFunction"; id: K.IdentifierKind; } interface DeclareClass extends Omit { type: "DeclareClass"; } interface DeclareModule extends Omit { type: "DeclareModule"; id: K.IdentifierKind | K.LiteralKind; body: K.BlockStatementKind; } interface DeclareModuleExports extends Omit { type: "DeclareModuleExports"; typeAnnotation: K.TypeAnnotationKind; } interface DeclareExportDeclaration extends Omit { type: "DeclareExportDeclaration"; default: boolean; declaration: K.DeclareVariableKind | K.DeclareFunctionKind | K.DeclareClassKind | K.FlowTypeKind | null; specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[]; source?: K.LiteralKind | null; } interface ExportSpecifier extends Omit { type: "ExportSpecifier"; exported: K.IdentifierKind; } interface ExportBatchSpecifier extends Omit { type: "ExportBatchSpecifier"; } interface DeclareExportAllDeclaration extends Omit { type: "DeclareExportAllDeclaration"; source?: K.LiteralKind | null; } interface FlowPredicate extends Flow { } interface InferredPredicate extends Omit { type: "InferredPredicate"; } interface DeclaredPredicate extends Omit { type: "DeclaredPredicate"; value: K.ExpressionKind; } interface ExportDeclaration extends Omit { type: "ExportDeclaration"; default: boolean; declaration: K.DeclarationKind | K.ExpressionKind | null; specifiers?: (K.ExportSpecifierKind | K.ExportBatchSpecifierKind)[]; source?: K.LiteralKind | null; } interface Block extends Comment { type: "Block"; } interface Line extends Comment { type: "Line"; } interface Noop extends Omit { type: "Noop"; } interface DoExpression extends Omit { type: "DoExpression"; body: K.StatementKind[]; } interface Super extends Omit { type: "Super"; } interface BindExpression extends Omit { type: "BindExpression"; object: K.ExpressionKind | null; callee: K.ExpressionKind; } interface Decorator extends Omit { type: "Decorator"; expression: K.ExpressionKind; } interface MetaProperty extends Omit { type: "MetaProperty"; meta: K.IdentifierKind; property: K.IdentifierKind; } interface ParenthesizedExpression extends Omit { type: "ParenthesizedExpression"; expression: K.ExpressionKind; } interface ExportDefaultDeclaration extends Omit { type: "ExportDefaultDeclaration"; declaration: K.DeclarationKind | K.ExpressionKind; } interface ExportNamedDeclaration extends Omit { type: "ExportNamedDeclaration"; declaration: K.DeclarationKind | null; specifiers?: K.ExportSpecifierKind[]; source?: K.LiteralKind | null; } interface ExportNamespaceSpecifier extends Omit { type: "ExportNamespaceSpecifier"; exported: K.IdentifierKind; } interface ExportDefaultSpecifier extends Omit { type: "ExportDefaultSpecifier"; exported: K.IdentifierKind; } interface ExportAllDeclaration extends Omit { type: "ExportAllDeclaration"; exported: K.IdentifierKind | null; source: K.LiteralKind; } interface CommentBlock extends Comment { type: "CommentBlock"; } interface CommentLine extends Comment { type: "CommentLine"; } interface Directive extends Omit { type: "Directive"; value: K.DirectiveLiteralKind; } interface DirectiveLiteral extends Omit, Omit { type: "DirectiveLiteral"; value?: string; } interface InterpreterDirective extends Omit { type: "InterpreterDirective"; value: string; } interface StringLiteral extends Omit { type: "StringLiteral"; value: string; } interface NumericLiteral extends Omit { type: "NumericLiteral"; value: number; raw?: string | null; extra?: { rawValue: number; raw: string; }; } interface BigIntLiteral extends Omit { type: "BigIntLiteral"; value: string | number; extra?: { rawValue: string; raw: string; }; } interface NullLiteral extends Omit { type: "NullLiteral"; value?: null; } interface BooleanLiteral extends Omit { type: "BooleanLiteral"; value: boolean; } interface RegExpLiteral extends Omit { type: "RegExpLiteral"; pattern: string; flags: string; value?: RegExp; } interface ObjectMethod extends Omit, Omit { type: "ObjectMethod"; kind: "method" | "get" | "set"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; params: K.PatternKind[]; body: K.BlockStatementKind; computed?: boolean; generator?: boolean; async?: boolean; accessibility?: K.LiteralKind | null; decorators?: K.DecoratorKind[] | null; } interface ClassPrivateProperty extends Omit { type: "ClassPrivateProperty"; key: K.PrivateNameKind; value?: K.ExpressionKind | null; } interface ClassMethod extends Omit, Omit { type: "ClassMethod"; key: K.LiteralKind | K.IdentifierKind | K.ExpressionKind; kind?: "get" | "set" | "method" | "constructor"; body: K.BlockStatementKind; computed?: boolean; static?: boolean | null; abstract?: boolean | null; access?: "public" | "private" | "protected" | null; accessibility?: "public" | "private" | "protected" | null; decorators?: K.DecoratorKind[] | null; optional?: boolean | null; } interface ClassPrivateMethod extends Omit, Omit { type: "ClassPrivateMethod"; key: K.PrivateNameKind; kind?: "get" | "set" | "method" | "constructor"; body: K.BlockStatementKind; computed?: boolean; static?: boolean | null; abstract?: boolean | null; access?: "public" | "private" | "protected" | null; accessibility?: "public" | "private" | "protected" | null; decorators?: K.DecoratorKind[] | null; optional?: boolean | null; } interface PrivateName extends Omit, Omit { type: "PrivateName"; id: K.IdentifierKind; } interface RestProperty extends Omit { type: "RestProperty"; argument: K.ExpressionKind; } interface ForAwaitStatement extends Omit { type: "ForAwaitStatement"; left: K.VariableDeclarationKind | K.ExpressionKind; right: K.ExpressionKind; body: K.StatementKind; } interface Import extends Omit { type: "Import"; } interface TSQualifiedName extends Omit { type: "TSQualifiedName"; left: K.IdentifierKind | K.TSQualifiedNameKind; right: K.IdentifierKind | K.TSQualifiedNameKind; } interface TSTypeReference extends Omit, TSHasOptionalTypeParameterInstantiation { type: "TSTypeReference"; typeName: K.IdentifierKind | K.TSQualifiedNameKind; } interface TSHasOptionalTypeParameters { typeParameters?: K.TSTypeParameterDeclarationKind | null | undefined; } interface TSHasOptionalTypeAnnotation { typeAnnotation?: K.TSTypeAnnotationKind | null; } interface TSAsExpression extends Omit, Omit { type: "TSAsExpression"; expression: K.ExpressionKind; typeAnnotation: K.TSTypeKind; extra?: { parenthesized: boolean; } | null; } interface TSNonNullExpression extends Omit, Omit { type: "TSNonNullExpression"; expression: K.ExpressionKind; } interface TSAnyKeyword extends Omit { type: "TSAnyKeyword"; } interface TSBigIntKeyword extends Omit { type: "TSBigIntKeyword"; } interface TSBooleanKeyword extends Omit { type: "TSBooleanKeyword"; } interface TSNeverKeyword extends Omit { type: "TSNeverKeyword"; } interface TSNullKeyword extends Omit { type: "TSNullKeyword"; } interface TSNumberKeyword extends Omit { type: "TSNumberKeyword"; } interface TSObjectKeyword extends Omit { type: "TSObjectKeyword"; } interface TSStringKeyword extends Omit { type: "TSStringKeyword"; } interface TSSymbolKeyword extends Omit { type: "TSSymbolKeyword"; } interface TSUndefinedKeyword extends Omit { type: "TSUndefinedKeyword"; } interface TSUnknownKeyword extends Omit { type: "TSUnknownKeyword"; } interface TSVoidKeyword extends Omit { type: "TSVoidKeyword"; } interface TSThisType extends Omit { type: "TSThisType"; } interface TSArrayType extends Omit { type: "TSArrayType"; elementType: K.TSTypeKind; } interface TSLiteralType extends Omit { type: "TSLiteralType"; literal: K.NumericLiteralKind | K.StringLiteralKind | K.BooleanLiteralKind | K.TemplateLiteralKind | K.UnaryExpressionKind; } interface TSUnionType extends Omit { type: "TSUnionType"; types: K.TSTypeKind[]; } interface TSIntersectionType extends Omit { type: "TSIntersectionType"; types: K.TSTypeKind[]; } interface TSConditionalType extends Omit { type: "TSConditionalType"; checkType: K.TSTypeKind; extendsType: K.TSTypeKind; trueType: K.TSTypeKind; falseType: K.TSTypeKind; } interface TSInferType extends Omit { type: "TSInferType"; typeParameter: K.TSTypeParameterKind; } interface TSTypeParameter extends Omit { type: "TSTypeParameter"; name: string; constraint?: K.TSTypeKind | undefined; default?: K.TSTypeKind | undefined; } interface TSParenthesizedType extends Omit { type: "TSParenthesizedType"; typeAnnotation: K.TSTypeKind; } interface TSFunctionType extends Omit, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation { type: "TSFunctionType"; parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]; } interface TSConstructorType extends Omit, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation { type: "TSConstructorType"; parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]; } interface TSDeclareFunction extends Omit, TSHasOptionalTypeParameters { type: "TSDeclareFunction"; declare?: boolean; async?: boolean; generator?: boolean; id?: K.IdentifierKind | null; params: K.PatternKind[]; returnType?: K.TSTypeAnnotationKind | K.NoopKind | null; } interface TSDeclareMethod extends Omit, TSHasOptionalTypeParameters { type: "TSDeclareMethod"; async?: boolean; generator?: boolean; params: K.PatternKind[]; abstract?: boolean; accessibility?: "public" | "private" | "protected" | undefined; static?: boolean; computed?: boolean; optional?: boolean; key: K.IdentifierKind | K.StringLiteralKind | K.NumericLiteralKind | K.ExpressionKind; kind?: "get" | "set" | "method" | "constructor"; access?: "public" | "private" | "protected" | undefined; decorators?: K.DecoratorKind[] | null; returnType?: K.TSTypeAnnotationKind | K.NoopKind | null; } interface TSMappedType extends Omit { type: "TSMappedType"; readonly?: boolean | "+" | "-"; typeParameter: K.TSTypeParameterKind; optional?: boolean | "+" | "-"; typeAnnotation?: K.TSTypeKind | null; } interface TSTupleType extends Omit { type: "TSTupleType"; elementTypes: (K.TSTypeKind | K.TSNamedTupleMemberKind)[]; } interface TSNamedTupleMember extends Omit { type: "TSNamedTupleMember"; label: K.IdentifierKind; optional?: boolean; elementType: K.TSTypeKind; } interface TSRestType extends Omit { type: "TSRestType"; typeAnnotation: K.TSTypeKind; } interface TSOptionalType extends Omit { type: "TSOptionalType"; typeAnnotation: K.TSTypeKind; } interface TSIndexedAccessType extends Omit { type: "TSIndexedAccessType"; objectType: K.TSTypeKind; indexType: K.TSTypeKind; } interface TSTypeOperator extends Omit { type: "TSTypeOperator"; operator: string; typeAnnotation: K.TSTypeKind; } interface TSIndexSignature extends Omit, TSHasOptionalTypeAnnotation { type: "TSIndexSignature"; parameters: K.IdentifierKind[]; readonly?: boolean; } interface TSPropertySignature extends Omit, TSHasOptionalTypeAnnotation { type: "TSPropertySignature"; key: K.ExpressionKind; computed?: boolean; readonly?: boolean; optional?: boolean; initializer?: K.ExpressionKind | null; } interface TSMethodSignature extends Omit, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation { type: "TSMethodSignature"; key: K.ExpressionKind; computed?: boolean; optional?: boolean; parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]; } interface TSTypePredicate extends Omit, Omit { type: "TSTypePredicate"; parameterName: K.IdentifierKind | K.TSThisTypeKind; typeAnnotation?: K.TSTypeAnnotationKind | null; asserts?: boolean; } interface TSCallSignatureDeclaration extends Omit, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation { type: "TSCallSignatureDeclaration"; parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]; } interface TSConstructSignatureDeclaration extends Omit, TSHasOptionalTypeParameters, TSHasOptionalTypeAnnotation { type: "TSConstructSignatureDeclaration"; parameters: (K.IdentifierKind | K.RestElementKind | K.ArrayPatternKind | K.ObjectPatternKind)[]; } interface TSEnumMember extends Omit { type: "TSEnumMember"; id: K.IdentifierKind | K.StringLiteralKind; initializer?: K.ExpressionKind | null; } interface TSTypeQuery extends Omit { type: "TSTypeQuery"; exprName: K.IdentifierKind | K.TSQualifiedNameKind | K.TSImportTypeKind; } interface TSImportType extends Omit, TSHasOptionalTypeParameterInstantiation { type: "TSImportType"; argument: K.StringLiteralKind; qualifier?: K.IdentifierKind | K.TSQualifiedNameKind | undefined; } interface TSTypeLiteral extends Omit { type: "TSTypeLiteral"; members: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]; } interface TSTypeAssertion extends Omit, Omit { type: "TSTypeAssertion"; typeAnnotation: K.TSTypeKind; expression: K.ExpressionKind; extra?: { parenthesized: boolean; } | null; } interface TSEnumDeclaration extends Omit { type: "TSEnumDeclaration"; id: K.IdentifierKind; const?: boolean; declare?: boolean; members: K.TSEnumMemberKind[]; initializer?: K.ExpressionKind | null; } interface TSTypeAliasDeclaration extends Omit, TSHasOptionalTypeParameters { type: "TSTypeAliasDeclaration"; id: K.IdentifierKind; declare?: boolean; typeAnnotation: K.TSTypeKind; } interface TSModuleBlock extends Omit { type: "TSModuleBlock"; body: K.StatementKind[]; } interface TSModuleDeclaration extends Omit { type: "TSModuleDeclaration"; id: K.StringLiteralKind | K.IdentifierKind | K.TSQualifiedNameKind; declare?: boolean; global?: boolean; body?: K.TSModuleBlockKind | K.TSModuleDeclarationKind | null; } interface TSImportEqualsDeclaration extends Omit { type: "TSImportEqualsDeclaration"; id: K.IdentifierKind; isExport?: boolean; moduleReference: K.IdentifierKind | K.TSQualifiedNameKind | K.TSExternalModuleReferenceKind; } interface TSExternalModuleReference extends Omit { type: "TSExternalModuleReference"; expression: K.StringLiteralKind; } interface TSExportAssignment extends Omit { type: "TSExportAssignment"; expression: K.ExpressionKind; } interface TSNamespaceExportDeclaration extends Omit { type: "TSNamespaceExportDeclaration"; id: K.IdentifierKind; } interface TSInterfaceBody extends Omit { type: "TSInterfaceBody"; body: (K.TSCallSignatureDeclarationKind | K.TSConstructSignatureDeclarationKind | K.TSIndexSignatureKind | K.TSMethodSignatureKind | K.TSPropertySignatureKind)[]; } interface TSInterfaceDeclaration extends Omit, TSHasOptionalTypeParameters { type: "TSInterfaceDeclaration"; id: K.IdentifierKind | K.TSQualifiedNameKind; declare?: boolean; extends?: K.TSExpressionWithTypeArgumentsKind[] | null; body: K.TSInterfaceBodyKind; } interface TSParameterProperty extends Omit { type: "TSParameterProperty"; accessibility?: "public" | "private" | "protected" | undefined; readonly?: boolean; parameter: K.IdentifierKind | K.AssignmentPatternKind; } interface OptionalMemberExpression extends Omit { type: "OptionalMemberExpression"; optional?: boolean; } interface OptionalCallExpression extends Omit { type: "OptionalCallExpression"; optional?: boolean; } 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 | MethodDefinition | SpreadElement | AssignmentPattern | ClassPropertyDefinition | ClassProperty | ClassBody | ClassDeclaration | ClassExpression | ImportSpecifier | ImportNamespaceSpecifier | ImportDefaultSpecifier | ImportDeclaration | TaggedTemplateExpression | TemplateLiteral | TemplateElement | SpreadProperty | SpreadPropertyPattern | AwaitExpression | ImportExpression | JSXAttribute | JSXIdentifier | JSXNamespacedName | JSXExpressionContainer | JSXMemberExpression | JSXSpreadAttribute | JSXElement | JSXOpeningElement | JSXClosingElement | JSXFragment | JSXText | JSXOpeningFragment | JSXClosingFragment | JSXEmptyExpression | JSXSpreadChild | TypeParameterDeclaration | TSTypeParameterDeclaration | TypeParameterInstantiation | TSTypeParameterInstantiation | ClassImplements | TSExpressionWithTypeArguments | AnyTypeAnnotation | EmptyTypeAnnotation | MixedTypeAnnotation | VoidTypeAnnotation | NumberTypeAnnotation | NumberLiteralTypeAnnotation | NumericLiteralTypeAnnotation | 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 | OpaqueType | DeclareTypeAlias | DeclareOpaqueType | TypeCastExpression | TupleTypeAnnotation | DeclareVariable | DeclareFunction | DeclareClass | DeclareModule | DeclareModuleExports | DeclareExportDeclaration | ExportSpecifier | ExportBatchSpecifier | DeclareExportAllDeclaration | InferredPredicate | DeclaredPredicate | ExportDeclaration | Block | Line | Noop | DoExpression | Super | BindExpression | Decorator | MetaProperty | ParenthesizedExpression | ExportDefaultDeclaration | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportDefaultSpecifier | ExportAllDeclaration | CommentBlock | CommentLine | Directive | DirectiveLiteral | InterpreterDirective | StringLiteral | NumericLiteral | BigIntLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ObjectMethod | ClassPrivateProperty | ClassMethod | ClassPrivateMethod | PrivateName | 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 | OptionalMemberExpression | OptionalCallExpression; let Printable: Type; let SourceLocation: Type; let Node: Type; let Comment: Type; let Position: Type; let File: Type; let Program: Type; let Statement: Type; let Function: Type; let Expression: Type; let Pattern: Type; let Identifier: Type; let BlockStatement: Type; let EmptyStatement: Type; let ExpressionStatement: Type; let IfStatement: Type; let LabeledStatement: Type; let BreakStatement: Type; let ContinueStatement: Type; let WithStatement: Type; let SwitchStatement: Type; let SwitchCase: Type; let ReturnStatement: Type; let ThrowStatement: Type; let TryStatement: Type; let CatchClause: Type; let WhileStatement: Type; let DoWhileStatement: Type; let ForStatement: Type; let Declaration: Type; let VariableDeclaration: Type; let ForInStatement: Type; let DebuggerStatement: Type; let FunctionDeclaration: Type; let FunctionExpression: Type; let VariableDeclarator: Type; let ThisExpression: Type; let ArrayExpression: Type; let ObjectExpression: Type; let Property: Type; let Literal: Type; let SequenceExpression: Type; let UnaryExpression: Type; let BinaryExpression: Type; let AssignmentExpression: Type; let MemberExpression: Type; let UpdateExpression: Type; let LogicalExpression: Type; let ConditionalExpression: Type; let NewExpression: Type; let CallExpression: Type; let RestElement: Type; let TypeAnnotation: Type; let TSTypeAnnotation: Type; let SpreadElementPattern: Type; let ArrowFunctionExpression: Type; let ForOfStatement: Type; let YieldExpression: Type; let GeneratorExpression: Type; let ComprehensionBlock: Type; let ComprehensionExpression: Type; let ObjectProperty: Type; let PropertyPattern: Type; let ObjectPattern: Type; let ArrayPattern: Type; let MethodDefinition: Type; let SpreadElement: Type; let AssignmentPattern: Type; let ClassPropertyDefinition: Type; let ClassProperty: Type; let ClassBody: Type; let ClassDeclaration: Type; let ClassExpression: Type; let Specifier: Type; let ModuleSpecifier: Type; let ImportSpecifier: Type; let ImportNamespaceSpecifier: Type; let ImportDefaultSpecifier: Type; let ImportDeclaration: Type; let TaggedTemplateExpression: Type; let TemplateLiteral: Type; let TemplateElement: Type; let SpreadProperty: Type; let SpreadPropertyPattern: Type; let AwaitExpression: Type; let ImportExpression: Type; let JSXAttribute: Type; let JSXIdentifier: Type; let JSXNamespacedName: Type; let JSXExpressionContainer: Type; let JSXMemberExpression: Type; let JSXSpreadAttribute: Type; let JSXElement: Type; let JSXOpeningElement: Type; let JSXClosingElement: Type; let JSXFragment: Type; let JSXText: Type; let JSXOpeningFragment: Type; let JSXClosingFragment: Type; let JSXEmptyExpression: Type; let JSXSpreadChild: Type; let TypeParameterDeclaration: Type; let TSTypeParameterDeclaration: Type; let TypeParameterInstantiation: Type; let TSTypeParameterInstantiation: Type; let ClassImplements: Type; let TSType: Type; let TSHasOptionalTypeParameterInstantiation: Type; let TSExpressionWithTypeArguments: Type; let Flow: Type; let FlowType: Type; let AnyTypeAnnotation: Type; let EmptyTypeAnnotation: Type; let MixedTypeAnnotation: Type; let VoidTypeAnnotation: Type; let NumberTypeAnnotation: Type; let NumberLiteralTypeAnnotation: Type; let NumericLiteralTypeAnnotation: Type; let StringTypeAnnotation: Type; let StringLiteralTypeAnnotation: Type; let BooleanTypeAnnotation: Type; let BooleanLiteralTypeAnnotation: Type; let NullableTypeAnnotation: Type; let NullLiteralTypeAnnotation: Type; let NullTypeAnnotation: Type; let ThisTypeAnnotation: Type; let ExistsTypeAnnotation: Type; let ExistentialTypeParam: Type; let FunctionTypeAnnotation: Type; let FunctionTypeParam: Type; let ArrayTypeAnnotation: Type; let ObjectTypeAnnotation: Type; let ObjectTypeProperty: Type; let ObjectTypeSpreadProperty: Type; let ObjectTypeIndexer: Type; let ObjectTypeCallProperty: Type; let ObjectTypeInternalSlot: Type; let Variance: Type; let QualifiedTypeIdentifier: Type; let GenericTypeAnnotation: Type; let MemberTypeAnnotation: Type; let UnionTypeAnnotation: Type; let IntersectionTypeAnnotation: Type; let TypeofTypeAnnotation: Type; let TypeParameter: Type; let InterfaceTypeAnnotation: Type; let InterfaceExtends: Type; let InterfaceDeclaration: Type